@filipebraida/adonis-function-points 0.3.0 → 0.4.0

package/CHANGELOG.md

@@ -6,6 +6,66 @@ 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.4.0
+
+**Rule set `afp@1.3.0`.** Conditional validator groups now count, and a nested
+schema is recognised however the formatter wrapped it — so a 0.3.0 baseline has to
+be recounted.
+
+Five items reported from real use of 0.3.0, three of them defects.
+
+### Fixed
+
+- **A newline decided whether a field counted.** The recogniser for a nested schema
+  was a regex over the property's source text (`/vine\.object/`), and Prettier breaks
+  a long chain across lines — `data: vine` then `.object({})` — so the regex missed
+  and the field was counted as one leaf instead of its nested ones, and never marked
+  opaque. Decided by structure now: is this literal the argument of a call named
+  `object`? The same applied to `.merge(…)` and `group.if(…)`, which had the same
+  kind of check. A count that depends on where the formatter put a newline is not a
+  measurement — the reason the implementation-scope hash strips whitespace before
+  hashing.
+- **The list of unreadable DETs ignored the overrides that answered it.** It was
+  computed before `applyOverrides` ran, so a function whose floor `detFromSchema` had
+  already replaced still appeared under "this is a FLOOR", telling the reader to map
+  something already mapped. It caused a real misreading of a production report, by
+  the author of this code. It now runs after the overrides, is grouped by FUNCTION,
+  and states per function how many were replaced by an override, how many reviewed,
+  and how many are still unanswered — only the last being a request to do anything.
+- **Emitted artefacts carried absolute paths.** `CountSource.app` is documented as
+  never being one, because that says where the machine keeps its files and travels
+  with every artefact sent anywhere — and the rule was applied to that one field. A
+  production count carried **858** absolute paths in its traces; an inventory
+  carried **2036** across ten fields, including the data-store `id`. Every path that
+  leaves is now relative to the application root, and the internal absolute form is
+  untouched because that is what ts-morph resolves against.
+- **`vine.group` and `.merge()` were not read.**
+  `vine.object({}).merge(vine.group([vine.group.if(p, {…})]))` reported the whole
+  validator as an open input object: five fields counted as one, and the report said
+  they were data when they are in the code. The branches are mutually exclusive at
+  runtime and the transaction can carry any of them, so §7.2 counts their union — a
+  field two branches share counts once. The group usually lives in an unexported
+  constant beside the validator, so the reference is resolved in the validator's own
+  file rather than the caller's.
+- **`fp:explain` matched by substring even when the exact name existed.** Asking
+  about `POST /orders/:param/submit` returned four functions, because
+  `/submit-ready` and `/submit-ready/return` contain it. An exact name now wins
+  outright; the substring search is the fallback.
+
+### New
+
+- **`detFromSchema` accepts a list**, unioned by leaf path. An ILF's DETs are the
+  fields the user recognises in the file, and an application with one schema per
+  template recognises all of them. Pointing at the largest and justifying it in
+  `reason` gives the same answer only while they land in the same band — reasoning
+  the configuration should not have to carry.
+- **`overrides.<fn>.opaqueReviewed`** records that someone looked at an opaque DET
+  and decided 1 is right. 1 DET is a floor and `fp:count` says so on every run, but
+  some of those columns really are one field, and a warning that cannot be answered
+  is one the team learns to scroll past. It moves no number, it is not counted as a
+  declared override in the "Declared by override" share, and the volume reviewed is
+  still printed.
+
 ## 0.3.0
 
 **Rule set `afp@1.2.0`.** Three counting fixes move the number for unchanged code,

package/README.md

@@ -13,7 +13,7 @@ node ace fp:count
 
 ```
 Unadjusted count: 46 FP
-Ruleset: afp@1.2.0
+Ruleset: afp@1.3.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-Bu6O1Nn0.js")
+		importer: () => import("../fp_inventory-DHwZzEQf.js")
 	},
 	{
 		commandName: "fp:metrics",
-		importer: () => import("../fp_metrics-MGDppfSa.js")
+		importer: () => import("../fp_metrics-M84qLYaE.js")
 	},
 	{
 		commandName: "fp:count",
-		importer: () => import("../fp_count-D21tQ_pv.js")
+		importer: () => import("../fp_count-DNSwaLUD.js")
 	},
 	{
 		commandName: "fp:explain",
-		importer: () => import("../fp_explain-BwFs-LW-.js")
+		importer: () => import("../fp_explain-Dpiby5Qx.js")
 	},
 	{
 		commandName: "fp:diff",
-		importer: () => import("../fp_diff-D0pHGMgi.js")
+		importer: () => import("../fp_diff-CCKxqGKh.js")
 	},
 	{
 		commandName: "fp:calibrate",
-		importer: () => import("../fp_calibrate-iFAec0tA.js")
+		importer: () => import("../fp_calibrate-DLZP5bUp.js")
 	}
 ];
 let cache = null;

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

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

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

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

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

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

@@ -1,4 +1,4 @@
-import { o as runMetrics, s as printResult } from "./runners-CmxNHuuq.js";
+import { o as runMetrics, s as printResult } from "./runners-DetZGfh5.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-CRB6lXoo.js";
-import { i as RULESET_VERSION, n as analyze, r as RULESET, t as CoverageTooLowError } from "./pipeline-CIAydCcT.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";
 export { AEP_FACTORS, BUILTIN_CALL_RESOLVERS, CoverageTooLowError, IncomparableRulesetsError, IncomparableSourcesError, RULESET, RULESET_VERSION, analyze, calibrate, configure, defineConfig, diffCounts, measureConformance, measureStructure, parseSamples };

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

@@ -1,4 +1,4 @@
-import { a as rootSymbolOf, c as toPosix, i as hooksFiredBy, n as resolveCall, o as collectEventBindings, r as detectAccess, s as samePath, t as BUILTIN_CALL_RESOLVERS } from "./resolvers-CRB6lXoo.js";
+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 fs from "node:fs/promises";
 import path from "node:path";
 import { Node, Project, SyntaxKind } from "ts-morph";
@@ -1248,7 +1248,14 @@ function validatorFieldsIn(body, file, app) {
 		const name = argument.getText();
 		const declaration = findValidator(name, file, app);
 		if (!declaration) continue;
-		const { leaves, opaque: unreadable } = leavesOf(declaration);
+		/**
+		* The reference is resolved in the VALIDATOR's file, not the caller's.
+		*
+		* `vine.object({}).merge(openaiOrAws)` names a constant that lives beside the
+		* validator and is usually not exported, so looking for it where the call site
+		* is finds nothing — which is how five fields stayed invisible.
+		*/
+		const { leaves, opaque: unreadable } = leavesOf(declaration, (ref) => findValidator(ref, declaration.getSourceFile(), app));
 		const isOpaque = new Set(unreadable);
 		for (const leaf of leaves) {
 			const field = `${name}.${leaf}`;
@@ -1344,7 +1351,54 @@ function findValidator(name, file, app) {
 	}
 	return null;
 }
-function leavesOf(node) {
+/**
+* Leaves of a VineJS schema, per the table in §7, and which of them are opaque.
+*
+* `answers: vine.object({}).allowUnknownProperties()` declares a field whose own
+* fields live in data, not in code. Walking into the empty literal found nothing
+* and then never pushed `answers` either, so the field counted ZERO — while an
+* opaque JSON column in the same position counts 1. The two are the same
+* situation and now get the same answer: one DET, and a warning that says the
+* number is a floor.
+*
+* That zero is also why `detFromSchema` was off by one. Its formula replaces the
+* opaque placeholder with the schema's fields, and there was no placeholder to
+* replace, so the subtraction ate a real field instead.
+*/
+/**
+* Is this literal the argument of a call named `name`?
+*
+* Structural, because the test used to be a regex over the property's source text
+* (`/vine\.object/`) and Prettier breaks a long chain across lines:
+*
+*     data: vine
+*       .object({})
+*       .allowUnknownProperties()
+*
+* `vine` and `.object` then sit on different lines, the regex misses, and the field
+* silently stops being recognised as an open object. A count that depends on where
+* the formatter put a newline is not a measurement — the same reason the
+* implementation-scope hash strips whitespace before hashing.
+*/
+function isArgumentOfCallNamed(literal, name) {
+	const call = literal.getParent();
+	if (!call || !Node.isCallExpression(call)) return false;
+	const callee = call.getExpression();
+	return Node.isPropertyAccessExpression(callee) && callee.getName() === name;
+}
+/** The last member of a call's callee: `vine.group.if(…)` is `if`, however it is wrapped. */
+function calleeName(call) {
+	const callee = call.getExpression();
+	return Node.isPropertyAccessExpression(callee) ? callee.getName() : void 0;
+}
+/** …and the member before it, so `group.if` can be told from any other `if`. */
+function calleeOwner(call) {
+	const callee = call.getExpression();
+	if (!Node.isPropertyAccessExpression(callee)) return void 0;
+	const owner = callee.getExpression();
+	return Node.isPropertyAccessExpression(owner) ? owner.getName() : void 0;
+}
+function leavesOf(node, resolveRef) {
 	const object = node.getFirstDescendantByKind(SyntaxKind.ObjectLiteralExpression);
 	if (!object) return {
 		leaves: [],
@@ -1356,9 +1410,8 @@ function leavesOf(node) {
 		for (const property of literal.getProperties()) {
 			if (!Node.isPropertyAssignment(property)) continue;
 			const name = property.getName().replace(/['"]/g, "");
-			const text = property.getText();
 			const nested = property.getFirstDescendantByKind(SyntaxKind.ObjectLiteralExpression);
-			if (nested && /vine\.object/.test(text)) {
+			if (nested && isArgumentOfCallNamed(nested, "object")) {
 				const path = prefix ? `${prefix}.${name}` : name;
 				/**
 				* An object declaring no properties enumerates nothing. It is the field
@@ -1378,6 +1431,20 @@ function leavesOf(node) {
 	};
 	walk(object, "");
 	/**
+	* Conditional groups: `vine.object({}).merge(vine.group([vine.group.if(p, {…})]))`.
+	*
+	* The branches are mutually exclusive at runtime and the transaction can carry
+	* any of them, so §7.2 counts the UNION — the fields the elementary process
+	* handles. Read from the first object literal alone, the whole validator looked
+	* like an open object and the count said the fields were data when they are
+	* plainly in the code: five fields reported as one, and `detFromSchema` could not
+	* fix it, because a group is not a JSON Schema.
+	*
+	* A `group.if` literal inside the outer object would be a nested schema `walk`
+	* already handled, so only the ones outside it are roots here.
+	*/
+	for (const branch of groupBranchesIn(node, object, resolveRef)) walk(branch, "");
+	/**
 	* The whole validator is an open object: nothing is enumerable, and the body
 	* that carries it is measured at the floor. Counted as one, reported as such.
 	*/
@@ -1386,10 +1453,38 @@ function leavesOf(node) {
 		opaque: ["*"]
 	};
 	return {
-		leaves,
-		opaque
+		leaves: [...new Set(leaves)],
+		opaque: [...new Set(opaque)]
 	};
 }
+/**
+* Object literals passed to `vine.group.if(…)`, following `.merge(x)` when `x` is
+* a name this file can resolve.
+*
+* The groups usually live in their own constant — which is why following the
+* reference matters more than recognising the inline form.
+*/
+function groupBranchesIn(node, outer, resolveRef, depth = 0) {
+	if (depth > 3) return [];
+	const found = [];
+	for (const call of node.getDescendantsOfKind(SyntaxKind.CallExpression)) {
+		const method = calleeName(call);
+		if ((method === "if" || method === "else") && calleeOwner(call) === "group") {
+			for (const argument of call.getArguments()) {
+				const literal = argument.asKind(SyntaxKind.ObjectLiteralExpression);
+				if (literal && !outer.getDescendants().includes(literal)) found.push(literal);
+			}
+			continue;
+		}
+		/** `.merge(openaiOrAws)`: the group is declared elsewhere */
+		if (method !== "merge" || !resolveRef) continue;
+		const reference = call.getArguments()[0];
+		if (!reference || !Node.isIdentifier(reference)) continue;
+		const declaration = resolveRef(reference.getText());
+		if (declaration) found.push(...groupBranchesIn(declaration, outer, resolveRef, depth + 1));
+	}
+	return found;
+}
 /** file name, to identify the unresolved call without dumping the full path */
 const pathOf = (file) => file.split("/").pop()?.replace(/\.ts$/, "") ?? file;
 const DEFAULT_MAX_DEPTH = 3;
@@ -2104,7 +2199,10 @@ function countTransactionalFunctions(entryPoints, behaviors, options) {
 				rule: behavior.writes ? "afp:6.5.3 modifies a data store -> EI" : "afp:6.5.3 uses without modifying -> EO (EQ collapsed per 6.5.3)",
 				detSources: sources,
 				refSources: touched.map((store) => `reaches:${store}`),
-				trace: behavior.trace
+				trace: behavior.trace.map((step) => ({
+					...step,
+					file: relativeTo(options.root, step.file)
+				}))
 			}
 		});
 	}
@@ -2250,7 +2348,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.2.0";
+const RULESET_VERSION = "1.3.0";
 function count(input, options = {}) {
 	const warnings = [];
 	const usage = usageOf(input);
@@ -2296,14 +2394,38 @@ function count(input, options = {}) {
 	const ignored = new Set(options.boundary?.ignoreEntryPoints ?? []);
 	const transactionalFunctions = countTransactionalFunctions(input.entryPoints.filter((entry) => !ignored.has(entry.identity) && !ignored.has(entry.name ?? "")), input.behaviors, {
 		countedStores,
+		root: input.app.root,
 		messageDet: options.messageDet ?? 0,
 		tables,
 		weights
 	});
-	warnings.push(...opaqueColumnWarnings(countable, input));
-	warnings.push(...unreadableInputWarnings(input));
-	warnings.push(...openValidatorWarnings(input));
+	/**
+	* `opaqueReviewed` answers a warning that is CORRECT and therefore permanent.
+	*
+	* 1 DET for an opaque column is a floor, and `fp:count` says so on every run. But
+	* some of those columns are one field — a copy, a checksum, a bag of metadata —
+	* and there was no way to record that someone had looked. A warning that cannot be
+	* answered is one the team learns to scroll past, which costs more than the warning
+	* reports. It silences nothing else: the count does not move, and how many were
+	* reviewed is still printed.
+	*/
+	const reviewed = reviewedOpaque(options.overrides ?? {});
 	const functions = applyOverrides([...dataFunctions, ...transactionalFunctions], options.overrides ?? {}, input.jsonSchemas ?? /* @__PURE__ */ new Map(), tables, weights, warnings);
+	/**
+	* Reported AFTER the overrides are applied, because the overrides are the answer
+	* to it.
+	*
+	* Computed first, the list kept naming functions whose floor had already been
+	* replaced by `detFromSchema` — telling the reader to go and map something that
+	* was mapped. It cost a real misreading: a report was taken as "two forms still
+	* unmapped" when both were declared, by whoever wrote this code.
+	*/
+	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
+	}));
+	warnings.push(...unreadableInputWarnings(input));
 	return {
 		ruleset: "afp",
 		rulesetVersion: RULESET_VERSION,
@@ -2325,45 +2447,93 @@ function count(input, options = {}) {
 * `metadata` column changes no number, and warning about it would be the noise
 * that teaches people to stop reading the confidence block.
 */
-function opaqueColumnWarnings(stores, input) {
+/**
+* Opaque DETs someone has declared reviewed, in both spellings a person might use.
+*
+* Qualified (`Petition.schema`) is unambiguous; bare (`schema`) is what someone reads
+* off the warning line.
+*/
+function reviewedOpaque(overrides) {
+	const reviewed = /* @__PURE__ */ new Set();
+	for (const [name, override] of Object.entries(overrides)) for (const entry of override.opaqueReviewed ?? []) {
+		reviewed.add(entry);
+		reviewed.add(`${name}.${entry}`);
+	}
+	return reviewed;
+}
+/** a column whose shape says nothing about what it holds */
+const OPAQUE_TYPE = /^(object|any|unknown|Record<|Json|JSON)/;
+/**
+* DETs the analysis cannot read: an opaque column, or an open input object.
+*
+* Both count 1, which is a FLOOR rather than a measurement, and counting-decisions §8
+* is the trade. Reporting it is the point — this was the one known blind spot the
+* package reported nowhere.
+*
+* Grouped by FUNCTION and stating what has already been answered, because a flat list
+* of columns could not say that. Computed before the overrides ran, it named functions
+* whose floor `detFromSchema` had already replaced, which reads as "go and map this"
+* about something already mapped. That misreading actually happened, to the author of
+* this code, reading someone else's report.
+*
+* Three states per function, and only the third is a request to do something:
+*
+*   replaced   a `detFromSchema` override stands in for one of them
+*   reviewed   someone looked and 1 is the right answer
+*   floor      still unanswered
+*/
+function opaqueWarnings(stores, input, state) {
 	const reached = /* @__PURE__ */ new Map();
 	for (const entry of input.entryPoints) for (const store of input.behaviors.get(entry.id)?.touches ?? []) reached.set(store, (reached.get(store) ?? 0) + 1);
-	const found = [];
+	const byFunction = /* @__PURE__ */ new Map();
+	const tally = (name, kind, transactions) => {
+		const found = byFunction.get(name) ?? {
+			kind,
+			floor: [],
+			reviewed: 0,
+			transactions
+		};
+		byFunction.set(name, found);
+		return found;
+	};
 	for (const store of stores) {
-		const transactions = reached.get(store.name);
-		if (!transactions) continue;
+		if (!reached.get(store.name)) continue;
 		for (const attribute of store.attributes) {
 			if (!attribute.type || !OPAQUE_TYPE.test(attribute.type)) continue;
-			found.push(`  ${store.name}.${attribute.name} (${attribute.type}) — ${transactions} transaction(s)`);
+			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 (found.length === 0) return [];
-	return [`${found.length} opaque column(s), each counted as 1 DET. If the user recognises fields inside one, declare the count with \`overrides\` — counting-decisions §8:`, ...found];
-}
-/**
-* Input fields declared as an open object: `vine.object({}).allowUnknownProperties()`.
-*
-* The same blind spot as an opaque column and, until now, reported nowhere — the
-* opaque-column warning names stores, and this one is on the transaction side, so
-* a route whose whole form arrives through one of these was invisible in the
-* confidence block. On a production application that was the route that saves the
-* main document, and it was the reason its EI never looked wrong.
-*
-* It counts 1 DET, which is a floor. When the fields are declared in the code
-* somewhere — a seeder, a schema module — `detFromSchema` replaces the floor with
-* the real count, and §8 of counting-decisions says how.
-*/
-function openValidatorWarnings(input) {
-	const found = [];
-	for (const entry of input.entryPoints) {
-		const fields = input.behaviors.get(entry.id)?.opaqueInputFields ?? [];
-		for (const field of fields) found.push(`  ${entry.trigger} ${entry.signature} — ${field}`);
+	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 (found.length === 0) return [];
+	const lines = [];
+	let answered = 0;
+	for (const [name, entry] of byFunction) {
+		/** a declared schema stands in for exactly one placeholder — §8, and the override warns when there are more */
+		const replaced = state.declared.has(name) && entry.floor.length > 0 ? 1 : 0;
+		const remaining = entry.floor.slice(replaced);
+		if (remaining.length === 0) {
+			answered += 1;
+			continue;
+		}
+		const answeredHere = [...replaced > 0 ? [`${replaced} replaced by override`] : [], ...entry.reviewed > 0 ? [`${entry.reviewed} reviewed`] : []];
+		/**
+		* How many transactions reach the store, so the reader can judge whether the
+		* floor is worth answering. A blob nothing touches changes no number.
+		*/
+		const reach = entry.kind === "column" ? `, reached by ${entry.transactions} transaction(s)` : "";
+		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;
 	return [
-		`${found.length} open input object(s), each counted as 1 DET. The fields the user fills are data, not code, so this is a FLOOR: if they are declared anywhere in the source, name that schema with \`overrides.detFromSchema\` — counting-decisions §8:`,
-		...found.slice(0, 10),
-		...found.length > 10 ? [`  … and ${found.length - 10} more`] : []
+		`${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
 	];
 }
 /**
@@ -2402,8 +2572,6 @@ function unreadableInputWarnings(input) {
 		...blind.length > 10 ? [`  … and ${blind.length - 10} more`] : []
 	];
 }
-/** a column whose shape says nothing about what it holds */
-const OPAQUE_TYPE = /^(object|any|unknown|Record<|Json|JSON)/;
 /**
 * Replaces what the analysis found with what a person declared.
 *
@@ -2438,7 +2606,25 @@ function applyOverrides(functions, overrides, schemas, tables, weights, warnings
 		* is born, not when a field is.
 		*/
 		if (override.detFromSchema) {
-			const schema = schemas.get(override.detFromSchema);
+			/**
+			* One name or several, unioned by leaf path.
+			*
+			* An ILF's DETs are the fields the user recognises in the file, and an
+			* application with one schema per template recognises all of them. A field
+			* two templates share is one DET, so the union is over paths rather than a
+			* sum of counts.
+			*/
+			const named = [override.detFromSchema].flat();
+			const resolved = named.map((name) => schemas.get(name)).filter((s) => s !== void 0);
+			const missing = named.filter((name) => !schemas.has(name));
+			const union = new Set(resolved.flatMap((s) => s.leaves));
+			const schema = resolved.length === 0 ? void 0 : {
+				/** only what resolved: naming a schema that contributed nothing would mislead */
+				name: resolved.map((s) => s.name).join(" + "),
+				fields: union.size,
+				leaves: [...union]
+			};
+			for (const name of missing) warnings.push(`override for "${fn.name}" names schema "${name}", which is not declared anywhere in the code: it contributed nothing. A renamed or moved schema breaks the mapping, and this says so rather than counting on silently.`);
 			if (schema) {
 				/**
 				* Replaces the opaque placeholder — the one the rationale marks — rather
@@ -2454,10 +2640,20 @@ function applyOverrides(functions, overrides, schemas, tables, weights, warnings
 				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 warnings.push(`override for "${fn.name}" names schema "${override.detFromSchema}", which is not declared anywhere in the code: the DET count was left as found. A renamed or moved schema breaks the mapping, and this says so rather than counting on silently.`);
+			}
 		}
 		const refs = override.refs ?? fn.refs;
 		const complexity = complexityOf(fn.type, refs, det, tables);
+		/**
+		* Only a DECLARED NUMBER is an override in the rationale.
+		*
+		* `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.
+		*/
+		if (fields.length === 0) return fn;
 		return {
 			...fn,
 			det,
@@ -2601,7 +2797,7 @@ function describeSource(root, config) {
 		]),
 		dirty: status === void 0 ? void 0 : status.length > 0,
 		countedAt: (/* @__PURE__ */ new Date()).toISOString(),
-		config: config === null ? null : toPosix(config)
+		config: config === null ? null : relativeTo(root, config)
 	};
 }
 function appName(root) {
@@ -2635,17 +2831,51 @@ 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);
+	/**
+	* Every path that LEAVES is relative to the application root.
+	*
+	* `CountSource.app` is documented as never being the absolute path, because that
+	* says where the machine keeps its files and travels with every artefact sent
+	* anywhere. The rule was stated on one field and applied to one field: the
+	* inventory carried 2036 absolute paths across ten of them, and a count carried
+	* 858 in its traces alone.
+	*
+	* Absolute is right INTERNALLY — it is what ts-morph resolves and what the call
+	* graph keys its caches on — so the conversion happens here, at the boundary, and
+	* the data-store `id` is relativised only after the ancestor filter has used it.
+	*/
+	const source = describeSource(root, options.configFile ?? null);
+	const emit = (value) => relativeTo(app.root, value);
+	const emitProvenance = (p) => ({
+		...p,
+		file: emit(p.file)
+	});
 	const inventory = {
 		version: 1,
 		generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-		app: app.root,
+		app: source.app,
 		framework: {
 			core: app.framework.core,
 			lucid: app.framework.lucid,
 			orm: app.framework.orm
 		},
-		dataStores: stores,
-		entryPoints,
+		dataStores: stores.map((store) => ({
+			...store,
+			id: emit(store.id),
+			provenance: emitProvenance(store.provenance),
+			attributes: store.attributes.map((a) => ({
+				...a,
+				provenance: emitProvenance(a.provenance)
+			}))
+		})),
+		entryPoints: entryPoints.map((entry) => ({
+			...entry,
+			provenance: emitProvenance(entry.provenance),
+			handler: entry.handler ? {
+				...entry.handler,
+				file: emit(entry.handler.file)
+			} : null
+		})),
 		behaviors: [...behaviors.entries()].map(([entryPointId, behavior]) => ({
 			entryPointId,
 			writes: behavior.writes,
@@ -2653,28 +2883,34 @@ async function analyze(root, options = {}) {
 			inputFields: behavior.inputFields.map((name) => ({
 				name,
 				provenance: {
-					file: app.root,
+					file: emit(app.root),
 					by: "validator"
 				}
 			})),
 			opaqueInputFields: behavior.opaqueInputFields.map((name) => ({
 				name,
 				provenance: {
-					file: app.root,
+					file: emit(app.root),
 					by: "validator"
 				}
 			})),
 			requestFields: behavior.requestFields.map((name) => ({
 				name,
 				provenance: {
-					file: app.root,
+					file: emit(app.root),
 					by: "request"
 				}
 			})),
 			opaqueRequest: behavior.opaqueRequest,
 			outputFields: [],
-			trace: behavior.trace,
-			unresolved: behavior.unresolved
+			trace: behavior.trace.map((step) => ({
+				...step,
+				file: emit(step.file)
+			})),
+			unresolved: behavior.unresolved.map((call) => ({
+				...call,
+				file: emit(call.file)
+			}))
 		})),
 		coverage: {
 			entryPointsTotal: entryPoints.length,
@@ -2696,7 +2932,7 @@ async function analyze(root, options = {}) {
 				jsonSchemas,
 				writtenAnywhere: analyzer.writtenAnywhere()
 			}, options),
-			source: describeSource(root, options.configFile ?? null)
+			source
 		}
 	};
 }

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

@@ -1,3 +1,4 @@
+import path from "node:path";
 import { Node, Project, SyntaxKind } from "ts-morph";
 //#region src/inventory/paths.ts
 /**
@@ -20,6 +21,23 @@ import { Node, Project, SyntaxKind } from "ts-morph";
 * it to each comparison costs vigilance forever.
 */
 const toPosix = (value) => value.split("\\").join("/");
+/**
+* A path as it should appear in an EMITTED artefact: relative to the application.
+*
+* `CountSource.app` is documented as never being the absolute path, because that
+* says where the machine keeps its files and travels with every count sent
+* anywhere. One field below it, `config` shipped the absolute path — and so did
+* every `trace[].file`, 858 times in a single production count. The rule was
+* stated and then applied to one field.
+*
+* Internally the absolute path is the right thing: it is what ts-morph resolves
+* and what the call graph keys its caches on. So this converts at the boundary
+* where a path LEAVES, and nowhere else.
+*
+* A path outside the root keeps its `../` prefix, which describes where it is
+* without naming the home directory.
+*/
+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);
 //#endregion
@@ -819,4 +837,4 @@ function resolveCall(call, ctx, resolvers = BUILTIN_CALL_RESOLVERS) {
 	return null;
 }
 //#endregion
-export { rootSymbolOf as a, toPosix as c, hooksFiredBy as i, resolveCall as n, collectEventBindings as o, detectAccess as r, samePath as s, BUILTIN_CALL_RESOLVERS as t };
+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 };

package/build/{runners-CmxNHuuq.js → runners-DetZGfh5.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 { c as toPosix } from "./resolvers-CRB6lXoo.js";
-import { n as analyze } from "./pipeline-CIAydCcT.js";
+import { l as toPosix } from "./resolvers-vMahHkAd.js";
+import { n as analyze } from "./pipeline-Dm9KvUvF.js";
 import { readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { existsSync } from "node:fs";
@@ -359,7 +359,17 @@ async function runMetrics(options) {
 async function runExplain(options) {
 	const { config, notes } = await configFor(options.root);
 	const { count } = await analyze(options.root, config);
-	const matched = count.functions.filter((fn) => fn.name.toLowerCase().includes(options.name.toLowerCase()));
+	/**
+	* An exact name wins outright; the substring search is the fallback.
+	*
+	* `fp:explain "POST /orders/:param/submit"` returned four functions, because
+	* `/submit`, `/submit-ready` and `/submit-ready/return` all contain it. Asking
+	* about a function by its exact name and being handed its neighbours makes the
+	* command useless for the thing it exists for — defending one number.
+	*/
+	const wanted = options.name.toLowerCase();
+	const exact = count.functions.filter((fn) => fn.name.toLowerCase() === wanted);
+	const matched = exact.length > 0 ? exact : count.functions.filter((fn) => fn.name.toLowerCase().includes(wanted));
 	if (matched.length === 0) return {
 		output: "",
 		notes,

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.2.0";
+export declare const RULESET_VERSION = "1.3.0";
 export type CountInput = {
     app: AppContext;
     stores: CollectedDataStore[];

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

@@ -31,5 +31,14 @@ export type TransactionOptions = {
     messageDet: number;
     tables: Record<FunctionType, ComplexityTable>;
     weights: Record<FunctionType, Record<Complexity, number>>;
+    /**
+     * Application root, used only to relativise the paths that LEAVE in the trace.
+     *
+     * `CountSource.app` is documented as never being the absolute path, because it
+     * says where the machine keeps its files and travels with every count sent
+     * anywhere. The trace shipped the absolute path regardless — 858 times in a
+     * single production count, which is most of the artefact a ledger would store.
+     */
+    root: string;
 };
 export declare function countTransactionalFunctions(entryPoints: CollectedEntryPoint[], behaviors: Map<string, Behavior>, options: TransactionOptions): CountedFunction[];

package/build/src/cli.js

@@ -1,5 +1,5 @@
-import { t as CoverageTooLowError } from "../pipeline-CIAydCcT.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-CmxNHuuq.js";
+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 path from "node:path";
 import { existsSync, readFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";

package/build/src/define_config.d.ts

@@ -161,9 +161,34 @@ export type FunctionOverride = {
      *
      * A name that matches no schema is a warning, never a silent fallback.
      */
-    detFromSchema?: string;
+    /**
+     * Name of a declared schema, or several whose fields are UNIONED.
+     *
+     * An ILF's DETs are the fields the user recognises in the file, and an
+     * application with one schema per template recognises the fields of all of them.
+     * Pointing at the largest and justifying it in `reason` gives the same answer
+     * only while they land in the same complexity band — which is a piece of
+     * reasoning the configuration should not have to carry.
+     *
+     * Unioned by leaf path, so a field two templates share counts once.
+     */
+    detFromSchema?: string | string[];
     /** declared RET (data function) or FTR (transaction) */
     refs?: number;
+    /**
+     * Opaque DETs someone has looked at and decided are correct at 1.
+     *
+     * `fp:count` reports every opaque column and open input object, because 1 DET is
+     * a floor rather than a measurement. But some of them ARE one field — a copy, a
+     * checksum, a bag of metadata — and there was no way to say so, so the warning
+     * fired on every run forever. A warning that cannot be answered is a warning the
+     * team learns to scroll past, which costs more than the one it reports.
+     *
+     * It silences nothing else: the count does not move, and `fp:count` still says
+     * how many were reviewed. Names are matched bare (`schema`) or qualified
+     * (`Petition.schema`).
+     */
+    opaqueReviewed?: string[];
     /** why — required, and printed by `fp:explain` beside the number */
     reason: string;
 };

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

@@ -18,5 +18,22 @@
  * it to each comparison costs vigilance forever.
  */
 export declare const toPosix: (value: string) => string;
+/**
+ * A path as it should appear in an EMITTED artefact: relative to the application.
+ *
+ * `CountSource.app` is documented as never being the absolute path, because that
+ * says where the machine keeps its files and travels with every count sent
+ * anywhere. One field below it, `config` shipped the absolute path — and so did
+ * every `trace[].file`, 858 times in a single production count. The rule was
+ * stated and then applied to one field.
+ *
+ * Internally the absolute path is the right thing: it is what ts-morph resolves
+ * and what the call graph keys its caches on. So this converts at the boundary
+ * where a path LEAVES, and nowhere else.
+ *
+ * A path outside the root keeps its `../` prefix, which describes where it is
+ * without naming the home directory.
+ */
+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;

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

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

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

@@ -33,7 +33,14 @@ export type CountSource = {
      */
     dirty?: boolean;
     countedAt: string;
-    /** configuration file that shaped the count, or null for the defaults */
+    /**
+     * Configuration file that shaped the count, RELATIVE to the application root,
+     * or null for the defaults.
+     *
+     * Relative for the same reason `app` is a name: an absolute path says where the
+     * machine keeps its files, and this artefact is what goes into a ledger and to
+     * whoever receives the invoice.
+     */
     config: string | null;
 };
 export declare function describeSource(root: string, config: string | null): CountSource;

package/build/src/pipeline.js

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

package/build/stubs/config.stub

@@ -42,7 +42,13 @@ export default defineConfig({
    * here.
    */
   // overrides: {
-  //   'POST /forms': { det: 42, reason: 'JSON Schema form; 42 user fields' },
+  //   // one schema, or several whose fields are unioned by leaf path
+  //   Form: { detFromSchema: ['intakeSchema', 'reviewSchema'], reason: 'one per template' },
+  //
+  //   // 1 DET is a floor, and `fp:count` says so on every run. When 1 IS the right
+  //   // answer, record that someone checked — otherwise the warning becomes noise
+  //   // the team learns to scroll past. It moves no number.
+  //   Petition: { opaqueReviewed: ['schema', 'uiSchema'], reason: 'metadata; one field each' },
   // },
 
   /**

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