@cplieger/deadset-ts 3.3.1 → 3.5.0

package/dist/src/serialization-contract.js

@@ -0,0 +1,405 @@
+/**
+ * The serialization-contract class: the properties of a class whose values reach
+ * `JSON.stringify` or a call `ts.serializers` names, and those and `toJSON` and
+ * `toString` where a value is passed to an `unknown` or `any` parameter of a function
+ * outside the analysis. A function of the project handing such a parameter of its own
+ * to a destination is one, holding back what that destination does, to a fixpoint. A
+ * function invoked through `Function.prototype.call`, `apply` or `bind` is the callee,
+ * given the arguments those methods pass it.
+ */
+import { isArrayLiteralExpression, isArrowFunction, isCallExpression, isClassDeclaration, isClassExpression, isClassStaticBlockDeclaration, isFunctionDeclaration, isFunctionExpression, isGetAccessorDeclaration, isIdentifier, isMethodDeclaration, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectLiteralExpression, isParenthesizedExpression, isPropertyAccessExpression, isSetAccessorDeclaration, isSpreadElement, isStringLiteral, isVariableDeclaration, ModifierFlags, SyntaxKind, } from "@typescript/native/unstable/ast";
+import { SignatureKind, SymbolFlags, TypeFlags, } from "@typescript/native/unstable/sync";
+import { aliasChains } from "./alias-chain.js";
+import { calleeName, resolvedTargets, valuesPassed } from "./calls.js";
+import { classMembers, memberComponent, typesAt } from "./class-members.js";
+import { names, namesADeclaration, resolveEntries, spelledEntry, } from "./configured-declarations.js";
+import { nodeKey } from "./inventory.js";
+import { renderPosition } from "./position.js";
+import { valueReach } from "./value-reach.js";
+/** The serializer every run reads, whatever the configuration names. */
+const JSON_STRINGIFY = { shape: "global", global: "JSON.stringify" };
+/** The methods a serializer and a formatter resolve by name on a value that left the analysis. */
+const CONVERSIONS = new Set(["toJSON", "toString"]);
+/** The parameter types that keep nothing of the value they are given. */
+const ERASED = TypeFlags.Any | TypeFlags.Unknown;
+/** The wider of two reaches, where either may be absent. */
+function wider(a, b) {
+    return a === "conversions" || b === "conversions" ? "conversions" : (a ?? b);
+}
+/** Whether one node declares a static member, whose `this` is the class itself. */
+function isStatic(node) {
+    const flags = node.modifierFlags ?? 0;
+    return (flags & ModifierFlags.Static) !== 0;
+}
+/** Whether one node opens a body whose `this` is not an instance of the enclosing class. */
+function resetsThis(node) {
+    return (isFunctionDeclaration(node) ||
+        isFunctionExpression(node) ||
+        isClassStaticBlockDeclaration(node) ||
+        isStatic(node) ||
+        ((isMethodDeclaration(node) ||
+            isGetAccessorDeclaration(node) ||
+            isSetAccessorDeclaration(node)) &&
+            isObjectLiteralExpression(node.parent)));
+}
+/** The parameters and declaring node of one function-like declaration of the project. */
+function functionOf(node) {
+    if (isFunctionDeclaration(node) ||
+        (isMethodDeclaration(node) && !isObjectLiteralExpression(node.parent))) {
+        return { declared: node, parameters: node.parameters };
+    }
+    if (isVariableDeclaration(node) &&
+        node.initializer !== undefined &&
+        (isArrowFunction(node.initializer) || isFunctionExpression(node.initializer))) {
+        return { declared: node, parameters: node.initializer.parameters };
+    }
+    return undefined;
+}
+/** Whether one parameter is a `this` parameter, which types `this` and binds no argument. */
+function isThisParameter(parameter) {
+    return isIdentifier(parameter.name) && parameter.name.text === "this";
+}
+/** Whether an argument is written in a form that holds no class instance, which saves a type. */
+function holdsNoInstance(argument) {
+    return (isArrowFunction(argument) ||
+        isFunctionExpression(argument) ||
+        isStringLiteral(argument) ||
+        isNumericLiteral(argument) ||
+        isNoSubstitutionTemplateLiteral(argument) ||
+        argument.kind === SyntaxKind.TemplateExpression);
+}
+/** The expression an argument evaluates, through parentheses and a spread. */
+function evaluated(argument) {
+    const value = isSpreadElement(argument) ? argument.expression : argument;
+    return isParenthesizedExpression(value) ? evaluated(value.expression) : value;
+}
+/** The methods of `Function.prototype` that invoke a function with arguments of their own. */
+const FUNCTION_METHODS = new Set(["call", "apply", "bind"]);
+/** The interfaces of the standard library that declare those methods for a function value. */
+const FUNCTION_INTERFACES = new Set([
+    "Function",
+    "CallableFunction",
+    "NewableFunction",
+]);
+function unparenthesized(expression) {
+    return isParenthesizedExpression(expression)
+        ? unparenthesized(expression.expression)
+        : expression;
+}
+/**
+ * The invocation a call writes through a method of `Function.prototype`, read from
+ * the syntax alone: `f.call(self, a)`, `f.apply(self, [a])`, `f.bind(self, a)`, which
+ * binds `a`, and `f.bind(self, a)(b)`, which passes `b` after it. An `apply` argument
+ * that is no array literal is the value of the first parameter, whose elements it
+ * carries. Whether the method is the prototype's is resolution's to say.
+ */
+function throughMethod(call) {
+    const expression = unparenthesized(call.expression);
+    if (isPropertyAccessExpression(expression) && FUNCTION_METHODS.has(expression.name.text)) {
+        const [, ...rest] = call.arguments;
+        let passed = rest;
+        if (expression.name.text === "apply") {
+            const list = rest[0] === undefined ? undefined : unparenthesized(rest[0]);
+            passed = list === undefined ? [] : isArrayLiteralExpression(list) ? list.elements : [list];
+        }
+        return {
+            method: expression.name,
+            invocation: { callee: expression.expression, arguments: passed, indirect: true },
+        };
+    }
+    if (isCallExpression(expression)) {
+        const bound = unparenthesized(expression.expression);
+        if (isPropertyAccessExpression(bound) && bound.name.text === "bind") {
+            return {
+                method: bound.name,
+                invocation: {
+                    callee: bound.expression,
+                    arguments: [...expression.arguments.slice(1), ...call.arguments],
+                    indirect: true,
+                },
+            };
+        }
+    }
+    return undefined;
+}
+/**
+ * Every call of the project's own files with the class `this` stands for there, and
+ * every identifier-named parameter of every function, method and function-valued
+ * variable the project declares, at the position of the argument it binds.
+ */
+function walkProject(project, held) {
+    const sites = [];
+    const parameters = [];
+    for (const file of project.ownSourceFiles()) {
+        const visit = (node, self) => {
+            let inner = self;
+            if (isClassDeclaration(node) || isClassExpression(node)) {
+                inner = held.declarations.get(nodeKey(file, node));
+            }
+            else if (resetsThis(node)) {
+                inner = undefined;
+            }
+            if (node.kind === SyntaxKind.CallExpression) {
+                sites.push({ call: node, self });
+            }
+            const fn = functionOf(node);
+            const id = fn === undefined ? undefined : held.declarations.get(nodeKey(file, fn.declared));
+            if (fn !== undefined && id !== undefined) {
+                fn.parameters
+                    .filter((parameter) => !isThisParameter(parameter))
+                    .forEach((parameter, index) => {
+                    if (isIdentifier(parameter.name)) {
+                        parameters.push({
+                            fn: id,
+                            index,
+                            rest: parameter.dotDotDotToken !== undefined,
+                            name: parameter.name,
+                        });
+                    }
+                });
+            }
+            node.forEachChild((child) => {
+                visit(child, inner);
+            });
+        };
+        file.forEachChild((child) => {
+            visit(child, undefined);
+        });
+    }
+    return { sites, parameters };
+}
+/**
+ * The parameters that keep nothing of the value they are given: one typed `unknown` or
+ * `any`, and a rest parameter whose elements are, each by its symbol.
+ */
+function erasedParameters(project, parameters) {
+    const types = typesAt(project, parameters.map((parameter) => parameter.name));
+    const erased = parameters.filter((parameter, index) => {
+        const type = types[index];
+        if (type === undefined) {
+            return false;
+        }
+        if (!parameter.rest) {
+            return (type.flags & ERASED) !== 0;
+        }
+        const [element] = type.isTypeReference() ? project.checker.getTypeArguments(type) : [];
+        return element !== undefined && (element.flags & ERASED) !== 0;
+    });
+    const bySymbol = new Map();
+    project
+        .symbolsAt(erased.map((parameter) => project.handle(parameter.name)))
+        .forEach((symbol, index) => {
+        const parameter = erased[index];
+        if (symbol !== undefined && parameter !== undefined) {
+            bySymbol.set(symbol.id, parameter);
+        }
+    });
+    return bySymbol;
+}
+/** Each place a call's argument passes one of the erased parameters it can see. */
+function handedOn(project, sites, erased, invocationOf) {
+    const spellings = new Set([...erased.values()].map((parameter) => parameter.name.getText()));
+    const candidates = sites.flatMap((site) => invocationOf(site.call).arguments.flatMap((argument, index) => valuesPassed(argument)
+        .filter((value) => spellings.has(value.name.getText()))
+        .map((value) => ({ site, argument: index, value }))));
+    const plain = candidates.filter((one) => !one.value.shorthand);
+    const resolved = project.symbolsAt(plain.map((one) => project.handle(one.value.name)));
+    const symbolOf = new Map(plain.map((one, index) => [one, resolved[index]]));
+    return candidates.flatMap((one) => {
+        const symbol = one.value.shorthand
+            ? project.shorthandValueAt(project.handle(one.value.name))
+            : symbolOf.get(one);
+        const parameter = symbol === undefined ? undefined : erased.get(symbol.id);
+        return parameter === undefined ? [] : [{ parameter, site: one.site, argument: one.argument }];
+    });
+}
+/**
+ * The destinations of one project's calls. A call is one at every argument where its
+ * callee is a serializer an entry names; at the arguments its resolved signature types
+ * `unknown` or `any` where its callee is declared outside the analysis; and, where its
+ * callee is a function of the project, at each parameter the function hands on to a
+ * destination, holding back the widest of what those destinations hold back, which is
+ * settled by widening until no parameter moves.
+ */
+function destinations(input, chains, walked) {
+    const { project, held } = input;
+    const checker = project.checker;
+    const own = new Set(project.ownSourceFiles().map((file) => file.fileName));
+    const named = resolveEntries(project, held, [JSON_STRINGIFY, ...input.ts.serializers]).filter(namesADeclaration);
+    const forms = new Map();
+    for (const site of walked.sites) {
+        const form = throughMethod(site.call);
+        if (form !== undefined) {
+            forms.set(site.call, form);
+        }
+    }
+    const callees = resolvedTargets(project, [
+        ...walked.sites.flatMap((site) => calleeName(site.call.expression) ?? []),
+        ...[...forms.values()].flatMap((form) => {
+            const name = calleeName(form.invocation.callee);
+            return name === undefined ? [form.method] : [form.method, name];
+        }),
+    ]);
+    const erased = erasedParameters(project, walked.parameters);
+    const byFunction = new Map();
+    for (const parameter of erased.values()) {
+        byFunction.set(parameter.fn, [...(byFunction.get(parameter.fn) ?? []), parameter]);
+    }
+    const outside = (target) => target.declarations.length > 0 &&
+        target.declarations.every((handle) => !own.has(handle.path) &&
+            !input.consumers.some((root) => handle.path === root || handle.path.startsWith(`${root}/`)));
+    const invocation = (call) => {
+        const form = forms.get(call);
+        const method = form === undefined ? undefined : callees.get(form.method);
+        // Only the standard library's function methods pass their arguments on: the
+        // program's own `call` and `Reflect.apply` invoke nothing here.
+        if (form !== undefined &&
+            method !== undefined &&
+            outside(method) &&
+            FUNCTION_INTERFACES.has(method.getParent()?.name ?? "")) {
+            return form.invocation;
+        }
+        return { callee: call.expression, arguments: call.arguments, indirect: false };
+    };
+    const calleeOf = (call) => {
+        const name = calleeName(invocation(call).callee);
+        return name === undefined ? undefined : callees.get(name);
+    };
+    const erasedArguments = new Map();
+    const erasedAt = (call, argument) => {
+        let indexes = erasedArguments.get(call);
+        if (indexes === undefined) {
+            const invoked = invocation(call);
+            // Through a method of the prototype the resolved signature is the method's, so
+            // the parameters are read off the callee's own signatures, any one erasing.
+            const type = invoked.indirect ? checker.getTypeAtLocation(invoked.callee) : undefined;
+            const signatures = invoked.indirect
+                ? type === undefined
+                    ? []
+                    : checker.getSignaturesOfType(type, SignatureKind.Call)
+                : [checker.getResolvedSignature(call)].filter((one) => one !== undefined);
+            indexes = new Set(invoked.arguments.flatMap((_unused, index) => signatures.some((signature) => {
+                const parameter = checker.getParameterType(signature, index);
+                return parameter !== undefined && (parameter.flags & ERASED) !== 0;
+            })
+                ? [index]
+                : []));
+            erasedArguments.set(call, indexes);
+        }
+        return indexes.has(argument);
+    };
+    const forwards = new Map();
+    const keyOf = (parameter) => `${parameter.fn}\u0000${String(parameter.index)}`;
+    const at = (call, argument) => {
+        const target = calleeOf(call);
+        if (target === undefined) {
+            return undefined;
+        }
+        const entry = named.find((one) => names(one, target, chains));
+        if (entry !== undefined) {
+            return { reach: "properties", callee: spelledEntry(entry.entry, held) };
+        }
+        const declared = chains.declarationsOf(target);
+        if (declared.length === 0) {
+            return outside(target) && erasedAt(call, argument)
+                ? {
+                    reach: "conversions",
+                    callee: invocation(call).callee.getText().replace(/\s+/gu, ""),
+                }
+                : undefined;
+        }
+        for (const fn of declared) {
+            const parameter = (byFunction.get(fn) ?? []).find((one) => one.index === argument || (one.rest && one.index <= argument));
+            const reach = parameter === undefined ? undefined : forwards.get(keyOf(parameter));
+            if (reach !== undefined) {
+                return { reach, callee: held.symbols.find((symbol) => symbol.id === fn)?.name ?? fn };
+            }
+        }
+        return undefined;
+    };
+    const forwarded = handedOn(project, walked.sites, erased, invocation);
+    for (let moved = true; moved;) {
+        moved = false;
+        for (const one of forwarded) {
+            const key = keyOf(one.parameter);
+            const before = forwards.get(key);
+            const after = wider(before, at(one.site.call, one.argument)?.reach);
+            if (after !== undefined && after !== before) {
+                forwards.set(key, after);
+                moved = true;
+            }
+        }
+    }
+    const mayReceive = (call) => {
+        const target = calleeOf(call);
+        if (target === undefined) {
+            return false;
+        }
+        const declared = chains.declarationsOf(target);
+        if (named.some((one) => names(one, target, chains))) {
+            return true;
+        }
+        if (declared.length === 0) {
+            return outside(target);
+        }
+        return declared.some((fn) => (byFunction.get(fn) ?? []).some((parameter) => forwards.has(keyOf(parameter))));
+    };
+    return { invocation, at, mayReceive };
+}
+/** Each argument of a call that can receive one whose value carries a class of the target. */
+function flowsOf(project, held, sites, to) {
+    const reach = valueReach(project, held);
+    const arguments_ = sites.flatMap((site) => to.mayReceive(site.call)
+        ? to.invocation(site.call).arguments.flatMap((argument, index) => {
+            const value = evaluated(argument);
+            return holdsNoInstance(value) ? [] : [{ site, argument: index, value }];
+        })
+        : []);
+    const asked = arguments_.filter((one) => one.value.kind !== SyntaxKind.ThisKeyword);
+    const types = typesAt(project, asked.map((one) => one.value));
+    const typeOf = new Map(asked.map((one, index) => [one.value, types[index]]));
+    return arguments_.flatMap((one) => {
+        const type = typeOf.get(one.value);
+        let classes = new Set();
+        if (one.value.kind === SyntaxKind.ThisKeyword) {
+            classes = new Set(one.site.self === undefined ? [] : [one.site.self]);
+        }
+        else if (type !== undefined) {
+            classes = reach.classesOf(type);
+        }
+        const destination = classes.size === 0 ? undefined : to.at(one.site.call, one.argument);
+        return destination === undefined ? [] : [{ site: one.value, classes, to: destination }];
+    });
+}
+/**
+ * The serialization-contract detector: each property of each class whose values reach
+ * a destination, and the two conversion methods where the destination is outside the
+ * analysis, recorded at the argument with the callee named.
+ */
+export function serializationContract(input) {
+    const { project, held, targetRoot } = input;
+    const walked = walkProject(project, held);
+    const flows = flowsOf(project, held, walked.sites, destinations(input, aliasChains(project, held), walked));
+    if (flows.length === 0) {
+        return [];
+    }
+    const members = classMembers(project, held, new Set(flows.flatMap((flow) => [...flow.classes])), "instance");
+    const byId = new Map(held.symbols.map((symbol) => [symbol.id, symbol]));
+    const found = [];
+    for (const flow of flows) {
+        const site = renderPosition(flow.site.getSourceFile(), targetRoot, flow.site.getStart());
+        const detail = `passed to ${flow.to.callee}`;
+        for (const member of [...flow.classes].flatMap((id) => members.get(id) ?? [])) {
+            const symbol = byId.get(member.id);
+            const isProperty = (member.flags & SymbolFlags.Property) !== 0;
+            const converts = flow.to.reach === "conversions" &&
+                (member.flags & SymbolFlags.Method) !== 0 &&
+                symbol !== undefined &&
+                CONVERSIONS.has(memberComponent(symbol, byId) ?? "");
+            if (isProperty || converts) {
+                found.push({ id: member.id, detail, site });
+            }
+        }
+    }
+    return found;
+}

package/dist/src/value-reach.js

@@ -0,0 +1,120 @@
+/**
+ * The classes of the target a value of one type carries, as a serializer walking the
+ * value reaches them: through union and intersection constituents, array and tuple
+ * elements, and the data members of the target's classes and of object types the
+ * target writes. The walk stops at `any`, `unknown`, a type parameter, a function and
+ * an interface or class of another program, so an instance held only there is missed.
+ */
+import { ObjectFlags, SymbolFlags, } from "@typescript/native/unstable/sync";
+import { classNames, typesAt } from "./class-members.js";
+/** The object types whose members the walk reads whatever declares them. */
+const WRITTEN = ObjectFlags.ObjectLiteral | ObjectFlags.Mapped;
+/** The symbols of an anonymous object type the target writes as a type. */
+const LITERAL_SYMBOLS = SymbolFlags.TypeLiteral | SymbolFlags.ObjectLiteral;
+/** The global array types, whose element type is what an array value carries. */
+function arrayTargets(project) {
+    const checker = project.checker;
+    return new Set(["Array", "ReadonlyArray"].flatMap((name) => {
+        const symbol = checker.resolveName(name, SymbolFlags.Type, undefined, false);
+        return symbol === undefined ? [] : [checker.getDeclaredTypeOfSymbol(symbol).id];
+    }));
+}
+/**
+ * The walk over one project's types, against the classes of `held`, the same
+ * project's inventory.
+ */
+export function valueReach(project, held) {
+    const checker = project.checker;
+    const names = [...classNames(project, held)];
+    const declared = typesAt(project, names.map(([, node]) => node));
+    const classOfTarget = new Map();
+    names.forEach(([id], index) => {
+        const type = declared[index];
+        if (type !== undefined) {
+            classOfTarget.set(type.id, id);
+        }
+    });
+    const arrays = arrayTargets(project);
+    const own = new Set(project.ownSourceFiles().map((file) => file.fileName));
+    const children = new Map();
+    /** The generic target of a type reference, and the type itself otherwise. */
+    const targetOf = (type) => (type.objectFlags & ObjectFlags.Reference) !== 0 && type.isTypeReference()
+        ? type.getTarget()
+        : type;
+    const classOf = (type) => {
+        if (!type.isObjectType()) {
+            return undefined;
+        }
+        return classOfTarget.get(type.id) ?? classOfTarget.get(targetOf(type).id);
+    };
+    /** Whether the target writes the object type, so its members are what the value holds. */
+    const isWritten = (type) => {
+        if ((type.objectFlags & WRITTEN) !== 0) {
+            return true;
+        }
+        const symbol = type.getSymbol();
+        if (symbol === undefined) {
+            return false;
+        }
+        if ((type.objectFlags & ObjectFlags.Anonymous) !== 0) {
+            return (symbol.flags & LITERAL_SYMBOLS) !== 0;
+        }
+        return ((symbol.flags & SymbolFlags.Interface) !== 0 &&
+            symbol.declarations.every((handle) => own.has(handle.path)));
+    };
+    /** The types a value of one object type holds in its data members. */
+    const memberTypes = (type) => {
+        const properties = checker
+            .getPropertiesOfType(type)
+            .filter((property) => (property.flags & SymbolFlags.Property) !== 0);
+        const types = properties.length === 0 ? [] : checker.getTypeOfSymbol(properties);
+        return [
+            ...types.filter((held) => held !== undefined),
+            ...checker.getIndexInfosOfType(type).map((info) => info.valueType),
+        ];
+    };
+    /** The types a value of one type holds, read once per type. */
+    const childrenOf = (type) => {
+        const known = children.get(type.id);
+        if (known !== undefined) {
+            return known;
+        }
+        let found = [];
+        if (type.isUnionType() || type.isIntersectionType()) {
+            found = type.getTypes();
+        }
+        else if (type.isObjectType()) {
+            const target = targetOf(type);
+            const isList = type.isTypeReference() &&
+                (arrays.has(target.id) ||
+                    (target.isObjectType() && (target.objectFlags & ObjectFlags.Tuple) !== 0));
+            if (classOf(type) !== undefined || (!isList && isWritten(type))) {
+                found = memberTypes(type);
+            }
+            else if (isList && type.isTypeReference()) {
+                found = checker.getTypeArguments(type);
+            }
+        }
+        children.set(type.id, found);
+        return found;
+    };
+    return {
+        classesOf: (type) => {
+            const found = new Set();
+            const seen = new Set();
+            const pending = [type];
+            for (let next = pending.pop(); next !== undefined; next = pending.pop()) {
+                if (seen.has(next.id)) {
+                    continue;
+                }
+                seen.add(next.id);
+                const owner = classOf(next);
+                if (owner !== undefined) {
+                    found.add(owner);
+                }
+                pending.push(...childrenOf(next));
+            }
+            return found;
+        },
+    };
+}

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 = "3.0.0";
+export const CONTRACT_VERSION = "3.2.0";

package/jsr.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/deadset-ts",
-  "version": "3.3.1",
+  "version": "3.5.0",
   "license": "GPL-3.0-or-later",
   "exports": {
     ".": "./src/index.ts"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/deadset-ts",
-  "version": "3.3.1",
+  "version": "3.5.0",
   "type": "module",
   "sideEffects": false,
   "description": "Deterministic dead-code analysis for TypeScript, class and type members included",
@@ -37,7 +37,7 @@
     "fast-check": "4.10.2",
     "prettier": "3.9.9",
     "typescript": "npm:@typescript/typescript6@6.0.2",
-    "typescript-eslint": "8.70.1",
+    "typescript-eslint": "8.71.0",
     "vitest": "5.0.2"
   },
   "publishConfig": {

package/src/analysis.ts

@@ -22,7 +22,9 @@ import {
 } from "./exempt.ts";
 import type { TSExemptionClass } from "./exempt-classes.ts";
 import type { Finding } from "./finding.ts";
+import { frameworkLifecycle } from "./framework-lifecycle.ts";
 import type { Host } from "./host.ts";
+import { injectionContainer } from "./injection-container.ts";
 import { interfaceSatisfaction } from "./interface-satisfaction.ts";
 import { inventory, type Inventory } from "./inventory.ts";
 import { readManifest } from "./manifest.ts";
@@ -33,6 +35,7 @@ import { reflectiveLookup } from "./reflective-lookup.ts";
 import { references } from "./references.ts";
 import { roots, unmatchedEverywhere, unmatchedRoots, type RootKind, type Roots } from "./roots.ts";
 import type { Scope } from "./scope.ts";
+import { serializationContract } from "./serialization-contract.ts";
 import { diagnosticsOf, runSession, type Engine, type ProjectView } from "./session.ts";
 import type { Exemption, SweepInput } from "./sweep.ts";
 import { readTemplates, templateField } from "./template-field.ts";
@@ -222,6 +225,9 @@ const DETECTORS: Detectors = new Map<TSExemptionClass, Detector>([
   ["template-field", templateField],
   ["reflective-lookup", reflectiveLookup],
   ["decorator", decorator],
+  ["injection-container", injectionContainer],
+  ["framework-lifecycle", frameworkLifecycle],
+  ["serialization-contract", serializationContract],
 ]);
 
 /**
@@ -247,6 +253,7 @@ export function runSweep(
   const templates = disabled.has("template-field")
     ? { delimiters: config.analysis.templateDelimiters, files: [] }
     : readTemplates(host, targetRoot, config.analysis);
+  const consumers = scope.consumers.map((consumer) => consumer.path);
   const read = readProjects(engine, host, scope, config, (project, projectRead) => {
     const resolved = references(project, projectRead.held, targetRoot, {
       testFiles: config.ts.testFiles,
@@ -259,7 +266,7 @@ export function runSweep(
       testFiles: resolved.testFilePaths,
     };
     const exempt = computeExemptions(
-      { project, held: projectRead.held, targetRoot, templates },
+      { project, held: projectRead.held, targetRoot, templates, ts: config.ts, consumers },
       detectors,
       {
         disabled,