@filipebraida/adonis-function-points 0.7.0 → 0.9.0

package/build/{resolvers-DaU4uAqT.js → resolvers-CneCj3sT.js}

@@ -380,11 +380,26 @@ function classOfReceiver(receiver) {
 		return target.isKind(SyntaxKind.Identifier) ? target.getText() : null;
 	}
 	if (receiver.isKind(SyntaxKind.Identifier)) {
-		const init = (receiver.getSymbol()?.getDeclarations().find((d) => d.isKind(SyntaxKind.VariableDeclaration)))?.asKind(SyntaxKind.VariableDeclaration)?.getInitializer();
+		let init = (receiver.getSymbol()?.getDeclarations().find((d) => d.isKind(SyntaxKind.VariableDeclaration)))?.asKind(SyntaxKind.VariableDeclaration)?.getInitializer();
+		while (init?.isKind(SyntaxKind.AwaitExpression) || init?.isKind(SyntaxKind.ParenthesizedExpression)) init = init.getExpression();
 		if (init?.isKind(SyntaxKind.NewExpression)) {
 			const target = init.getExpression();
 			return target.isKind(SyntaxKind.Identifier) ? target.getText() : null;
 		}
+		/**
+		* `const svc = await app.container.make(AssignmentService)`: the container hands
+		* back an instance of the class named — the same binding as `new`, written the
+		* way a controller writes it when the service has dependencies of its own. On a
+		* reviewed application this shape carried the write of `POST /assignments`
+		* and 31 more sites, and none was followed (plan 0.8 §B).
+		*/
+		if (init?.isKind(SyntaxKind.CallExpression)) {
+			const callee = init.getExpression();
+			if (callee.isKind(SyntaxKind.PropertyAccessExpression) && callee.getName() === "make" && callee.getExpression().isKind(SyntaxKind.PropertyAccessExpression) && callee.getExpression().asKind(SyntaxKind.PropertyAccessExpression).getName() === "container") {
+				const made = init.getArguments()[0];
+				return made?.isKind(SyntaxKind.Identifier) ? made.getText() : null;
+			}
+		}
 	}
 	return null;
 }
@@ -399,6 +414,7 @@ function collectEventBindings(app) {
 		compilerOptions: { allowJs: false }
 	});
 	for (const root of app.scanRoots) project.addSourceFilesAtPaths(`${root}/**/*.ts`);
+	project.addSourceFilesAtPaths(`${toPosix(app.root)}/start/**/*.ts`);
 	const bindings = /* @__PURE__ */ new Map();
 	for (const file of project.getSourceFiles()) for (const call of file.getDescendantsOfKind(SyntaxKind.CallExpression)) {
 		const expression = call.getExpression();
@@ -406,11 +422,16 @@ function collectEventBindings(app) {
 		if (expression.getName() !== "on") continue;
 		const [event, handlers] = call.getArguments();
 		if (!event || !handlers) continue;
-		const eventFile = resolveEventClass(event, file, app);
-		if (!eventFile) continue;
+		/**
+		* `emitter.on('order:closed', …)`: a STRING event, keyed by its name, which
+		* `emitter.emit('order:closed', payload)` reaches. An application that binds every
+		* listener this way had none of them followed (plan 0.9 §C).
+		*/
+		const key = Node.isStringLiteral(event) ? eventKey(event.getLiteralValue()) : resolveEventClass(event, file, app);
+		if (!key) continue;
 		const refs = listenersOf(handlers, file, app);
 		if (refs.length === 0) continue;
-		bindings.set(eventFile, [...bindings.get(eventFile) ?? [], ...refs]);
+		bindings.set(key, [...bindings.get(key) ?? [], ...refs]);
 	}
 	return bindings;
 }
@@ -436,10 +457,23 @@ function resolveEventClass(expression, from, app) {
 	return registryEntry(registry, expression.getName(), from.getProject(), app);
 }
 /** listener bodies named by the second argument of `emitter.on` */
+/** the binding key of a string event: `emitter.on('order:closed', …)` */
+const eventKey = (name) => `event:${name}`;
 function listenersOf(handlers, from, app) {
 	const entries = handlers.isKind(SyntaxKind.ArrayLiteralExpression) ? handlers.getElements() : [handlers];
 	const refs = [];
 	for (const entry of entries) {
+		/**
+		* `emitter.on(event, async function (payload) { … })`: the listener IS the body,
+		* located by its line — the way a route's inline closure already is a handler.
+		*/
+		if (Node.isArrowFunction(entry) || Node.isFunctionExpression(entry)) {
+			refs.push({
+				file: toPosix(from.getFilePath()),
+				line: entry.getStartLineNumber()
+			});
+			continue;
+		}
 		/**
 		* `[SomeListener, 'method']`: AdonisJS lets the binding name the method,
 		* and taking `handle` on faith there would look for a body that is not
@@ -513,6 +547,8 @@ function registryEntry(registryFile, key, project, app) {
 }
 //#endregion
 //#region src/inventory/resolvers/event_dispatch.ts
+/** the emitter's ways of firing a string event */
+const EMITS = new Set(["emit", "emitSerial"]);
 /**
 * "Event" pattern: the handler announces, and listeners act.
 *
@@ -535,6 +571,18 @@ const eventDispatchResolver = {
 		if (ctx.eventBindings.size === 0) return [];
 		const expression = call.getExpression();
 		if (!expression.isKind(SyntaxKind.PropertyAccessExpression)) return [];
+		/**
+		* `emitter.emit('order:closed', payload)`: a string event reaches the listeners bound
+		* to that name — the same decision as `Event.dispatch()`. A name built at runtime
+		* binds nothing.
+		*/
+		if (EMITS.has(expression.getName())) {
+			const emitterNode = expression.getExpression();
+			const isEmitter = Node.isIdentifier(emitterNode) ? emitterNode.getText() === "emitter" : Node.isPropertyAccessExpression(emitterNode) && emitterNode.getName() === "emitter";
+			const name = call.getArguments()[0];
+			if (!isEmitter || !name || !Node.isStringLiteral(name)) return [];
+			return ctx.eventBindings.get(eventKey(name.getLiteralValue())) ?? [];
+		}
 		if (expression.getName() !== "dispatch") return [];
 		const receiver = expression.getExpression();
 		if (!Node.isIdentifier(receiver) && !Node.isPropertyAccessExpression(receiver)) return [];
@@ -624,7 +672,7 @@ const jobDispatchResolver = {
 * "Local function" pattern: a helper declared in the same file, not imported.
 *
 *     const lista = await proximos(id)          // function proximos() { … }
-*     return rows.map(paraLinha)                // const paraLinha = (row) => …
+*     return rows.map(toRow)                // const toRow = (row) => …
 *
 * A query object that keeps its helpers beside it is common, and before this
 * every such call was unresolved: the store a helper read was reached by nobody
@@ -648,7 +696,7 @@ const localFunctionResolver = {
 		}];
 	}
 };
-/** callbacks that apply a function to each element: `rows.map(paraLinha)` calls `paraLinha` */
+/** callbacks that apply a function to each element: `rows.map(toRow)` calls `toRow` */
 const APPLIES_CALLBACK = new Set([
 	"map",
 	"flatMap",
@@ -661,8 +709,8 @@ const APPLIES_CALLBACK = new Set([
 	"reduce"
 ]);
 /**
-* The function a call names: `proximos(id)` names `proximos`; `rows.map(paraLinha)`
-* names `paraLinha`, called once per row — the body the graph must read is the
+* The function a call names: `proximos(id)` names `proximos`; `rows.map(toRow)`
+* names `toRow`, called once per row — the body the graph must read is the
 * same, whichever way it was reached.
 */
 function calledFunctionOf(call) {
@@ -849,7 +897,7 @@ function transformerResourceOf(cls) {
 *   { autor: AutorTransformer.transform } 0 here; the nested body contributes
 *   { endereco: { rua, cidade } }        leaves individually
 *   { tags: xs.map((t) => t.nome) }      1 — a repeating group of one attribute
-*   { itens: xs.map((i) => ({ a, b })) } the leaves, once
+*   { items: xs.map((i) => ({ a, b })) } the leaves, once
 *   ...this.pick(this.resource, [...])   the listed names
 *   ...this.toObject()                   0 here; the followed body contributes
 *   ...anythingElse                      1, opaque, reported
@@ -889,7 +937,7 @@ function outputFieldsIn(body, owner, stores, followed) {
 *   { autor: AutorTransformer.transform } 0 here; the followed body contributes
 *   { endereco: { rua, cidade } }        leaves individually
 *   { tags: xs.map((t) => t.nome) }      1 — a repeating group of one attribute
-*   { itens: xs.map((i) => ({ a, b })) } the leaves, once
+*   { items: xs.map((i) => ({ a, b })) } the leaves, once
 *   ...this.pick(this.resource, [...])   the listed names
 *   ...this.toObject()                   0 here; the followed body contributes
 *   ...anythingElse                      1, opaque, reported
@@ -1226,7 +1274,7 @@ const BUILTIN_CALL_RESOLVERS = [
 			if (!found) return [];
 			const { file, owner } = found;
 			/**
-			* `X.transform(p).useVariant('forEgresso')`: the variant is a METHOD of the
+			* `X.transform(p).useVariant('forSummary')`: the variant is a METHOD of the
 			* transformer, named after it, and it REPLACES `toObject()` — the shape that
 			* leaves is the variant's. The chain is visited call by call: the `useVariant`
 			* call resolves the variant's body, and the `transform` call before it resolves

package/build/{runners-Dm7cWGa-.js → runners-BuZNr-FE.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-DaU4uAqT.js";
-import { n as analyze } from "./pipeline-DO2301fV.js";
+import { y as toPosix } from "./resolvers-CneCj3sT.js";
+import { n as analyze } from "./pipeline-DqPrDZfD.js";
 import { readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { existsSync } from "node:fs";
@@ -112,12 +112,21 @@ function renderCount(result) {
 	if (unresolvedCalls > 0 || entryPointsWithoutHandler > 0 || warnings.length > 0) {
 		lines.push("");
 		lines.push("Confidence:");
-		if (unresolvedCalls > 0) lines.push(`  ${unresolvedCalls} unresolved calls`);
+		if (unresolvedCalls > 0) {
+			lines.push(`  ${unresolvedCalls} unresolved call(s) — one line per site, whatever the number of transactions reaching it:`);
+			const sites = result.confidence.unresolved ?? [];
+			for (const site of sites.slice(0, 25)) lines.push(`    ${describeSite(site)}`);
+			if (sites.length > 25) lines.push(`    … and ${sites.length - 25} more — fp:inventory lists them all`);
+		}
 		if (entryPointsWithoutHandler > 0) lines.push(`  ${entryPointsWithoutHandler} entry points without a handler`);
 		for (const warning of warnings) lines.push(`  ${warning}`);
 	}
 	return lines.join("\n");
 }
+/** one unresolved site, the way both reports print it: where, what, why, how many transactions */
+function describeSite(site) {
+	return `${site.file}:${site.line}  ${site.expression} — ${site.reason}` + (site.transactions > 1 ? ` (${site.transactions} transactions)` : "");
+}
 /** `fp:explain`: a function's provenance, which is what supports a dispute */
 /**
 * Structure and conformance, beside the count and never instead of it.
@@ -302,7 +311,8 @@ async function runInventory(options) {
 		output: [
 			`data stores:   ${inventory.dataStores.length}`,
 			`entry points:  ${coverage.entryPointsTotal}`,
-			`coverage:      ${(coverage.ratio * 100).toFixed(1)}% (${coverage.unresolvedCalls} unresolved calls)`
+			`coverage:      ${(coverage.ratio * 100).toFixed(1)}% (${coverage.unresolvedCalls} unresolved calls)`,
+			...inventory.unresolved.map((site) => `  ${describeSite(site)}`)
 		].join("\n")
 	};
 }

package/build/src/albrecht/counter.d.ts

@@ -5,7 +5,7 @@ import type { Behavior } from '../inventory/graph/call_graph.js';
 import type { DiscoveredSchema } from '../inventory/sources/json_schemas.js';
 import type { CollectedJob } from '../inventory/sources/jobs.js';
 import type { OpaqueDeclaration } from './opaque.js';
-import type { Complexity, CountResult, FunctionType } from '../types.js';
+import type { Complexity, CountResult, FunctionType, UnresolvedSite } from '../types.js';
 import type { FunctionOverride } from '../define_config.js';
 import type { ComplexityTable } from './tables.js';
 import type { GroupingStrategy } from './data_functions.js';
@@ -40,13 +40,19 @@ export declare const RULESET = "afp";
  * Three in 1.6.0: an output's DETs are what the transaction DELIVERS (the render
  * props, the response payload, what a command prints) read back to their origin;
  * a function of the same file and a `.map(fn)` by reference are followed, so
- * FTRs move; and ace commands are transactions, with flags as input.
+ * FTRs move; and ace commands are transactions, with flags as input. One in
+ * 1.7.0, wide: a write binds to what the variable IS — a destructured named
+ * interface, a followed method's return, a relation off a row, a loop over rows,
+ * the guard's user, a service the container made — and a write nobody can type is
+ * an unresolved call instead of silence. Two in 1.8.0: a method the model
+ * declares names the store its caller writes, and a listener written inline on a
+ * string event is followed like a listener class.
  *
  * Without the bump, a baseline saved by the previous version compares cleanly
  * against this one and bills the tool's own improvement as work done. The guard
  * exists for exactly that, and only this constant arms it.
  */
-export declare const RULESET_VERSION = "1.6.0";
+export declare const RULESET_VERSION = "1.8.0";
 export type CountInput = {
     app: AppContext;
     stores: CollectedDataStore[];
@@ -57,6 +63,12 @@ export type CountInput = {
     jsonSchemas?: Map<string, DiscoveredSchema>;
     /** the queue jobs and who dispatches each — a job no transaction reaches is reported (plan 0.7 §D) */
     jobs?: CollectedJob[];
+    /**
+     * The unresolved call sites as the inventory lists them — one per site, route and
+     * store problems included. Given, the count shows the same number and the same list;
+     * absent, it lists the sites the behaviors show, one each.
+     */
+    unresolved?: UnresolvedSite[];
     /**
      * Stores written anywhere in the application's code, reachable from an entry
      * point or not — AFP §6.5.4 asks who MAINTAINS the store, and a job or a

package/build/src/cli.js

@@ -1,5 +1,5 @@
-import { t as CoverageTooLowError } from "../pipeline-DO2301fV.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-Dm7cWGa-.js";
+import { t as CoverageTooLowError } from "../pipeline-DqPrDZfD.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-BuZNr-FE.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

@@ -97,6 +97,13 @@ export type Behavior = {
         opaqueFields: string[];
         stores: string[];
     };
+    /**
+     * Of the stores delivered raw to a page, the columns the page reads off them
+     * (plan 0.8 §D). A store absent here leaves whole; one in `unreadablePages` leaves
+     * whole because the page could not be read, and says why.
+     */
+    pageReads: Record<string, string[]>;
+    unreadablePages: Record<string, string>;
     trace: TraceStep[];
     /** bodies reached, for `fp:diff` */
     scope: ScopeEntry[];

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

@@ -1,6 +1,7 @@
 import { Node } from 'ts-morph';
 import type { CallExpression, SourceFile } from 'ts-morph';
 import type { RelationMap, StoreSymbols } from '../detectors/lucid.js';
+import type { PageRef } from './pages.js';
 import type { HandlerRef } from '../../types.js';
 /**
  * What a transaction DELIVERS — counting-decisions §6, plan 0.7 §A′.
@@ -18,7 +19,11 @@ import type { HandlerRef } from '../../types.js';
  * body returns — the graph does that in `run()`, once the bodies are known; this
  * module only says WHAT was delivered and where it came from.
  */
-export type Delivery = 
+export type Delivery = DeliveredValue & {
+    /** the page or template this value was handed to, when it was a render — what the page shows of it is read there */
+    via?: PageRef;
+};
+type DeliveredValue = 
 /** a variable bound to a store: its columns leave */
 {
     kind: 'store';
@@ -38,7 +43,7 @@ export type Delivery =
     args: Delivery[];
     /**
      * One key of what the call returns — `const { data } = await q.handle()`,
-     * `relatorio.linhas` — rather than the whole result. Resolved against the
+     * `report.rows` — rather than the whole result. Resolved against the
      * body's classified return, keeping only that key.
      */
     pick?: string;
@@ -59,7 +64,11 @@ export type Delivery =
     path: string;
     expression: string;
 };
-/** keys of a result that carry its rows: picking one of these is not picking one value */
+/**
+ * Keys under which a paginator or a wrapper hands its rows on: picking one of these
+ * is not picking one value. Framework and JavaScript conventions only — a key named
+ * in one application's language is that application's, not a rule.
+ */
 export declare const PASSES_ROWS: Set<string>;
 export type DeliveryContext = {
     body: Node;
@@ -86,3 +95,4 @@ export type BodyDeliveries = {
  * response method, and what a `return` hands back that is not one of those calls.
  */
 export declare function deliveriesIn(ctx: DeliveryContext): BodyDeliveries;
+export {};

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

@@ -68,7 +68,7 @@ export declare function transformerResourceOf(cls: ClassDeclaration): string | n
  *   { autor: AutorTransformer.transform } 0 here; the nested body contributes
  *   { endereco: { rua, cidade } }        leaves individually
  *   { tags: xs.map((t) => t.nome) }      1 — a repeating group of one attribute
- *   { itens: xs.map((i) => ({ a, b })) } the leaves, once
+ *   { items: xs.map((i) => ({ a, b })) } the leaves, once
  *   ...this.pick(this.resource, [...])   the listed names
  *   ...this.toObject()                   0 here; the followed body contributes
  *   ...anythingElse                      1, opaque, reported
@@ -101,7 +101,7 @@ type LeafOptions = {
  *   { autor: AutorTransformer.transform } 0 here; the followed body contributes
  *   { endereco: { rua, cidade } }        leaves individually
  *   { tags: xs.map((t) => t.nome) }      1 — a repeating group of one attribute
- *   { itens: xs.map((i) => ({ a, b })) } the leaves, once
+ *   { items: xs.map((i) => ({ a, b })) } the leaves, once
  *   ...this.pick(this.resource, [...])   the listed names
  *   ...this.toObject()                   0 here; the followed body contributes
  *   ...anythingElse                      1, opaque, reported

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

@@ -0,0 +1,44 @@
+import type { Project } from 'ts-morph';
+import type { RelationMap } from '../detectors/lucid.js';
+import type { CollectedDataStore } from '../sources/data_stores.js';
+/**
+ * What the page SHOWS of a store handed to it raw — plan 0.7 §B / 0.8 §D,
+ * counting-decisions §6.
+ *
+ * The delivery rule (§A′) says which store leaves; a transformer or a `.select()`
+ * says which columns. With neither, the store left whole — and the CPM defines an
+ * output's DETs by what the user sees. The page is TypeScript (`.tsx`) or Edge,
+ * and the same reader that opened the controller can open it: from the
+ * component's props to every member read off a row, one child component deep.
+ *
+ * Where it cannot read — a second level of components, a spread, a package's
+ * component, two files answering to one page name — the store leaves whole and
+ * the transaction is REPORTED with the reason. Overestimating in the open, never a
+ * floor: a floor would undercount what the user sees.
+ */
+export type PageRef = {
+    engine: 'inertia' | 'edge';
+    page: string;
+};
+/** a store handed raw to a page, at a key path of its props (`vagas.data`) */
+export type RawDelivery = PageRef & {
+    store: string;
+    path: string;
+};
+export type PageReading = {
+    /** store -> columns the page reads off its rows */
+    columns: Map<string, Set<string>>;
+    /** store -> why the page could not be read for it (the store then leaves whole) */
+    unreadable: Map<string, string>;
+    /** store -> members the page reads that are NOT its columns (`member.displayName`, computed on the way) */
+    unknownMembers: Map<string, Set<string>>;
+};
+export type PageEnvironment = {
+    root: string;
+    project: Project;
+    stores: Map<string, CollectedDataStore>;
+    relations: RelationMap;
+    /** the application's subpath imports (`#tecnologias/ui/components/x`), as the graph resolves them */
+    resolveSpecifier: (specifier: string) => string | null;
+};
+export declare function readPages(deliveries: RawDelivery[], env: PageEnvironment): PageReading;

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-DaU4uAqT.js";
+import { i as resolveCall, n as ignoreCalls, r as isTechnicalWrite, t as BUILTIN_CALL_RESOLVERS } from "../../../resolvers-CneCj3sT.js";
 export { BUILTIN_CALL_RESOLVERS, ignoreCalls, isTechnicalWrite, resolveCall };

package/build/src/inventory/resolvers/local_function.d.ts

@@ -4,7 +4,7 @@ import type { CallResolver } from './types.js';
  * "Local function" pattern: a helper declared in the same file, not imported.
  *
  *     const lista = await proximos(id)          // function proximos() { … }
- *     return rows.map(paraLinha)                // const paraLinha = (row) => …
+ *     return rows.map(toRow)                // const toRow = (row) => …
  *
  * A query object that keeps its helpers beside it is common, and before this
  * every such call was unresolved: the store a helper read was reached by nobody
@@ -15,8 +15,8 @@ import type { CallResolver } from './types.js';
  */
 export declare const localFunctionResolver: CallResolver;
 /**
- * The function a call names: `proximos(id)` names `proximos`; `rows.map(paraLinha)`
- * names `paraLinha`, called once per row — the body the graph must read is the
+ * The function a call names: `proximos(id)` names `proximos`; `rows.map(toRow)`
+ * names `toRow`, called once per row — the body the graph must read is the
  * same, whichever way it was reached.
  */
 export declare function calledFunctionOf(call: CallExpression): import('ts-morph').Identifier | null;

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

@@ -41,4 +41,7 @@ export declare function collectEventBindings(app: AppContext): EventBindings;
  * this" would drift.
  */
 export declare function resolveEventClass(expression: Expression | Node, from: SourceFile, app: SpecifierResolver): string | null;
+/** listener bodies named by the second argument of `emitter.on` */
+/** the binding key of a string event: `emitter.on('order:closed', …)` */
+export declare const eventKey: (name: string) => string;
 export {};

package/build/src/pipeline.js

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

package/build/src/reporters/table.d.ts

@@ -1,7 +1,9 @@
-import type { CountResult, CountedFunction, Inventory } from '../types.js';
+import type { CountResult, CountedFunction, Inventory, UnresolvedSite } from '../types.js';
 import type { FunctionPointDiff } from '../albrecht/diff.js';
 import type { Conformance, StructureMetrics } from '../metrics/structure.js';
 export declare function renderCount(result: CountResult): string;
+/** one unresolved site, the way both reports print it: where, what, why, how many transactions */
+export declare function describeSite(site: UnresolvedSite): string;
 /** `fp:explain`: a function's provenance, which is what supports a dispute */
 /**
  * Structure and conformance, beside the count and never instead of it.

package/build/src/types.d.ts

@@ -144,6 +144,10 @@ export type HandlerBehavior = {
         opaqueFields: string[];
         stores: string[];
     };
+    /** of the stores delivered raw to a page, the columns the page reads off them (§6, plan 0.8 §D) */
+    pageReads?: Record<string, string[]>;
+    /** stores a page could not be read for, and why: they leave whole */
+    unreadablePages?: Record<string, 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`).
@@ -186,6 +190,11 @@ export type UnresolvedCall = {
     expression: string;
     reason: string;
 };
+/** an unresolved call as the reports list it: one site, however many transactions reach it */
+export type UnresolvedSite = UnresolvedCall & {
+    /** transactions whose walk reached this call; 0 for a route or store problem */
+    transactions: number;
+};
 export type Inventory = {
     /** format version, for diffs across releases */
     version: 1;
@@ -203,10 +212,16 @@ export type Inventory = {
     coverage: {
         entryPointsTotal: number;
         entryPointsResolved: number;
+        /** distinct call sites nobody could follow, route and store problems included — the number the count shows too */
         unresolvedCalls: number;
         /** fraction of entry points whose handler was traced to completion */
         ratio: number;
     };
+    /**
+     * The unresolved calls, listed: what `fp:inventory` prints and what a person acts
+     * on. One entry per site — a body five routes reach is one gap, not five.
+     */
+    unresolved: UnresolvedSite[];
 };
 export type FunctionType = 'ILF' | 'EIF' | 'EI' | 'EO' | 'EQ';
 export type Complexity = 'low' | 'average' | 'high';
@@ -279,9 +294,12 @@ export type CountResult = {
     };
     /** flags when the count does not deserve confidence */
     confidence: {
+        /** distinct call sites nobody could follow — the same number the inventory shows */
         unresolvedCalls: number;
         entryPointsWithoutHandler: number;
         warnings: string[];
+        /** the sites themselves, so the report can list them; absent on a count built by hand */
+        unresolved?: UnresolvedSite[];
     };
 };
 /** Maintenance type, for enhancement-project counting. */

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.7.0",
+  "version": "0.9.0",
   "engines": {
     "node": ">=24.0.0"
   },