@filipebraida/adonis-function-points 0.4.0 → 0.6.0

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

@@ -1,4 +1,4 @@
-import { a as rootSymbolOf, c as samePath, i as hooksFiredBy, l as toPosix, n as resolveCall, o as collectEventBindings, r as detectAccess, s as relativeTo, t as BUILTIN_CALL_RESOLVERS } from "./resolvers-vMahHkAd.js";
+import { a as chainShapeOf, c as hooksFiredBy, d as isApplicationCode, f as isSeeder, h as toPosix, i as resolveCall, l as rootSymbolOf, m as samePath, o as outputFieldsIn, p as relativeTo, r as isTechnicalWrite, s as detectAccess, t as BUILTIN_CALL_RESOLVERS, u as collectEventBindings } from "./resolvers-DlKJOZnk.js";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { Node, Project, SyntaxKind } from "ts-morph";
@@ -465,7 +465,7 @@ function walkChain(start, app, project) {
 		if (samePath(cls.getSourceFile().getFilePath(), app.generated.dataSchema)) columnSource = "generated-schema";
 		for (const attribute of columnsOf(cls)) if (!attributes.has(attribute.name)) attributes.set(attribute.name, attribute);
 		for (const parent of parentsOf(cls)) {
-			const origin = originOf(parent.getText(), cls.getSourceFile());
+			const origin = originOf$1(parent.getText(), cls.getSourceFile());
 			if (origin?.specifier === LUCID_ORM && origin.exportedName === BASE_MODEL) {
 				reachesLucid = true;
 				continue;
@@ -501,7 +501,7 @@ function walkChain(start, app, project) {
 */
 function reasonFor(parent, file, app) {
 	if (Node.isCallExpression(parent)) return "mixin factory: the column only exists on the class the function returns, and evaluating that return is beyond the current static analysis";
-	const origin = originOf(parent.getText(), file);
+	const origin = originOf$1(parent.getText(), file);
 	if (origin && !app.resolveSpecifier(origin.specifier)) return `base class outside the application (${origin.specifier}): the package cannot know which columns it adds`;
 	return "base class not found in the application";
 }
@@ -519,7 +519,7 @@ function parentsOf(cls) {
 function resolveClass(name, from, app, project) {
 	const local = from.getClass(name);
 	if (local) return local;
-	const origin = originOf(name, from);
+	const origin = originOf$1(name, from);
 	if (!origin) return null;
 	const target = app.resolveSpecifier(origin.specifier);
 	if (!target) return null;
@@ -528,7 +528,7 @@ function resolveClass(name, from, app, project) {
 	if (origin.exportedName === "default") return file.getClasses().find((candidate) => candidate.isDefaultExport()) ?? null;
 	return file.getClass(origin.exportedName) ?? null;
 }
-function originOf(local, file) {
+function originOf$1(local, file) {
 	for (const declaration of file.getImportDeclarations()) {
 		const specifier = declaration.getModuleSpecifierValue();
 		if (declaration.getDefaultImport()?.getText() === local) return {
@@ -556,11 +556,27 @@ function columnsOf(cls) {
 	for (const property of cls.getProperties()) for (const decorator of property.getDecorators()) {
 		const full = decorator.getFullName();
 		if (full !== "column" && !full.startsWith("column.")) continue;
-		const isIdentifier = /isPrimary\s*:\s*true/.test(decorator.getExpression().getText());
+		const options = decorator.getExpression().getText();
+		const isIdentifier = /isPrimary\s*:\s*true/.test(options);
+		/**
+		* `autoCreate` / `autoUpdate`: the framework stamps it on insert or update.
+		* The user neither supplies nor maintains the value, so it is not a DET —
+		* counting-decisions §6. Recorded here as a fact about the column; the
+		* counting side decides what to do with it.
+		*/
+		const system = /auto(Create|Update)\s*:\s*true/.test(options);
+		/**
+		* `serializeAs: null`: Lucid never serialises the column, so it cannot leave
+		* the boundary on an output. It is still a DET of the data function — the
+		* user supplies a password — counting-decisions §6.
+		*/
+		const hidden = /serializeAs\s*:\s*null/.test(options);
 		attributes.push({
 			name: property.getName(),
 			type: property.getTypeNode()?.getText(),
 			isIdentifier,
+			...system ? { system } : {},
+			...hidden ? { hidden } : {},
 			provenance: {
 				file,
 				line: property.getStartLineNumber(),
@@ -1511,6 +1527,12 @@ function createAnalyzer(app, stores, options = {}) {
 	* per route, uniformly. Loading everything first trades N rebuilds for one.
 	*/
 	for (const root of app.scanRoots) project.addSourceFilesAtPaths(`${root}/**/*.ts`);
+	/**
+	* Seeders under `database/` as well — not application code, and never followed
+	* from a handler, but an EIF only a seed populates is a fact the report needs
+	* (counting-decisions §11), and `make:seeder` puts them exactly there.
+	*/
+	project.addSourceFilesAtPaths(`${toPosix(app.root)}/database/**/seeders/**/*.ts`);
 	const storesByName = new Map(stores.map((store) => [store.name, store]));
 	const relationsByStore = new Map(stores.map((store) => [store.name, store.relations]));
 	const maxDepth = options.maxDepth ?? DEFAULT_MAX_DEPTH;
@@ -1584,16 +1606,71 @@ function createAnalyzer(app, stores, options = {}) {
 		const accesses = [];
 		const followUps = [];
 		const unresolved = [];
+		const reads = [];
+		/** calls a strategy claimed: a nested transformer's keys arrive through its body */
+		const followedCalls = /* @__PURE__ */ new Set();
 		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
 				});
 				/**
+				* How the chain reads the store decides what leaves when nothing transforms
+				* it — §6: rows whole, `.select()` columns, or one scalar from `.count()`.
+				* A select list that is not literal is reported, and the store falls back
+				* to every column, which overestimates in the open.
+				*
+				* `related('itens').query().count()` reads the RELATION target, and the
+				* parent only as a receiver; `preload('itens')` reads the target whole.
+				*/
+				if (access.mode === "read") {
+					const chain = chainShapeOf(call);
+					const shape = chain.aggregate ? "aggregate" : chain.selected.length > 0 ? "select" : "whole";
+					const read = (store, how, via) => reads.push({
+						store,
+						shape: how,
+						columns: how === "select" ? chain.selected : [],
+						...via ? { via } : {}
+					});
+					if (access.method === "related" && access.viaRelation) read(access.viaRelation, shape);
+					else {
+						read(access.store, shape);
+						if (access.viaRelation) read(access.viaRelation, "whole", access.store);
+					}
+					for (const problem of chain.unreadable) unresolved.push({
+						file: ref.file,
+						line: problem.line,
+						expression: problem.expression,
+						reason: `select with a column list that is not literal: ${access.store} counts every column`
+					});
+				}
+				/**
 				* 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.
@@ -1619,22 +1696,20 @@ 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
 				});
+				followedCalls.add(call);
 				continue;
 			}
 			if (isWorthReporting(call, symbols, imports) && !isNoise(call, owner)) unresolved.push({
@@ -1644,6 +1719,11 @@ function createAnalyzer(app, stores, options = {}) {
 				reason: "call that no strategy knew how to follow"
 			});
 		}
+		/**
+		* Read after the loop: whether a key holds a nested transformer is known only
+		* once the strategies have said which calls they follow.
+		*/
+		const output = outputFieldsIn(body, owner, storesByName, (c) => followedCalls.has(c));
 		return {
 			accesses,
 			followUps,
@@ -1652,6 +1732,10 @@ function createAnalyzer(app, stores, options = {}) {
 			opaqueValidators: validator.opaque,
 			requestFields: request.fields,
 			opaqueRequest: request.opaque,
+			outputs: output.outputs,
+			opaqueOutputs: output.opaqueOutputs,
+			transformed: output.resource,
+			reads,
 			bodyHash: hashOf(body)
 		};
 	}
@@ -1670,14 +1754,50 @@ function createAnalyzer(app, stores, options = {}) {
 	* transaction reaches the store still decides if it is counted at all; this
 	* only decides who maintains it.
 	*/
-	const writtenAnywhere = () => {
+	/**
+	* Both project-wide facts come from one pass, computed once: which stores the
+	* application WRITES (maintenance, §6.5.4) and which it ADDRESSES directly
+	* (grouping, counting-decisions §10). A store reached only through a relation
+	* — `preload('itens')`, `related('itens').create()` — is read or written, but
+	* not addressed: the user never sees it outside its parent.
+	*/
+	let projectWide;
+	const scanProject = () => {
+		if (projectWide) return projectWide;
 		const written = /* @__PURE__ */ new Set();
+		const addressed = /* @__PURE__ */ new Set();
+		/** written by a seeder: not maintenance, but a fact the report needs (an EIF only a seed populates) */
+		const seeded = /* @__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())) {
+				if (isSeeder(app.root, file.getFilePath())) {
+					const symbols = storeSymbolsFor(file, file, app, storesByName);
+					for (const call of file.getDescendantsOfKind(SyntaxKind.CallExpression)) {
+						const access = symbols.size > 0 ? detectAccess(call, symbols, relationsByStore) : null;
+						if (access?.mode !== "write") continue;
+						seeded.add(access.store);
+						if (access.viaRelation && access.relationWritten) seeded.add(access.viaRelation);
+					}
+				}
+				continue;
+			}
 			const symbols = storeSymbolsFor(file, file, app, storesByName);
 			if (symbols.size === 0) continue;
 			for (const call of file.getDescendantsOfKind(SyntaxKind.CallExpression)) {
 				const access = detectAccess(call, symbols, relationsByStore);
-				if (access?.mode !== "write") continue;
+				if (!access) continue;
+				addressed.add(access.store);
+				if (access.mode !== "write") continue;
 				written.add(access.store);
 				/**
 				* `distribution.related('files').create(…)` maintains the related table.
@@ -1687,27 +1807,47 @@ function createAnalyzer(app, stores, options = {}) {
 				*/
 				if (access.viaRelation && access.relationWritten) written.add(access.viaRelation);
 			}
+			for (const construction of file.getDescendantsOfKind(SyntaxKind.NewExpression)) {
+				const target = construction.getExpression();
+				const store = Node.isIdentifier(target) ? symbols.get(target.getText()) : void 0;
+				if (store) addressed.add(store);
+			}
 		}
-		return written;
+		projectWide = {
+			written,
+			addressed,
+			seeded
+		};
+		return projectWide;
 	};
+	const writtenAnywhere = () => scanProject().written;
+	const addressedAnywhere = () => scanProject().addressed;
+	const seededAnywhere = () => scanProject().seeded;
 	return {
 		analyze: (handler) => run(handler),
 		writtenAnywhere,
+		addressedAnywhere,
+		seededAnywhere,
 		/** how many files the project loaded — used to prove it does not grow */
 		fileCount: () => project.getSourceFiles().length
 	};
 	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();
 		let opaqueRequest = false;
+		const outputFields = /* @__PURE__ */ new Set();
+		const opaqueOutputFields = /* @__PURE__ */ new Set();
+		const transformedStores = /* @__PURE__ */ new Set();
+		const outputReads = /* @__PURE__ */ new Map();
 		const trace = [];
 		const scope = [];
 		const unresolved = [];
 		const visited = /* @__PURE__ */ new Set();
 		let writes = false;
-		const visit = (ref, depth) => {
+		const visit = (ref, depth, technical = false) => {
 			const key = `${ref.file}#${ref.member ?? ref.line ?? "*"}`;
 			if (visited.has(key) || depth > maxDepth) return;
 			visited.add(key);
@@ -1732,16 +1872,40 @@ 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);
 			for (const field of facts.opaqueValidators) opaqueInputFields.add(field);
 			for (const field of facts.requestFields) requestFields.add(field);
 			if (facts.opaqueRequest) opaqueRequest = true;
+			for (const field of facts.outputs) outputFields.add(field);
+			for (const field of facts.opaqueOutputs) opaqueOutputFields.add(field);
+			if (facts.transformed) transformedStores.add(facts.transformed);
+			for (const { store, shape, columns, via } of facts.reads) {
+				const known = outputReads.get(store) ?? {
+					whole: false,
+					selected: /* @__PURE__ */ new Set(),
+					aggregate: false,
+					direct: false,
+					via: /* @__PURE__ */ new Set()
+				};
+				if (shape === "whole") known.whole = true;
+				if (shape === "aggregate") known.aggregate = true;
+				for (const column of columns) known.selected.add(column);
+				if (via) known.via.add(via);
+				else known.direct = true;
+				outputReads.set(store, known);
+			}
 			trace.push({
 				file: ref.file,
 				member: ref.member,
@@ -1757,7 +1921,7 @@ function createAnalyzer(app, stores, options = {}) {
 			if (depth >= maxDepth) return;
 			for (const followUp of facts.followUps) {
 				const before = trace.length;
-				visit(followUp.ref, depth + 1);
+				visit(followUp.ref, depth + 1, technical || followUp.technical === true);
 				if (trace.length > before) trace[before].by = followUp.by;
 			}
 		};
@@ -1765,10 +1929,21 @@ function createAnalyzer(app, stores, options = {}) {
 		return {
 			writes,
 			touches: [...touches].sort(),
+			writtenStores: [...writtenStores].sort(),
 			inputFields: [...inputFields].sort(),
 			opaqueInputFields: [...opaqueInputFields].sort(),
 			requestFields: [...requestFields].sort(),
 			opaqueRequest,
+			outputFields: [...outputFields].sort(),
+			opaqueOutputFields: [...opaqueOutputFields].sort(),
+			transformedStores: [...transformedStores].sort(),
+			outputReads: Object.fromEntries([...outputReads.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([store, read]) => [store, {
+				whole: read.whole,
+				selected: [...read.selected].sort(),
+				aggregate: read.aggregate,
+				direct: read.direct,
+				via: [...read.via].sort()
+			}])),
 			trace,
 			scope,
 			unresolved
@@ -2117,40 +2292,360 @@ function pointsOf(type, complexity, weights = DEFAULT_WEIGHTS) {
 	return weights[type][complexity];
 }
 //#endregion
+//#region src/albrecht/opaque.ts
+/**
+* DETs the analysis cannot read, and what a person declared about them —
+* counting-decisions §8 and §9.
+*
+* Three shapes are opaque: a JSON column (`ast:surveys.answers`), an open
+* input object (`validator:answerSurveyValidator.answers`), and a spread a
+* transformer emits (`transformer:X.<this.resource.serialize()>`). Each counts
+* 1 DET — a floor, never a zero — and is marked `(opaque)` in the rationale.
+*
+* A declaration is about the ORIGIN of the placeholder, not about a function,
+* and it applies to every function that carries the DET: the data function and
+* each transaction that takes or shows the column. Keyed by function it had to
+* be written twice and still missed the third place, so the same column was
+* worth two numbers in one count — and matching by bare name meant reviewing
+* `Attachment.metadata` reviewed every `metadata` column of every table.
+*/
+const OPAQUE_TYPE = /^(object|any|unknown|Record<|Json|JSON)/;
+const isOpaqueType = (type) => type !== void 0 && OPAQUE_TYPE.test(type);
+const OPAQUE = " (opaque)";
+const REVIEWED = " (opaque, reviewed)";
+/** the origin of a placeholder, spelled the way the configuration keys it */
+function originOf(source, storeOfTable) {
+	if (!source.endsWith(OPAQUE)) return null;
+	const body = source.slice(0, -9);
+	const colon = body.indexOf(":");
+	const prefix = body.slice(0, colon);
+	const rest = body.slice(colon + 1);
+	switch (prefix) {
+		case "ast":
+		case "generated-schema": {
+			const dot = rest.indexOf(".");
+			const table = rest.slice(0, dot);
+			return `${storeOfTable.get(table) ?? table}.${rest.slice(dot + 1)}`;
+		}
+		case "output":
+		case "validator":
+		case "transformer": return rest;
+		default: return null;
+	}
+}
+/**
+* Applies the declarations to every function carrying the origin they name.
+*
+*   schemas    the placeholder's 1 DET becomes the schema's leaves, and the line
+*              says which schema stood in
+*   reviewed   the placeholder stays 1, marked reviewed; the warning stops
+*
+* A declaration keyed by the physical table (`surveys.answers`) is accepted
+* as well as one keyed by the model (`Survey.answers`): the count prints
+* the model, `fp:explain` prints the table, and a person copies from either.
+*/
+function applyOpaque(functions, options) {
+	const storeOfTable = new Map(options.stores.map((store) => [store.table ?? store.name, store.name]));
+	/** declarations by the origin the rationale will produce */
+	const declared = /* @__PURE__ */ new Map();
+	for (const [key, declaration] of Object.entries(options.declarations)) {
+		const dot = key.indexOf(".");
+		const head = dot === -1 ? key : key.slice(0, dot);
+		const normalised = dot === -1 ? key : `${storeOfTable.get(head) ?? head}.${key.slice(dot + 1)}`;
+		declared.set(normalised, {
+			key,
+			declaration
+		});
+	}
+	const answered = /* @__PURE__ */ new Map();
+	const used = /* @__PURE__ */ new Set();
+	const warnings = [];
+	const warned = /* @__PURE__ */ new Set();
+	const resolveSchemas = (key, names) => {
+		const resolved = names.map((name) => options.schemas.get(name)).filter((schema) => schema !== void 0);
+		for (const name of names) {
+			if (options.schemas.has(name) || warned.has(`${key}:${name}`)) continue;
+			warned.add(`${key}:${name}`);
+			warnings.push(`opaque declaration "${key}" 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 (resolved.length === 0) return null;
+		/** unioned by leaf path: a field two templates share is one DET */
+		const leaves = new Set(resolved.flatMap((schema) => schema.leaves));
+		return {
+			name: resolved.map((schema) => schema.name).join(" + "),
+			fields: leaves.size
+		};
+	};
+	const applied = functions.map((fn) => {
+		let det = fn.det;
+		const sources = [];
+		const overrides = [...fn.rationale.overrides ?? []];
+		const recorded = /* @__PURE__ */ new Set();
+		for (const source of fn.rationale.detSources) {
+			const origin = originOf(source, storeOfTable);
+			const found = origin ? declared.get(origin) : void 0;
+			if (!origin || !found) {
+				sources.push(source);
+				continue;
+			}
+			const { key, declaration } = found;
+			used.add(origin);
+			const body = source.slice(0, -9);
+			if (declaration.schemas) {
+				const schema = resolveSchemas(key, [declaration.schemas].flat());
+				if (!schema) {
+					sources.push(source);
+					continue;
+				}
+				det += schema.fields - 1;
+				sources.push(`${body} → ${schema.name} (${schema.fields} fields)`);
+				answered.set(origin, "replaced");
+				if (!recorded.has(key)) {
+					recorded.add(key);
+					overrides.push({
+						by: `config:opaque.${key} (from ${schema.name}: ${schema.fields} fields)`,
+						reason: declaration.reason,
+						fields: ["det"]
+					});
+				}
+				continue;
+			}
+			if (declaration.reviewed) {
+				sources.push(body + REVIEWED);
+				answered.set(origin, "reviewed");
+				if (!recorded.has(key)) {
+					recorded.add(key);
+					overrides.push({
+						by: `config:opaque.${key}`,
+						reason: declaration.reason,
+						fields: []
+					});
+				}
+				continue;
+			}
+			sources.push(source);
+		}
+		if (det === fn.det && overrides.length === (fn.rationale.overrides?.length ?? 0)) return fn;
+		const complexity = complexityOf(fn.type, fn.refs, det, options.tables);
+		return {
+			...fn,
+			det,
+			complexity,
+			points: pointsOf(fn.type, complexity, options.weights),
+			rationale: {
+				...fn.rationale,
+				detSources: sources,
+				overrides
+			}
+		};
+	});
+	for (const [origin, { key }] of declared) {
+		if (used.has(origin)) continue;
+		warnings.push(`opaque declaration "${key}" matches no DET the analysis found opaque: it had no effect. The origins it can answer are the ones \`fp:count\` lists — \`Store.column\` or \`validator.field\`.`);
+	}
+	return {
+		functions: applied,
+		answered,
+		warnings
+	};
+}
+/**
+* The floors still standing, by origin — the one blind spot this package used
+* to keep to itself.
+*
+* Grouped by origin because that is what a declaration answers: one line for
+* `Form.definition` however many transactions show it. A transformer's spread has
+* its own warning and is not repeated here. Only what is unanswered is a request
+* to do something; what was answered is counted at the end so the fact is
+* recorded rather than erased.
+*/
+function opaqueWarnings(input) {
+	const storeOfTable = new Map(input.stores.map((store) => [store.table ?? store.name, store.name]));
+	const typeOf = /* @__PURE__ */ new Map();
+	for (const store of input.stores) for (const attribute of store.attributes) if (attribute.type) typeOf.set(`${store.name}.${attribute.name}`, attribute.type);
+	/** how many transactions reach each store, so the reader can judge a column's weight */
+	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 floors = /* @__PURE__ */ new Map();
+	for (const fn of input.functions) for (const source of fn.rationale.detSources) {
+		const origin = originOf(source, storeOfTable);
+		if (!origin || source.startsWith("transformer:")) continue;
+		const kind = source.startsWith("validator:") ? "input object" : "column";
+		const floor = floors.get(origin) ?? {
+			kind,
+			carriers: []
+		};
+		if (!floor.carriers.includes(fn.name)) floor.carriers.push(fn.name);
+		floors.set(origin, floor);
+	}
+	const lines = [...floors.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([origin, floor]) => {
+		if (floor.kind === "input object") return `  ${origin} — input object on ${floor.carriers.join(", ")}`;
+		const store = origin.slice(0, origin.indexOf("."));
+		const type = typeOf.get(origin);
+		return `  ${origin}${type ? ` (${type})` : ""} — column on ${store}, reached by ${reached.get(store) ?? 0} transaction(s)`;
+	});
+	const replaced = [...input.answered.values()].filter((how) => how === "replaced").length;
+	const reviewed = [...input.answered.values()].filter((how) => how === "reviewed").length;
+	const settled = replaced + reviewed === 0 ? [] : [`  (already answered: ` + [...replaced > 0 ? [`${replaced} replaced by a schema`] : [], ...reviewed > 0 ? [`${reviewed} reviewed`] : []].join(", ") + `)`];
+	if (lines.length === 0) return settled;
+	return [
+		`${lines.length} DET(s) 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 \`opaque.<origin>.schemas\`; where 1 is the right answer, record it with \`opaque.<origin>.reviewed\` — counting-decisions §8:`,
+		...lines,
+		...settled
+	];
+}
+//#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.
+* A store `C` is a RET of `P` when, and only when:
+*
+*   1. `P` declares `hasMany` / `hasOne` -> `C` (collected as `subgroups`);
+*   2. no application code addresses `C` directly — the user only ever reaches
+*      it through `P`, so under the CPM it is not a logical file of its own;
+*   3. exactly one `P` satisfies (1). More than one: `C` stays apart, reported.
+*
+* Cascade delete was measured and rejected as the signal: on a real application
+* 11 of 13 cascades pointed at the tenant table. Usage is the rule the rest of
+* the count already runs on.
 */
-const OPAQUE_TYPE$1 = /^(object|any|unknown|Record<|Json|JSON)/;
+function groupStores(stores, options) {
+	const rootOf = /* @__PURE__ */ new Map();
+	const members = /* @__PURE__ */ new Map();
+	const linkColumns = /* @__PURE__ */ new Map();
+	const warnings = [];
+	const byName = new Map(stores.map((store) => [store.name, store]));
+	for (const store of stores) {
+		rootOf.set(store.name, store.name);
+		members.set(store.name, [store.name]);
+	}
+	const strategy = options.grouping;
+	if (strategy === "none") return {
+		strategy,
+		rootOf,
+		members,
+		linkColumns,
+		warnings
+	};
+	/** child -> the parents declaring a composition relation to it */
+	const parentsOf = /* @__PURE__ */ new Map();
+	for (const store of stores) for (const child of store.subgroups) {
+		if (!byName.has(child)) continue;
+		parentsOf.set(child, [...parentsOf.get(child) ?? [], store.name]);
+	}
+	const parentChosen = /* @__PURE__ */ new Map();
+	for (const [child, parents] of [...parentsOf.entries()].sort(([a], [b]) => a.localeCompare(b))) {
+		if (options.addressedAnywhere.has(child)) continue;
+		if (parents.length > 1) {
+			warnings.push(`not grouped: ${child} is a composition child of ${parents.sort().join(" and ")} and no application code addresses it directly. Which parent it belongs to is not derivable from the code, so it stays its own data function.`);
+			continue;
+		}
+		parentChosen.set(child, parents[0]);
+	}
+	/** follow parent -> parent up to a store that is its own root; a cycle stops at the child */
+	const rootFor = (child) => {
+		let current = child;
+		const seen = /* @__PURE__ */ new Set();
+		while (parentChosen.has(current) && !seen.has(current)) {
+			seen.add(current);
+			current = parentChosen.get(current);
+		}
+		return seen.has(current) ? child : current;
+	};
+	for (const [child, parent] of parentChosen) {
+		const root = rootFor(child);
+		if (root === child) continue;
+		rootOf.set(child, root);
+		members.get(root).push(child);
+		members.delete(child);
+		linkColumns.set(child, foreignKeysTo(byName.get(child), parent));
+		warnings.push(`grouped: ${child} is a RET of ${root} — ${parent} declares hasMany/hasOne to it, and no application code addresses it directly (counting-decisions §10)`);
+	}
+	for (const [root, list] of members) members.set(root, [root, ...list.filter((member) => member !== root).sort()]);
+	return {
+		strategy,
+		rootOf,
+		members,
+		linkColumns,
+		warnings
+	};
+}
+/**
+* The child's foreign keys to its parent, by Lucid's convention: the
+* `belongsTo` property plus `Id`. Inside one logical file that key is the
+* subgroup's link, not an attribute the user recognises. A key to a DIFFERENT
+* data function still counts, as IFPUG requires.
+*/
+function foreignKeysTo(child, parent) {
+	const names = new Set(child.attributes.map((attribute) => attribute.name));
+	const keys = /* @__PURE__ */ new Set();
+	for (const [property, target] of Object.entries(child.relations)) {
+		if (target !== parent) continue;
+		const key = `${property}Id`;
+		if (names.has(key)) keys.add(key);
+	}
+	return keys;
+}
+/** the DET attributes of one store: not the key, not a system stamp, not a link to its parent */
+function detAttributesOf(store, links = /* @__PURE__ */ new Set()) {
+	return store.attributes.filter((attribute) => !attribute.isIdentifier && !attribute.system && !links.has(attribute.name));
+}
 function countDataFunctions(stores, usage, options) {
 	const counted = [];
+	const byName = new Map(stores.map((store) => [store.name, store]));
+	const { rootOf, members, linkColumns } = options.grouping;
 	for (const store of stores) {
-		const use = usage.get(store.name);
-		if (!use?.used) continue;
+		if (rootOf.get(store.name) !== store.name) continue;
+		const group = (members.get(store.name) ?? [store.name]).map((name) => byName.get(name)).filter((member) => member !== void 0);
 		/**
-		* DETs exclude the technical identifier.
+		* Usage and maintenance are properties of the GROUP: a transaction that
+		* reaches or writes the detail reaches or writes the logical file.
+		*/
+		const use = group.reduce((total, member) => {
+			const each = usage.get(member.name);
+			return {
+				used: total.used || each?.used === true,
+				written: total.written || each?.written === true
+			};
+		}, {
+			used: false,
+			written: false
+		});
+		if (!use.used) continue;
+		/**
+		* DETs exclude the technical identifier, the system timestamps, and — for a
+		* child folded in — its link to the parent.
 		*
 		* IFPUG defines a DET as a "user recognizable" attribute, and an
 		* auto-increment surrogate key is not something the user recognises.
-		* Counting it would inflate every data function by one.
+		* Counting it would inflate every data function by one. A column the
+		* framework stamps (`autoCreate` / `autoUpdate`) is the same kind of field —
+		* counting-decisions §6.
 		*/
-		const detAttributes = store.attributes.filter((attribute) => !attribute.isIdentifier);
-		const det = detAttributes.length;
-		const refs = options.retStrategy === "composition" ? 1 + store.subgroups.length : 1;
+		const detSources = [];
+		let det = 0;
+		for (const member of group) for (const attribute of detAttributesOf(member, linkColumns.get(member.name))) {
+			det++;
+			detSources.push(`${member.columnSource}:${member.table ?? member.name}.${attribute.name}` + (isOpaqueType(attribute.type) ? " (opaque)" : ""));
+		}
+		const refs = group.length;
 		/**
 		* Maintained by the application, or by another system?
 		*
 		* A write reachable from an entry point is the common case. A write from a
-		* job or a seeder maintains the store just as much — AFP §6.5.4 asks who
-		* maintains it, not which route does.
+		* job maintains the store just as much — AFP §6.5.4 asks who maintains it,
+		* not which route does.
 		*/
-		const maintained = use.written || options.writtenAnywhere.has(store.name);
-		const type = options.externallyMaintained.has(store.name) || !maintained ? "EIF" : "ILF";
+		const maintained = use.written || group.some((member) => options.writtenAnywhere.has(member.name));
+		const declaredExternal = group.some((member) => options.externallyMaintained.has(member.name));
+		const type = declaredExternal || !maintained ? "EIF" : "ILF";
 		const complexity = complexityOf(type, refs, det, options.tables);
 		counted.push({
-			id: `data:${store.name}`,
+			/**
+			* Identity is the physical table — counting-decisions §5 — never the class.
+			* Renaming a model is implementation; keyed by the class it billed as a
+			* deletion plus an addition for zero functional change.
+			*/
+			id: `data:${store.table ?? store.name}`,
 			name: store.name,
 			module: store.module,
 			type,
@@ -2159,9 +2654,12 @@ function countDataFunctions(stores, usage, options) {
 			complexity,
 			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}` + (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)"]
+				rule: declaredExternal ? "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,
+				refSources: [options.grouping.strategy === "none" ? `1 (grouping disabled: every table is its own data function)` : `1 (main group: ${store.table ?? store.name})`, ...group.slice(1).map((member) => {
+					const links = [...linkColumns.get(member.name) ?? []].join(", ") || "none found";
+					return `subgroup:${member.name} — a composition child no application code addresses directly; its link to the parent (${links}) is not a DET`;
+				})]
 			}
 		});
 	}
@@ -2182,7 +2680,19 @@ function countTransactionalFunctions(entryPoints, behaviors, options) {
 		*/
 		if (touched.length === 0) continue;
 		const type = behavior.writes ? "EI" : "EO";
-		const refs = touched.length;
+		/**
+		* FTR counts logical files, not tables: the master and the detail folded
+		* into it are one. `reaches:Pedido (via ItemPedido)` keeps the path visible.
+		*/
+		const { rootOf } = options.grouping;
+		const viaOf = /* @__PURE__ */ new Map();
+		for (const store of touched) {
+			const root = rootOf.get(store) ?? store;
+			const via = viaOf.get(root) ?? [];
+			if (root !== store) via.push(store);
+			viaOf.set(root, via);
+		}
+		const refs = viaOf.size;
 		const { det, sources } = detsFor(entry, behavior, touched, type, options);
 		const complexity = complexityOf(type, refs, det, options.tables);
 		counted.push({
@@ -2198,7 +2708,7 @@ function countTransactionalFunctions(entryPoints, behaviors, options) {
 			rationale: {
 				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}`),
+				refSources: [...viaOf.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([root, via]) => `reaches:${root}${via.length ? ` (via ${via.join(", ")})` : ""}`),
 				trace: behavior.trace.map((step) => ({
 					...step,
 					file: relativeTo(options.root, step.file)
@@ -2236,7 +2746,8 @@ function scopeHashOf(behavior) {
 * With no `.select()` and no visible transformer, the output fields are the
 * whole table, which **overestimates**. That is the trade AFP makes on purpose,
 * favouring repeatability over fidelity; the origin is recorded in `Rationale`
-* so `fp:calibrate` can measure the bias.
+* (`transformer:` / `select:` / `output:`) so `fp:calibrate` can measure the
+* bias per origin.
 */
 function detsFor(entry, behavior, touched, type, options) {
 	const sources = [];
@@ -2266,9 +2777,73 @@ function detsFor(entry, behavior, touched, type, options) {
 	* paid for twice.
 	*/
 	for (const field of behavior.requestFields) add(field, `request:${field}`);
-	if (type === "EO" || type === "EQ") for (const store of touched) {
-		const columns = options.countedStores.get(store).attributes.filter((attribute) => !attribute.isIdentifier);
-		for (const column of columns) add(`${store}.${column.name}`, `output:${store}.${column.name}`);
+	if (type === "EO" || type === "EQ") {
+		/**
+		* counting-decisions §6, per store, in order of what is visible:
+		*
+		*   transformer   covers ITS resource: the keys leave, the columns do not.
+		*                 A store read beside it and passed raw is not covered.
+		*   aggregate     `.count()` / `.exists()`: one derived scalar leaves — 1 DET,
+		*                 whatever else is known about the store
+		*   whole         rows leave: every column
+		*   select        only the columns named
+		*   unknown       reached some other way (a hook, a relation): every column
+		*
+		* An unreadable spread in a transformer is a placeholder at 1 DET, marked
+		* `(opaque)` like an open input object, and the counter reports it.
+		*/
+		const opaqueOutputs = new Set(behavior.opaqueOutputFields);
+		/**
+		* Covered: the stores a transformer is for, and the stores preloaded ONLY
+		* through a covered one — `Livro.query().preload('autor')` handed to
+		* `RecenteTransformer<Livro>` loads the author for the transformer, which
+		* emits whatever of it leaves. A store read by a chain of its own is shown
+		* for itself and is never covered this way. Iterated to a fixpoint: a
+		* relation of a relation.
+		*/
+		const covered = new Set(behavior.transformedStores);
+		for (let changed = true; changed;) {
+			changed = false;
+			for (const [store, read] of Object.entries(behavior.outputReads)) {
+				if (covered.has(store) || read.direct || read.via.length === 0) continue;
+				if (!read.via.every((parent) => covered.has(parent))) continue;
+				covered.add(store);
+				changed = true;
+			}
+		}
+		for (const field of behavior.outputFields) add(field, `transformer:${field}${opaqueOutputs.has(field) ? " (opaque)" : ""}`);
+		for (const store of touched) {
+			const read = behavior.outputReads[store];
+			if (read?.aggregate) add(`${store}.<aggregate>`, `aggregate:${store} (a count or an existence check: one scalar)`);
+			if (covered.has(store)) continue;
+			if (read && read.aggregate && !read.whole && read.selected.length === 0) continue;
+			/**
+			* The key and the system timestamps are not DETs however they leave —
+			* selected by name or as part of the whole table. Same ground as on the
+			* data function: the user neither supplies nor recognises them (§6). A
+			* hidden column is a DET of the file and never of an output.
+			*/
+			const attributes = options.countedStores.get(store).attributes;
+			const excluded = new Set([...attributes.filter((a) => a.isIdentifier || a.system || a.hidden).map((a) => a.name), ...options.grouping.linkColumns.get(store) ?? []]);
+			/**
+			* A JSON column leaving the boundary is as unreadable here as on the data
+			* function: 1 DET, marked, so a declaration about the column (§8) reaches the
+			* transactions that show it and not only the store.
+			*/
+			const opaqueOf = new Map(attributes.map((a) => [a.name, isOpaqueType(a.type)]));
+			const mark = (column) => opaqueOf.get(column) ? " (opaque)" : "";
+			if (read && !read.whole && read.selected.length > 0) {
+				for (const column of read.selected) {
+					if (excluded.has(column)) continue;
+					add(`${store}.${column}`, `select:${store}.${column}${mark(column)}`);
+				}
+				continue;
+			}
+			for (const column of attributes) {
+				if (excluded.has(column.name)) continue;
+				add(`${store}.${column.name}`, `output:${store}.${column.name}${mark(column.name)}`);
+			}
+		}
 	}
 	let det = counted.size + options.messageDet;
 	if (options.messageDet > 0) sources.push("message:1");
@@ -2280,20 +2855,17 @@ function detsFor(entry, behavior, touched, type, options) {
 //#endregion
 //#region src/albrecht/technical_filter.ts
 /**
-* Temporary and technical data filter — AFP §6.5.2.1.1.
+* Naming conventions, with the defaults given by the spec itself (§6.5.2.1.3)
+* plus the one AdonisJS asks for.
 *
-*   "Database tables identified as temporary or technical shall be marked as
-*    such to be presented in the final report, and shall be ignored in the rest
-*    of this process."
+* The standard treats these as user-provided inputs, so `boundary.technicalPatterns`
+* REPLACES this list when set — a team that finds `.+types?` catching its
+* business data drops it there — and `boundary.business` restores one table.
 *
-* Returns the reason when a table is technical, `null` otherwise: the report
-* must say WHY something was excluded, not merely that it was.
-*/
-/**
-* Naming conventions, with the defaults given by the spec itself (§6.5.2.1.3).
-*
-* The standard treats these as user-provided inputs, so they stay overridable
-* through the boundary configuration.
+* `token` is not in the spec's list and is here because the framework's own
+* tables are: `auth_access_tokens`, `remember_me_tokens`, `password_reset_tokens`.
+* A token is the machinery of authentication, not data the user maintains, and
+* on two applications it came out as an ILF at 7 PF each.
 */
 const DEFAULT_TECHNICAL_PATTERNS = [
 	{
@@ -2311,11 +2883,18 @@ const DEFAULT_TECHNICAL_PATTERNS = [
 	{
 		label: "template entity",
 		pattern: /^(.*template.*)$/i
+	},
+	{
+		label: "token entity",
+		pattern: /^(.*tokens?.*)$/i
 	}
 ];
 function isTechnical(store, patterns = DEFAULT_TECHNICAL_PATTERNS) {
 	const table = store.table ?? store.name;
-	for (const { label, pattern } of patterns) if (pattern.test(table)) return `${label} (AFP §6.5.2.1.3: ${pattern.source})`;
+	for (const { label, pattern } of patterns) {
+		const regex = typeof pattern === "string" ? new RegExp(pattern, "i") : pattern;
+		if (regex.test(table)) return `${label} (AFP §6.5.2.1.3: ${regex.source})`;
+	}
 	return null;
 }
 //#endregion
@@ -2340,15 +2919,19 @@ const RULESET = "afp";
 * 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 — and three more in 1.2.0: an open input object counting 1 instead of 0,
+* as a DET — 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.
+* write through `related(…)` maintaining the related table — and six in 1.5.0:
+* output DETs read from transformers, selects and aggregates instead of every
+* column; system timestamps and `serializeAs: null` columns leaving the DETs;
+* master-detail folded into one data function; identity by table; token tables
+* technical; and opaque declarations reaching every function carrying the origin.
 *
 * 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.3.0";
+const RULESET_VERSION = "1.5.0";
 function count(input, options = {}) {
 	const warnings = [];
 	const usage = usageOf(input);
@@ -2367,7 +2950,7 @@ function count(input, options = {}) {
 			warnings.push(`excluded by boundary configuration: ${store.name}`);
 			return false;
 		}
-		const technical = isTechnical(store);
+		const technical = isTechnical(store, options.boundary?.technicalPatterns);
 		if (!technical) return true;
 		/**
 		* The naming filter is a heuristic over names, so it catches business data
@@ -2377,55 +2960,95 @@ 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})`);
 		return false;
 	});
+	/**
+	* A configuration the code does not honour is worse than none: whoever set it
+	* believes something changed. `retStrategy` left the type in 0.6.0 — but a
+	* configuration file is loaded without types, so an old one still arrives here
+	* and has to be told.
+	*/
+	if (options.retStrategy !== void 0) warnings.push("`retStrategy` is no longer read: RET comes from how the application uses each table (counting-decisions §10), configurable as `dataFunctions.grouping: 'usage' | 'none'`. Remove the key.");
+	/**
+	* 3. how the stores fold into data functions — §10 — then the data functions.
+	*
+	* Grouping by usage needs the project-wide pass. Without it an empty set would
+	* read as "nobody addresses this table" and fold every composition child into
+	* its parent — the absence of a fact is not the fact. The pipeline always
+	* provides it; a direct caller that does not is told, and gets no grouping.
+	*/
+	const strategy = options.dataFunctions?.grouping ?? "usage";
+	if (strategy === "usage" && input.addressedAnywhere === void 0) warnings.push("grouping by usage needs the project-wide pass (`addressedAnywhere`) and none was provided: every table is its own data function in this count.");
+	const grouping = groupStores(countable, {
+		grouping: input.addressedAnywhere === void 0 ? "none" : strategy,
+		addressedAnywhere: input.addressedAnywhere ?? /* @__PURE__ */ new Set()
+	});
+	warnings.push(...grouping.warnings);
 	const dataFunctions = countDataFunctions(countable, usage, {
+		grouping,
 		writtenAnywhere: input.writtenAnywhere ?? /* @__PURE__ */ new Set(),
-		retStrategy: options.retStrategy ?? "constant",
 		externallyMaintained: new Set(options.boundary?.externallyMaintained ?? []),
 		tables,
 		weights
 	});
-	const countedStores = new Map(dataFunctions.map((fn) => [fn.name, countable.find((store) => store.name === fn.name)]));
+	/**
+	* 4. transactional functions, over the stores that actually count — a child
+	* folded into a counted root counts too: a transaction reaching it reaches the
+	* group, and its columns are the group's output.
+	*/
+	const countedRoots = new Set(dataFunctions.map((fn) => fn.name));
+	const countedStores = new Map(countable.filter((store) => countedRoots.has(grouping.rootOf.get(store.name) ?? store.name)).map((store) => [store.name, store]));
 	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,
+		grouping,
 		root: input.app.root,
 		messageDet: options.messageDet ?? 0,
 		tables,
 		weights
 	});
 	/**
-	* `opaqueReviewed` answers a warning that is CORRECT and therefore permanent.
+	* What the analysis could not read, answered by ORIGIN — counting-decisions §8.
 	*
-	* 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.
+	* A declaration is about a column or a validator field, and it applies to every
+	* function that carries the DET: the data function and each transaction that
+	* takes or shows it. Keyed by function it was declared twice and still missed
+	* the third place, so the same column was worth two numbers in one count.
 	*/
-	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
+	const opaque = applyOpaque([...dataFunctions, ...transactionalFunctions], {
+		declarations: options.opaque ?? {},
+		stores: countable,
+		schemas: input.jsonSchemas ?? /* @__PURE__ */ new Map(),
+		tables,
+		weights
+	});
+	warnings.push(...opaque.warnings);
+	const functions = applyOverrides(opaque.functions, options.overrides ?? {}, tables, weights, warnings);
+	warnings.push(...opaqueWarnings({
+		functions,
+		stores: countable,
+		entryPoints: input.entryPoints,
+		behaviors: input.behaviors,
+		answered: opaque.answered
 	}));
 	warnings.push(...unreadableInputWarnings(input));
+	warnings.push(...unreadableOutputWarnings(input));
+	warnings.push(...lookAlikeWarnings(functions));
+	warnings.push(...seededOnlyWarnings(functions, grouping.members, input.seededAnywhere));
 	return {
 		ruleset: "afp",
 		rulesetVersion: RULESET_VERSION,
@@ -2435,106 +3058,57 @@ function count(input, options = {}) {
 	};
 }
 /**
-* Columns whose content static analysis cannot read — counting-decisions §8.
-*
-* A JSON column holding a form the user fills counts as 1 DET, because the
-* schema is runtime data. That is the documented trade, and until now it was
-* documented ONLY: the count said nothing, which is the one known blind spot
-* this package reported nowhere. It reports an unresolved call, a technical
-* table, an unresolved mixin and a handler-less route — and stayed silent here.
-*
-* Only columns on a store some transaction reaches are named. An untouched
-* `metadata` column changes no number, and warning about it would be the noise
-* that teaches people to stop reading the confidence block.
-*/
-/**
-* 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.
+* Transactions that look like the same elementary process.
+*
+* The CPM counts identical processing logic once. `GET /perfil` and
+* `GET /perfil/editar` on a real application walk the same queries and the same
+* transformers, touch the same stores and emit the same DETs, and were 7 FP each.
+* Whether the second is a screen the user needs or a second URL for the same one
+* is not derivable from code, so both stay counted and the pair is named with
+* the FP at stake — a request to decide, answered with `boundary.ignoreEntryPoints`.
+*
+* The key is deliberately narrow: same type, same stores, same DET sources AND
+* the same bodies below the entry point. Two fat controllers that merely read the
+* same table are not flagged — with nothing followed, nothing says the logic is
+* the same.
 */
-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;
+function lookAlikeWarnings(functions) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const fn of functions) {
+		if (!fn.id.startsWith("tx:")) continue;
+		const below = (fn.rationale.trace ?? []).filter((step) => step.depth > 0).map((step) => `${step.file}#${step.member ?? "*"}`).sort();
+		if (below.length === 0) continue;
+		const key = [
+			fn.type,
+			[...fn.rationale.refSources].sort().join(","),
+			[...fn.rationale.detSources].sort().join(","),
+			below.join(",")
+		].join("|");
+		groups.set(key, [...groups.get(key) ?? [], fn]);
+	}
+	const alike = [...groups.values()].filter((group) => group.length > 1);
+	if (alike.length === 0) return [];
+	return [`${alike.length} group(s) of transactions share the same stores, the same DETs and the same bodies below the controller — the CPM counts identical processing logic once. Whether the second is a screen of its own is not derivable from the code: decide, and record it with \`boundary.ignoreEntryPoints\`:`, ...alike.map((group) => {
+		const names = group.map((fn) => fn.name).sort();
+		const atStake = group.slice(1).reduce((total, fn) => total + fn.points, 0);
+		return `  ${names.join(" ≡ ")}   (${atStake} FP at stake)`;
+	})];
 }
-/** 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
+* EIFs that only a seeder writes.
+*
+* After 0.5.0 a seeder's inserts are not maintenance, so a table only the seed
+* populates is "used but not maintained" — an EIF. That is right for a table
+* that mirrors data another system maintains in production, and wrong for a
+* `roles` table: reference data the team maintains is code data under the CPM,
+* and is not counted at all. The code cannot tell the two apart, and should not
+* try; it names them and says what each answer costs.
 */
-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 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) {
-		if (!reached.get(store.name)) continue;
-		for (const attribute of store.attributes) {
-			if (!attribute.type || !OPAQUE_TYPE.test(attribute.type)) continue;
-			const entry = tally(store.name, "column", reached.get(store.name) ?? 0);
-			if (state.reviewed.has(`${store.name}.${attribute.name}`) || state.reviewed.has(attribute.name)) entry.reviewed += 1;
-			else entry.floor.push(`${attribute.name} (${attribute.type})`);
-		}
-	}
-	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
-	];
+function seededOnlyWarnings(functions, members, seeded) {
+	if (!seeded || seeded.size === 0) return [];
+	const named = functions.filter((fn) => fn.type === "EIF" && fn.rationale.rule.includes("used but not maintained") && (members.get(fn.name) ?? [fn.name]).some((member) => seeded.has(member)));
+	if (named.length === 0) return [];
+	return [`${named.length} EIF(s) are written by a seeder and by nothing else in the application. Reference data the team maintains is code data (CPM) and is not counted — exclude it with \`boundary.infrastructure\`; data another system maintains in production is a legitimate EIF — keep it. The code cannot tell which:`, ...named.map((fn) => `  ${fn.name} (${fn.points} FP)`)];
 }
 /**
 * Transactions that read the request in a way that enumerates nothing.
@@ -2573,87 +3147,63 @@ function unreadableInputWarnings(input) {
 	];
 }
 /**
-* Replaces what the analysis found with what a person declared.
+* Transformers that emit something the analysis cannot read.
 *
-* Only for facts static analysis cannot reach — a JSON column whose schema
-* lives in the database, per counting-decisions §8. The declared number is
-* reproducible because it comes from a versioned file, and auditable because it
-* travels with its justification into the rationale, which `fp:explain` prints.
-*
-* 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.
+* `...this.resource.serialize()`, `...this.extras`: whatever the model has, or
+* whatever was handed in. Each counts 1 DET — a floor, the same as an open input
+* object — and the transaction's output is understated by however many fields
+* the spread carries. Reported with the expression, because the fix is in the
+* transformer: name the fields, or `pick` them.
 */
-function applyOverrides(functions, overrides, schemas, tables, weights, warnings) {
+function unreadableOutputWarnings(input) {
+	const blind = input.entryPoints.map((entry) => ({
+		entry,
+		behavior: input.behaviors.get(entry.id)
+	})).filter(({ behavior }) => (behavior?.opaqueOutputFields.length ?? 0) > 0);
+	if (blind.length === 0) return [];
+	return [
+		`${blind.length} transaction(s) pass through a transformer that spreads something the analysis cannot read, counted as 1 DET each — a FLOOR. This UNDERSTATES the output; the fix is in the transformer (\`this.pick(...)\` or named keys), not a configuration:`,
+		...blind.slice(0, 10).map(({ entry, behavior }) => `  ${entry.trigger} ${entry.signature}: ${behavior.opaqueOutputFields.join(", ")}`),
+		...blind.length > 10 ? [`  … and ${blind.length - 10} more`] : []
+	];
+}
+/**
+* Replaces what the analysis found with a NUMBER a person declared — DET or RET
+* of one function.
+*
+* Only for facts static analysis cannot reach, and only when naming the origin
+* (`opaque`) is not possible: a declared number is reproducible because it comes
+* from a versioned file, and auditable because it travels with its justification
+* into the rationale, which `fp:explain` prints — but it freezes the moment the
+* form grows. An override naming no function is a warning, never silence.
+*/
+function applyOverrides(functions, overrides, tables, weights, warnings) {
 	const keys = Object.keys(overrides);
 	if (keys.length === 0) return functions;
+	/**
+	* A configuration the code does not honour is worse than none. The two keys
+	* that used to live here moved to `opaque`, by origin, in 0.6.0 and left the
+	* type — but a configuration file is loaded without types, so an old one still
+	* arrives here believing something happened.
+	*/
+	for (const [name, override] of Object.entries(overrides)) {
+		const legacy = override;
+		const moved = [...legacy.detFromSchema ? ["detFromSchema"] : [], ...legacy.opaqueReviewed ? ["opaqueReviewed"] : []];
+		if (moved.length === 0) continue;
+		warnings.push(`override "${name}" uses \`${moved.join("` and `")}\`, which moved to \`opaque.<Store.column | validator.field>\` in 0.6.0 and is no longer read here: it had no effect. Declare the origin, and it applies to every function carrying it.`);
+	}
 	const used = /* @__PURE__ */ new Set();
 	const applied = functions.map((fn) => {
 		const override = overrides[fn.name];
 		if (!override) return fn;
 		used.add(fn.name);
 		const fields = [];
-		if (override.det !== void 0 || override.detFromSchema) fields.push("det");
+		if (override.det !== void 0) fields.push("det");
 		if (override.refs !== void 0) fields.push("refs");
-		let det = override.det ?? fn.det;
-		let by = `config:overrides.${fn.name}`;
-		/**
-		* Read from the schema rather than declared as a number.
-		*
-		* A frozen number goes stale the moment someone adds a field: the count
-		* would not move and `fp:diff` would report no change for real functional
-		* growth. Naming the schema keeps the number coming from the code, and the
-		* only thing maintained by hand is the mapping — which changes when a form
-		* is born, not when a field is.
-		*/
-		if (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
-				* 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)`;
-				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.`);
-			}
-		}
+		if (fields.length === 0) return fn;
+		const det = override.det ?? fn.det;
 		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,
@@ -2663,7 +3213,7 @@ function applyOverrides(functions, overrides, schemas, tables, weights, warnings
 			rationale: {
 				...fn.rationale,
 				overrides: [...fn.rationale.overrides ?? [], {
-					by,
+					by: `config:overrides.${fn.name}`,
 					reason: override.reason,
 					fields
 				}]
@@ -2690,7 +3240,16 @@ function usageOf(input) {
 			};
 			usage.set(store, {
 				used: true,
-				written: current.written || behavior.writes
+				/**
+				* Per STORE, not per transaction.
+				*
+				* `behavior.writes` decides EI against EO and says nothing about which of
+				* the tables was written. Read as "this store is maintained", a reference
+				* table merely READ by a route that writes something else became an ILF —
+				* and on a production application that left exactly one EIF in the whole
+				* count, which should have been the signal.
+				*/
+				written: current.written || behavior.writtenStores.includes(store)
 			});
 		}
 	}
@@ -2880,6 +3439,7 @@ async function analyze(root, options = {}) {
 			entryPointId,
 			writes: behavior.writes,
 			touches: behavior.touches,
+			writtenStores: behavior.writtenStores,
 			inputFields: behavior.inputFields.map((name) => ({
 				name,
 				provenance: {
@@ -2902,7 +3462,22 @@ async function analyze(root, options = {}) {
 				}
 			})),
 			opaqueRequest: behavior.opaqueRequest,
-			outputFields: [],
+			outputFields: behavior.outputFields.map((name) => ({
+				name,
+				provenance: {
+					file: emit(app.root),
+					by: "transformer"
+				}
+			})),
+			opaqueOutputFields: behavior.opaqueOutputFields.map((name) => ({
+				name,
+				provenance: {
+					file: emit(app.root),
+					by: "transformer"
+				}
+			})),
+			transformedStores: behavior.transformedStores,
+			outputReads: behavior.outputReads,
 			trace: behavior.trace.map((step) => ({
 				...step,
 				file: emit(step.file)
@@ -2930,11 +3505,13 @@ async function analyze(root, options = {}) {
 				entryPoints,
 				behaviors,
 				jsonSchemas,
-				writtenAnywhere: analyzer.writtenAnywhere()
+				writtenAnywhere: analyzer.writtenAnywhere(),
+				addressedAnywhere: analyzer.addressedAnywhere(),
+				seededAnywhere: analyzer.seededAnywhere()
 			}, options),
 			source
 		}
 	};
 }
 //#endregion
-export { RULESET_VERSION as i, analyze as n, RULESET as r, CoverageTooLowError as t };
+export { DEFAULT_TECHNICAL_PATTERNS as a, RULESET_VERSION as i, analyze as n, RULESET as r, CoverageTooLowError as t };