@filipebraida/adonis-function-points 0.2.0 → 0.4.0

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

@@ -1,7 +1,7 @@
-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-MFjRl2ef.js";
-import { Node, Project, SyntaxKind } from "ts-morph";
+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";
 import { createHash } from "node:crypto";
 import { execFileSync } from "node:child_process";
 import { readFileSync } from "node:fs";
@@ -956,7 +956,21 @@ function collectJsonSchemas(app) {
 		skipFileDependencyResolution: true,
 		compilerOptions: { allowJs: false }
 	});
-	for (const root of app.scanRoots) project.addSourceFilesAtPaths(`${root}/**/*.ts`);
+	/**
+	* Wider than `scanRoots`, and only here.
+	*
+	* `database/` is excluded from the application roots on purpose: test factories
+	* and migrations contain real persistence calls, and scanning them would turn a
+	* test write into a counted function. But `node ace make:seeder` puts seeders in
+	* `database/seeders`, which is where seed data — and therefore a form's schema —
+	* normally lives. Reading a literal counts nothing, so there is no conflict: the
+	* exclusion protects the call graph, not the schema catalogue.
+	*
+	* Without this, `overrides.detFromSchema` naming a schema declared in a seeder
+	* reported "not declared anywhere in the code" and left the DET count at the
+	* floor — the exact case the override exists for.
+	*/
+	for (const root of [...app.scanRoots.map(toPosix), `${toPosix(app.root)}/database`]) project.addSourceFilesAtPaths(`${root}/**/*.ts`);
 	const found = /* @__PURE__ */ new Map();
 	for (const file of project.getSourceFiles()) for (const declaration of file.getVariableDeclarations()) {
 		const literal = unwrap(declaration.getInitializer())?.asKind(SyntaxKind.ObjectLiteralExpression);
@@ -1224,6 +1238,7 @@ function isNoiseMember(file, member) {
 */
 function validatorFieldsIn(body, file, app) {
 	const fields = [];
+	const opaque = [];
 	for (const call of body.getDescendantsOfKind(SyntaxKind.CallExpression)) {
 		const expression = call.getExpression();
 		if (!Node.isPropertyAccessExpression(expression)) continue;
@@ -1233,9 +1248,25 @@ function validatorFieldsIn(body, file, app) {
 		const name = argument.getText();
 		const declaration = findValidator(name, file, app);
 		if (!declaration) continue;
-		for (const leaf of leavesOf(declaration)) fields.push(`${name}.${leaf}`);
+		/**
+		* 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}`;
+			fields.push(field);
+			if (isOpaque.has(leaf)) opaque.push(field);
+		}
 	}
-	return fields;
+	return {
+		fields,
+		opaque
+	};
 }
 /**
 * Fields read straight off the request, with no validator in between.
@@ -1320,26 +1351,139 @@ function findValidator(name, file, app) {
 	}
 	return null;
 }
-/** leaves of a VineJS schema, per the table in §7 */
-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 [];
+	if (!object) return {
+		leaves: [],
+		opaque: []
+	};
 	const leaves = [];
+	const opaque = [];
 	const walk = (literal, prefix) => {
 		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)) {
-				walk(nested, prefix ? `${prefix}.${name}` : name);
+			if (nested && isArgumentOfCallNamed(nested, "object")) {
+				const path = prefix ? `${prefix}.${name}` : name;
+				/**
+				* An object declaring no properties enumerates nothing. It is the field
+				* itself that crosses the boundary, so it counts once — never zero,
+				* which would make it cheaper than a plain string.
+				*/
+				if (nested.getProperties().length === 0) {
+					leaves.push(path);
+					opaque.push(path);
+					continue;
+				}
+				walk(nested, path);
 				continue;
 			}
 			leaves.push(prefix ? `${prefix}.${name}` : name);
 		}
 	};
 	walk(object, "");
-	return leaves;
+	/**
+	* 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.
+	*/
+	if (leaves.length === 0 && object.getProperties().length === 0) return {
+		leaves: ["*"],
+		opaque: ["*"]
+	};
+	return {
+		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;
@@ -1440,7 +1584,7 @@ function createAnalyzer(app, stores, options = {}) {
 		const accesses = [];
 		const followUps = [];
 		const unresolved = [];
-		const validators = validatorFieldsIn(body, file, app);
+		const validator = validatorFieldsIn(body, file, app);
 		const request = requestFieldsIn(body);
 		for (const call of body.getDescendantsOfKind(SyntaxKind.CallExpression)) {
 			const access = detectAccess(call, symbols, relationsByStore);
@@ -1449,9 +1593,14 @@ function createAnalyzer(app, stores, options = {}) {
 					store: access.store,
 					write: access.mode === "write"
 				});
+				/**
+				* A relation reached by `preload`/`load` is read; one written through
+				* `related('files').create(…)` is written. Assuming read either way made
+				* a table maintained only through a relation come out as an EIF.
+				*/
 				if (access.viaRelation) accesses.push({
 					store: access.viaRelation,
-					write: false
+					write: access.relationWritten === true
 				});
 				/**
 				* counting-decisions §3: a hook belongs to the transaction that fired
@@ -1499,7 +1648,8 @@ function createAnalyzer(app, stores, options = {}) {
 			accesses,
 			followUps,
 			unresolved,
-			validators,
+			validators: validator.fields,
+			opaqueValidators: validator.opaque,
 			requestFields: request.fields,
 			opaqueRequest: request.opaque,
 			bodyHash: hashOf(body)
@@ -1527,7 +1677,15 @@ function createAnalyzer(app, stores, options = {}) {
 			if (symbols.size === 0) continue;
 			for (const call of file.getDescendantsOfKind(SyntaxKind.CallExpression)) {
 				const access = detectAccess(call, symbols, relationsByStore);
-				if (access?.mode === "write") written.add(access.store);
+				if (access?.mode !== "write") continue;
+				written.add(access.store);
+				/**
+				* `distribution.related('files').create(…)` maintains the related table.
+				* Recording only the parent left a table written exclusively that way
+				* looking like somebody else's — reported by a production application as
+				* an EIF it was sure it maintained.
+				*/
+				if (access.viaRelation && access.relationWritten) written.add(access.viaRelation);
 			}
 		}
 		return written;
@@ -1541,6 +1699,7 @@ function createAnalyzer(app, stores, options = {}) {
 	function run(handler) {
 		const touches = /* @__PURE__ */ new Set();
 		const inputFields = /* @__PURE__ */ new Set();
+		const opaqueInputFields = /* @__PURE__ */ new Set();
 		const requestFields = /* @__PURE__ */ new Set();
 		let opaqueRequest = false;
 		const trace = [];
@@ -1580,6 +1739,7 @@ function createAnalyzer(app, stores, options = {}) {
 			}
 			unresolved.push(...facts.unresolved);
 			for (const field of facts.validators) inputFields.add(field);
+			for (const field of facts.opaqueValidators) opaqueInputFields.add(field);
 			for (const field of facts.requestFields) requestFields.add(field);
 			if (facts.opaqueRequest) opaqueRequest = true;
 			trace.push({
@@ -1606,6 +1766,7 @@ function createAnalyzer(app, stores, options = {}) {
 			writes,
 			touches: [...touches].sort(),
 			inputFields: [...inputFields].sort(),
+			opaqueInputFields: [...opaqueInputFields].sort(),
 			requestFields: [...requestFields].sort(),
 			opaqueRequest,
 			trace,
@@ -1957,6 +2118,12 @@ function pointsOf(type, complexity, weights = DEFAULT_WEIGHTS) {
 }
 //#endregion
 //#region src/albrecht/data_functions.ts
+/**
+* A column whose shape says nothing about what it holds. Marked in the rationale
+* because `detFromSchema` replaces exactly this placeholder, and because a reader
+* deserves to know which of the DETs is a floor rather than a count.
+*/
+const OPAQUE_TYPE$1 = /^(object|any|unknown|Record<|Json|JSON)/;
 function countDataFunctions(stores, usage, options) {
 	const counted = [];
 	for (const store of stores) {
@@ -1993,7 +2160,7 @@ function countDataFunctions(stores, usage, options) {
 			points: pointsOf(type, complexity, options.weights),
 			rationale: {
 				rule: options.externallyMaintained.has(store.name) ? "afp:6.5.4 externally maintained by boundary configuration -> EIF" : maintained ? "afp:6.5.4 maintained by an application transaction -> ILF" : "afp:6.5.4 used but not maintained -> EIF",
-				detSources: detAttributes.map((attribute) => `${store.columnSource}:${store.table ?? store.name}.${attribute.name}`),
+				detSources: detAttributes.map((attribute) => `${store.columnSource}:${store.table ?? store.name}.${attribute.name}` + (attribute.type && OPAQUE_TYPE$1.test(attribute.type) ? " (opaque)" : "")),
 				refSources: options.retStrategy === "composition" ? ["1 (main group)", ...store.subgroups.map((s) => `composition:${s}`)] : ["1 (constant: a logical subgroup is not derivable from code)"]
 			}
 		});
@@ -2032,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)
+				}))
 			}
 		});
 	}
@@ -2077,7 +2247,14 @@ function detsFor(entry, behavior, touched, type, options) {
 		sources.push(source);
 	};
 	for (const param of entry.signature.match(/:[A-Za-z_][\w]*/g) ?? []) add(param.slice(1), `param:${param}`);
-	for (const field of behavior.inputFields) add(field.split(".").pop(), `validator:${field}`);
+	/**
+	* `(opaque)` is not decoration: `detFromSchema` replaces the opaque placeholder
+	* with a schema's fields, and it used to assume there was exactly one and that
+	* it was worth 1. An open `vine.object` counted zero, so the subtraction ate a
+	* real field — off by one, in the direction of undercounting.
+	*/
+	const opaqueInputs = new Set(behavior.opaqueInputFields);
+	for (const field of behavior.inputFields) add(field.split(".").pop(), `validator:${field}${opaqueInputs.has(field) ? " (opaque)" : ""}`);
 	/**
 	* §7.2 asks whether a user-recognisable field crosses the boundary, not how it
 	* was declared. `request.input('title')` does, and counted for nothing while
@@ -2141,6 +2318,17 @@ function isTechnical(store, patterns = DEFAULT_TECHNICAL_PATTERNS) {
 	for (const { label, pattern } of patterns) if (pattern.test(table)) return `${label} (AFP §6.5.2.1.3: ${pattern.source})`;
 	return null;
 }
+//#endregion
+//#region src/albrecht/counter.ts
+/**
+* Assembles the count from the inventory.
+*
+* The order is not arbitrary: data functions depend on HOW transactions use
+* each store (AFP §6.5.4), and transactional functions depend on which stores
+* ended up counted. Hence: usage first, then the technical filter, then data,
+* then transactions.
+*/
+const RULESET = "afp";
 /**
 * Version of the rule set.
 *
@@ -2149,14 +2337,18 @@ function isTechnical(store, patterns = DEFAULT_TECHNICAL_PATTERNS) {
 * change rather than the work.
 *
 * It must be bumped by ANY change that moves the number for unchanged code, and
-* that is easy to forget: four such changes landed in 1.1.0 — maintenance read
+* that is easy to forget. Four such changes landed in 1.1.0 — maintenance read
 * across the whole project rather than from routes alone, a job followed into
 * `process`, an event followed into its listeners, and `request.input(…)` counted
-* as a DET. Without the bump, a baseline saved by the previous version would have
-* compared cleanly against this one and billed the tool's own improvement as work
-* done. The guard exists for exactly that, and only this constant arms it.
+* as a DET — and three more in 1.2.0: an open input object counting 1 instead of 0,
+* `detFromSchema` no longer subtracting a placeholder that was not there, and a
+* write through `related(…)` maintaining the related table.
+*
+* Without the bump, a baseline saved by the previous version compares cleanly
+* against this one and bills the tool's own improvement as work done. The guard
+* exists for exactly that, and only this constant arms it.
 */
-const RULESET_VERSION = "1.1.0";
+const RULESET_VERSION = "1.3.0";
 function count(input, options = {}) {
 	const warnings = [];
 	const usage = usageOf(input);
@@ -2202,13 +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));
+	/**
+	* `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,
@@ -2230,20 +2447,94 @@ 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];
+	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);
+	}
+	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 [
+		`${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
+	];
 }
 /**
 * Transactions that read the request in a way that enumerates nothing.
@@ -2281,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.
 *
@@ -2317,14 +2606,54 @@ 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) {
-				det = Math.max(fn.det - 1, 0) + schema.fields;
+				/**
+				* Replaces the opaque placeholder — the one the rationale marks — rather
+				* than assuming there is one and that it is worth 1.
+				*
+				* That assumption was wrong twice over. An open `vine.object` counted
+				* ZERO, not 1, so subtracting 1 removed a field the analysis had read
+				* correctly: 86 DETs where 87 was right. And a function with no opaque
+				* DET at all was silently charged the subtraction too.
+				*/
+				const placeholders = fn.rationale.detSources.filter((source) => source.endsWith("(opaque)"));
+				det = Math.max(fn.det - Math.min(placeholders.length, 1), 0) + schema.fields;
 				by = `config:overrides.${fn.name} (from ${schema.name}: ${schema.fields} fields)`;
-			} 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.`);
+				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.`);
+			}
 		}
 		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,
@@ -2468,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) {
@@ -2502,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,
@@ -2520,21 +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: 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,
@@ -2556,9 +2932,9 @@ async function analyze(root, options = {}) {
 				jsonSchemas,
 				writtenAnywhere: analyzer.writtenAnywhere()
 			}, options),
-			source: describeSource(root, options.configFile ?? null)
+			source
 		}
 	};
 }
 //#endregion
-export { analyze as n, CoverageTooLowError as t };
+export { RULESET_VERSION as i, analyze as n, RULESET as r, CoverageTooLowError as t };