@filipebraida/adonis-function-points 0.8.0 → 0.10.0

package/CHANGELOG.md

@@ -6,6 +6,105 @@ 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.10.0
+
+**Rule set `afp@1.9.0`.** One rule and two report fixes, from a team's third review of their
+own count — the one they accepted as a baseline. The rule moves no point on the three
+validated applications and no point on its fixture: it moves a gap from the wrong line to
+the right one. A 0.9.0 baseline still has to be recounted, because the rule set says so.
+
+### Fixed
+
+- **A warning names a transaction the way the table and the config keys do.** Four warnings
+  printed the route's own pattern (`GET /orders/:id`) where the table, `fp:explain` and the
+  keys of `overrides` / `boundary.ignoreEntryPoints` use the identity (`GET /orders/:param`,
+  §5). Copying from a warning into the configuration required a translation nobody was told
+  about. All of them print the identity now.
+- **"leaves whole — page never reads X" contradicted itself.** The rule was right — a store
+  handed to a page that uses nothing of it the reader can see leaves whole, in the open, never
+  as a floor — and the sentence was not. It says now: "handed to page "x", and nothing the
+  reader can see uses X: every column counted, in the open".
+
+### Counting
+
+- **The value of a transaction callback is what it returns.** `const { row } = await
+db.transaction(async (trx) => { … return { row: created } })`, then `row.save()`: the write
+  was an unreadable receiver. The callback is a body — its own locals are bound first, in
+  source order — and every `return` names the store the value holds, whole or under one key
+  of a returned literal; `Model.transaction` and `trx.transaction` are the same shape. A
+  returned number binds nothing; a raw-query row nobody can type stays reported. On the three
+  applications the value of a transaction callback is used 17 times. The 0.8 rule "a value a
+  package built is not a store" narrows to a call with no function argument: `db` is a
+  package import, and `db.transaction(cb)` hands back the application's value.
+
+### Documented
+
+- counting-decisions §3 gains the transaction-callback row of the bindings table.
+- Fixtures: `transacao_valor` (18 FP — the same before and after; one unresolved call moves
+  from `row.save` to the raw-query row that deserves it); `inertia_pages` grows a page that
+  uses nothing of its rows (29 FP).
+- Measured and set aside: a model's instance method that writes — one in 52 models on the
+  three applications, not a rule.
+
+## 0.9.0
+
+**Rule set `afp@1.8.0`.** Two rules from a team's second review of their own count, one
+report fixed, and a rule about the library itself. A 0.8.0 baseline has to be recounted:
+the totals move 0, −3 and +1 FP — a writing transaction leaves EO for EI, two EIs gain an
+FTR — and the coverage line now means one thing in both reports.
+
+### Fixed
+
+- **The unresolved calls are listed, once each, and the inventory and the count show one
+  number.** The 0.8 CHANGELOG said `fp:inventory` listed them; it printed a total — and the
+  count printed a different total, because it summed each transaction's unresolved calls
+  (a body five routes reach counted five times) while the inventory added the route and
+  store problems. Now `inventory.unresolved` and `count.confidence.unresolved` are the same
+  list — one entry per site (`file:line expression — reason`, how many transactions reach
+  it), route and store problems included — and `unresolvedCalls` is its length in both.
+  `fp:inventory` prints every site, `fp:count` up to 25, `--json` / `--out` carry them. The
+  number changes without any code changing: it counts places to look at now, which is what
+  a person acts on.
+- **A method the model declares is application code.** `const items = await
+order.pendingItems().forUpdate()`, then `item.save()` in a loop: the rows come from a
+  method declared on the model class, and the chain was read as an access to the model at
+  its root — the write went to the wrong store, or was reported unreadable. The method's
+  return annotation (`typeof Item`), or its returns when every one is `Item.query()…`, names
+  the store; a builder chain after it hands the same rows on, an aggregate a number; the
+  chain is read from its innermost call outwards. On the reviewing team's application the
+  one writing transaction still counted as EO after 0.8 turns EI (7 → 4 FP).
+
+### New
+
+- **A listener written inline is a listener, and a string event is an event.**
+  `emitter.on('order:closed', async function ({ orderId }) { … })` binds a body to a
+  string, and the collector read only `emitter.on(EventClass, [ListenerClass])`: an
+  application that binds every listener this way had none followed, its jobs "reached by no
+  transaction", their writes nobody's FTR. The inline function or arrow is a handler located
+  by its line; the string is a binding key that `emitter.emit('…', payload)` / `emitSerial`
+  reach — the same decision as `Event.dispatch()`; a name built at runtime binds nothing;
+  `start/**` is scanned. Fixture `eventos_inline`: 27 FP where the previous rule set said 13.
+
+### The library itself
+
+- **The library names no application.** Its rules are found by recounting real
+  applications, and their names had leaked in: two heuristics keyed on one team's result
+  keys and one front-end's page layout, forty comments quoting somebody's routes and models,
+  a few shipped-doc lines. A heuristic keyed on one application's vocabulary is not a rule.
+  The result-key list keeps only framework and language conventions (one list page of one
+  application goes from 76 back to 83 DET, same FP); a module-scoped `pages/` directory is
+  read structurally; comments illustrate with the library's own domain; docs cite the
+  measurement, not the domain. `tests/unit/no_project_literals.spec.ts` holds the words that
+  belong to the validated applications — in the test, nowhere else — and fails when one
+  appears in `src`, `docs`, README or CHANGELOG.
+
+### Documented
+
+- counting-decisions §3 gains the model-method row of the bindings table; §9 gains "A
+  listener written inline is a listener; a string event is an event".
+- Fixtures: `escritas_indiretas` grows to 97 FP (a model's own query method);
+  `eventos_inline` (27 FP) is new.
+
 ## 0.8.0
 
 **Rule set `afp@1.7.0`.** One rule, wide, found by a team reviewing a 0.6.0 count of
@@ -44,7 +143,7 @@ new X()`, `(await q.first()) ?? new X()`), as `auth.user` / `auth.getUserOrFail(
 - **A service is what the container returns.** `const svc = await
 app.container.make(X)` binds `svc` to X as `new X()` already did, so `svc.method()` is
   followed. On the reviewed application this shape carried the write of
-  `POST /gestao/atribuicao` and 31 more sites.
+  the assignment route and 31 more sites.
 - A method chain on store rows handed to a delivery (`rows.map(f).join('\n')`) delivers
   the rows, not one field.
 
@@ -60,7 +159,7 @@ app.container.make(X)` binds `svc` to X as `new X()` already did, so `svc.method
   spread, a function receiving the rows, a package's `<DataTable data={…} />`, two files
   answering to one name, one prop carrying several stores, members that are not columns
   — the store leaves whole and the count says why, by transaction. Measured on the three
-  applications: **0 FP moved** (sae: three pages read, 22 stores reported; the other two
+  applications: **0 FP moved** (one of them: three pages read, 22 stores reported; the other two
   hand every raw store through a transformer). Fixture `inertia_pages` (25 FP): the DETs
   change, the points do not.
 
@@ -102,10 +201,10 @@ and most of that is new elementary processes the count had never seen.
   attribute; a yes/no, a formatted value, a framework service's answer and an Inertia
   lazy prop are one value. Without a delivery point the output falls back to the
   stores read, as before. On the applications: a home page at 1 DET became 10; a
-  petitions list at 8 DET became 60 — its nested transformers, which the unresolved
+  list page at 8 DET became 60 — its nested transformers, which the unresolved
   variant had hidden; every listing page stopped counting its filters twice.
 - **A function of the same file is followed** (`local-function`), and so is
-  `rows.map(paraLinha)`. Not only DETs: the stores those helpers read are FTRs now, and
+  `rows.map(toRow)`. Not only DETs: the stores those helpers read are FTRs now, and
   two `POST`s that wrote through a local helper moved from EO to EI. Models and modules
   imported **inside** a body (`const { default: X } = await import('#…')`) bind like a
   static import — an importer that wrote four tables this way had touched nothing.
@@ -183,7 +282,7 @@ of it is EOs losing DETs they never showed and one data function that was four.
   benchmark depends on it); a child hanging off two parents stays apart and the report
   says why. Cascade delete was measured and rejected as the signal: on one application
   11 of 13 cascades pointed at the tenant table. On the three applications the rule
-  folds four stores in all — the `Inpi*` mirror of an external registry becomes **one**
+  folds four stores in all — the four-table mirror of an external registry becomes **one**
   EIF with 4 RET, which is what the CPM says.
 - **A data function is identified by its table**, as counting-decisions §5 always said.
   Keyed by the class, renaming a model billed as a deletion plus an addition.

package/README.md

@@ -13,7 +13,7 @@ node ace fp:count
 
 ```
 Unadjusted count: 46 FP
-Ruleset: afp@1.7.0
+Ruleset: afp@1.9.0
 
 type      n     FP
 ILF       2     14

package/build/commands/main.js

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

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

@@ -1,4 +1,4 @@
-import { s as printResult, t as runCalibrate } from "./runners-BpBJsGMj.js";
+import { s as printResult, t as runCalibrate } from "./runners-b1tgLA1B.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-B_KPNKMO.js → fp_count-B5hxDyGJ.js}

@@ -1,4 +1,4 @@
-import { n as runCount, s as printResult } from "./runners-BpBJsGMj.js";
+import { n as runCount, s as printResult } from "./runners-b1tgLA1B.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-B3NhXzrb.js → fp_diff-7S8NcKIY.js}

@@ -1,4 +1,4 @@
-import { r as runDiff, s as printResult } from "./runners-BpBJsGMj.js";
+import { r as runDiff, s as printResult } from "./runners-b1tgLA1B.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-C2s6Kpaj.js → fp_explain-C4X_-Rp7.js}

@@ -1,4 +1,4 @@
-import { i as runExplain, s as printResult } from "./runners-BpBJsGMj.js";
+import { i as runExplain, s as printResult } from "./runners-b1tgLA1B.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-B322MvZT.js → fp_inventory-BJlIoetL.js}

@@ -1,4 +1,4 @@
-import { a as runInventory, s as printResult } from "./runners-BpBJsGMj.js";
+import { a as runInventory, s as printResult } from "./runners-b1tgLA1B.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-DjADb7F6.js → fp_metrics-BDKaNL0B.js}

@@ -1,4 +1,4 @@
-import { o as runMetrics, s as printResult } from "./runners-BpBJsGMj.js";
+import { o as runMetrics, s as printResult } from "./runners-b1tgLA1B.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-DhJO-qvQ.js";
-import { a as DEFAULT_TECHNICAL_PATTERNS, i as RULESET_VERSION, n as analyze, r as RULESET, t as CoverageTooLowError } from "./pipeline-C6kHKB9-.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";
 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-C6kHKB9-.js → pipeline-4sZBYGKU.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-DhJO-qvQ.js";
+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 fs from "node:fs/promises";
 import path, { dirname, join, resolve } from "node:path";
 import { Node, Project, SyntaxKind } from "ts-morph";
@@ -969,7 +969,7 @@ const problemAt = (call, expression, reason) => ({
 /**
 * Ace commands as entry points — counting-decisions §5, plan 0.7 §C.
 *
-* IFPUG counts batch processes an operator starts. `node ace noticias:importar`
+* IFPUG counts batch processes an operator starts. `node ace articles:import`
 * reads a feed and writes news: an EI exactly like a `POST`, and until this the
 * collector emitted only `kind: 'http'`, although the type had `command` and §5
 * had decided its identity since 0.1.0.
@@ -1036,7 +1036,7 @@ function baseCommandNameIn(file) {
 	}
 	return null;
 }
-/** `static commandName = 'noticias:importar'` — a literal; a computed name is nobody's identity */
+/** `static commandName = 'articles:import'` — a literal; a computed name is nobody's identity */
 function commandNameOf(cls) {
 	const property = cls.getStaticProperty("commandName");
 	if (!property || !Node.isPropertyDeclaration(property)) return null;
@@ -1190,7 +1190,8 @@ const FRAMEWORK_SERVICES = new Set([
 	"bouncer",
 	"ui",
 	"colors",
-	"app"
+	"app",
+	"prompt"
 ]);
 /** Is this call one that cannot reach a data store? */
 function isNoise(call, owner) {
@@ -1295,15 +1296,17 @@ const PASSES_THROUGH$1 = new Set([
 	"toJSON",
 	"serialize"
 ]);
-/** 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.
+*/
 const PASSES_ROWS = new Set([
 	"data",
 	"rows",
 	"items",
 	"results",
-	"list",
-	"linhas",
-	"itens"
+	"records"
 ]);
 /** properties of a result that are one value, not its rows */
 const SCALAR_PROPS = new Set([
@@ -1790,7 +1793,7 @@ function classifyCall(value, path, ctx, out, depth, pick) {
 		/**
 		* `rows.map(…).join('\n')` in a body whose parameter is `rows`: the whole input
 		* transformed, so the input says what leaves — the caller's arguments decide,
-		* and the body itself says nothing. `noticia.publicadaEm?.toISO()` on that
+		* and the body itself says nothing. `article.publicadaEm?.toISO()` on that
 		* parameter is one FIELD of it, and stays one value below.
 		*/
 		if (Node.isPropertyAccessExpression(callee) && transformsParameter(callee, ctx.body)) {
@@ -1803,7 +1806,7 @@ function classifyCall(value, path, ctx, out, depth, pick) {
 		}
 		if (Node.isPropertyAccessExpression(callee)) {
 			/**
-			* `comunicado.enviadoEm!.toISODate()`, `(a ?? b).toRFC2822()`: a FIELD read off
+			* `notice.enviadoEm!.toISODate()`, `(a ?? b).toRFC2822()`: a FIELD read off
 			* the chain, or an expression, then a method — one value. A chain rooted at
 			* `this` (`this.service.find()`) is a call into a service, and not this.
 			*/
@@ -1838,7 +1841,7 @@ function classifyCall(value, path, ctx, out, depth, pick) {
 }
 /**
 * `xs.map(cb)` with no literal in the callback: what the callback RETURNS,
-* once — a function passed by reference (`rows.map(paraLinha)`) is a call to
+* once — a function passed by reference (`rows.map(toRow)`) is a call to
 * that function over the rows; an expression body (`(m) => new T(m).toObject()`)
 * is classified as if it were the value; anything else is one repeating attribute.
 */
@@ -1877,7 +1880,7 @@ function callbackValueOf(callback) {
 }
 /**
 * Does this chain read a property (not a method) or hold an expression before
-* the method is applied? `comunicado.enviadoEm.toISO()` does; `rows.map(f).join()`
+* the method is applied? `notice.enviadoEm.toISO()` does; `rows.map(f).join()`
 * does not; a chain rooted at `this` is a service, and does not.
 */
 function readsField(node) {
@@ -1906,7 +1909,7 @@ function readsField(node) {
 }
 /**
 * Is this chain a method (or methods) applied to a plain parameter of the body,
-* with no field read in between? `rows.map(f).join(s)` is; `noticia.capa?.toISO()`
+* with no field read in between? `rows.map(f).join(s)` is; `article.capa?.toISO()`
 * reads a field first and is not.
 */
 function transformsParameter(callee, body) {
@@ -1956,7 +1959,7 @@ function returnsPrimitive(call) {
 	}
 }
 /**
-* `x.data`, `resultado.linhas`, `rows[0]`: a part of a value the body holds.
+* `x.data`, `result.rows`, `rows[0]`: a part of a value the body holds.
 *
 *   on a variable bound to a followed call    that key of what the call returns
 *   on a store-bound variable                 the store (`rows[0]`, `.data`) or a field (scalar)
@@ -1993,7 +1996,7 @@ function classifyAccess(value, path, ctx, out, depth) {
 				return;
 			}
 			/**
-			* `resultado.linhas`: one key of what the call returns; `meta.pagina` on a
+			* `result.rows`: one key of what the call returns; `meta.pagina` on a
 			* destructured `meta`: the key under the key; `rows[0]`, `.data`: the whole.
 			*/
 			const own = property && !PASSES_THROUGH$1.has(property) ? property : void 0;
@@ -2165,7 +2168,7 @@ function readPages(deliveries, env) {
 		for (const { store } of readable) {
 			if (reading.columns.has(store) || reading.unreadable.has(store)) continue;
 			const members = [...reading.unknownMembers.get(store) ?? []];
-			markUnreadable(reading, store, members.length > 0 ? `page "${page}" reads ${members.slice(0, 4).map((m) => `\`${m}\``).join(", ")} off ${store}, none of them a column of it` : `page "${page}" never reads ${store}`);
+			markUnreadable(reading, store, members.length > 0 ? `page "${page}" reads ${members.slice(0, 4).map((m) => `\`${m}\``).join(", ")} off ${store}, none of them a column of it` : `handed to page "${page}", and nothing the reader can see uses ${store}: every column counted, in the open`);
 		}
 	}
 	return reading;
@@ -2183,33 +2186,37 @@ const SKIPPED_DIRS = new Set([
 	".adonisjs"
 ]);
 /**
-* `inertia.render('livros/index')` → `inertia/pages/livros/index.tsx` (the default),
-* `app/<first>/ui/pages/<rest>.tsx` (a domain-module layout), or any `pages/` directory
-* under the root holding that path. The `resolve` function of the front-end is not
+* `inertia.render('livros/index')` → `inertia/pages/livros/index.tsx` (the default), or any
+* `pages/` directory under the root holding that path — a module-scoped one included. The `resolve` function of the front-end is not
 * run — a convention is read, a function is not.
 */
 function inertiaPageFiles(root, page) {
 	const found = /* @__PURE__ */ new Set();
+	/**
+	* `orders/show` → `<…>/orders/<…>/pages/show.tsx`: a front-end that keeps one `pages/`
+	* directory per module names the module in the page name's first segment. Read
+	* structurally — a `pages/` directory whose path carries that segment — never as a
+	* fixed layout: the default is `inertia/pages/<name>`, and anything else is one
+	* application's convention.
+	*/
 	const [first, ...rest] = page.split("/");
-	if (rest.length > 0) for (const extension of [
-		".tsx",
-		".jsx",
-		".vue",
-		".svelte"
-	]) {
-		const file = join(root, "app", first, "ui", "pages", `${rest.join("/")}${extension}`);
-		if (existsSync(file)) found.add(file);
-	}
-	for (const dir of pagesDirectories(root)) for (const extension of [
-		".tsx",
-		".jsx",
-		".vue",
-		".svelte"
-	]) {
-		const file = join(dir, `${page}${extension}`);
-		if (existsSync(file)) found.add(file);
-		const index = join(dir, page, `index${extension}`);
-		if (existsSync(index)) found.add(index);
+	for (const dir of pagesDirectories(root)) {
+		const scopedToModule = rest.length > 0 && toPosix(dir).split("/").includes(first);
+		for (const extension of [
+			".tsx",
+			".jsx",
+			".vue",
+			".svelte"
+		]) {
+			const file = join(dir, `${page}${extension}`);
+			if (existsSync(file)) found.add(file);
+			const index = join(dir, page, `index${extension}`);
+			if (existsSync(index)) found.add(index);
+			if (scopedToModule) {
+				const scoped = join(dir, `${rest.join("/")}${extension}`);
+				if (existsSync(scoped)) found.add(scoped);
+			}
+		}
 	}
 	return [...found].sort();
 }
@@ -3031,6 +3038,86 @@ function createAnalyzer(app, stores, options = {}) {
 			}
 			return found.size === 1 ? [...found][0] : null;
 		};
+		/**
+		* `order.pendingItems({ client })`: a method declared on the model class, returning
+		* `Item.query()…`. The model file is application code, and the method's annotation
+		* (`typeof Item` names the store) or its returns say what it hands back (plan 0.9 §B).
+		*/
+		const modelMethodStore = (callee, scope) => {
+			const root = rootSymbolOf(callee.getExpression());
+			const store = root ? scope.get(root) : void 0;
+			if (!store) return null;
+			const declared = storesByName.get(store);
+			const method = (declared ? sourceFile(declared.provenance.file) : null)?.getClasses().flatMap((c) => c.getMethods()).find((m) => m.getName() === callee.getName());
+			if (!method) return null;
+			const annotation = method.getReturnTypeNode()?.getText();
+			if (annotation) {
+				const named = annotation.match(/typeof\s+([A-Za-z_]\w*)/)?.[1];
+				return storeNamedBy(named ?? annotation, storesByName);
+			}
+			const found = /* @__PURE__ */ new Set();
+			for (const statement of method.getDescendantsOfKind(SyntaxKind.ReturnStatement)) {
+				const value = statement.getExpression();
+				if (!value) return null;
+				const returnedRoot = rootSymbolOf(unwrapAwait(value));
+				if (returnedRoot && storesByName.has(returnedRoot)) found.add(returnedRoot);
+				else return null;
+			}
+			return found.size === 1 ? [...found][0] : null;
+		};
+		/**
+		* `await db.transaction(async (trx) => { … return … })` — also `Model.transaction`
+		* and `trx.transaction` (a savepoint): a body whose VALUE is what it returns. The
+		* callback's own locals are bound first, in source order, so `return { row: created }`
+		* can be read; then every return names one store, or nothing binds (plan 0.10 §B).
+		*/
+		const transactionCallbackOf = (call) => {
+			const callee = call.getExpression();
+			if (!Node.isPropertyAccessExpression(callee) || callee.getName() !== "transaction") return null;
+			return call.getArguments().find((a) => Node.isArrowFunction(a) || Node.isFunctionExpression(a)) ?? null;
+		};
+		const returnsOf = (callback) => {
+			if (!Node.isArrowFunction(callback) && !Node.isFunctionExpression(callback)) return [];
+			const callbackBody = callback.getBody();
+			if (!Node.isBlock(callbackBody)) return [callbackBody];
+			const returned = [];
+			for (const statement of callbackBody.getDescendantsOfKind(SyntaxKind.ReturnStatement)) {
+				const owner = statement.getFirstAncestor((n) => Node.isArrowFunction(n) || Node.isFunctionExpression(n) || Node.isFunctionDeclaration(n) || Node.isMethodDeclaration(n));
+				const expression = statement.getExpression();
+				if (owner === callback && expression) returned.push(expression);
+			}
+			return returned;
+		};
+		const bindCallbackLocals = (callback) => {
+			for (const declaration of callback.getDescendantsOfKind(SyntaxKind.VariableDeclaration)) {
+				const nameNode = declaration.getNameNode();
+				const initializer = declaration.getInitializer();
+				if (!initializer || !Node.isIdentifier(nameNode)) continue;
+				const store = storeOfValue(initializer);
+				if (store) symbols.set(nameNode.getText(), store);
+			}
+		};
+		/** the store every return of the callback names — whole, or under one key of a returned literal */
+		const transactionValueStore = (callback, key) => {
+			bindCallbackLocals(callback);
+			const returned = returnsOf(callback);
+			if (returned.length === 0) return null;
+			const found = /* @__PURE__ */ new Set();
+			for (const expression of returned) {
+				let value = unwrapAwait(expression);
+				if (key) {
+					if (!Node.isObjectLiteralExpression(value)) return null;
+					const property = value.getProperty(key);
+					if (!property) return null;
+					value = Node.isPropertyAssignment(property) ? property.getInitializer() : Node.isShorthandPropertyAssignment(property) ? property.getNameNode() : void 0;
+					if (!value) return null;
+				}
+				const store = storeOfValue(value);
+				if (!store) return null;
+				found.add(store);
+			}
+			return found.size === 1 ? [...found][0] : null;
+		};
 		const isAuthUser = (node) => {
 			if (!authUserStore) return false;
 			const chain = Node.isCallExpression(node) ? node.getExpression() : node;
@@ -3062,9 +3149,27 @@ function createAnalyzer(app, stores, options = {}) {
 			if (isAuthUser(node)) return authUserStore;
 			if (Node.isPropertyAccessExpression(node)) return storeOfExpression(node, symbols, relationsByStore);
 			if (Node.isCallExpression(node)) {
+				const callee = node.getExpression();
+				const callback = transactionCallbackOf(node);
+				if (callback) return transactionValueStore(callback);
+				if (Node.isPropertyAccessExpression(callee)) {
+					/**
+					* `q.forUpdate()`, `q.where(…)`: a query-builder chain hands the same rows on —
+					* read from the innermost call outwards, so a model's method at the root of
+					* the chain is seen before Lucid's API is assumed for the whole chain. An
+					* aggregate (`.count()`) hands back a number.
+					*/
+					const receiver = unwrapAwait(callee.getExpression());
+					if (Node.isCallExpression(receiver)) {
+						if (AGGREGATES.has(callee.getName())) return null;
+						const inner = storeOfValue(receiver, depth + 1);
+						if (inner) return inner;
+					}
+					const fromModel = modelMethodStore(callee, symbols);
+					if (fromModel) return fromModel;
+				}
 				const access = detectAccess(node, symbols, relationsByStore);
 				if (access) return access.method === "related" && access.viaRelation ? access.viaRelation : access.store;
-				const callee = node.getExpression();
 				if (Node.isPropertyAccessExpression(callee) && ONE_OF_ROWS.has(callee.getName())) return storeOfValue(callee.getExpression(), depth + 1);
 				return returnedStoreOf(node);
 			}
@@ -3086,9 +3191,22 @@ function createAnalyzer(app, stores, options = {}) {
 				const nameNode = node.getNameNode();
 				if (!initializer) return;
 				if (Node.isIdentifier(nameNode)) {
-					if (symbols.has(nameNode.getText())) return;
+					/**
+					* Re-read even when the parameter pass already bound the name by the chain's
+					* root: `const items = await order.pendingItems().forUpdate()` is rooted at
+					* `order` and holds `Item` rows — what the model's method returns wins over
+					* where the chain started.
+					*/
 					const store = storeOfValue(initializer);
 					if (store) symbols.set(nameNode.getText(), store);
+				} else if (Node.isObjectBindingPattern(nameNode)) {
+					const call = unwrapAwait(initializer);
+					const callback = Node.isCallExpression(call) ? transactionCallbackOf(call) : null;
+					if (!callback) return;
+					for (const element of nameNode.getElements()) {
+						const store = transactionValueStore(callback, element.getPropertyNameNode()?.getText() ?? element.getName());
+						if (store) symbols.set(element.getName(), store);
+					}
 				}
 				return;
 			}
@@ -3096,7 +3214,7 @@ function createAnalyzer(app, stores, options = {}) {
 				const declared = node.getInitializer();
 				if (!Node.isVariableDeclarationList(declared)) return;
 				const nameNode = declared.getDeclarations()[0]?.getNameNode();
-				if (!nameNode || !Node.isIdentifier(nameNode) || symbols.has(nameNode.getText())) return;
+				if (!nameNode || !Node.isIdentifier(nameNode)) return;
 				const store = storeOfValue(node.getExpression());
 				if (store) symbols.set(nameNode.getText(), store);
 				return;
@@ -3107,7 +3225,7 @@ function createAnalyzer(app, stores, options = {}) {
 				const callback = node.getArguments()[0];
 				if (!callback || !(Node.isArrowFunction(callback) || Node.isFunctionExpression(callback))) return;
 				const parameter = callback.getParameters()[0]?.getNameNode();
-				if (!parameter || !Node.isIdentifier(parameter) || symbols.has(parameter.getText())) return;
+				if (!parameter || !Node.isIdentifier(parameter)) return;
 				const store = storeOfValue(callee.getExpression());
 				if (store) symbols.set(parameter.getText(), store);
 			}
@@ -3176,8 +3294,8 @@ function createAnalyzer(app, stores, options = {}) {
 				* A select list that is not literal is reported, and the store falls back
 				* to every column, which overestimates in the open.
 				*
-				* `related('itens').query().count()` reads the RELATION target, and the
-				* parent only as a receiver; `preload('itens')` reads the target whole.
+				* `related('items').query().count()` reads the RELATION target, and the
+				* parent only as a receiver; `preload('items')` reads the target whole.
 				*/
 				if (access.mode === "read") {
 					const chain = chainShapeOf(call);
@@ -3318,7 +3436,7 @@ function createAnalyzer(app, stores, options = {}) {
 	* Both project-wide facts come from one pass, computed once: which stores the
 	* application WRITES (maintenance, §6.5.4) and which it ADDRESSES directly
 	* (grouping, counting-decisions §10). A store reached only through a relation
-	* — `preload('itens')`, `related('itens').create()` — is read or written, but
+	* — `preload('items')`, `related('items').create()` — is read or written, but
 	* not addressed: the user never sees it outside its parent.
 	*/
 	let projectWide;
@@ -3465,8 +3583,8 @@ function createAnalyzer(app, stores, options = {}) {
 						}
 						const returned = facts.deliveries.returns.filter((r) => !item.pick || r.path === item.pick || r.path.startsWith(`${item.pick}.`));
 						/**
-						* `egresso.curso` where the body returns the row itself (`return
-						* Egresso.query()…first()`, path ''): the pick lands INSIDE a returned
+						* `member.curso` where the body returns the row itself (`return
+						* Member.query()…first()`, path ''): the pick lands INSIDE a returned
 						* value — one field of a store is one value; one key of a returned call
 						* is that call picked deeper.
 						*/
@@ -3727,7 +3845,7 @@ function storeSymbolsFor(body, file, app, stores, relations = /* @__PURE__ */ ne
 		}
 	}
 	/**
-	* `const { default: Noticia } = await import('#noticias/models/noticia')`: a
+	* `const { default: Article } = await import('#articles/models/article')`: a
 	* model imported INSIDE the body — an ace command does this to keep the app
 	* from booting for `--help`. The store is the same; only the binding moved.
 	*/
@@ -3808,7 +3926,7 @@ function storeSymbolsFor(body, file, app, stores, relations = /* @__PURE__ */ ne
 		}
 	}
 	/**
-	* `const { preIntake } = input` where `input.preIntake` is a registered path:
+	* `const { order } = input` where `input.order` is a registered path:
 	* each element inherits the store of its path. Read AFTER the parameters, which
 	* is where the paths come from.
 	*/
@@ -3931,6 +4049,17 @@ const ONE_OF_ROWS = new Set([
 	"first",
 	"last"
 ]);
+/** query-builder terminals that hand back one number or one yes/no, never rows */
+const AGGREGATES = new Set([
+	"count",
+	"sum",
+	"avg",
+	"min",
+	"max",
+	"exists",
+	"pojo",
+	"pluck"
+]);
 /** array methods whose callback receives one row of the receiver */
 const ITERATES_ROWS = new Set([
 	"map",
@@ -4015,8 +4144,8 @@ function importMapsOf(file, app) {
 		}
 	}
 	/**
-	* `const { default: SincronizarBulk } = await import('#inpi/actions/sincronizar_bulk')`
-	* `const { execucaoEmAndamento } = await import('#inpi/services/execucao')`
+	* `const { default: SyncCatalog } = await import('#catalog/actions/sync_catalog')`
+	* `const { runInProgress } = await import('#catalog/services/runs')`
 	*
 	* A module imported INSIDE a body — the shape ace commands use so `--help` does
 	* not boot the application. The binding moved; the body it names did not, and
@@ -4128,8 +4257,15 @@ function isUnreadableWrite(call, symbols, imports, packageImports, body) {
 		const nameNode = declaration.getNameNode();
 		if (!Node.isIdentifier(nameNode) || nameNode.getText() !== root) continue;
 		const initializer = declaration.getInitializer();
-		const origin = initializer ? rootSymbolOf(unwrapAwait(initializer)) : null;
-		if (origin && packageImports.has(origin)) return false;
+		const initialized = initializer ? unwrapAwait(initializer) : null;
+		/**
+		* `await db.transaction(async (trx) => …)` is rooted at a package too, but its value
+		* is what the CALLBACK returns — the application's. Only a call with no function
+		* argument is a package's own object.
+		*/
+		const handsBackACallback = initialized && Node.isCallExpression(initialized) && initialized.getArguments().some((a) => Node.isArrowFunction(a) || Node.isFunctionExpression(a));
+		const origin = initialized ? rootSymbolOf(initialized) : null;
+		if (origin && packageImports.has(origin) && !handsBackACallback) return false;
 	}
 	return true;
 }
@@ -5074,13 +5210,16 @@ const RULESET = "afp";
 * 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.
+* 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. One in 1.9.0: the value of a
+* transaction callback is what its returns name.
 *
 * 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.
 */
-const RULESET_VERSION = "1.7.0";
+const RULESET_VERSION = "1.9.0";
 function count(input, options = {}) {
 	const warnings = [];
 	const usage = usageOf(input);
@@ -5228,7 +5367,7 @@ function unreadableDeliveryWarnings(input) {
 	if (blind.length === 0) return [];
 	return [
 		`${blind.length} transaction(s) deliver a value the analysis cannot read — a generated document, a call nobody followed — counted as 1 DET each, a FLOOR. This UNDERSTATES the output:`,
-		...blind.slice(0, 10).map(({ entry, behavior }) => `  ${entry.trigger} ${entry.signature}: ${behavior.delivered.opaqueFields.join(", ")}`),
+		...blind.slice(0, 10).map(({ entry, behavior }) => `  ${entry.identity}: ${behavior.delivered.opaqueFields.join(", ")}`),
 		...blind.length > 10 ? [`  … and ${blind.length - 10} more`] : []
 	];
 }
@@ -5244,7 +5383,7 @@ function unreadablePageWarnings(input) {
 	for (const entry of input.entryPoints) {
 		const behavior = input.behaviors.get(entry.id);
 		if (!behavior || behavior.writes) continue;
-		for (const [store, reason] of Object.entries(behavior.unreadablePages ?? {})) lines.push(`  ${entry.trigger} ${entry.signature}: ${store} leaves whole — ${reason}`);
+		for (const [store, reason] of Object.entries(behavior.unreadablePages ?? {})) lines.push(`  ${entry.identity}: ${store} leaves whole — ${reason}`);
 	}
 	if (lines.length === 0) return [];
 	return [
@@ -5378,7 +5517,7 @@ function unreadableInputWarnings(input) {
 	if (blind.length === 0) return [];
 	return [
 		`${blind.length} transaction(s) read the request without enumerating fields (\`all()\`, \`body()\`, \`except()\`), so their input DETs could not be counted and each sits at the floor of its band. This UNDERSTATES the total — the fix is a validator, not a configuration:`,
-		...blind.slice(0, 10).map(({ entry }) => `  ${entry.trigger} ${entry.signature}`),
+		...blind.slice(0, 10).map(({ entry }) => `  ${entry.identity}`),
 		...blind.length > 10 ? [`  … and ${blind.length - 10} more`] : []
 	];
 }
@@ -5399,7 +5538,7 @@ function unreadableOutputWarnings(input) {
 	if (blind.length === 0) return [];
 	return [
 		`${blind.length} transaction(s) pass through a transformer that spreads something the analysis cannot read, counted as 1 DET each — a FLOOR. This UNDERSTATES the output; the fix is in the transformer (\`this.pick(...)\` or named keys), not a configuration:`,
-		...blind.slice(0, 10).map(({ entry, behavior }) => `  ${entry.trigger} ${entry.signature}: ${behavior.opaqueOutputFields.join(", ")}`),
+		...blind.slice(0, 10).map(({ entry, behavior }) => `  ${entry.identity}: ${behavior.opaqueOutputFields.join(", ")}`),
 		...blind.length > 10 ? [`  … and ${blind.length - 10} more`] : []
 	];
 }
@@ -5537,20 +5676,32 @@ function totalsOf(functions) {
 * reader must see that without having to go looking.
 */
 function confidenceOf(input, warnings) {
-	let unresolvedCalls = 0;
 	let withoutHandler = 0;
+	const sites = /* @__PURE__ */ new Map();
+	for (const site of input.unresolved ?? []) sites.set(`${site.file}:${site.line}:${site.expression}`, { ...site });
 	for (const entry of input.entryPoints) {
 		const behavior = input.behaviors.get(entry.id);
 		if (!behavior) {
 			withoutHandler++;
 			continue;
 		}
-		unresolvedCalls += behavior.unresolved.length;
+		if (input.unresolved) continue;
+		for (const call of behavior.unresolved) {
+			const key = `${call.file}:${call.line}:${call.expression}`;
+			const site = sites.get(key);
+			if (site) site.transactions++;
+			else sites.set(key, {
+				...call,
+				transactions: 1
+			});
+		}
 	}
+	const unresolved = [...sites.values()].sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line);
 	return {
-		unresolvedCalls,
+		unresolvedCalls: unresolved.length,
 		entryPointsWithoutHandler: withoutHandler,
-		warnings
+		warnings,
+		unresolved
 	};
 }
 //#endregion
@@ -5627,7 +5778,27 @@ async function analyze(root, options = {}) {
 	});
 	const behaviors = new Map(entryPoints.filter((entry) => entry.handler).map((entry) => [entry.id, analyzer.analyze(entry.handler)]));
 	const resolved = [...behaviors.values()].filter((behavior) => behavior.unresolved.length === 0).length;
-	const unresolvedCalls = storeProblems.length + routeProblems.length + [...behaviors.values()].reduce((total, behavior) => total + behavior.unresolved.length, 0);
+	/**
+	* One site, however many transactions reach it: a body five routes walk is one gap
+	* to close, not five. The count shows the same number — a reviewing team found 10
+	* in one report and 13 in the other and could act on neither.
+	*/
+	const sites = /* @__PURE__ */ new Map();
+	for (const problem of [...storeProblems, ...routeProblems]) sites.set(`${problem.file}:${problem.line}:${problem.expression}`, {
+		...problem,
+		transactions: 0
+	});
+	for (const behavior of behaviors.values()) for (const call of behavior.unresolved) {
+		const key = `${call.file}:${call.line}:${call.expression}`;
+		const site = sites.get(key);
+		if (site) site.transactions++;
+		else sites.set(key, {
+			...call,
+			transactions: 1
+		});
+	}
+	const unresolvedSites = [...sites.values()].sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line);
+	const unresolvedCalls = unresolvedSites.length;
 	/**
 	* Every path that LEAVES is relative to the application root.
 	*
@@ -5740,7 +5911,11 @@ async function analyze(root, options = {}) {
 			entryPointsResolved: resolved,
 			unresolvedCalls,
 			ratio: entryPoints.length === 0 ? 1 : resolved / entryPoints.length
-		}
+		},
+		unresolved: unresolvedSites.map((site) => ({
+			...site,
+			file: emit(site.file)
+		}))
 	};
 	const minimum = options.minCoverage ?? 0;
 	if (inventory.coverage.ratio < minimum) throw new CoverageTooLowError(inventory.coverage.ratio, minimum);
@@ -5754,6 +5929,7 @@ async function analyze(root, options = {}) {
 				behaviors,
 				jsonSchemas,
 				jobs: collectJobs(app),
+				unresolved: inventory.unresolved,
 				writtenAnywhere: analyzer.writtenAnywhere(),
 				addressedAnywhere: analyzer.addressedAnywhere(),
 				seededAnywhere: analyzer.seededAnywhere()

package/build/{resolvers-DhJO-qvQ.js → resolvers-CneCj3sT.js}

@@ -387,10 +387,10 @@ function classOfReceiver(receiver) {
 			return target.isKind(SyntaxKind.Identifier) ? target.getText() : null;
 		}
 		/**
-		* `const svc = await app.container.make(IntakeService)`: the container hands
+		* `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 /gestao/atribuicao`
+		* 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)) {
@@ -414,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();
@@ -421,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;
 }
@@ -451,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
@@ -528,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.
 *
@@ -550,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 [];
@@ -639,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
@@ -663,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",
@@ -676,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) {
@@ -864,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
@@ -904,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
@@ -1241,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-BpBJsGMj.js → runners-b1tgLA1B.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-DhJO-qvQ.js";
-import { n as analyze } from "./pipeline-C6kHKB9-.js";
+import { y as toPosix } from "./resolvers-CneCj3sT.js";
+import { n as analyze } from "./pipeline-4sZBYGKU.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';
@@ -44,13 +44,16 @@ export declare const RULESET = "afp";
  * 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.
+ * 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. One in 1.9.0: the value of a
+ * transaction callback is what its returns name.
  *
  * 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.7.0";
+export declare const RULESET_VERSION = "1.9.0";
 export type CountInput = {
     app: AppContext;
     stores: CollectedDataStore[];
@@ -61,6 +64,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-C6kHKB9-.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-BpBJsGMj.js";
+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 path from "node:path";
 import { existsSync, readFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";

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

@@ -43,7 +43,7 @@ type DeliveredValue =
     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;
@@ -64,7 +64,11 @@ type DeliveredValue =
     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;

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

@@ -30,7 +30,7 @@ export type PageReading = {
     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 (`inventor.nomeCompleto`, computed on the way) */
+    /** store -> members the page reads that are NOT its columns (`member.displayName`, computed on the way) */
     unknownMembers: Map<string, Set<string>>;
 };
 export type PageEnvironment = {

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-DhJO-qvQ.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-C6kHKB9-.js";
+import { n as analyze, t as CoverageTooLowError } from "../pipeline-4sZBYGKU.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

@@ -190,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;
@@ -207,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';
@@ -283,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.8.0",
+  "version": "0.10.0",
   "engines": {
     "node": ">=24.0.0"
   },