@filipebraida/adonis-function-points 0.10.0 → 0.11.0

package/CHANGELOG.md

@@ -6,6 +6,59 @@ release moves the number for unchanged code, the rule set version moves with it
 otherwise the difference would measure the tool's change rather than the work, and
 that difference becomes an invoice.
 
+## 0.11.0
+
+Rule set unchanged (`afp@1.9.0`); no number moves. What changes is what the **coverage**
+means: it measures what of the application the walk could not follow, and nothing else.
+
+### Fixed
+
+- **A call into a package is outside the boundary — noted, not an unresolved call.** An
+  authorisation service from a package injected into the application's façade, a variant of an
+  attachment whose column type is a package's, a content collection built by a package factory,
+  a mailer method inherited from a package base: none is code the analysis should follow, so none
+  is a gap it failed to follow. What a package does with its own tables is technical (§4); what it
+  hands back is a value. Read structurally — the injected property's declared type, the model
+  property's declared type, the exported const's factory, the class's base, each resolving to a
+  specifier the application does not — never by package name. One note per site in
+  `inventory.notes`, naming the transactions that reach it; behind the same noise gate as an
+  unresolved call, so what was silent stays silent. A receiver typed by the application stays a
+  gap. Fixture `fronteira_pacote` (23 FP before and after; four unresolved calls become three
+  notes and the one gap of the application).
+- **A `Map` or `Set` that arrives through the constructor, one level down a named type**
+  (`this.extras?.panel?.get(id)` with `extras?: Extras`, `Extras = { panel: Map<…> }`) is noise,
+  as `private names = new Map()` already was. Fixture `patterns/native_receivers`.
+- **A command's `@flags.*` / `@args.*` property is a string, a number or a boolean**: a method on
+  it (`this.name.trim()`) is the language's, not a gap.
+- **A method of an interface says so**: "interface method: the implementation is injected at
+  runtime and cannot be followed statically" — a gap, with the right words, where "probably
+  inherited from a package class" pointed the reader at the wrong place.
+- **A local mixin factory whose returned class declares no `@column`** adds behaviour, not
+  attributes: a note. One that declares a column stays a gap — reading its columns off the
+  returned class is a rule for a release that moves numbers.
+
+On the three validated applications, unresolved calls go from 13 / 8 / 12 to **0 / 0 / 1** —
+the one an interface method, which is a gap of the application — with no point moved.
+
+### Documented
+
+- counting-decisions §4 gains "A call into a package is outside the boundary".
+
+## 0.10.1
+
+Rule set unchanged (`afp@1.9.0`); no number moves.
+
+### Fixed
+
+- **A base class or a mixin from a package is a fact about the declaration, not an
+  unresolved call.** `compose(Base, Auditable)`, `withAuthFinder(…)` inline or through a local
+  const (which came out as "base class not found in the application" — code that is in the
+  application, built by a package's factory). Nobody follows a mixin, and in function points
+  it is nothing: what it adds is technical, never a user-recognisable attribute; the model's
+  own columns and the schema decide. Listed as a **note** by `fp:inventory` and in
+  `inventory.notes`, kept out of the coverage number. A base of the application that was not
+  found stays an unresolved call.
+
 ## 0.10.0
 
 **Rule set `afp@1.9.0`.** One rule and two report fixes, from a team's third review of their

package/build/commands/main.js

@@ -14,27 +14,27 @@
 const commands = [
 	{
 		commandName: "fp:inventory",
-		importer: () => import("../fp_inventory-BJlIoetL.js")
+		importer: () => import("../fp_inventory-D3_6QCD2.js")
 	},
 	{
 		commandName: "fp:metrics",
-		importer: () => import("../fp_metrics-BDKaNL0B.js")
+		importer: () => import("../fp_metrics-lnnhnVaw.js")
 	},
 	{
 		commandName: "fp:count",
-		importer: () => import("../fp_count-B5hxDyGJ.js")
+		importer: () => import("../fp_count-mDQgQeEq.js")
 	},
 	{
 		commandName: "fp:explain",
-		importer: () => import("../fp_explain-C4X_-Rp7.js")
+		importer: () => import("../fp_explain-CQESTS5W.js")
 	},
 	{
 		commandName: "fp:diff",
-		importer: () => import("../fp_diff-7S8NcKIY.js")
+		importer: () => import("../fp_diff-BnWi2Fx8.js")
 	},
 	{
 		commandName: "fp:calibrate",
-		importer: () => import("../fp_calibrate-DUPUXVaJ.js")
+		importer: () => import("../fp_calibrate-U5xdt5Qe.js")
 	}
 ];
 let cache = null;

package/build/{fp_calibrate-DUPUXVaJ.js → fp_calibrate-U5xdt5Qe.js}

@@ -1,4 +1,4 @@
-import { s as printResult, t as runCalibrate } from "./runners-b1tgLA1B.js";
+import { s as printResult, t as runCalibrate } from "./runners-CzzlX7h-.js";
 import { n as printerFor, t as __decorate } from "./decorate-D6enDn9D.js";
 import { BaseCommand, args } from "@adonisjs/core/ace";
 //#region commands/fp_calibrate.ts

package/build/{fp_count-B5hxDyGJ.js → fp_count-mDQgQeEq.js}

@@ -1,4 +1,4 @@
-import { n as runCount, s as printResult } from "./runners-b1tgLA1B.js";
+import { n as runCount, s as printResult } from "./runners-CzzlX7h-.js";
 import { n as printerFor, t as __decorate } from "./decorate-D6enDn9D.js";
 import { BaseCommand, flags } from "@adonisjs/core/ace";
 //#region commands/fp_count.ts

package/build/{fp_diff-7S8NcKIY.js → fp_diff-BnWi2Fx8.js}

@@ -1,4 +1,4 @@
-import { r as runDiff, s as printResult } from "./runners-b1tgLA1B.js";
+import { r as runDiff, s as printResult } from "./runners-CzzlX7h-.js";
 import { n as printerFor, t as __decorate } from "./decorate-D6enDn9D.js";
 import { BaseCommand, args } from "@adonisjs/core/ace";
 //#region commands/fp_diff.ts

package/build/{fp_explain-C4X_-Rp7.js → fp_explain-CQESTS5W.js}

@@ -1,4 +1,4 @@
-import { i as runExplain, s as printResult } from "./runners-b1tgLA1B.js";
+import { i as runExplain, s as printResult } from "./runners-CzzlX7h-.js";
 import { n as printerFor, t as __decorate } from "./decorate-D6enDn9D.js";
 import { BaseCommand, args } from "@adonisjs/core/ace";
 //#region commands/fp_explain.ts

package/build/{fp_inventory-BJlIoetL.js → fp_inventory-D3_6QCD2.js}

@@ -1,4 +1,4 @@
-import { a as runInventory, s as printResult } from "./runners-b1tgLA1B.js";
+import { a as runInventory, s as printResult } from "./runners-CzzlX7h-.js";
 import { n as printerFor, t as __decorate } from "./decorate-D6enDn9D.js";
 import { BaseCommand, flags } from "@adonisjs/core/ace";
 //#region commands/fp_inventory.ts

package/build/{fp_metrics-BDKaNL0B.js → fp_metrics-lnnhnVaw.js}

@@ -1,4 +1,4 @@
-import { o as runMetrics, s as printResult } from "./runners-b1tgLA1B.js";
+import { o as runMetrics, s as printResult } from "./runners-CzzlX7h-.js";
 import { n as printerFor, t as __decorate } from "./decorate-D6enDn9D.js";
 import { BaseCommand, flags } from "@adonisjs/core/ace";
 //#region commands/fp_metrics.ts

package/build/index.js

@@ -1,6 +1,6 @@
 import { configure } from "./configure.js";
 import { a as AEP_FACTORS, c as IncomparableSourcesError, f as defineConfig, i as measureStructure, l as SISP_FACTORS, n as parseSamples, o as FACTOR_PRESETS, r as measureConformance, s as IncomparableRulesetsError, t as calibrate, u as diffCounts } from "./calibration-DVIf8hcE.js";
 import "./src/types.js";
-import { n as ignoreCalls, t as BUILTIN_CALL_RESOLVERS } from "./resolvers-CneCj3sT.js";
-import { a as DEFAULT_TECHNICAL_PATTERNS, i as RULESET_VERSION, n as analyze, r as RULESET, t as CoverageTooLowError } from "./pipeline-4sZBYGKU.js";
+import { n as ignoreCalls, t as BUILTIN_CALL_RESOLVERS } from "./resolvers-Bz1F-Tgf.js";
+import { a as DEFAULT_TECHNICAL_PATTERNS, i as RULESET_VERSION, n as analyze, r as RULESET, t as CoverageTooLowError } from "./pipeline-CdDJRsLM.js";
 export { AEP_FACTORS, BUILTIN_CALL_RESOLVERS, CoverageTooLowError, DEFAULT_TECHNICAL_PATTERNS, FACTOR_PRESETS, IncomparableRulesetsError, IncomparableSourcesError, RULESET, RULESET_VERSION, SISP_FACTORS, analyze, calibrate, configure, defineConfig, diffCounts, ignoreCalls, measureConformance, measureStructure, parseSamples };

package/build/{pipeline-4sZBYGKU.js → pipeline-CdDJRsLM.js}

@@ -1,4 +1,4 @@
-import { _ as relativeTo, a as chainShapeOf, c as unwrap$1, d as collectEventBindings, f as detectAccess, g as isSeeder, h as isApplicationCode, i as resolveCall, l as DISPATCH_METHODS, m as rootSymbolOf, o as mappedLiteralOf, p as hooksFiredBy, r as isTechnicalWrite, s as outputFieldsIn, t as BUILTIN_CALL_RESOLVERS, u as EXECUTION_METHODS, v as samePath, y as toPosix } from "./resolvers-CneCj3sT.js";
+import { _ as isSeeder, a as chainShapeOf, b as toPosix, c as transformerResourceOf, d as EXECUTION_METHODS, f as collectEventBindings, g as isApplicationCode, h as rootSymbolOf, i as resolveCall, l as unwrap$1, m as hooksFiredBy, o as mappedLiteralOf, p as detectAccess, r as isTechnicalWrite, s as outputFieldsIn, t as BUILTIN_CALL_RESOLVERS, u as DISPATCH_METHODS, v as relativeTo, y as samePath } from "./resolvers-Bz1F-Tgf.js";
 import fs from "node:fs/promises";
 import path, { dirname, join, resolve } from "node:path";
 import { Node, Project, SyntaxKind } from "ts-morph";
@@ -384,6 +384,7 @@ async function collectDataStores(app) {
 	if (app.generated.dataSchema) project.addSourceFileAtPathIfExists(app.generated.dataSchema);
 	const candidates = [];
 	const unresolved = [];
+	const notes = [];
 	/**
 	* Classes appearing as an ANCESTOR of some model.
 	*
@@ -395,7 +396,7 @@ async function collectDataStores(app) {
 	for (const file of project.getSourceFiles()) {
 		if (samePath(file.getFilePath(), app.generated.dataSchema)) continue;
 		for (const cls of file.getClasses()) {
-			const described = describeStore(cls, app, project, unresolved);
+			const described = describeStore(cls, app, project, unresolved, notes);
 			if (!described) continue;
 			candidates.push(described.store);
 			for (const ancestor of described.ancestors) ancestors.add(ancestor);
@@ -403,18 +404,20 @@ async function collectDataStores(app) {
 	}
 	return {
 		stores: candidates.filter((store) => !ancestors.has(store.id)).sort(byName),
-		unresolved
+		unresolved,
+		notes
 	};
 }
 /** stable identity of a class, to separate a base from a store */
 const classKey = (cls) => `${cls.getSourceFile().getFilePath()}#${cls.getName()}`;
 const byName = (a, b) => a.name.localeCompare(b.name);
-function describeStore(cls, app, project, unresolved) {
+function describeStore(cls, app, project, unresolved, notes) {
 	const name = cls.getName();
 	if (!name) return null;
 	const chain = walkChain(cls, app, project);
 	if (!chain.reachesLucid) return null;
 	unresolved.push(...chain.unresolved);
+	notes.push(...chain.notes);
 	const file = cls.getSourceFile().getFilePath();
 	return {
 		store: {
@@ -455,6 +458,7 @@ function walkChain(start, app, project) {
 	* the coverage report.
 	*/
 	const unresolved = [];
+	const notes = [];
 	let reachesLucid = false;
 	let columnSource = "ast";
 	const visit = (cls) => {
@@ -475,6 +479,31 @@ function walkChain(start, app, project) {
 				visit(resolved);
 				continue;
 			}
+			/**
+			* A base or a mixin from a PACKAGE — `compose(Base, Auditable)` imported from
+			* outside, `withAuthFinder(…)` inline or through a local const — is a fact about
+			* the declaration, not a gap in the walk: nobody follows a mixin. What it adds is
+			* technical (a hashed password, audit stamps) and never a user-recognisable
+			* attribute (§7.2); the model's own columns and the schema decide. Noted, and kept
+			* out of the coverage number. A base of the application that was not found stays
+			* a gap.
+			*/
+			/**
+			* A mixin factory OF THE APPLICATION whose returned class declares no `@column`
+			* adds methods, not attributes: a fact, not a gap. One that declares columns
+			* stays a gap — reading them off the returned class is a rule for a release
+			* that moves numbers (plan 0.11 §E).
+			*/
+			const columnless = localFactoryWithoutColumns(parent, cls.getSourceFile(), app, project);
+			if (columnless) {
+				notes.push(`${cls.getName() ?? "?"}: local mixin factory ${columnless} declares no column — adds behaviour, not attributes`);
+				continue;
+			}
+			const packaged = packageOriginOf(parent, cls.getSourceFile(), app);
+			if (packaged) {
+				notes.push(`${cls.getName() ?? "?"}: base or mixin from ${packaged.specifier} (${packaged.expression}) — technical, adds no user-recognisable attribute; the model's own columns and the schema decide`);
+				continue;
+			}
 			unresolved.push({
 				file: cls.getSourceFile().getFilePath(),
 				line: parent.getStartLineNumber(),
@@ -489,8 +518,75 @@ function walkChain(start, app, project) {
 		classes,
 		attributes: [...attributes.values()],
 		columnSource,
-		unresolved
+		unresolved,
+		notes
+	};
+}
+/**
+* `compose(Base, withTracking())` where `withTracking` is a function of the application
+* whose body returns a class expression: the factory's name when that class declares no
+* `@column`, `null` when it declares one (or when the factory cannot be read).
+*/
+function localFactoryWithoutColumns(parent, file, app, project) {
+	if (!Node.isCallExpression(parent)) return null;
+	const callee = parent.getExpression();
+	if (!Node.isIdentifier(callee)) return null;
+	const name = callee.getText();
+	let declared = file.getFunction(name);
+	if (!declared) {
+		const origin = originOf$1(name, file);
+		const target = origin ? app.resolveSpecifier(origin.specifier) : null;
+		declared = (target ? project.getSourceFile(target) ?? project.addSourceFileAtPathIfExists(target) : null)?.getFunction(origin?.exportedName === "default" ? name : origin?.exportedName ?? name) ?? void 0;
+	}
+	if (!declared) return null;
+	return [...declared.getDescendantsOfKind(SyntaxKind.ClassExpression), ...declared.getDescendantsOfKind(SyntaxKind.ClassDeclaration)].some((c) => c.getProperties().some((p) => p.getDecorators().some((d) => /^column\b/.test(d.getFullName())))) ? null : `${name}()`;
+}
+/**
+* Where a base or a mixin comes from, when it comes from a package: the class
+* imported from a specifier the application does not resolve, a factory call whose
+* callee is, or a local const initialised by such a call.
+*/
+function packageOriginOf(parent, file, app) {
+	const fromPackage = (local) => {
+		const origin = originOf$1(local, file);
+		return origin && !app.resolveSpecifier(origin.specifier) ? origin.specifier : null;
+	};
+	const rootOf = (node) => {
+		let current = node;
+		for (let depth = 0; depth < 20; depth++) {
+			if (Node.isCallExpression(current) || Node.isPropertyAccessExpression(current)) {
+				current = current.getExpression();
+				continue;
+			}
+			return Node.isIdentifier(current) ? current.getText() : null;
+		}
+		return null;
+	};
+	const brief = (text) => text.replace(/\s+/g, " ").slice(0, 60);
+	if (Node.isCallExpression(parent)) {
+		const root = rootOf(parent);
+		const specifier = root ? fromPackage(root) : null;
+		return specifier ? {
+			specifier,
+			expression: brief(parent.getText())
+		} : null;
+	}
+	if (!Node.isIdentifier(parent)) return null;
+	const direct = fromPackage(parent.getText());
+	if (direct) return {
+		specifier: direct,
+		expression: parent.getText()
 	};
+	const initializer = file.getVariableDeclaration(parent.getText())?.getInitializer();
+	if (initializer && Node.isCallExpression(initializer)) {
+		const root = rootOf(initializer);
+		const specifier = root ? fromPackage(root) : null;
+		if (specifier) return {
+			specifier,
+			expression: `${parent.getText()} = ${brief(initializer.getText())}`
+		};
+	}
+	return null;
 }
 /**
 * Why the base class could not be resolved.
@@ -1193,8 +1289,7 @@ const FRAMEWORK_SERVICES = new Set([
 	"app",
 	"prompt"
 ]);
-/** Is this call one that cannot reach a data store? */
-function isNoise(call, owner) {
+function isNoise(call, owner, membersOf) {
 	const expression = call.getExpression();
 	if (!Node.isPropertyAccessExpression(expression)) return false;
 	if (NEVER_DATA_METHODS.has(expression.getName())) return true;
@@ -1207,7 +1302,7 @@ function isNoise(call, owner) {
 	* than a bare identifier.
 	*/
 	if (Node.isPropertyAccessExpression(receiver) && Node.isThisExpression(receiver.getExpression()) && FRAMEWORK_SERVICES.has(receiver.getName())) return true;
-	return isNativeReceiver(receiver, owner);
+	return isNativeReceiver(receiver, owner, membersOf);
 }
 /**
 * Iteration over a list, checked BEFORE the resolvers run.
@@ -1233,14 +1328,40 @@ function isIteration(method, call) {
 	return first !== void 0 && (Node.isArrowFunction(first) || Node.isFunctionExpression(first));
 }
 /** Does the receiver resolve to a built-in, by its declaration? */
-function isNativeReceiver(receiver, owner) {
+function isNativeReceiver(receiver, owner, membersOf) {
 	if (Node.isArrayLiteralExpression(receiver) || Node.isStringLiteral(receiver)) return true;
-	if (Node.isPropertyAccessExpression(receiver) && receiver.getExpression().getKind()) {
+	if (Node.isPropertyAccessExpression(receiver)) {
 		const inner = receiver.getExpression();
-		if (Node.isThisExpression(inner) && owner) return isNativeProperty(owner, receiver.getName());
+		if (Node.isThisExpression(inner) && owner) return isNativeProperty(owner, receiver.getName()) || isPrimitiveInput(owner, receiver.getName());
+		/**
+		* `this.extras?.painel?.get(id)` where `constructor(protected extras?: Extras)` and
+		* `type Extras = { painel: Map<number, Row> }`: the lookups a transformer receives
+		* arrive one level down, through a named type. The caller resolves the type; here
+		* only its member's type is read.
+		*/
+		if (Node.isPropertyAccessExpression(inner) && Node.isThisExpression(inner.getExpression()) && owner && membersOf) {
+			const typeNode = declaredOn(owner, inner.getName())?.getTypeNode();
+			if (!typeNode) return false;
+			const memberType = membersOf(typeNode).get(receiver.getName());
+			return !!memberType && NATIVE_TYPES.has(memberType.replace(/<.*/, "").trim());
+		}
 	}
 	return false;
 }
+/** a class property or a constructor parameter property by name */
+function declaredOn(owner, name) {
+	return owner.getProperty(name) ?? owner.getConstructors()[0]?.getParameters().find((parameter) => parameter.getName() === name);
+}
+/** an ace command's `@flags.*` / `@args.*` property is a string, a number or a boolean: any method on it is the language's */
+function isPrimitiveInput(owner, name) {
+	const property = owner.getProperty(name);
+	if (!property) return false;
+	return property.getDecorators().some((decorator) => {
+		const callee = decorator.getCallExpression()?.getExpression();
+		const root = callee && Node.isPropertyAccessExpression(callee) ? callee.getExpression().getText() : "";
+		return root === "flags" || root === "args";
+	});
+}
 function isNativeProperty(owner, name) {
 	/**
 	* Both shapes declare a field: a class property, and a constructor parameter
@@ -3252,6 +3373,7 @@ function createAnalyzer(app, stores, options = {}) {
 		const accesses = [];
 		const followUps = [];
 		const unresolved = [];
+		const packageCalls = [];
 		const reads = [];
 		/** calls a strategy claimed, and where they lead: a nested transformer's keys arrive through its body */
 		const followedCalls = /* @__PURE__ */ new Map();
@@ -3371,7 +3493,14 @@ function createAnalyzer(app, stores, options = {}) {
 			* counted as EOs under a coverage of 99.5%, because a write on an unknown
 			* local was dropped without a word. It lowers coverage and is named.
 			*/
-			if (isUnreadableWrite(call, symbols, imports, packageImports, body) && !isNoise(call, owner)) {
+			/**
+			* A call INTO a package — `this.authz.can()` on an injected package type,
+			* `row.avatar.getVariant()` on a package-typed column, `catalogue.load()` on a
+			* package factory's product — is outside the boundary: what a package does with
+			* its own tables is technical (§4), what it hands back is a value. Not a gap
+			* the walk failed at; noted (plan 0.11 §A).
+			*/
+			if (isUnreadableWrite(call, symbols, imports, packageImports, body) && !isNoise(call, owner, (typeNode) => membersOfType(typeNode, file, app))) {
 				unresolved.push({
 					file: ref.file,
 					line: call.getStartLineNumber(),
@@ -3380,12 +3509,24 @@ function createAnalyzer(app, stores, options = {}) {
 				});
 				continue;
 			}
-			if (isWorthReporting(call, symbols, imports) && !isNoise(call, owner)) unresolved.push({
-				file: ref.file,
-				line: call.getStartLineNumber(),
-				expression: call.getExpression().getText().replace(/\s+/g, ""),
-				reason: "call that no strategy knew how to follow"
-			});
+			if (isWorthReporting(call, symbols, imports) && !isNoise(call, owner, (typeNode) => membersOfType(typeNode, file, app))) {
+				const specifier = packageTargetOf(call, owner, file, symbols, app, storesByName, sourceFile);
+				if (specifier) {
+					packageCalls.push({
+						file: ref.file,
+						line: call.getStartLineNumber(),
+						expression: call.getExpression().getText().replace(/\s+/g, ""),
+						specifier
+					});
+					continue;
+				}
+				unresolved.push({
+					file: ref.file,
+					line: call.getStartLineNumber(),
+					expression: call.getExpression().getText().replace(/\s+/g, ""),
+					reason: "call that no strategy knew how to follow"
+				});
+			}
 		}
 		/**
 		* Read after the loop: whether a key holds a nested transformer is known only
@@ -3405,6 +3546,7 @@ function createAnalyzer(app, stores, options = {}) {
 			followUps,
 			unresolved,
 			validators: validator.fields,
+			packageCalls,
 			commandFields,
 			opaqueValidators: validator.opaque,
 			requestFields: request.fields,
@@ -3514,6 +3656,7 @@ function createAnalyzer(app, stores, options = {}) {
 		const writtenStores = /* @__PURE__ */ new Set();
 		const inputFields = /* @__PURE__ */ new Set();
 		const commandFields = /* @__PURE__ */ new Set();
+		const packageCalls = [];
 		const opaqueInputFields = /* @__PURE__ */ new Set();
 		const requestFields = /* @__PURE__ */ new Set();
 		let opaqueRequest = false;
@@ -3677,12 +3820,36 @@ function createAnalyzer(app, stores, options = {}) {
 				* Dropping it silently is the worst possible defect: the transaction
 				* loses a path and nobody knows.
 				*/
-				if (!isNoiseMember(ref.file, ref.member)) unresolved.push({
-					file: ref.file,
-					line: ref.line ?? 0,
-					expression: `${pathOf(ref.file)}.${ref.member ?? "handle"}`,
-					reason: "body not found in the resolved file: probably inherited from a package class"
-				});
+				if (!isNoiseMember(ref.file, ref.member)) {
+					/**
+					* `catalogue.load()` where `catalogue` is `defineCollection(…)` from a package,
+					* or a class extending a package base without the member: the body is the
+					* package's. Outside the boundary — noted, not a gap (plan 0.11 §A).
+					*/
+					const source = sourceFile(ref.file);
+					const fromPackage = source ? packageMemberOriginOf(source, ref.member, app) : null;
+					if (fromPackage) {
+						packageCalls.push({
+							file: ref.file,
+							line: ref.line ?? 0,
+							expression: `${pathOf(ref.file)}.${ref.member ?? "handle"}`,
+							specifier: fromPackage
+						});
+						return;
+					}
+					/**
+					* `fonte.varrerPorDocumento()` where the file declares an INTERFACE with that
+					* member and no class: there is no body because the implementation is injected
+					* at runtime — a gap, and the right words for it.
+					*/
+					const declaredAsInterface = !!ref.member && !!source && source.getInterfaces().some((i) => i.getMethod(ref.member) || i.getProperty(ref.member));
+					unresolved.push({
+						file: ref.file,
+						line: ref.line ?? 0,
+						expression: `${pathOf(ref.file)}.${ref.member ?? "handle"}`,
+						reason: declaredAsInterface ? "interface method: the implementation is injected at runtime and cannot be followed statically" : "body not found in the resolved file: probably inherited from a package class"
+					});
+				}
 				return;
 			}
 			let bodyWrites = false;
@@ -3702,6 +3869,7 @@ function createAnalyzer(app, stores, options = {}) {
 			unresolved.push(...facts.unresolved);
 			for (const field of facts.validators) inputFields.add(field);
 			for (const field of facts.commandFields) commandFields.add(field);
+			for (const packaged of facts.packageCalls) packageCalls.push(packaged);
 			for (const field of facts.opaqueValidators) opaqueInputFields.add(field);
 			for (const field of facts.requestFields) requestFields.add(field);
 			if (facts.opaqueRequest) opaqueRequest = true;
@@ -3768,6 +3936,7 @@ function createAnalyzer(app, stores, options = {}) {
 			writtenStores: [...writtenStores].sort(),
 			inputFields: [...inputFields].sort(),
 			commandFields: [...commandFields].sort(),
+			packageCalls,
 			opaqueInputFields: [...opaqueInputFields].sort(),
 			requestFields: [...requestFields].sort(),
 			opaqueRequest,
@@ -4002,7 +4171,91 @@ function dependencyTypeOf(node) {
 		if (Node.isIdentifier(target)) return target.getText();
 	}
 }
-/** type identifier -> application file where it is declared */
+/** the specifier a type name is imported from in `file`, when the application does not resolve it */
+function packageSpecifierOfType(typeName, file, app) {
+	const bare = typeName.replace(/<.*/, "").replace(/\|.*$/, "").replace(/\[\]$/, "").trim();
+	for (const declaration of file.getImportDeclarations()) {
+		const specifier = declaration.getModuleSpecifierValue();
+		if (![declaration.getDefaultImport()?.getText(), ...declaration.getNamedImports().map((n) => n.getAliasNode()?.getText() ?? n.getName())].includes(bare)) continue;
+		return app.resolveSpecifier(specifier) ? null : specifier;
+	}
+	return null;
+}
+/** the declared type of `this.<property>` on the owner class: a constructor parameter or a property */
+function declaredTypeOfProperty(owner, property) {
+	if (!owner) return void 0;
+	const parameter = owner.getConstructors()[0]?.getParameters().find((p) => p.getName() === property);
+	if (parameter) return dependencyTypeOf(parameter);
+	const declared = owner.getProperties().find((p) => p.getName() === property);
+	return declared ? dependencyTypeOf(declared) : void 0;
+}
+/**
+* Does this call go INTO a package? Structurally, never by name:
+*
+*   this.authz.can(…)              `authz` injected as a type imported from a package
+*   this.resource.avatar.getVariant  a column of the store whose declared type is a package's
+*   attachmentManager.create(…)    the receiver itself imported from a package
+*
+* The specifier comes back so the note can say which package.
+*/
+function packageTargetOf(call, owner, file, symbols, app, stores, sourceFile) {
+	const callee = call.getExpression();
+	if (!Node.isPropertyAccessExpression(callee)) return null;
+	const receiver = unwrapAwait(callee.getExpression());
+	if (Node.isPropertyAccessExpression(receiver) && Node.isThisExpression(receiver.getExpression())) {
+		const declared = declaredTypeOfProperty(owner, receiver.getName());
+		if (declared) return packageSpecifierOfType(declared, file, app);
+	}
+	if (Node.isPropertyAccessExpression(receiver)) {
+		const holder = receiver.getExpression();
+		const holderText = holder.getText();
+		const store = symbols.get(rootSymbolOf(holder) ?? "") ?? (holderText === "this.resource" && owner ? transformerResourceOf(owner) : null);
+		const declared = store ? stores.get(store) : void 0;
+		const modelFile = declared ? sourceFile(declared.provenance.file) : null;
+		if (declared && modelFile) {
+			const type = modelFile.getClasses().flatMap((c) => c.getProperties()).find((p) => p.getName() === receiver.getName())?.getTypeNode()?.getText() ?? declared.attributes.find((a) => a.name === receiver.getName())?.type;
+			if (type) return packageSpecifierOfType(type, modelFile, app);
+		}
+	}
+	if (Node.isIdentifier(receiver)) return packageSpecifierOfType(receiver.getText(), file, app);
+	return null;
+}
+/**
+* A member the resolved file does not declare, because it is a package's: the
+* exported symbol is a const built by a package factory, or a class extending a
+* package base. Returns the package's specifier.
+*/
+function packageMemberOriginOf(file, member, app) {
+	const rootOf = (node) => {
+		let current = node;
+		for (let depth = 0; depth < 20; depth++) {
+			if (Node.isCallExpression(current) || Node.isPropertyAccessExpression(current)) {
+				current = current.getExpression();
+				continue;
+			}
+			return Node.isIdentifier(current) ? current.getText() : null;
+		}
+		return null;
+	};
+	const defaultExported = file.getExportAssignments().map((e) => e.getExpression().getText());
+	const declarations = file.getVariableDeclarations();
+	const exported = declarations.filter((d) => d.getVariableStatement()?.isExported() || defaultExported.includes(d.getName()));
+	for (const declaration of exported.length > 0 ? exported : declarations) {
+		const initializer = declaration.getInitializer();
+		if (!initializer || !Node.isCallExpression(initializer)) continue;
+		const root = rootOf(initializer);
+		const specifier = root ? packageSpecifierOfType(root, file, app) : null;
+		if (specifier) return specifier;
+	}
+	for (const cls of file.getClasses()) {
+		if (member && cls.getMethod(member)) return null;
+		const parent = cls.getExtends()?.getExpression();
+		const root = parent ? rootOf(parent) : null;
+		const specifier = root ? packageSpecifierOfType(root, file, app) : null;
+		if (specifier) return specifier;
+	}
+	return null;
+}
 function resolveTypeToFile(typeName, file, app) {
 	const bare = typeName.replace(/<.*/, "").trim();
 	for (const declaration of file.getImportDeclarations()) {
@@ -5763,9 +6016,32 @@ var CoverageTooLowError = class extends Error {
 		this.name = "CoverageTooLowError";
 	}
 };
+/**
+* One note per call site into a package, naming the transactions that reach it —
+* outside the boundary (§4): what a package does with its own tables is technical,
+* what it hands back is a value. Never in coverage (plan 0.11 §A).
+*/
+function packageCallNotes(entryPoints, behaviors, emit) {
+	const sites = /* @__PURE__ */ new Map();
+	for (const entry of entryPoints) {
+		const behavior = behaviors.get(entry.id);
+		for (const call of behavior?.packageCalls ?? []) {
+			const key = `${call.file}:${call.line}:${call.expression}`;
+			const site = sites.get(key) ?? {
+				specifier: call.specifier,
+				expression: call.expression,
+				where: call.line > 0 ? `${emit(call.file)}:${call.line}` : emit(call.file),
+				reached: []
+			};
+			if (!site.reached.includes(entry.identity)) site.reached.push(entry.identity);
+			sites.set(key, site);
+		}
+	}
+	return [...sites.values()].sort((a, b) => a.where.localeCompare(b.where)).map((site) => `${site.reached.join(", ")}: call into ${site.specifier} (${site.expression}) — outside the boundary; what a package does with its own tables is technical (§4), what it hands back is a value [${site.where}]`);
+}
 async function analyze(root, options = {}) {
 	const app = await discoverApp(root);
-	const { stores, unresolved: storeProblems } = await collectDataStores(app);
+	const { stores, unresolved: storeProblems, notes: storeNotes } = await collectDataStores(app);
 	const routes = await collectEntryPoints(app);
 	const routeProblems = routes.unresolved;
 	const entryPoints = [...routes.entryPoints, ...collectCommands(app)];
@@ -5895,6 +6171,10 @@ async function analyze(root, options = {}) {
 			transformedStores: behavior.transformedStores,
 			delivered: behavior.delivered,
 			pageReads: behavior.pageReads,
+			packageCalls: behavior.packageCalls.map((c) => ({
+				...c,
+				file: emit(c.file)
+			})),
 			unreadablePages: behavior.unreadablePages,
 			outputReads: behavior.outputReads,
 			trace: behavior.trace.map((step) => ({
@@ -5915,7 +6195,8 @@ async function analyze(root, options = {}) {
 		unresolved: unresolvedSites.map((site) => ({
 			...site,
 			file: emit(site.file)
-		}))
+		})),
+		notes: [...storeNotes, ...packageCallNotes(entryPoints, behaviors, emit)]
 	};
 	const minimum = options.minCoverage ?? 0;
 	if (inventory.coverage.ratio < minimum) throw new CoverageTooLowError(inventory.coverage.ratio, minimum);

package/build/{resolvers-CneCj3sT.js → resolvers-Bz1F-Tgf.js}

@@ -1368,4 +1368,4 @@ function ignoreCalls(options) {
 	};
 }
 //#endregion
-export { relativeTo as _, chainShapeOf as a, unwrap as c, collectEventBindings as d, detectAccess as f, isSeeder as g, isApplicationCode as h, resolveCall as i, DISPATCH_METHODS as l, rootSymbolOf as m, ignoreCalls as n, mappedLiteralOf as o, hooksFiredBy as p, isTechnicalWrite as r, outputFieldsIn as s, BUILTIN_CALL_RESOLVERS as t, EXECUTION_METHODS as u, samePath as v, toPosix as y };
+export { isSeeder as _, chainShapeOf as a, toPosix as b, transformerResourceOf as c, EXECUTION_METHODS as d, collectEventBindings as f, isApplicationCode as g, rootSymbolOf as h, resolveCall as i, unwrap as l, hooksFiredBy as m, ignoreCalls as n, mappedLiteralOf as o, detectAccess as p, isTechnicalWrite as r, outputFieldsIn as s, BUILTIN_CALL_RESOLVERS as t, DISPATCH_METHODS as u, relativeTo as v, samePath as y };

package/build/{runners-b1tgLA1B.js → runners-CzzlX7h-.js}

@@ -1,6 +1,6 @@
 import { c as IncomparableSourcesError, d as DEFAULTS, f as defineConfig, i as measureStructure, n as parseSamples, o as FACTOR_PRESETS, r as measureConformance, s as IncomparableRulesetsError, t as calibrate, u as diffCounts } from "./calibration-DVIf8hcE.js";
-import { y as toPosix } from "./resolvers-CneCj3sT.js";
-import { n as analyze } from "./pipeline-4sZBYGKU.js";
+import { b as toPosix } from "./resolvers-Bz1F-Tgf.js";
+import { n as analyze } from "./pipeline-CdDJRsLM.js";
 import { readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { existsSync } from "node:fs";
@@ -312,7 +312,8 @@ async function runInventory(options) {
 			`data stores:   ${inventory.dataStores.length}`,
 			`entry points:  ${coverage.entryPointsTotal}`,
 			`coverage:      ${(coverage.ratio * 100).toFixed(1)}% (${coverage.unresolvedCalls} unresolved calls)`,
-			...inventory.unresolved.map((site) => `  ${describeSite(site)}`)
+			...inventory.unresolved.map((site) => `  ${describeSite(site)}`),
+			...inventory.notes.length > 0 ? ["notes (declarations, not gaps):", ...inventory.notes.map((note) => `  ${note}`)] : []
 		].join("\n")
 	};
 }

package/build/src/cli.js

@@ -1,5 +1,5 @@
-import { t as CoverageTooLowError } from "../pipeline-4sZBYGKU.js";
-import { a as runInventory, c as ConfigLoadError, i as runExplain, n as runCount, o as runMetrics, r as runDiff, s as printResult, t as runCalibrate } from "../runners-b1tgLA1B.js";
+import { t as CoverageTooLowError } from "../pipeline-CdDJRsLM.js";
+import { a as runInventory, c as ConfigLoadError, i as runExplain, n as runCount, o as runMetrics, r as runDiff, s as printResult, t as runCalibrate } from "../runners-CzzlX7h-.js";
 import path from "node:path";
 import { existsSync, readFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";

package/build/src/inventory/graph/call_graph.d.ts

@@ -1,3 +1,4 @@
+import { Node } from 'ts-morph';
 import type { ClassDeclaration, SourceFile } from 'ts-morph';
 import type { AppContext } from '../app_context.js';
 import type { CollectedDataStore } from '../sources/data_stores.js';
@@ -104,6 +105,12 @@ export type Behavior = {
      */
     pageReads: Record<string, string[]>;
     unreadablePages: Record<string, string>;
+    /**
+     * Calls into a PACKAGE the walk met on the way — an injected package type, a
+     * package-typed column, a package factory's product, a member inherited from a
+     * package base. Outside the boundary (§4): noted, never a gap (plan 0.11 §A).
+     */
+    packageCalls: PackageCall[];
     trace: TraceStep[];
     /** bodies reached, for `fp:diff` */
     scope: ScopeEntry[];
@@ -157,6 +164,15 @@ export declare function analyzeHandler(app: AppContext, stores: CollectedDataSto
  * as any import. No type checker is needed.
  */
 export declare function injectedFor(owner: ClassDeclaration | undefined, file: SourceFile, app: AppContext): Map<string, string>;
+/** type identifier -> application file where it is declared */
+/** a call whose target resolves to a package: where, what, which package */
+export type PackageCall = {
+    file: string;
+    line: number;
+    expression: string;
+    specifier: string;
+};
+export declare function membersOfType(typeNode: Node, file: SourceFile, app: AppContext): Map<string, string>;
 /**
  * Both maps a file's imports produce: where a local name resolves, and what it
  * was called where it was exported.

package/build/src/inventory/graph/noise.d.ts

@@ -1,6 +1,9 @@
+import { Node } from 'ts-morph';
 import type { CallExpression, ClassDeclaration } from 'ts-morph';
 /** Is this call one that cannot reach a data store? */
-export declare function isNoise(call: CallExpression, owner?: ClassDeclaration): boolean;
+/** resolves a type annotation to its members (`name -> type text`), when the caller can */
+export type MembersOf = (typeNode: Node) => Map<string, string>;
+export declare function isNoise(call: CallExpression, owner?: ClassDeclaration, membersOf?: MembersOf): boolean;
 /**
  * Iteration over a list, checked BEFORE the resolvers run.
  *

package/build/src/inventory/resolvers/index.js

@@ -1,2 +1,2 @@
-import { i as resolveCall, n as ignoreCalls, r as isTechnicalWrite, t as BUILTIN_CALL_RESOLVERS } from "../../../resolvers-CneCj3sT.js";
+import { i as resolveCall, n as ignoreCalls, r as isTechnicalWrite, t as BUILTIN_CALL_RESOLVERS } from "../../../resolvers-Bz1F-Tgf.js";
 export { BUILTIN_CALL_RESOLVERS, ignoreCalls, isTechnicalWrite, resolveCall };

package/build/src/inventory/sources/data_stores.d.ts

@@ -27,5 +27,12 @@ export type DataStoreCollection = {
     stores: CollectedDataStore[];
     /** chains that left the application, required by AFP §6.5.3 */
     unresolved: UnresolvedCall[];
+    /**
+     * Facts about the declarations that are not gaps: a base class or a mixin that
+     * comes from a package. What it adds is technical (a hashed password, audit
+     * stamps, a soft-delete mark) and never a user-recognisable attribute (§7.2); the
+     * model's own columns and the schema decide. Listed, never counted in coverage.
+     */
+    notes: string[];
 };
 export declare function collectDataStores(app: AppContext): Promise<DataStoreCollection>;

package/build/src/pipeline.js

@@ -1,2 +1,2 @@
-import { n as analyze, t as CoverageTooLowError } from "../pipeline-4sZBYGKU.js";
+import { n as analyze, t as CoverageTooLowError } from "../pipeline-CdDJRsLM.js";
 export { CoverageTooLowError, analyze };

package/build/src/types.d.ts

@@ -148,6 +148,13 @@ export type HandlerBehavior = {
     pageReads?: Record<string, string[]>;
     /** stores a page could not be read for, and why: they leave whole */
     unreadablePages?: Record<string, string>;
+    /** calls into a package met on the way: outside the boundary, noted, never a gap (plan 0.11 §A) */
+    packageCalls?: {
+        file: string;
+        line: number;
+        expression: string;
+        specifier: string;
+    }[];
     /**
      * How each store was read: rows whole, `.select()` columns, or one aggregate
      * scalar; by its own chain (`direct`) or preloaded through another store (`via`).
@@ -222,6 +229,11 @@ export type Inventory = {
      * on. One entry per site — a body five routes reach is one gap, not five.
      */
     unresolved: UnresolvedSite[];
+    /**
+     * Facts about the declarations that are not gaps — a base class or a mixin from a
+     * package, whose additions are technical. Listed for the reader; never in coverage.
+     */
+    notes: string[];
 };
 export type FunctionType = 'ILF' | 'EIF' | 'EI' | 'EO' | 'EQ';
 export type Complexity = 'low' | 'average' | 'high';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@filipebraida/adonis-function-points",
   "description": "Automated function point counting and code metrics for AdonisJS applications.",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "engines": {
     "node": ">=24.0.0"
   },