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

package/dist/src/conformance-record.js

@@ -2,9 +2,9 @@
 // Regenerate it with `UPDATE_GOLDEN=1 npx vitest --run src/conformance.corpus.test.ts`.
 export const RECORD = {
     conformance: {
-        corpusVersion: "5.0.0",
+        corpusVersion: "5.1.0",
         result: "pass",
-        digest: "sha256:c46c7d06b6f0c58504c5f311870efefc0b85f18c2c46ba7d7b722081cb370c0c",
+        digest: "sha256:befd5e68f8d68e859b2a0920464a5470a157d5d40a881d9cca28716a4575751d",
     },
     gaps: [],
 };

package/dist/src/erased-stores.js

@@ -1,15 +1,15 @@
 /**
- * The values the program stores in a slot of a container: a property, an index signature,
- * an array element, and a variable. A serializer walking the container emits the value the
- * slot holds, so it walks each stored value at its own static type, a subtype stored where
- * the slot's type names a supertype, `object`, `unknown` or `any` included. A container is
- * identified by the checker's type identity, so two containers of one type share what
+ * The values the program stores in a property, an index signature, an array element or a
+ * variable. A serializer emits the value a slot holds, so it walks each stored value at its
+ * own static type and each type it is checked against, whatever supertype the slot names.
+ * Containers are identified by the checker's type identity, so two of one type share what
  * either stores. A store into an erased property of a type the analyzed program does not
- * declare hands the value to the code that declares the type.
+ * declare hands the value to the code that declares it.
  */
 import { isArrayLiteralExpression, isBinaryExpression, isCallExpression, isElementAccessExpression, isIdentifier, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectLiteralExpression, isParenthesizedExpression, isPropertyAccessExpression, isPropertyAssignment, isShorthandPropertyAssignment, isSpreadElement, isStringLiteral, isVariableDeclaration, SyntaxKind, } from "@typescript/native/ast";
 import { SymbolFlags, TypeFlags } from "@typescript/native/sync";
 import { must } from "./query.js";
+import { checkedTypes } from "./value-reach.js";
 /** The types that keep nothing of the value they are given. */
 const ERASED = TypeFlags.Any | TypeFlags.Unknown;
 /** The array methods whose arguments become elements of the array they are called on. */
@@ -256,15 +256,20 @@ export function erasedStores(project) {
     };
     /** The type of the part of a stored value its path names, a step at a time. */
     const partOf = (type, path) => path.reduce((at, step) => (at === undefined ? undefined : slotOf(at, String(step))), type);
-    const valueTypes = queries
-        .typesAt(stores.map((one) => one.value))
-        .map((type, at) => partOf(must(type), stores[at]?.path ?? []));
+    /** The types of what each stored value puts in its slot: its own and those it is checked against. */
+    const storedTypes = (stored) => {
+        const checked = checkedTypes(project, stored.map((one) => one.value));
+        return queries
+            .typesAt(stored.map((one) => one.value))
+            .map((type, at) => [must(type), ...(checked[at] ?? [])].flatMap((one) => partOf(one, stored[at]?.path ?? []) ?? []));
+    };
+    const valueTypes = storedTypes(stores);
     const inside = new Map();
     const outside = [];
     stores.forEach((store, at) => {
         const container = containerOf.get(store);
-        const value = valueTypes[at];
-        if (container === undefined || value === undefined) {
+        const values = valueTypes[at] ?? [];
+        if (container === undefined) {
             return;
         }
         const parts = container.isUnionType() || container.isIntersectionType()
@@ -277,10 +282,10 @@ export function erasedStores(project) {
             const { name } = store;
             const erased = name !== undefined && ((slotOf(part, name)?.flags ?? 0) & ERASED) !== 0;
             if (erased && declaredOutside(part)) {
-                outside.push({ value: store.value, type: value, property: name });
+                outside.push(...values.map((type) => ({ value: store.value, type, property: name })));
             }
             else {
-                inside.set(part.id, [...(inside.get(part.id) ?? []), value]);
+                inside.set(part.id, [...(inside.get(part.id) ?? []), ...values]);
             }
         }
     });
@@ -291,15 +296,13 @@ export function erasedStores(project) {
         const handle = symbol?.valueDeclaration ?? symbol?.declarations[0];
         return handle === undefined ? undefined : project.declarationAt(handle)?.node;
     };
-    const assignedTypes = queries
-        .typesAt(assigned.map((one) => one.value))
-        .map((type, at) => partOf(must(type), assigned[at]?.path ?? []));
+    const assignedTypes = storedTypes(assigned);
     const byVariable = new Map();
     assigned.forEach((_one, at) => {
         const declaration = declarationOf(symbols[at]);
-        const type = assignedTypes[at];
-        if (declaration !== undefined && slots.has(declaration) && type !== undefined) {
-            byVariable.set(declaration, [...(byVariable.get(declaration) ?? []), type]);
+        const types = assignedTypes[at] ?? [];
+        if (declaration !== undefined && slots.has(declaration) && types.length > 0) {
+            byVariable.set(declaration, [...(byVariable.get(declaration) ?? []), ...types]);
         }
     });
     return {

package/dist/src/serialization-contract.js

@@ -6,7 +6,7 @@
  * function of the project handing such a parameter to a destination is one, to a fixpoint,
  * and a function invoked through `call`, `apply` or `bind` is the callee.
  */
-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/ast";
+import { isArrayLiteralExpression, isArrowFunction, isAsExpression, isCallExpression, isClassDeclaration, isClassExpression, isClassStaticBlockDeclaration, isFunctionDeclaration, isFunctionExpression, isGetAccessorDeclaration, isIdentifier, isInterfaceDeclaration, isMethodDeclaration, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectLiteralExpression, isParenthesizedExpression, isPropertyAccessExpression, isPropertyDeclaration, isSatisfiesExpression, isSetAccessorDeclaration, isSpreadElement, isStringLiteral, isTypeLiteralNode, isVariableDeclaration, ModifierFlags, NodeFlags, SyntaxKind, } from "@typescript/native/ast";
 import { SignatureKind, SymbolFlags, TypeFlags, } from "@typescript/native/sync";
 import { aliasChains } from "./alias-chain.js";
 import { calleeName, resolvedTargets, valuesPassed } from "./calls.js";
@@ -16,7 +16,7 @@ import { nodeKey } from "./inventory.js";
 import { renderPosition } from "./position.js";
 import { must } from "./query.js";
 import { erasedStores } from "./erased-stores.js";
-import { valueReach } from "./value-reach.js";
+import { checkedTypes, 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. */
@@ -217,13 +217,74 @@ function handedOn(project, sites, erased, invocationOf) {
         return parameter === undefined ? [] : [{ parameter, site: one.site, argument: one.argument }];
     });
 }
+/**
+ * The symbols of the interfaces and object types code of the analysis implements: those a
+ * class's `implements` and `extends` clauses name, those an object literal is typed as by
+ * a variable or property annotation or a `satisfies` or `as` expression, and every type
+ * each of those extends. Read at the first call, which asks the checker.
+ */
+function implementedOwners(project, inAnalysis) {
+    let owners;
+    return () => {
+        if (owners !== undefined) {
+            return owners;
+        }
+        const found = new Set();
+        const queries = project.queries;
+        const own = project.ownPaths();
+        const files = [
+            ...project.ownSourceFiles(),
+            ...project.program
+                .getSourceFileNames()
+                .filter((name) => !own.has(name) && inAnalysis(name))
+                .flatMap((name) => project.program.getSourceFile(name) ?? []),
+        ];
+        const naming = [];
+        const visit = (node) => {
+            if (isClassDeclaration(node) || isClassExpression(node)) {
+                naming.push(...(node.heritageClauses ?? []).flatMap((clause) => [...clause.types]));
+            }
+            else if ((isVariableDeclaration(node) || isPropertyDeclaration(node)) &&
+                node.type !== undefined &&
+                node.initializer !== undefined &&
+                isObjectLiteralExpression(evaluated(node.initializer))) {
+                naming.push(node.type);
+            }
+            else if ((isSatisfiesExpression(node) || isAsExpression(node)) &&
+                isObjectLiteralExpression(evaluated(node.expression))) {
+                naming.push(node.type);
+            }
+            node.forEachChild(visit);
+        };
+        for (const file of files) {
+            file.forEachChild(visit);
+        }
+        const pending = typesAt(project, naming).filter((type) => type !== undefined);
+        const seen = new Set();
+        for (let type = pending.pop(); type !== undefined; type = pending.pop()) {
+            for (const part of must(queries.constituents(type))) {
+                const target = must(queries.targetOf(part));
+                if (!seen.has(target.id)) {
+                    seen.add(target.id);
+                    const symbol = must(queries.symbolOfType(target));
+                    if (symbol !== undefined) {
+                        found.add(symbol.id);
+                    }
+                    pending.push(...must(queries.baseTypes(target)));
+                }
+            }
+        }
+        owners = found;
+        return owners;
+    };
+}
 /**
  * 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.
+ * `unknown` or `any` where its callee is declared outside the analysis or only ambiently
+ * with no implementation in it; 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;
@@ -249,9 +310,29 @@ function destinations(input, chains, walked) {
     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 inAnalysis = (path) => own.has(path) || input.consumers.some((root) => path === root || path.startsWith(`${root}/`));
+    const implemented = implementedOwners(project, inAnalysis);
+    /**
+     * Whether every declaration of a callee is outside the analysis or ambient. An ambient
+     * declaration has no body, so the code that runs is outside the analysis, unless it is a
+     * member of an interface or an object type a class or a typed object literal of the
+     * analysis implements; `settled` false skips that question, which asks the checker.
+     */
+    const outside = (target, settled) => target.declarations.length > 0 &&
+        target.declarations.every((handle) => {
+            if (!inAnalysis(handle.path)) {
+                return true;
+            }
+            const node = project.declarationAt(handle)?.node;
+            if (node === undefined || (node.flags & NodeFlags.Ambient) === 0) {
+                return false;
+            }
+            if (!settled || !(isInterfaceDeclaration(node.parent) || isTypeLiteralNode(node.parent))) {
+                return true;
+            }
+            const owner = must(queries.parentOf(target));
+            return owner === undefined || !implemented().has(owner.id);
+        });
     const invocation = (call) => {
         const form = forms.get(call);
         const method = form === undefined ? undefined : callees.get(form.method);
@@ -259,7 +340,7 @@ function destinations(input, chains, walked) {
         // program's own `call` and `Reflect.apply` invoke nothing here.
         if (form !== undefined &&
             method !== undefined &&
-            outside(method) &&
+            outside(method, false) &&
             FUNCTION_INTERFACES.has(must(project.queries.parentOf(method))?.name ?? "")) {
             return form.invocation;
         }
@@ -303,16 +384,15 @@ function destinations(input, chains, walked) {
         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)
+        if (outside(target, true)) {
+            return erasedAt(call, argument)
                 ? {
                     reach: "conversions",
                     callee: invocation(call).callee.getText().replace(/\s+/gu, ""),
                 }
                 : undefined;
         }
-        for (const fn of declared) {
+        for (const fn of chains.declarationsOf(target)) {
             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) {
@@ -339,14 +419,12 @@ function destinations(input, chains, walked) {
         if (target === undefined) {
             return false;
         }
-        const declared = chains.declarationsOf(target);
-        if (named.some((one) => names(one, target, chains))) {
+        if (named.some((one) => names(one, target, chains)) || outside(target, false)) {
             return true;
         }
-        if (declared.length === 0) {
-            return outside(target);
-        }
-        return declared.some((fn) => (byFunction.get(fn) ?? []).some((parameter) => forwards.has(keyOf(parameter))));
+        return chains
+            .declarationsOf(target)
+            .some((fn) => (byFunction.get(fn) ?? []).some((parameter) => forwards.has(keyOf(parameter))));
     };
     return { invocation, at, mayReceive };
 }
@@ -366,7 +444,8 @@ function flowsOf(project, held, sites, to, stores) {
     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]]));
-    const passed = arguments_.flatMap((one) => {
+    const checked = checkedTypes(project, arguments_.map((one) => one.value));
+    const passed = arguments_.flatMap((one, index) => {
         const type = typeOf.get(one.value);
         let reached = { classes: new Set(), members: [] };
         if (one.value.kind === SyntaxKind.ThisKeyword) {
@@ -378,7 +457,7 @@ function flowsOf(project, held, sites, to, stores) {
         else if (type !== undefined) {
             reached = reach.reachedFrom(type);
         }
-        for (const stored of stores.ofVariable(one.value) ?? []) {
+        for (const stored of [...(checked[index] ?? []), ...(stores.ofVariable(one.value) ?? [])]) {
             reached = joined(reached, reach.reachedFrom(stored));
         }
         const carries = reached.classes.size > 0 || reached.members.length > 0;

package/dist/src/value-reach.js

@@ -6,6 +6,7 @@
  * it erases them. 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 { isAsExpression, isParenthesizedExpression, isSatisfiesExpression, isTypeAssertion, } from "@typescript/native/ast";
 import { ObjectFlags, SymbolFlags, } from "@typescript/native/sync";
 import { classNames, typesAt } from "./class-members.js";
 import { must } from "./query.js";
@@ -15,6 +16,36 @@ const WRITTEN = ObjectFlags.ObjectLiteral | ObjectFlags.Mapped;
 const LITERAL_SYMBOLS = SymbolFlags.TypeLiteral | SymbolFlags.ObjectLiteral;
 /** The two conversion methods a serializer or a formatter resolves on a value's own shape. */
 const CONVERSION_NAMES = new Set(["toJSON", "toString"]);
+/**
+ * The types each value is checked against by the `satisfies` expressions and type assertions
+ * it is written as, through parentheses, and the innermost operand's own type where there is
+ * one. A `satisfies` expression's static type is its operand's, so an object literal it
+ * checks carries its own members and not the target's, though the literal's properties
+ * write the target's; an assertion to `unknown` or `any` hides the operand's type.
+ */
+export function checkedTypes(project, values) {
+    const nodes = values.map((value) => {
+        const found = [];
+        let at = value;
+        while (isParenthesizedExpression(at) ||
+            isSatisfiesExpression(at) ||
+            isAsExpression(at) ||
+            isTypeAssertion(at)) {
+            if (!isParenthesizedExpression(at)) {
+                found.push(at.type);
+            }
+            at = at.expression;
+        }
+        return found.length === 0 ? found : [...found, at];
+    });
+    const types = typesAt(project, nodes.flat());
+    let next = 0;
+    return nodes.map((one) => {
+        const part = types.slice(next, next + one.length);
+        next += one.length;
+        return part.filter((type) => type !== undefined);
+    });
+}
 /** The global array types, whose element type is what an array value carries. */
 function arrayTargets(project) {
     const queries = project.queries;

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

package/jsr.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/deadset-ts",
-  "version": "7.0.1",
+  "version": "7.1.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.0.1",
+  "version": "7.1.0-dev.2",
   "type": "module",
   "sideEffects": false,
   "description": "Deterministic dead-code analysis for TypeScript, class and type members included",

package/src/conformance-record.ts

@@ -2,9 +2,9 @@
 // Regenerate it with `UPDATE_GOLDEN=1 npx vitest --run src/conformance.corpus.test.ts`.
 export const RECORD = {
   conformance: {
-    corpusVersion: "5.0.0",
+    corpusVersion: "5.1.0",
     result: "pass",
-    digest: "sha256:c46c7d06b6f0c58504c5f311870efefc0b85f18c2c46ba7d7b722081cb370c0c",
+    digest: "sha256:befd5e68f8d68e859b2a0920464a5470a157d5d40a881d9cca28716a4575751d",
   },
   gaps: [],
 } as const;

package/src/erased-stores.ts

@@ -1,11 +1,10 @@
 /**
- * The values the program stores in a slot of a container: a property, an index signature,
- * an array element, and a variable. A serializer walking the container emits the value the
- * slot holds, so it walks each stored value at its own static type, a subtype stored where
- * the slot's type names a supertype, `object`, `unknown` or `any` included. A container is
- * identified by the checker's type identity, so two containers of one type share what
+ * The values the program stores in a property, an index signature, an array element or a
+ * variable. A serializer emits the value a slot holds, so it walks each stored value at its
+ * own static type and each type it is checked against, whatever supertype the slot names.
+ * Containers are identified by the checker's type identity, so two of one type share what
  * either stores. A store into an erased property of a type the analyzed program does not
- * declare hands the value to the code that declares the type.
+ * declare hands the value to the code that declares it.
  */
 
 import {
@@ -31,6 +30,7 @@ import {
 import { SymbolFlags, TypeFlags, type Type } from "@typescript/native/sync";
 import { must } from "./query.ts";
 import type { ProjectView } from "./session.ts";
+import { checkedTypes } from "./value-reach.ts";
 
 /** The types that keep nothing of the value they are given. */
 const ERASED = TypeFlags.Any | TypeFlags.Unknown;
@@ -348,15 +348,27 @@ export function erasedStores<Brand>(project: ProjectView<Brand>): ErasedStores {
       (at, step) => (at === undefined ? undefined : slotOf(at, String(step))),
       type,
     );
-  const valueTypes = queries
-    .typesAt(stores.map((one) => one.value))
-    .map((type, at) => partOf(must(type), stores[at]?.path ?? []));
+  /** The types of what each stored value puts in its slot: its own and those it is checked against. */
+  const storedTypes = (stored: readonly Stored[]): readonly (readonly Type[])[] => {
+    const checked = checkedTypes(
+      project,
+      stored.map((one) => one.value),
+    );
+    return queries
+      .typesAt(stored.map((one) => one.value))
+      .map((type, at) =>
+        [must(type), ...(checked[at] ?? [])].flatMap(
+          (one) => partOf(one, stored[at]?.path ?? []) ?? [],
+        ),
+      );
+  };
+  const valueTypes = storedTypes(stores);
   const inside = new Map<number, Type[]>();
   const outside: OutsideStore[] = [];
   stores.forEach((store, at) => {
     const container = containerOf.get(store);
-    const value = valueTypes[at];
-    if (container === undefined || value === undefined) {
+    const values = valueTypes[at] ?? [];
+    if (container === undefined) {
       return;
     }
     const parts =
@@ -370,9 +382,9 @@ export function erasedStores<Brand>(project: ProjectView<Brand>): ErasedStores {
       const { name } = store;
       const erased = name !== undefined && ((slotOf(part, name)?.flags ?? 0) & ERASED) !== 0;
       if (erased && declaredOutside(part)) {
-        outside.push({ value: store.value, type: value, property: name });
+        outside.push(...values.map((type) => ({ value: store.value, type, property: name })));
       } else {
-        inside.set(part.id, [...(inside.get(part.id) ?? []), value]);
+        inside.set(part.id, [...(inside.get(part.id) ?? []), ...values]);
       }
     }
   });
@@ -386,15 +398,13 @@ export function erasedStores<Brand>(project: ProjectView<Brand>): ErasedStores {
     const handle = symbol?.valueDeclaration ?? symbol?.declarations[0];
     return handle === undefined ? undefined : project.declarationAt(handle)?.node;
   };
-  const assignedTypes = queries
-    .typesAt(assigned.map((one) => one.value))
-    .map((type, at) => partOf(must(type), assigned[at]?.path ?? []));
+  const assignedTypes = storedTypes(assigned);
   const byVariable = new Map<Node, Type[]>();
   assigned.forEach((_one, at) => {
     const declaration = declarationOf(symbols[at]);
-    const type = assignedTypes[at];
-    if (declaration !== undefined && slots.has(declaration) && type !== undefined) {
-      byVariable.set(declaration, [...(byVariable.get(declaration) ?? []), type]);
+    const types = assignedTypes[at] ?? [];
+    if (declaration !== undefined && slots.has(declaration) && types.length > 0) {
+      byVariable.set(declaration, [...(byVariable.get(declaration) ?? []), ...types]);
     }
   });
 

package/src/serialization-contract.ts

@@ -10,6 +10,7 @@
 import {
   isArrayLiteralExpression,
   isArrowFunction,
+  isAsExpression,
   isCallExpression,
   isClassDeclaration,
   isClassExpression,
@@ -18,17 +19,22 @@ import {
   isFunctionExpression,
   isGetAccessorDeclaration,
   isIdentifier,
+  isInterfaceDeclaration,
   isMethodDeclaration,
   isNoSubstitutionTemplateLiteral,
   isNumericLiteral,
   isObjectLiteralExpression,
   isParenthesizedExpression,
   isPropertyAccessExpression,
+  isPropertyDeclaration,
+  isSatisfiesExpression,
   isSetAccessorDeclaration,
   isSpreadElement,
   isStringLiteral,
+  isTypeLiteralNode,
   isVariableDeclaration,
   ModifierFlags,
+  NodeFlags,
   SyntaxKind,
   type CallExpression,
   type Expression,
@@ -58,7 +64,7 @@ import { renderPosition } from "./position.ts";
 import { must } from "./query.ts";
 import type { ProjectView } from "./session.ts";
 import { erasedStores, type ErasedStores } from "./erased-stores.ts";
-import { valueReach, type Reached } from "./value-reach.ts";
+import { checkedTypes, valueReach, type Reached } from "./value-reach.ts";
 
 /** The serializer every run reads, whatever the configuration names. */
 const JSON_STRINGIFY: DeclarationEntry = { shape: "global", global: "JSON.stringify" };
@@ -359,6 +365,73 @@ function handedOn<Brand>(
   });
 }
 
+/**
+ * The symbols of the interfaces and object types code of the analysis implements: those a
+ * class's `implements` and `extends` clauses name, those an object literal is typed as by
+ * a variable or property annotation or a `satisfies` or `as` expression, and every type
+ * each of those extends. Read at the first call, which asks the checker.
+ */
+function implementedOwners<Brand>(
+  project: ProjectView<Brand>,
+  inAnalysis: (path: string) => boolean,
+): () => ReadonlySet<number> {
+  let owners: Set<number> | undefined;
+  return () => {
+    if (owners !== undefined) {
+      return owners;
+    }
+    const found = new Set<number>();
+    const queries = project.queries;
+    const own = project.ownPaths();
+    const files = [
+      ...project.ownSourceFiles(),
+      ...project.program
+        .getSourceFileNames()
+        .filter((name) => !own.has(name) && inAnalysis(name))
+        .flatMap((name) => project.program.getSourceFile(name) ?? []),
+    ];
+    const naming: Node[] = [];
+    const visit = (node: Node): void => {
+      if (isClassDeclaration(node) || isClassExpression(node)) {
+        naming.push(...(node.heritageClauses ?? []).flatMap((clause) => [...clause.types]));
+      } else if (
+        (isVariableDeclaration(node) || isPropertyDeclaration(node)) &&
+        node.type !== undefined &&
+        node.initializer !== undefined &&
+        isObjectLiteralExpression(evaluated(node.initializer))
+      ) {
+        naming.push(node.type);
+      } else if (
+        (isSatisfiesExpression(node) || isAsExpression(node)) &&
+        isObjectLiteralExpression(evaluated(node.expression))
+      ) {
+        naming.push(node.type);
+      }
+      node.forEachChild(visit);
+    };
+    for (const file of files) {
+      file.forEachChild(visit);
+    }
+    const pending = typesAt(project, naming).filter((type) => type !== undefined);
+    const seen = new Set<number>();
+    for (let type = pending.pop(); type !== undefined; type = pending.pop()) {
+      for (const part of must(queries.constituents(type))) {
+        const target = must(queries.targetOf(part));
+        if (!seen.has(target.id)) {
+          seen.add(target.id);
+          const symbol = must(queries.symbolOfType(target));
+          if (symbol !== undefined) {
+            found.add(symbol.id);
+          }
+          pending.push(...must(queries.baseTypes(target)));
+        }
+      }
+    }
+    owners = found;
+    return owners;
+  };
+}
+
 /** The destination of each call's arguments, with the project's forwarding functions settled. */
 interface Destinations {
   /** The function one call invokes and the arguments its parameters bind. */
@@ -372,10 +445,10 @@ interface Destinations {
 /**
  * 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.
+ * `unknown` or `any` where its callee is declared outside the analysis or only ambiently
+ * with no implementation in it; 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<Brand>(
   input: DetectorInput<Brand>,
@@ -407,13 +480,31 @@ function destinations<Brand>(
   for (const parameter of erased.values()) {
     byFunction.set(parameter.fn, [...(byFunction.get(parameter.fn) ?? []), parameter]);
   }
-  const outside = (target: TSSymbol): boolean =>
+  const inAnalysis = (path: string): boolean =>
+    own.has(path) || input.consumers.some((root) => path === root || path.startsWith(`${root}/`));
+  const implemented = implementedOwners(project, inAnalysis);
+  /**
+   * Whether every declaration of a callee is outside the analysis or ambient. An ambient
+   * declaration has no body, so the code that runs is outside the analysis, unless it is a
+   * member of an interface or an object type a class or a typed object literal of the
+   * analysis implements; `settled` false skips that question, which asks the checker.
+   */
+  const outside = (target: TSSymbol, settled: boolean): boolean =>
     target.declarations.length > 0 &&
-    target.declarations.every(
-      (handle) =>
-        !own.has(handle.path) &&
-        !input.consumers.some((root) => handle.path === root || handle.path.startsWith(`${root}/`)),
-    );
+    target.declarations.every((handle) => {
+      if (!inAnalysis(handle.path)) {
+        return true;
+      }
+      const node = project.declarationAt(handle)?.node;
+      if (node === undefined || (node.flags & NodeFlags.Ambient) === 0) {
+        return false;
+      }
+      if (!settled || !(isInterfaceDeclaration(node.parent) || isTypeLiteralNode(node.parent))) {
+        return true;
+      }
+      const owner = must(queries.parentOf(target));
+      return owner === undefined || !implemented().has(owner.id);
+    });
   const invocation = (call: CallExpression): Invocation => {
     const form = forms.get(call);
     const method = form === undefined ? undefined : callees.get(form.method);
@@ -422,7 +513,7 @@ function destinations<Brand>(
     if (
       form !== undefined &&
       method !== undefined &&
-      outside(method) &&
+      outside(method, false) &&
       FUNCTION_INTERFACES.has(must(project.queries.parentOf(method))?.name ?? "")
     ) {
       return form.invocation;
@@ -472,16 +563,15 @@ function destinations<Brand>(
     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)
+    if (outside(target, true)) {
+      return erasedAt(call, argument)
         ? {
             reach: "conversions",
             callee: invocation(call).callee.getText().replace(/\s+/gu, ""),
           }
         : undefined;
     }
-    for (const fn of declared) {
+    for (const fn of chains.declarationsOf(target)) {
       const parameter = (byFunction.get(fn) ?? []).find(
         (one) => one.index === argument || (one.rest && one.index <= argument),
       );
@@ -512,16 +602,12 @@ function destinations<Brand>(
     if (target === undefined) {
       return false;
     }
-    const declared = chains.declarationsOf(target);
-    if (named.some((one) => names(one, target, chains))) {
+    if (named.some((one) => names(one, target, chains)) || outside(target, false)) {
       return true;
     }
-    if (declared.length === 0) {
-      return outside(target);
-    }
-    return declared.some((fn) =>
-      (byFunction.get(fn) ?? []).some((parameter) => forwards.has(keyOf(parameter))),
-    );
+    return chains
+      .declarationsOf(target)
+      .some((fn) => (byFunction.get(fn) ?? []).some((parameter) => forwards.has(keyOf(parameter))));
   };
   return { invocation, at, mayReceive };
 }
@@ -567,7 +653,11 @@ function flowsOf<Brand>(
   const typeOf = new Map<Expression, Type | undefined>(
     asked.map((one, index) => [one.value, types[index]]),
   );
-  const passed = arguments_.flatMap((one) => {
+  const checked = checkedTypes(
+    project,
+    arguments_.map((one) => one.value),
+  );
+  const passed = arguments_.flatMap((one, index) => {
     const type = typeOf.get(one.value);
     let reached: Reached = { classes: new Set<string>(), members: [] };
     if (one.value.kind === SyntaxKind.ThisKeyword) {
@@ -578,7 +668,7 @@ function flowsOf<Brand>(
     } else if (type !== undefined) {
       reached = reach.reachedFrom(type);
     }
-    for (const stored of stores.ofVariable(one.value) ?? []) {
+    for (const stored of [...(checked[index] ?? []), ...(stores.ofVariable(one.value) ?? [])]) {
       reached = joined(reached, reach.reachedFrom(stored));
     }
     const carries = reached.classes.size > 0 || reached.members.length > 0;

package/src/value-reach.ts

@@ -7,6 +7,13 @@
  * interface or class of another program, so an instance held only there is missed.
  */
 
+import {
+  isAsExpression,
+  isParenthesizedExpression,
+  isSatisfiesExpression,
+  isTypeAssertion,
+  type Node,
+} from "@typescript/native/ast";
 import {
   ObjectFlags,
   SymbolFlags,
@@ -44,6 +51,42 @@ interface ValueReach {
 /** The two conversion methods a serializer or a formatter resolves on a value's own shape. */
 const CONVERSION_NAMES: ReadonlySet<string> = new Set(["toJSON", "toString"]);
 
+/**
+ * The types each value is checked against by the `satisfies` expressions and type assertions
+ * it is written as, through parentheses, and the innermost operand's own type where there is
+ * one. A `satisfies` expression's static type is its operand's, so an object literal it
+ * checks carries its own members and not the target's, though the literal's properties
+ * write the target's; an assertion to `unknown` or `any` hides the operand's type.
+ */
+export function checkedTypes<Brand>(
+  project: ProjectView<Brand>,
+  values: readonly Node[],
+): readonly (readonly Type[])[] {
+  const nodes = values.map((value) => {
+    const found: Node[] = [];
+    let at = value;
+    while (
+      isParenthesizedExpression(at) ||
+      isSatisfiesExpression(at) ||
+      isAsExpression(at) ||
+      isTypeAssertion(at)
+    ) {
+      if (!isParenthesizedExpression(at)) {
+        found.push(at.type);
+      }
+      at = at.expression;
+    }
+    return found.length === 0 ? found : [...found, at];
+  });
+  const types = typesAt(project, nodes.flat());
+  let next = 0;
+  return nodes.map((one) => {
+    const part = types.slice(next, next + one.length);
+    next += one.length;
+    return part.filter((type): type is Type => type !== undefined);
+  });
+}
+
 /** The global array types, whose element type is what an array value carries. */
 function arrayTargets<Brand>(project: ProjectView<Brand>): ReadonlySet<number> {
   const queries = project.queries;

package/src/version.ts

@@ -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.0.0";
+export const CONTRACT_VERSION = "7.1.0";