eslint-plugin-no-mistakes 0.98.0 → 0.99.0

package/README.md

@@ -9,6 +9,22 @@ callers, fetches, or selectors behind aliases and dynamic values. See
 npm install --save-dev eslint-plugin-no-mistakes
 ```
 
+For `async-call-disposition` to inspect imported callback implementations when
+the linter does not provide a TypeScript program (including Oxlint's
+`--type-aware` mode), also install `typescript` and
+`@typescript-eslint/parser` in your project:
+
+```sh
+npm install --save-dev typescript @typescript-eslint/parser
+```
+
+These are optional peer dependencies. This fallback requires TypeScript 5 or
+later for Bundler module resolution. With older TypeScript or missing or
+incompatible tooling, calls that rely on this cross-file proof are reported as
+unproven. Same-file proofs and explicitly configured awaiting-consumer
+contracts continue to work. When ESLint provides a typed TypeScript program,
+the rule continues to use that program for its typed proof.
+
 Configure the plugin in a flat config and scope rules with `files` globs. For
 example, this checks test files for skipped or exclusive tests while allowing
 `todo`:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-no-mistakes",
-  "version": "0.98.0",
+  "version": "0.99.0",
   "description": "ESLint and Oxlint rules that keep code static enough for no-mistakes analyzers and coding agents",
   "license": "MIT",
   "repository": {
@@ -25,10 +25,21 @@
     "@vitest/coverage-v8": "^5.0.4",
     "eslint": "^10.12.0",
     "oxlint": "^1.87.0",
+    "typescript": "^6.0.3",
     "vitest": "^5.0.4"
   },
   "peerDependencies": {
-    "eslint": ">=9"
+    "@typescript-eslint/parser": ">=8",
+    "eslint": ">=9",
+    "typescript": ">=4.8.4"
+  },
+  "peerDependenciesMeta": {
+    "@typescript-eslint/parser": {
+      "optional": true
+    },
+    "typescript": {
+      "optional": true
+    }
   },
   "engines": {
     "node": "^20.19.0 || ^22.13.0 || >=24"

package/src/rules/async-call-disposition.js

@@ -5,37 +5,34 @@ const { ruleSuppression } = require("../rule-suppression");
 const {
   collectedPromise,
   isPromiseAllCall,
-  retainedCollection,
   retainedPromise,
 } = require("./async-disposition-bindings");
 const {
   directlyDisposed,
+  mappedArgumentDisposed,
   observedExpression,
   promiseAllDisposed,
   mappedPromise,
 } = require("./async-disposition-expressions");
 const { dispositionOptionsSchema } = require("./async-schema");
 const { createTargetMatcher } = require("./async-targets");
+const { promiseChainFrom } = require("./async-disposition-observers");
 const { createAwaitingConsumers } = require("./async-disposition-consumers");
+const { createPromiseHandoff } = require("./async-promise-handoff");
 
-function isDisposed(node, context, returnsThroughConsumer, seen = new Set()) {
+function isDisposed(node, context, consumers, seen = new Set(), catchProven = true) {
   if (seen.has(node)) return false;
   seen.add(node);
   const observed = observedExpression(node, context);
-  const disposed = (value) => isDisposed(value, context, returnsThroughConsumer, seen);
+  const retainedCatch =
+    catchProven && (observed === node || promiseChainFrom(observed, node, context));
+  const disposed = (value) => isDisposed(value, context, consumers, seen, retainedCatch);
   return (
-    directlyDisposed(node, context, returnsThroughConsumer) ||
-    directlyDisposed(observed, context, returnsThroughConsumer) ||
-    promiseAllDisposed(observed, context, returnsThroughConsumer) ||
+    directlyDisposed(node, context, consumers) ||
+    directlyDisposed(observed, context, consumers, catchProven ? node : null) ||
+    promiseAllDisposed(observed, context, consumers) ||
     retainedPromise(observed, context, disposed) ||
-    mappedPromise(observed, (value) =>
-      retainedCollection(
-        value,
-        context,
-        (aggregate) => isPromiseAllCall(aggregate, context),
-        disposed,
-      ),
-    ) ||
+    mappedPromise(observed, context, consumers, disposed) ||
     collectedPromise(
       observed,
       context,
@@ -63,7 +60,20 @@ module.exports = rule(
   },
   (context) => {
     const matcher = createTargetMatcher(context);
-    const consumers = createAwaitingConsumers(context);
+    const sourceFacts = { typed: new WeakMap(), sources: null, targets: matcher.targets };
+    const { promiseSlotHandoff, promiseTypedTargetCall } = createPromiseHandoff(
+      context,
+      sourceFacts,
+    );
+    const consumers = createAwaitingConsumers(
+      context,
+      (fn, argument) =>
+        mappedArgumentDisposed(fn, argument, context, consumers, (value) =>
+          isDisposed(value, context, consumers),
+        ),
+      sourceFacts,
+      promiseSlotHandoff,
+    );
     const suppressed = ruleSuppression(context, "async-call-disposition");
     if (!matcher.hasTargets) return {};
 
@@ -78,12 +88,10 @@ module.exports = rule(
         ]),
       ),
       CallExpression(node) {
-        if (
-          !matcher.isTargetCall(node) ||
-          suppressed(node) ||
-          isDisposed(node, context, consumers.returnsThroughConsumer)
-        )
-          return;
+        if (suppressed(node)) return;
+        // Disposed calls need no cross-file type lookup, including local/configured JS consumers.
+        if (isDisposed(node, context, consumers)) return;
+        if (!matcher.isTargetCall(node) && !promiseTypedTargetCall(node)) return;
         context.report({
           node,
           messageId: "disposition",

package/src/rules/async-consumer-cache-proof.js

@@ -0,0 +1,146 @@
+"use strict";
+
+const { resolveVariable } = require("./async-target-bindings");
+const { propertiesWritten } = require("./async-disposition-mocks");
+
+function sameKey(first, key, context) {
+  if (key?.type === "Literal")
+    return typeof key.value === "string" && first?.type === "Literal" && first.value === key.value;
+  return (
+    first?.type === "Identifier" &&
+    key?.type === "Identifier" &&
+    resolveVariable(first, context) === resolveVariable(key, context)
+  );
+}
+
+function stableKey(key, fn, param, context) {
+  if (key?.type === "Literal") return typeof key.value === "string";
+  if (key?.type !== "Identifier") return false;
+  const variable = resolveVariable(key, context);
+  if (!variable) return false;
+  return (
+    fn.params.some((item) => item !== param && resolveVariable(item, context) === variable) &&
+    !variable.references.some((ref) => ref.isWrite())
+  );
+}
+
+function builtinMap(node, context) {
+  if (resolveVariable(node, context)?.defs.length || propertiesWritten(node, context)) return false;
+  // Global-holder writes can replace Map without mentioning its bare identifier.
+  const references = context.sourceCode.scopeManager.scopes
+    .flatMap((scope) => scope.references)
+    .filter((ref) => !(ref.isTypeReference && !ref.isValueReference));
+  if (
+    references.some(
+      (ref) =>
+        ["eval", "Function"].includes(ref.identifier.name) &&
+        !resolveVariable(ref.identifier, context)?.defs.length,
+    )
+  )
+    return false;
+  const binding = resolveVariable(node, context);
+  // Do not infer built-in semantics after the constructor/prototype escapes to
+  // reflective APIs or unknown consumers, whose effects are not modeled here.
+  if (
+    references.some(
+      (ref) =>
+        ref.identifier.name === "Map" &&
+        resolveVariable(ref.identifier, context) === binding &&
+        !(
+          ref.identifier.parent.type === "NewExpression" &&
+          ref.identifier.parent.callee === ref.identifier
+        ),
+    )
+  )
+    return false;
+  const holders = ["globalThis", "global", "window", "self"];
+  return !references.some((ref) => {
+    if (!holders.includes(ref.identifier.name)) return false;
+    if (resolveVariable(ref.identifier, context)?.defs.length) return false;
+    if (propertiesWritten(ref.identifier, context)) return true;
+    const member = ref.identifier.parent;
+    if (member.type !== "MemberExpression" || member.object !== ref.identifier) return true;
+    const name = member.computed ? member.property.value : member.property.name;
+    if (["eval", "Function"].includes(name)) return true;
+    if (name !== "Map" && typeof name === "string") return false;
+    return member.parent.type !== "NewExpression" || member.parent.callee !== member;
+  });
+}
+
+function mapCall(node, method, cache, key, context, count) {
+  const member = node?.callee;
+  const first = node?.arguments?.[0];
+  return (
+    node?.type === "CallExpression" &&
+    !node.optional &&
+    node.arguments.length === count &&
+    member?.type === "MemberExpression" &&
+    !member.computed &&
+    !member.optional &&
+    member.property.name === method &&
+    member.object.type === "Identifier" &&
+    resolveVariable(member.object, context) === cache &&
+    sameKey(first, key, context)
+  );
+}
+
+// This is deliberately a complete body grammar: any intervening effect, alias,
+// escape, overwrite, early return, or exception may strand the stored promise.
+function cachedBodyAwaited(fn, param, context) {
+  if (!fn.async || fn.generator || fn.params.some((item) => item.type !== "Identifier"))
+    return false;
+  const body = fn.body?.type === "BlockStatement" ? fn.body.body : [];
+  if (body.length !== 3) return false;
+  const [declaration, guard, returned] = body;
+  const entry = declaration.declarations?.[0];
+  const init = entry?.init;
+  if (
+    declaration.type !== "VariableDeclaration" ||
+    declaration.kind !== "const" ||
+    declaration.declarations.length !== 1 ||
+    entry.id.type !== "Identifier" ||
+    init?.type !== "NewExpression" ||
+    init.callee.type !== "Identifier" ||
+    init.callee.name !== "Map" ||
+    init.arguments.length !== 0 ||
+    !builtinMap(init.callee, context)
+  )
+    return false;
+  const cache = resolveVariable(entry.id, context);
+  const test = guard.test;
+  const inserted =
+    guard.consequent?.type === "BlockStatement"
+      ? guard.consequent.body.length === 1 && guard.consequent.body[0]
+      : guard.consequent;
+  const set = inserted?.expression;
+  const key = set?.arguments?.[0];
+  if (
+    !stableKey(key, fn, param, context) ||
+    guard.type !== "IfStatement" ||
+    guard.alternate ||
+    test?.type !== "UnaryExpression" ||
+    test.operator !== "!" ||
+    inserted?.type !== "ExpressionStatement" ||
+    !mapCall(test.argument, "has", cache, key, context, 1) ||
+    !mapCall(set, "set", cache, key, context, 2) ||
+    returned.type !== "ReturnStatement" ||
+    returned.argument?.type !== "AwaitExpression" ||
+    !mapCall(returned.argument.argument, "get", cache, key, context, 1)
+  )
+    return false;
+  const invocation = set.arguments[1];
+  const parameter = resolveVariable(param, context);
+  const reads = parameter?.references.filter((ref) => !ref.init) || [];
+  return (
+    invocation?.type === "CallExpression" &&
+    !invocation.optional &&
+    invocation.arguments.length === 0 &&
+    invocation.callee.type === "Identifier" &&
+    resolveVariable(invocation.callee, context) === parameter &&
+    reads.length === 1 &&
+    !reads[0].isWrite() &&
+    reads[0].identifier === invocation.callee
+  );
+}
+
+module.exports = { cachedBodyAwaited };

package/src/rules/async-consumer-copy-spellings.js

@@ -0,0 +1,82 @@
+"use strict";
+
+const { unwrapTransparentParent } = require("./async-ast");
+const { followConst } = require("./async-consumer-property-carrier");
+
+const copyOperators = new Set(["??", "||"]);
+
+// Only the left operand is the supplied callback. The right-hand default is not.
+function unwrapCopyLogical(node) {
+  const selected = unwrapTransparentParent(node);
+  const parent = selected.parent;
+  if (
+    parent?.type === "LogicalExpression" &&
+    copyOperators.has(parent.operator) &&
+    parent.left === selected
+  )
+    return unwrapTransparentParent(parent);
+  return selected;
+}
+
+function logicalCopyLeft(value) {
+  if (value?.type !== "LogicalExpression" || !copyOperators.has(value.operator)) return null;
+  return value.left;
+}
+
+function plainProperty(entry) {
+  return entry.type === "Property" && !entry.computed && !entry.method && entry.kind === "init";
+}
+
+// A key before the spread is overwritten by the source object. A key after it
+// replaces the copied callback, so that order stays unproven.
+function propertyKey(key) {
+  return key.type === "Identifier" ? key.name : key.value;
+}
+
+function patternBinding(value) {
+  const node = value?.type === "AssignmentPattern" ? value.left : value;
+  return node?.type === "Identifier" ? node : null;
+}
+
+function spreadPreserves(object, spread, property) {
+  if (object?.type !== "ObjectExpression") return false;
+  const index = object.properties.indexOf(spread);
+  const keyOf = (entry) => propertyKey(entry.key);
+  return (
+    object.properties.slice(0, index).every(plainProperty) &&
+    object.properties
+      .slice(index + 1)
+      .every((entry) => plainProperty(entry) && keyOf(entry) !== property)
+  );
+}
+
+// Shorthand `const { name }` and `const { name = defaultImpl }` only. A rename,
+// rest, or computed key can hide the callback, so those patterns stay unproven.
+function destructuredBinding(declarator, property) {
+  if (declarator.parent.kind !== "const") return false;
+  let binding = null;
+  for (const entry of declarator.id.properties) {
+    if (entry.type !== "Property" || entry.computed || entry.kind !== "init") return false;
+    const name = propertyKey(entry.key);
+    const id = patternBinding(entry.value);
+    if (id?.name !== name) return false;
+    if (name === property) binding = id;
+  }
+  return binding ?? "safe";
+}
+
+// "safe" is a read of some other field. false is an unproven pattern.
+function destructureMode(value, property, context, shape, api, seen) {
+  const declarator = value.parent;
+  if (
+    declarator?.type !== "VariableDeclarator" ||
+    declarator.init !== value ||
+    declarator.id.type !== "ObjectPattern"
+  )
+    return null;
+  const binding = destructuredBinding(declarator, property);
+  if (binding === "safe" || binding === false) return binding;
+  return followConst(binding, null, context, shape, api, seen);
+}
+
+module.exports = { destructureMode, logicalCopyLeft, spreadPreserves, unwrapCopyLogical };

package/src/rules/async-consumer-imported-proof.js

@@ -0,0 +1,96 @@
+"use strict";
+const { createImportedSources } = require("./async-source-store");
+const { unwrapExpression } = require("./async-ast");
+const { resolveVariable } = require("./async-target-bindings");
+const { propertiesWritten } = require("./async-disposition-mocks");
+const { localFunction } = require("./async-consumer-local-proof");
+
+function exportedFunction(filename, name, sources, seen = new Set()) {
+  if (seen.size >= 32 || seen.has(filename)) return null;
+  seen.add(filename);
+  const source = sources.load(filename);
+  if (!source) return null;
+  const matches = [];
+  for (const statement of source.ast.body) {
+    if (statement.type !== "ExportNamedDeclaration" || statement.exportKind === "type") continue;
+    const declaration = statement.declaration;
+    const ids =
+      declaration?.type === "FunctionDeclaration"
+        ? [declaration.id]
+        : declaration?.type === "VariableDeclaration"
+          ? declaration.declarations.map((item) => item.id)
+          : [];
+    for (const id of ids) if (id?.name === name) matches.push({ local: id });
+    for (const item of statement.specifiers)
+      if (item.exportKind !== "type" && (item.exported.name ?? item.exported.value) === name)
+        matches.push({ local: item.local, source: statement.source });
+  }
+  if (matches.length !== 1) return null;
+  const { local, source: reexport } = matches[0];
+  if (reexport) {
+    const target = sources.resolve(reexport.value, filename);
+    return target ? exportedFunction(target, local.name, sources, seen) : null;
+  }
+  const fn = localFunction(local, source.context);
+  const variable = resolveVariable(local, source.context);
+  // Exporting preserves live binding identity; any other non-call use may mutate it.
+  if (
+    !fn ||
+    variable.references.some((ref) => {
+      if (ref.init) return false;
+      const parent = ref.identifier.parent;
+      return (
+        parent.type !== "ExportSpecifier" &&
+        !(parent.type === "CallExpression" && parent.callee === ref.identifier)
+      );
+    })
+  )
+    return null;
+  return { fn, context: source.context };
+}
+
+function importedAwaited(call, index, context, state, property, proveBody) {
+  const program = context.sourceCode.parserServices?.program;
+  if (program?.getCompilerOptions().noResolve) return false;
+  if (program && property === null)
+    return require("./async-consumer-typed-proof").importedAwaited(
+      call,
+      index,
+      context,
+      state.typed,
+    );
+
+  const resolved = importedFunction(unwrapExpression(call.callee), context, state);
+  if (!resolved) return false;
+  const mode = proveBody(resolved.fn, index, resolved.context, property);
+  return mode?.returned ? { ...mode, async: Boolean(resolved.fn.async) } : mode;
+}
+
+function importedFunction(callee, context, state) {
+  const binding = resolveVariable(callee, context);
+  if (
+    binding?.defs.length !== 1 ||
+    binding.defs[0].type !== "ImportBinding" ||
+    binding.references.some((ref) => ref.isWrite()) ||
+    propertiesWritten(callee, context, new Set(), null, true)
+  )
+    return false;
+  const def = binding.defs[0];
+  if (
+    def.node.type !== "ImportSpecifier" ||
+    def.parent.importKind === "type" ||
+    def.node.importKind === "type"
+  )
+    return false;
+  // Cache unavailable peers too; a new lint context retries without persisting state.
+  if (state.sources === null) state.sources = createImportedSources(context) || false;
+  const sources = state.sources;
+  if (!sources) return false;
+  const filename = context.filename;
+  const target = sources.resolve(def.parent.source.value, filename);
+  const resolved =
+    target && exportedFunction(target, def.node.imported.name ?? def.node.imported.value, sources);
+  return resolved;
+}
+
+module.exports = { importedAwaited, importedFunction, createImportedSources };

package/src/rules/async-consumer-local-proof.js

@@ -0,0 +1,86 @@
+"use strict";
+const { unwrapExpression, unwrapTransparentParent } = require("./async-ast");
+const { resolveVariable, stableConstInitializer } = require("./async-target-bindings");
+const { cachedBodyAwaited } = require("./async-consumer-cache-proof");
+const { propertiesWritten } = require("./async-disposition-mocks");
+
+function localFunction(id, context, seen = new Set()) {
+  if (id?.type !== "Identifier") return null;
+  const variable = resolveVariable(id, context);
+  if (
+    !variable ||
+    seen.has(variable) ||
+    variable.defs.length !== 1 ||
+    variable.references.some((ref) => ref.isWrite() && !ref.init) ||
+    propertiesWritten(id, context, new Set(), null, true)
+  )
+    return null;
+  const def = variable.defs[0];
+  if (def.type === "FunctionName" && def.node.type === "FunctionDeclaration") return def.node;
+  const init = unwrapExpression(stableConstInitializer(id, context, seen));
+  return ["ArrowFunctionExpression", "FunctionExpression"].includes(init?.type)
+    ? init
+    : localFunction(init, context, seen);
+}
+
+function localBodySafe(fn, context) {
+  let safe = true;
+  function visit(node) {
+    if (!node?.type || !safe) return;
+    if (
+      node.type === "Identifier" &&
+      (node.name === "arguments" ||
+        (node.name === "eval" &&
+          node.parent?.type === "CallExpression" &&
+          node.parent.callee === node))
+    )
+      safe = false;
+    for (const key of context.sourceCode.visitorKeys[node.type] || []) {
+      const child = node[key];
+      if (Array.isArray(child)) child.forEach(visit);
+      else visit(child);
+    }
+  }
+  fn.params.forEach(visit);
+  visit(fn.body);
+  return safe;
+}
+
+function bodyAwaited(fn, index, context) {
+  const param = fn?.params[index];
+  if (
+    !param ||
+    param.type !== "Identifier" ||
+    !localBodySafe(fn, context) ||
+    fn.params.some((p) => p.type === "RestElement")
+  )
+    return false;
+  if (cachedBodyAwaited(fn, param, context)) return true;
+  const variable = resolveVariable(param, context);
+  const reads = variable?.references.filter((ref) => !ref.init) || [];
+  return (
+    reads.length > 0 &&
+    reads.every((ref) => {
+      if (ref.isWrite()) return false;
+      for (let owner = ref.identifier.parent; owner && owner !== fn; owner = owner.parent)
+        if (
+          ["ArrowFunctionExpression", "FunctionExpression", "FunctionDeclaration"].includes(
+            owner.type,
+          )
+        )
+          return false;
+      const value = unwrapTransparentParent(ref.identifier);
+      const invocation = value.parent;
+      if (
+        invocation?.type !== "CallExpression" ||
+        invocation.callee !== value ||
+        invocation.optional
+      )
+        return false;
+      const result = unwrapTransparentParent(invocation);
+      return result.parent?.type === "AwaitExpression" && result.parent.argument === result;
+    })
+  );
+}
+
+module.exports = { localFunction, localBodySafe, bodyAwaited };

package/src/rules/async-consumer-proof.js

@@ -0,0 +1,113 @@
+"use strict";
+
+const { unwrapExpression, unwrapTransparentParent } = require("./async-ast");
+const { resolveVariable } = require("./async-target-bindings");
+const { importedAwaited } = require("./async-consumer-imported-proof");
+const { localFunction, bodyAwaited } = require("./async-consumer-local-proof");
+const { adoptReturned } = require("./async-consumer-property-carrier");
+const {
+  forwarded,
+  lexicalCallback,
+  propertyBodyAwaited,
+  propertyWritten,
+} = require("./async-consumer-property-proof");
+const { createReceiverProof } = require("./async-consumer-receivers");
+
+function createConsumerProof(context, sourceFacts) {
+  const results = new WeakMap();
+  const receiverShape = (sourceFacts.receiverShape ||= createReceiverProof(sourceFacts));
+  const noParameter = Object.create(null);
+  let depth = 0;
+  return function provenAwaitingConsumer(argument) {
+    let value = unwrapTransparentParent(argument);
+    let property = null;
+    if (value.parent?.type === "Property") {
+      const entry = value.parent;
+      const object = entry.parent;
+      if (
+        entry.value !== value ||
+        object.type !== "ObjectExpression" ||
+        object.properties.some(
+          (item) =>
+            item.type !== "Property" || item.computed || item.method || item.kind !== "init",
+        )
+      )
+        return false;
+      const names = object.properties.map((item) => item.key.name ?? item.key.value);
+      if (new Set(names).size !== names.length) return false;
+      property = entry.key.name ?? entry.key.value;
+      value = unwrapTransparentParent(object);
+    }
+    const call = value.parent;
+    const mode = proveCall(call, call?.arguments?.indexOf(value), property, context);
+    // A returned dependencies object still has to be awaited by this caller.
+    if (mode?.returned) {
+      return (
+        adoptReturned(call, mode, property, context, {
+          proveCall,
+          receiverShape,
+          propertyWritten,
+          forward: forwarded,
+          lexicalCallback,
+          variable: noParameter,
+        }) === true
+      );
+    }
+    return mode === true;
+  };
+
+  function withAsync(fn, mode) {
+    return mode?.returned ? { ...mode, async: Boolean(fn.async) } : mode;
+  }
+
+  function proveBody(fn, index, owner, property, shape) {
+    return property === null
+      ? bodyAwaited(fn, index, owner)
+      : propertyBodyAwaited(fn, index, owner, property, proveCall, receiverShape, shape);
+  }
+  function proveCall(call, index, property, owner, shape) {
+    if (
+      call?.type !== "CallExpression" ||
+      call.optional ||
+      call.callee.type !== "Identifier" ||
+      call.arguments.some((arg) => arg.type === "SpreadElement") ||
+      index < 0 ||
+      depth >= 32
+    )
+      return false;
+    if (!shape) {
+      const argument = unwrapExpression(call.arguments[index]);
+      shape = argument.type === "ObjectExpression" ? receiverShape(argument, owner) : new Map();
+    }
+    // A custom prototype can supply an otherwise absent optional method.
+    if (shape.has("__proto__")) return false;
+    const binding = resolveVariable(call.callee, owner);
+    if (!binding) return false;
+    if (!results.has(binding)) results.set(binding, new Map());
+    const slots = results.get(binding);
+    const key = JSON.stringify([index, property, [...shape].sort()]);
+    if (!slots.has(key)) {
+      // Mark before recursion: cyclic forwarding cannot establish a contract.
+      slots.set(key, false);
+      depth++;
+      const localFn = localFunction(unwrapExpression(call.callee), owner);
+      let mode = false;
+      if (localFn) mode = withAsync(localFn, proveBody(localFn, index, owner, property, shape));
+      if (!mode) {
+        mode = importedAwaited(
+          call,
+          index,
+          owner,
+          sourceFacts,
+          property,
+          (fn, index, owner, property) => proveBody(fn, index, owner, property, shape),
+        );
+      }
+      slots.set(key, mode || false);
+      depth--;
+    }
+    return slots.get(key);
+  }
+}
+
+module.exports = { createConsumerProof };