@filipebraida/adonis-function-points 0.4.0 → 0.5.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.5.0
+
+**Rule set `afp@1.4.0`.** Two classification defects are fixed and both move numbers,
+so a 0.4.0 baseline has to be recounted.
+
+Found by auditing a production count function by function against the code, rather than
+by reading the report's warnings — which is where the previous rounds had been looking.
+
+### Fixed
+
+- **Maintenance was decided per REQUEST instead of per store.** `behavior.writes`
+  decides EI against EO and was also read as "this store is maintained", so every store
+  a writing transaction touched became an ILF. A reference table merely READ by a route
+  that writes something else counted as maintained. On a production application this
+  left exactly one EIF in the whole count, which should have been the signal.
+- **Seeders, tests and factories counted as maintenance.** The project-wide pass read a
+  seeder's inserts as the application maintaining a table, so reference data only the
+  seed populates came out as an ILF — which the CPM does not allow. The filter on scan
+  roots drops `tests/` and `database/` only at the ROOT, and a domain-module layout puts
+  both inside `app/`. It now applies at any depth.
+- **The override warning counted floors that were already answered**, said "one schema"
+  whatever it was given, and therefore fired on a configuration that was complete.
+- **`opaqueReviewed` matching nothing was silent.** `detFromSchema` already warns when
+  it names a schema that is not declared; a review naming a field that does not exist
+  reviewed nothing while the warning kept firing, which reads as the tool ignoring the
+  configuration.
+- **A review was invisible in `fp:explain`.** Its reason appeared nowhere, which defeats
+  requiring one. Reviewed floors are now marked `(opaque, reviewed)` and the reason is
+  printed — without being counted in the "Declared by override" share, since a review
+  declares no number.
+
+### Documented
+
+- **In CI, prefer the standalone binary.** `node ace` validates `start/env.ts` before
+  running any command, so `node ace fp:count` fails on a missing environment variable
+  that has nothing to do with counting — measured on a production application, it
+  stopped at `Missing environment variable "AUTHZ_STORE"` and never reached the
+  command. The `fp:*` commands declare `startApp: false`, which is not enough. The
+  README said the two front-ends were interchangeable; for a pipeline that only checks
+  out code, they are not.
+
+### New
+
+- **`CallResolver.technicalWrite()`** declares that a write is not what the transaction
+  is for. §6.5.3 reads any write as an EI, which misreads a screen that records the
+  visit; the CPM asks about primary intent. The fact is declared about the CALL, so a
+  bookkeeping helper called from several screens is declared once. It does not hide the
+  write: the store stays an ILF and stays an FTR.
+- **`boundary.business` says when it contradicts the code.** It accepted without comment
+  a table nothing in the application writes — which is how two read-only lookup tables
+  were declared as business data on the belief they had a CRUD, when the routes were
+  `.only(['index', 'show'])`. The declaration is still honoured; the fact is reported.
+
 ## 0.4.0
 
 **Rule set `afp@1.3.0`.** Conditional validator groups now count, and a nested

package/README.md

@@ -13,7 +13,7 @@ node ace fp:count
 
 ```
 Unadjusted count: 46 FP
-Ruleset: afp@1.3.0
+Ruleset: afp@1.4.0
 
 type      n     FP
 ILF       2     14
@@ -63,11 +63,21 @@ For CI, or a one-off count on a project you do not want to touch:
 npx @filipebraida/adonis-function-points count --root ./my-app
 ```
 
-Nothing is booted either way — the engine only reads files — so a standalone
-run needs no `.env`, no database, and no install inside the analysed project.
-The standalone binary **does not replace installing**: a project that installs
-the package keeps the `node ace fp:*` commands, and both front-ends call the
-same code, so they cannot disagree about a number.
+The engine itself boots nothing — it only reads files — and the standalone binary
+needs no `.env`, no database, and no install inside the analysed project. The
+`fp:*` commands declare `startApp: false` for the same reason.
+
+**In CI, prefer the standalone binary.** Not for convenience: `node ace` validates
+`start/env.ts` before it runs any command, so `node ace fp:count` fails on a
+missing environment variable that has nothing to do with counting. Measured on a
+production application, it stopped at `Missing environment variable "AUTHZ_STORE"`
+and never reached the command. A pipeline that only checks out the code has no
+secrets, and does not need them to count.
+
+The standalone binary **does not replace installing**: a project that installs the
+package keeps the `node ace fp:*` commands — which is the right front-end at a
+developer's terminal, where the `.env` is already there — and both call the same
+code, so they cannot disagree about a number.
 
 ```
 adonis-function-points <command> [options]
@@ -75,6 +85,7 @@ adonis-function-points <command> [options]
   count                    count the unadjusted function points
   inventory                the raw facts: stores, routes, tracing coverage
   explain <name>           why one function was counted that way
+  metrics                  density, coupling and conformance, from the same run
   diff <previous.json>     additions / modifications / deletions, and billable FP
   calibrate <samples.csv>  correction factors against a manual count
 

package/build/commands/main.js

@@ -14,27 +14,27 @@
 const commands = [
 	{
 		commandName: "fp:inventory",
-		importer: () => import("../fp_inventory-DHwZzEQf.js")
+		importer: () => import("../fp_inventory-CPtmuuke.js")
 	},
 	{
 		commandName: "fp:metrics",
-		importer: () => import("../fp_metrics-M84qLYaE.js")
+		importer: () => import("../fp_metrics-et8F1Wvt.js")
 	},
 	{
 		commandName: "fp:count",
-		importer: () => import("../fp_count-DNSwaLUD.js")
+		importer: () => import("../fp_count-ChtblhZV.js")
 	},
 	{
 		commandName: "fp:explain",
-		importer: () => import("../fp_explain-Dpiby5Qx.js")
+		importer: () => import("../fp_explain-DZJ--0-S.js")
 	},
 	{
 		commandName: "fp:diff",
-		importer: () => import("../fp_diff-CCKxqGKh.js")
+		importer: () => import("../fp_diff-Dt7J4IWu.js")
 	},
 	{
 		commandName: "fp:calibrate",
-		importer: () => import("../fp_calibrate-DLZP5bUp.js")
+		importer: () => import("../fp_calibrate-DUbHiifm.js")
 	}
 ];
 let cache = null;

package/build/{fp_calibrate-DLZP5bUp.js → fp_calibrate-DUbHiifm.js}

@@ -1,4 +1,4 @@
-import { s as printResult, t as runCalibrate } from "./runners-DetZGfh5.js";
+import { s as printResult, t as runCalibrate } from "./runners-DIt1G85i.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-DNSwaLUD.js → fp_count-ChtblhZV.js}

@@ -1,4 +1,4 @@
-import { n as runCount, s as printResult } from "./runners-DetZGfh5.js";
+import { n as runCount, s as printResult } from "./runners-DIt1G85i.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-CCKxqGKh.js → fp_diff-Dt7J4IWu.js}

@@ -1,4 +1,4 @@
-import { r as runDiff, s as printResult } from "./runners-DetZGfh5.js";
+import { r as runDiff, s as printResult } from "./runners-DIt1G85i.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-Dpiby5Qx.js → fp_explain-DZJ--0-S.js}

@@ -1,4 +1,4 @@
-import { i as runExplain, s as printResult } from "./runners-DetZGfh5.js";
+import { i as runExplain, s as printResult } from "./runners-DIt1G85i.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-DHwZzEQf.js → fp_inventory-CPtmuuke.js}

@@ -1,4 +1,4 @@
-import { a as runInventory, s as printResult } from "./runners-DetZGfh5.js";
+import { a as runInventory, s as printResult } from "./runners-DIt1G85i.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-M84qLYaE.js → fp_metrics-et8F1Wvt.js}

@@ -1,4 +1,4 @@
-import { o as runMetrics, s as printResult } from "./runners-DetZGfh5.js";
+import { o as runMetrics, s as printResult } from "./runners-DIt1G85i.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 diffCounts, i as measureStructure, n as parseSamples, o as IncomparableRulesetsError, r as measureConformance, s as IncomparableSourcesError, t as calibrate, u as defineConfig } from "./calibration-8eV8CEix.js";
 import "./src/types.js";
-import { t as BUILTIN_CALL_RESOLVERS } from "./resolvers-vMahHkAd.js";
-import { i as RULESET_VERSION, n as analyze, r as RULESET, t as CoverageTooLowError } from "./pipeline-Dm9KvUvF.js";
+import { t as BUILTIN_CALL_RESOLVERS } from "./resolvers-PJwo2Z8R.js";
+import { i as RULESET_VERSION, n as analyze, r as RULESET, t as CoverageTooLowError } from "./pipeline-CNTBhs6o.js";
 export { AEP_FACTORS, BUILTIN_CALL_RESOLVERS, CoverageTooLowError, IncomparableRulesetsError, IncomparableSourcesError, RULESET, RULESET_VERSION, analyze, calibrate, configure, defineConfig, diffCounts, measureConformance, measureStructure, parseSamples };

package/build/{pipeline-Dm9KvUvF.js → pipeline-CNTBhs6o.js}

@@ -1,4 +1,4 @@
-import { a as rootSymbolOf, c as samePath, i as hooksFiredBy, l as toPosix, n as resolveCall, o as collectEventBindings, r as detectAccess, s as relativeTo, t as BUILTIN_CALL_RESOLVERS } from "./resolvers-vMahHkAd.js";
+import { a as hooksFiredBy, c as isApplicationCode, d as toPosix, i as detectAccess, l as relativeTo, n as isTechnicalWrite, o as rootSymbolOf, r as resolveCall, s as collectEventBindings, t as BUILTIN_CALL_RESOLVERS, u as samePath } from "./resolvers-PJwo2Z8R.js";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { Node, Project, SyntaxKind } from "ts-morph";
@@ -1586,12 +1586,34 @@ function createAnalyzer(app, stores, options = {}) {
 		const unresolved = [];
 		const validator = validatorFieldsIn(body, file, app);
 		const request = requestFieldsIn(body);
+		const context = {
+			file,
+			depth: 0,
+			imports,
+			exportedAs,
+			injected,
+			eventBindings,
+			dataStoresBySymbol: storesByName,
+			resolveSpecifier: app.resolveSpecifier,
+			sourceFile
+		};
 		for (const call of body.getDescendantsOfKind(SyntaxKind.CallExpression)) {
 			const access = detectAccess(call, symbols, relationsByStore);
 			if (access) {
+				/**
+				* Asked about a DIRECT write too, not only about a call a resolver follows.
+				*
+				* `Notification.query().…update({ status: 'read' })` in a `show` handler is
+				* exactly the shape this exists for, and the write IS the call — there is no
+				* method to declare. Asking in one place only would have covered the service
+				* call and missed the query builder beside it, which is the same fact written
+				* differently.
+				*/
+				const technical = access.mode === "write" && isTechnicalWrite(call, context, resolvers);
 				accesses.push({
 					store: access.store,
-					write: access.mode === "write"
+					write: access.mode === "write",
+					technical
 				});
 				/**
 				* A relation reached by `preload`/`load` is read; one written through
@@ -1619,21 +1641,18 @@ function createAnalyzer(app, stores, options = {}) {
 			* shape must not be CLAIMED, not merely not reported.
 			*/
 			if (isIterationCall(call)) continue;
-			const resolved = resolveCall(call, {
-				file,
-				depth: 0,
-				imports,
-				exportedAs,
-				injected,
-				eventBindings,
-				dataStoresBySymbol: storesByName,
-				resolveSpecifier: app.resolveSpecifier,
-				sourceFile
-			}, resolvers);
+			const resolved = resolveCall(call, context, resolvers);
 			if (resolved) {
+				/**
+				* Declared about the CALL, so everything reached through it is incidental too:
+				* `persistOrganizationVisit` is called from several screens and saying it once
+				* covers all of them.
+				*/
+				const technical = isTechnicalWrite(call, context, resolvers);
 				for (const next of resolved.refs) followUps.push({
 					ref: next,
-					by: resolved.by
+					by: resolved.by,
+					technical
 				});
 				continue;
 			}
@@ -1673,6 +1692,17 @@ function createAnalyzer(app, stores, options = {}) {
 	const writtenAnywhere = () => {
 		const written = /* @__PURE__ */ new Set();
 		for (const file of project.getSourceFiles()) {
+			/**
+			* A seeder's inserts are not the application maintaining a table, and a test
+			* factory's are not either. Counting them made every reference table an ILF:
+			* the CPM puts data maintained by the development team at an EIF at most, and
+			* code data outside the count entirely.
+			*
+			* This is the same notion `scanRoots` applies at the root, applied at any
+			* depth — because a domain-module layout puts `tests/` and `seeders/` inside
+			* `app/`, where the root filter never looks.
+			*/
+			if (!isApplicationCode(app.root, file.getFilePath())) continue;
 			const symbols = storeSymbolsFor(file, file, app, storesByName);
 			if (symbols.size === 0) continue;
 			for (const call of file.getDescendantsOfKind(SyntaxKind.CallExpression)) {
@@ -1698,6 +1728,7 @@ function createAnalyzer(app, stores, options = {}) {
 	};
 	function run(handler) {
 		const touches = /* @__PURE__ */ new Set();
+		const writtenStores = /* @__PURE__ */ new Set();
 		const inputFields = /* @__PURE__ */ new Set();
 		const opaqueInputFields = /* @__PURE__ */ new Set();
 		const requestFields = /* @__PURE__ */ new Set();
@@ -1707,7 +1738,7 @@ function createAnalyzer(app, stores, options = {}) {
 		const unresolved = [];
 		const visited = /* @__PURE__ */ new Set();
 		let writes = false;
-		const visit = (ref, depth) => {
+		const visit = (ref, depth, technical = false) => {
 			const key = `${ref.file}#${ref.member ?? ref.line ?? "*"}`;
 			if (visited.has(key) || depth > maxDepth) return;
 			visited.add(key);
@@ -1732,10 +1763,16 @@ function createAnalyzer(app, stores, options = {}) {
 			let bodyWrites = false;
 			for (const access of facts.accesses) {
 				touches.add(access.store);
-				if (access.write) {
-					bodyWrites = true;
-					writes = true;
-				}
+				if (!access.write) continue;
+				/**
+				* The store is maintained either way — a visit table really is written by this
+				* application, so it stays an ILF and stays an FTR. What a technical write does
+				* not do is decide what the transaction is FOR: §6.5.3 would read a `GET` that
+				* notes the visit as an EI, and the CPM asks about primary intent.
+				*/
+				writtenStores.add(access.store);
+				bodyWrites = true;
+				if (!technical && !access.technical) writes = true;
 			}
 			unresolved.push(...facts.unresolved);
 			for (const field of facts.validators) inputFields.add(field);
@@ -1757,7 +1794,7 @@ function createAnalyzer(app, stores, options = {}) {
 			if (depth >= maxDepth) return;
 			for (const followUp of facts.followUps) {
 				const before = trace.length;
-				visit(followUp.ref, depth + 1);
+				visit(followUp.ref, depth + 1, technical || followUp.technical === true);
 				if (trace.length > before) trace[before].by = followUp.by;
 			}
 		};
@@ -1765,6 +1802,7 @@ function createAnalyzer(app, stores, options = {}) {
 		return {
 			writes,
 			touches: [...touches].sort(),
+			writtenStores: [...writtenStores].sort(),
 			inputFields: [...inputFields].sort(),
 			opaqueInputFields: [...opaqueInputFields].sort(),
 			requestFields: [...requestFields].sort(),
@@ -2348,7 +2386,7 @@ const RULESET = "afp";
 * 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.3.0";
+const RULESET_VERSION = "1.4.0";
 function count(input, options = {}) {
 	const warnings = [];
 	const usage = usageOf(input);
@@ -2377,7 +2415,17 @@ function count(input, options = {}) {
 		* quietly counting one more store.
 		*/
 		if (business.has(store.name) || business.has(store.table ?? "")) {
-			warnings.push(`kept by boundary configuration: ${store.name} — the AFP naming filter had excluded it (${technical})`);
+			/**
+			* Whether any transaction WRITES it, said out loud.
+			*
+			* `business` is meant for data the user maintains, and it accepted without
+			* comment a table nothing in the application writes. That is how a team put two
+			* read-only lookup tables in it believing they had a CRUD — the routes were
+			* `.only(['index', 'show'])`. The declaration is still honoured, because only a
+			* person knows, but the fact that contradicts it is now in the report.
+			*/
+			const maintained = usage.get(store.name)?.written === true || (input.writtenAnywhere?.has(store.name) ?? false);
+			warnings.push(`kept by boundary configuration: ${store.name} — the AFP naming filter had excluded it (${technical})` + (maintained ? "" : ". NOTE: no transaction of this application writes it, so it counts as an EIF — check that the screens for it are more than index and show"));
 			return true;
 		}
 		warnings.push(`technical, excluded: ${store.name} (${technical})`);
@@ -2410,7 +2458,7 @@ function count(input, options = {}) {
 	* reviewed is still printed.
 	*/
 	const reviewed = reviewedOpaque(options.overrides ?? {});
-	const functions = applyOverrides([...dataFunctions, ...transactionalFunctions], options.overrides ?? {}, input.jsonSchemas ?? /* @__PURE__ */ new Map(), tables, weights, warnings);
+	const functions = applyOverrides([...dataFunctions, ...transactionalFunctions], options.overrides ?? {}, input.jsonSchemas ?? /* @__PURE__ */ new Map(), tables, weights, warnings, reviewed);
 	/**
 	* Reported AFTER the overrides are applied, because the overrides are the answer
 	* to it.
@@ -2423,7 +2471,8 @@ function count(input, options = {}) {
 	const declared = new Set(functions.filter((fn) => fn.rationale.overrides?.some((o) => o.fields.includes("det"))).map((fn) => fn.name));
 	warnings.push(...opaqueWarnings(countable, input, {
 		reviewed,
-		declared
+		declared,
+		overrides: options.overrides ?? {}
 	}));
 	warnings.push(...unreadableInputWarnings(input));
 	return {
@@ -2458,9 +2507,35 @@ function reviewedOpaque(overrides) {
 	for (const [name, override] of Object.entries(overrides)) for (const entry of override.opaqueReviewed ?? []) {
 		reviewed.add(entry);
 		reviewed.add(`${name}.${entry}`);
+		/**
+		* The bare field too, because the two sides of this comparison spell things
+		* differently. `opaqueReviewed` is written against the FUNCTION (`Petition.schema`)
+		* while a rationale source carries the TABLE (`ast:petitions.schema`), and the
+		* qualified form cannot be recovered from either. The last segment is what they
+		* share, and without it a correctly written review matched the count and not the
+		* rationale — so `fp:explain` showed no review and the override warning still
+		* claimed five unanswered floors.
+		*/
+		reviewed.add(entry.split(".").pop() ?? entry);
 	}
 	return reviewed;
 }
+/**
+* The identity of an opaque DET inside a rationale source.
+*
+* `ast:petitions.schema (opaque)` is the store's TABLE name, and `opaqueReviewed` is
+* written against the FUNCTION name (`Petition.schema`), so the qualified form cannot
+* be recovered from the source alone — the bare field is what both sides share.
+*/
+const opaqueNameOf = (source) => source.replace(/^[a-z-]+:/, "").replace(/ \(opaque.*\)$/, "");
+const shortOpaqueNameOf = (source) => opaqueNameOf(source).split(".").pop() ?? "";
+/** `fp:explain` should say which floors someone has already looked at */
+function markReviewed(sources, reviewed) {
+	return sources.map((source) => {
+		if (!source.endsWith("(opaque)")) return source;
+		return reviewed.has(opaqueNameOf(source)) || reviewed.has(shortOpaqueNameOf(source)) ? source.replace("(opaque)", "(opaque, reviewed)") : source;
+	});
+}
 /** a column whose shape says nothing about what it holds */
 const OPAQUE_TYPE = /^(object|any|unknown|Record<|Json|JSON)/;
 /**
@@ -2491,6 +2566,7 @@ function opaqueWarnings(stores, input, state) {
 			kind,
 			floor: [],
 			reviewed: 0,
+			reviewedNames: [],
 			transactions
 		};
 		byFunction.set(name, found);
@@ -2501,15 +2577,40 @@ function opaqueWarnings(stores, input, state) {
 		for (const attribute of store.attributes) {
 			if (!attribute.type || !OPAQUE_TYPE.test(attribute.type)) continue;
 			const entry = tally(store.name, "column", reached.get(store.name) ?? 0);
-			if (state.reviewed.has(`${store.name}.${attribute.name}`) || state.reviewed.has(attribute.name)) entry.reviewed += 1;
-			else entry.floor.push(`${attribute.name} (${attribute.type})`);
+			if (state.reviewed.has(`${store.name}.${attribute.name}`) || state.reviewed.has(attribute.name)) {
+				entry.reviewed += 1;
+				entry.reviewedNames.push(attribute.name);
+			} else entry.floor.push(`${attribute.name} (${attribute.type})`);
 		}
 	}
 	for (const point of input.entryPoints) for (const field of input.behaviors.get(point.id)?.opaqueInputFields ?? []) {
 		const entry = tally(point.identity, "input object", 1);
-		if (state.reviewed.has(field) || state.reviewed.has(`${point.identity}.${field}`)) entry.reviewed += 1;
-		else entry.floor.push(field);
+		if (state.reviewed.has(field) || state.reviewed.has(`${point.identity}.${field}`)) {
+			entry.reviewed += 1;
+			entry.reviewedNames.push(field);
+		} else entry.floor.push(field);
 	}
+	/**
+	* A review that matches nothing is a review that does nothing.
+	*
+	* `detFromSchema` already warns when it names a schema that is not declared, and
+	* `opaqueReviewed` did not — so `['messages.schema']` against a field actually named
+	* `createMessageValidator.messages.schema` reviewed nothing in silence while the
+	* warning kept firing, which reads as the tool ignoring the configuration.
+	*/
+	const seen = /* @__PURE__ */ new Set();
+	for (const [name, entry] of byFunction) for (const field of [...entry.floor, ...entry.reviewedNames]) {
+		const bare = field.replace(/ \(.*\)$/, "");
+		seen.add(bare);
+		seen.add(`${name}.${bare}`);
+		seen.add(bare.split(".").pop() ?? bare);
+	}
+	const unmatched = [];
+	for (const [name, override] of Object.entries(state.overrides)) for (const declaredName of override.opaqueReviewed ?? []) if (![
+		declaredName,
+		`${name}.${declaredName}`,
+		declaredName.split(".").pop() ?? ""
+	].some((spelling) => seen.has(spelling))) unmatched.push(`${name}.opaqueReviewed: ${declaredName}`);
 	const lines = [];
 	let answered = 0;
 	for (const [name, entry] of byFunction) {
@@ -2529,11 +2630,13 @@ function opaqueWarnings(stores, input, state) {
 		lines.push(`  ${name} — ${remaining.length} ${entry.kind}(s) at 1 DET${reach}` + (answeredHere.length > 0 ? ` (${answeredHere.join(", ")} already)` : "") + `: ${remaining.map((f) => entry.kind === "column" ? `${name}.${f}` : f).join(", ")}`);
 	}
 	const settled = answered === 0 ? [] : [`  (${answered} more function(s) whose opaque DETs are all accounted for)`];
-	if (lines.length === 0) return settled;
+	const unmatchedLines = unmatched.length === 0 ? [] : [`${unmatched.length} \`opaqueReviewed\` entr(ies) match no opaque DET, so they review nothing. The name is the one the count prints:`, ...unmatched.map((u) => `  ${u}`)];
+	if (lines.length === 0) return [...unmatchedLines, ...settled];
 	return [
 		`${lines.length} function(s) with a DET the analysis cannot read, counted as 1 each — a FLOOR, not a measurement. Where the fields are declared in the source, name that schema with \`overrides.detFromSchema\`; where 1 is the right answer, record it with \`overrides.<fn>.opaqueReviewed\` — counting-decisions §8:`,
 		...lines,
-		...settled
+		...settled,
+		...unmatchedLines
 	];
 }
 /**
@@ -2583,7 +2686,7 @@ function unreadableInputWarnings(input) {
 * An override naming no function is a warning, never silence: a typo in the key
 * would otherwise mean the declaration did nothing and nobody was told.
 */
-function applyOverrides(functions, overrides, schemas, tables, weights, warnings) {
+function applyOverrides(functions, overrides, schemas, tables, weights, warnings, reviewed) {
 	const keys = Object.keys(overrides);
 	if (keys.length === 0) return functions;
 	const used = /* @__PURE__ */ new Set();
@@ -2639,21 +2742,34 @@ function applyOverrides(functions, overrides, schemas, tables, weights, warnings
 				det = Math.max(fn.det - Math.min(placeholders.length, 1), 0) + schema.fields;
 				by = `config:overrides.${fn.name} (from ${schema.name}: ${schema.fields} fields)`;
 				if (placeholders.length === 0) warnings.push(`override for "${fn.name}" names schema "${schema.name}", but this function has no opaque DET for it to stand in for: the ${schema.fields} fields were ADDED to the ${fn.det} already counted. Check the override is on the right function.`);
-				else if (placeholders.length > 1) warnings.push(`override for "${fn.name}" names one schema and the function has ${placeholders.length} opaque DETs (${placeholders.join(", ")}). Only one was replaced; the others still count 1 each.`);
+				else {
+					/**
+					* Only the placeholders nobody has answered are worth reporting.
+					*
+					* The message used to count every opaque DET of the function and say "names
+					* one schema" whatever it was given. With four of five columns in
+					* `opaqueReviewed` and a LIST of two schemas, it still fired, still said
+					* "one schema", and still counted the four already answered — a warning
+					* wrong on all three counts, about a configuration that was complete.
+					*/
+					const unanswered = placeholders.filter((source) => !reviewed.has(opaqueNameOf(source)) && !reviewed.has(shortOpaqueNameOf(source)));
+					if (unanswered.length > 1) warnings.push(`override for "${fn.name}" names ${named.length === 1 ? "one schema" : `${named.length} schemas`} and the function has ${unanswered.length} unanswered opaque DETs (${unanswered.join(", ")}). One was replaced; the others still count 1 each — declare them or record them with \`opaqueReviewed\`.`);
+				}
 			}
 		}
 		const refs = override.refs ?? fn.refs;
 		const complexity = complexityOf(fn.type, refs, det, tables);
 		/**
-		* Only a DECLARED NUMBER is an override in the rationale.
+		* A review is recorded with NO fields, and the reporter's "declared by override"
+		* share counts only entries that declared one.
 		*
-		* `fp:count` prints what share of the total came from a person, and that line is
-		* the reason the mechanism is acceptable at all. An `opaqueReviewed`-only entry
-		* declares no number, and recording it here read as "1 function, 7 FP, 35% of the
-		* total declared by override" — misrepresenting the one number that exists to keep
-		* this honest. The review is recorded in the warning, which is where it belongs.
+		* Dropping it entirely lost the `reason`, so an `opaqueReviewed`-only decision
+		* appeared nowhere — not in `fp:explain`, not anywhere — which defeats the point
+		* of requiring a reason. Counting it in the share was the opposite error: it read
+		* as "1 function, 7 FP, 35% of the total declared by override" when no number had
+		* been declared at all.
 		*/
-		if (fields.length === 0) return fn;
+		const marked = markReviewed(fn.rationale.detSources, reviewed);
 		return {
 			...fn,
 			det,
@@ -2662,6 +2778,7 @@ function applyOverrides(functions, overrides, schemas, tables, weights, warnings
 			points: pointsOf(fn.type, complexity, weights),
 			rationale: {
 				...fn.rationale,
+				detSources: marked,
 				overrides: [...fn.rationale.overrides ?? [], {
 					by,
 					reason: override.reason,
@@ -2690,7 +2807,16 @@ function usageOf(input) {
 			};
 			usage.set(store, {
 				used: true,
-				written: current.written || behavior.writes
+				/**
+				* Per STORE, not per transaction.
+				*
+				* `behavior.writes` decides EI against EO and says nothing about which of
+				* the tables was written. Read as "this store is maintained", a reference
+				* table merely READ by a route that writes something else became an ILF —
+				* and on a production application that left exactly one EIF in the whole
+				* count, which should have been the signal.
+				*/
+				written: current.written || behavior.writtenStores.includes(store)
 			});
 		}
 	}
@@ -2880,6 +3006,7 @@ async function analyze(root, options = {}) {
 			entryPointId,
 			writes: behavior.writes,
 			touches: behavior.touches,
+			writtenStores: behavior.writtenStores,
 			inputFields: behavior.inputFields.map((name) => ({
 				name,
 				provenance: {

package/build/{resolvers-vMahHkAd.js → resolvers-PJwo2Z8R.js}

@@ -40,6 +40,42 @@ const toPosix = (value) => value.split("\\").join("/");
 const relativeTo = (root, value) => toPosix(path.relative(toPosix(root), toPosix(value))) || ".";
 /** Compares two paths that may have come from different sources. */
 const samePath = (a, b) => a !== void 0 && b !== void 0 && toPosix(a) === toPosix(b);
+/**
+* Is this file the application's own code, as opposed to the scaffolding around it?
+*
+* The top-level filter on `scanRoots` already drops `tests/`, `database/` and the
+* rest — but only at the ROOT. Applications organised by domain module put both
+* inside `app/`:
+*
+*     app/billing/tests/functional/invoice.spec.ts
+*     app/billing/seeders/plan_seeder.ts
+*
+* so they land in the project, and `writtenAnywhere()` read a seeder's inserts as
+* the application maintaining the table. A reference table only the seed populates
+* came out as an ILF — which the CPM does not allow: data maintained by the
+* development team is at most an EIF, and code data is not counted at all.
+*
+* The segments are AdonisJS's own: `make:test` writes to a suite directory,
+* `make:seeder` to `seeders`, `make:migration` to `migrations`, `make:factory` to
+* `factories`. The `.spec`/`.test` suffixes come from the suite globs in
+* `adonisrc.ts`.
+*/
+const SCAFFOLDING = new Set([
+	"tests",
+	"test",
+	"seeders",
+	"seeder",
+	"migrations",
+	"factories"
+]);
+function isApplicationCode(root, file) {
+	const relative = relativeTo(root, file);
+	if (relative.startsWith("..")) return false;
+	const parts = relative.split("/");
+	const name = parts.at(-1) ?? "";
+	if (/\.(spec|test)\.[jt]s$/.test(name)) return false;
+	return !parts.slice(0, -1).some((segment) => SCAFFOLDING.has(segment));
+}
 //#endregion
 //#region src/inventory/sources/event_bindings.ts
 /** the method a listener declares; AdonisJS calls `handle` unless told otherwise */
@@ -817,6 +853,15 @@ const BUILTIN_CALL_RESOLVERS = [
 * them apart. Hence specific strategies declare a lower `order` than generic
 * ones, and `module-function` comes last — it would match almost anything.
 */
+/**
+* Does any strategy call this a technical write?
+*
+* Asked separately from resolution, because the strategy that recognises the call as
+* incidental is not necessarily the one that knows where it goes.
+*/
+function isTechnicalWrite(call, ctx, resolvers = BUILTIN_CALL_RESOLVERS) {
+	return resolvers.some((resolver) => resolver.technicalWrite?.(call, ctx) === true);
+}
 function resolveCall(call, ctx, resolvers = BUILTIN_CALL_RESOLVERS) {
 	for (const resolver of resolvers) {
 		/**
@@ -837,4 +882,4 @@ function resolveCall(call, ctx, resolvers = BUILTIN_CALL_RESOLVERS) {
 	return null;
 }
 //#endregion
-export { rootSymbolOf as a, samePath as c, hooksFiredBy as i, toPosix as l, resolveCall as n, collectEventBindings as o, detectAccess as r, relativeTo as s, BUILTIN_CALL_RESOLVERS as t };
+export { hooksFiredBy as a, isApplicationCode as c, toPosix as d, detectAccess as i, relativeTo as l, isTechnicalWrite as n, rootSymbolOf as o, resolveCall as r, collectEventBindings as s, BUILTIN_CALL_RESOLVERS as t, samePath as u };

package/build/{runners-DetZGfh5.js → runners-DIt1G85i.js}

@@ -1,6 +1,6 @@
 import { c as diffCounts, i as measureStructure, l as DEFAULTS, n as parseSamples, o as IncomparableRulesetsError, r as measureConformance, s as IncomparableSourcesError, t as calibrate, u as defineConfig } from "./calibration-8eV8CEix.js";
-import { l as toPosix } from "./resolvers-vMahHkAd.js";
-import { n as analyze } from "./pipeline-Dm9KvUvF.js";
+import { d as toPosix } from "./resolvers-PJwo2Z8R.js";
+import { n as analyze } from "./pipeline-CNTBhs6o.js";
 import { readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { existsSync } from "node:fs";
@@ -91,7 +91,12 @@ function renderCount(result) {
 	* habit: if it grows, the count comes from a spreadsheet and the tool loses
 	* its reason to exist. Printing the share is what keeps that visible.
 	*/
-	const overridden = result.functions.filter((fn) => fn.rationale.overrides?.length);
+	/**
+	* Only entries that DECLARED a number. A review records a decision and declares
+	* nothing, so counting it here would read as "35% of the total declared by
+	* override" about a count nobody touched.
+	*/
+	const overridden = result.functions.filter((fn) => fn.rationale.overrides?.some((o) => o.fields.length > 0));
 	if (overridden.length > 0) {
 		const points = overridden.reduce((total, fn) => total + fn.points, 0);
 		const share = (points / (result.totals.unadjusted || 1) * 100).toFixed(1);

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

@@ -34,7 +34,7 @@ export declare const RULESET = "afp";
  * 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.3.0";
+export declare const RULESET_VERSION = "1.4.0";
 export type CountInput = {
     app: AppContext;
     stores: CollectedDataStore[];

package/build/src/cli.js

@@ -1,5 +1,5 @@
-import { t as CoverageTooLowError } from "../pipeline-Dm9KvUvF.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-DetZGfh5.js";
+import { t as CoverageTooLowError } from "../pipeline-CNTBhs6o.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-DIt1G85i.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

@@ -30,6 +30,16 @@ export type Behavior = {
     writes: boolean;
     /** data stores reached */
     touches: string[];
+    /**
+     * Of those, the ones this transaction WRITES.
+     *
+     * `writes` is a property of the transaction — it decides EI against EO — and was
+     * being read as a property of every store the transaction touched: a table merely
+     * read by a route that writes something else counted as maintained, so almost
+     * nothing could be an EIF. §6.5.4 asks who maintains THIS store, which is a
+     * question about the access, not about the request.
+     */
+    writtenStores: string[];
     /**
      * Declared input fields: `request.validateUsing(x)` resolved down to the
      * fields of the VineJS schema — counting-decisions §7.

package/build/src/inventory/paths.d.ts

@@ -37,3 +37,4 @@ export declare const toPosix: (value: string) => string;
 export declare const relativeTo: (root: string, value: string) => string;
 /** Compares two paths that may have come from different sources. */
 export declare const samePath: (a: string | undefined, b: string | undefined) => boolean;
+export declare function isApplicationCode(root: string, file: string): boolean;

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

@@ -17,6 +17,13 @@ export declare const BUILTIN_CALL_RESOLVERS: CallResolver[];
  * them apart. Hence specific strategies declare a lower `order` than generic
  * ones, and `module-function` comes last — it would match almost anything.
  */
+/**
+ * Does any strategy call this a technical write?
+ *
+ * Asked separately from resolution, because the strategy that recognises the call as
+ * incidental is not necessarily the one that knows where it goes.
+ */
+export declare function isTechnicalWrite(call: import('ts-morph').CallExpression, ctx: import('./types.js').ResolverContext, resolvers?: CallResolver[]): boolean;
 export declare function resolveCall(call: import('ts-morph').CallExpression, ctx: import('./types.js').ResolverContext, resolvers?: CallResolver[]): {
     by: string;
     refs: import('../../types.js').HandlerRef[];

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

@@ -1,2 +1,2 @@
-import { n as resolveCall, t as BUILTIN_CALL_RESOLVERS } from "../../../resolvers-vMahHkAd.js";
-export { BUILTIN_CALL_RESOLVERS, resolveCall };
+import { n as isTechnicalWrite, r as resolveCall, t as BUILTIN_CALL_RESOLVERS } from "../../../resolvers-PJwo2Z8R.js";
+export { BUILTIN_CALL_RESOLVERS, isTechnicalWrite, resolveCall };

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

@@ -97,4 +97,23 @@ export interface CallResolver {
      * defect this package can have, whoever writes it.
      */
     ignores?(call: CallExpression, ctx: ResolverContext): boolean;
+    /**
+     * "This call writes, and the write is not what the transaction is FOR."
+     *
+     * AFP §6.5.3 decides EI against EO mechanically: a transaction that modifies a data
+     * store is an EI. That is deliberate — repeatability over CPM fidelity — and it
+     * misreads one shape: a screen that records a visit, a last-seen organisation, a
+     * view counter. The CPM asks what the elementary process is PRIMARILY for, and for a
+     * `GET` that shows a record while noting the visit, the answer is presentation.
+     *
+     * So the fact is declared about the CALL, not about each transaction that reaches it:
+     * `persistOrganizationVisit` is called from several screens and saying it once covers
+     * all of them.
+     *
+     * It does NOT hide the write. The store is still maintained by this application —
+     * still an ILF, still an FTR of the transaction — and only the transaction's
+     * classification changes. A resolver that wanted the write to disappear would use
+     * `ignores`, and would be wrong to.
+     */
+    technicalWrite?(call: CallExpression, ctx: ResolverContext): boolean;
 }

package/build/src/pipeline.js

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

package/build/src/types.d.ts

@@ -84,6 +84,8 @@ export type HandlerBehavior = {
     writes: boolean;
     /** DataStores reached (ids) */
     touches: string[];
+    /** of those, the ones this transaction writes — §6.5.4 is per store, not per request */
+    writtenStores: string[];
     /** declared input fields (validators) */
     inputFields: Field[];
     /**

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