@filipebraida/adonis-function-points 0.3.0 → 0.5.0

package/build/{pipeline-CIAydCcT.js → pipeline-CNTBhs6o.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 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";
@@ -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;
@@ -1491,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
@@ -1524,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;
 			}
@@ -1578,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)) {
@@ -1603,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();
@@ -1612,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);
@@ -1637,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);
@@ -1662,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;
 			}
 		};
@@ -1670,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(),
@@ -2104,7 +2237,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 +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.2.0";
+const RULESET_VERSION = "1.4.0";
 function count(input, options = {}) {
 	const warnings = [];
 	const usage = usageOf(input);
@@ -2279,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})`);
@@ -2296,14 +2442,39 @@ 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));
+	/**
+	* `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, reviewed);
+	/**
+	* 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,
+		overrides: options.overrides ?? {}
+	}));
 	warnings.push(...unreadableInputWarnings(input));
-	warnings.push(...openValidatorWarnings(input));
-	const functions = applyOverrides([...dataFunctions, ...transactionalFunctions], options.overrides ?? {}, input.jsonSchemas ?? /* @__PURE__ */ new Map(), tables, weights, warnings);
 	return {
 		ruleset: "afp",
 		rulesetVersion: RULESET_VERSION,
@@ -2325,45 +2496,147 @@ 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}`);
+		/**
+		* 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)/;
+/**
+* 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,
+			reviewedNames: [],
+			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;
+				entry.reviewedNames.push(attribute.name);
+			} 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;
+			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);
 	}
-	if (found.length === 0) return [];
+	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) {
+		/** 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)`];
+	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 [
-		`${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,
+		...unmatchedLines
 	];
 }
 /**
@@ -2402,8 +2675,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.
 *
@@ -2415,7 +2686,7 @@ const OPAQUE_TYPE = /^(object|any|unknown|Record<|Json|JSON)/;
 * 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();
@@ -2438,7 +2709,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
@@ -2453,11 +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 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.`);
+				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);
+		/**
+		* A review is recorded with NO fields, and the reporter's "declared by override"
+		* share counts only entries that declared one.
+		*
+		* 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.
+		*/
+		const marked = markReviewed(fn.rationale.detSources, reviewed);
 		return {
 			...fn,
 			det,
@@ -2466,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,
@@ -2494,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)
 			});
 		}
 	}
@@ -2601,7 +2923,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,46 +2957,87 @@ 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,
 			touches: behavior.touches,
+			writtenStores: behavior.writtenStores,
 			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 +3059,7 @@ async function analyze(root, options = {}) {
 				jsonSchemas,
 				writtenAnywhere: analyzer.writtenAnywhere()
 			}, options),
-			source: describeSource(root, options.configFile ?? null)
+			source
 		}
 	};
 }