@filipebraida/adonis-function-points 0.5.0 → 0.7.0

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

@@ -1,4 +1,4 @@
-import { a as hooksFiredBy, c as isApplicationCode, d as toPosix, i as detectAccess, l as relativeTo, n as isTechnicalWrite, o as rootSymbolOf, r as resolveCall, s as collectEventBindings, t as BUILTIN_CALL_RESOLVERS, u as samePath } from "./resolvers-PJwo2Z8R.js";
+import { _ as relativeTo, a as chainShapeOf, c as unwrap$1, d as collectEventBindings, f as detectAccess, g as isSeeder, h as isApplicationCode, i as resolveCall, l as DISPATCH_METHODS, m as rootSymbolOf, o as mappedLiteralOf, p as hooksFiredBy, r as isTechnicalWrite, s as outputFieldsIn, t as BUILTIN_CALL_RESOLVERS, u as EXECUTION_METHODS, v as samePath, y as toPosix } from "./resolvers-DaU4uAqT.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(),
@@ -949,93 +965,116 @@ const problemAt = (call, expression, reason) => ({
 	reason
 });
 //#endregion
-//#region src/inventory/sources/json_schemas.ts
-function collectJsonSchemas(app) {
+//#region src/inventory/sources/commands.ts
+/**
+* Ace commands as entry points — counting-decisions §5, plan 0.7 §C.
+*
+* IFPUG counts batch processes an operator starts. `node ace noticias:importar`
+* reads a feed and writes news: an EI exactly like a `POST`, and until this the
+* collector emitted only `kind: 'http'`, although the type had `command` and §5
+* had decided its identity since 0.1.0.
+*
+* AdonisJS scans `./commands` for the application's own commands; so does this.
+* A command is a class extending `BaseCommand` from `@adonisjs/core/ace` with a
+* literal `static commandName`; its body is `run()`, followed by the same
+* strategies as any handler. What it reaches decides whether it is a transaction
+* at all — a scaffolder that writes files reaches no store and falls out, as a
+* static route does.
+*/
+const ACE_MODULE = "@adonisjs/core/ace";
+const BASE_COMMAND = "BaseCommand";
+/** a generator of test data, by the package everyone uses for it */
+const FAKER = /^@faker-js\/faker/;
+const GENERATES_DATA_HINT = "imports @faker-js/faker: generates data, probably a development tool";
+function collectCommands(app) {
 	const project = new Project({
 		skipAddingFilesFromTsConfig: true,
 		skipFileDependencyResolution: true,
 		compilerOptions: { allowJs: false }
 	});
-	/**
-	* 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);
-		if (!literal || !isJsonSchema(literal)) continue;
-		const leaves = leavesOf$1(literal);
-		if (leaves.length === 0) continue;
-		found.set(declaration.getName(), {
-			name: declaration.getName(),
-			fields: leaves.length,
-			leaves,
-			provenance: {
-				file: toPosix(file.getFilePath()),
-				line: declaration.getStartLineNumber(),
-				by: "json-schema"
-			}
-		});
+	project.addSourceFilesAtPaths(`${toPosix(app.root)}/commands/**/*.ts`);
+	const entryPoints = [];
+	for (const file of project.getSourceFiles()) {
+		if (/\.(spec|test)\.ts$/.test(file.getBaseName())) continue;
+		const baseCommand = baseCommandNameIn(file);
+		if (!baseCommand) continue;
+		for (const cls of file.getClasses()) {
+			if (cls.getExtends()?.getExpression().getText() !== baseCommand) continue;
+			const name = commandNameOf(cls);
+			if (!name) continue;
+			const filePath = file.getFilePath();
+			const hints = importsFaker(file) ? [GENERATES_DATA_HINT] : [];
+			entryPoints.push({
+				id: `ace ${name}`,
+				kind: "command",
+				module: app.moduleOf(filePath),
+				trigger: "ace",
+				signature: name,
+				name,
+				handler: {
+					file: filePath,
+					member: "run"
+				},
+				identity: `ace ${name}`,
+				provenance: {
+					file: filePath,
+					line: cls.getStartLineNumber(),
+					by: "ace-commands"
+				},
+				...hints.length ? { hints } : {}
+			});
+		}
 	}
-	return found;
+	return entryPoints.sort((a, b) => a.identity.localeCompare(b.identity));
 }
-/** `{ … } as const` and `{ … } satisfies X` still hold the literal */
-function unwrap(node) {
-	if (!node) return void 0;
-	if (Node.isAsExpression(node) || Node.isSatisfiesExpression(node)) return unwrap(node.getExpression());
-	return node;
+/** the local name `BaseCommand` was imported under from `@adonisjs/core/ace`, if it was */
+function baseCommandNameIn(file) {
+	for (const declaration of file.getImportDeclarations()) {
+		if (declaration.getModuleSpecifierValue() !== ACE_MODULE) continue;
+		const named = declaration.getNamedImports().find((n) => n.getName() === BASE_COMMAND);
+		if (named) return named.getAliasNode()?.getText() ?? BASE_COMMAND;
+	}
+	return null;
 }
-/**
-* Recognised by shape, never by name.
-*
-* A const called `schema` may be anything; an object declaring `type: 'object'`
-* with a `properties` map is a JSON Schema whatever it is called.
-*/
-function isJsonSchema(literal) {
-	return (literal.getProperty("type")?.asKind(SyntaxKind.PropertyAssignment))?.getInitializer()?.asKind(SyntaxKind.StringLiteral)?.getLiteralValue() === "object" && literal.getProperty("properties") !== void 0;
+/** `static commandName = 'noticias:importar'` — a literal; a computed name is nobody's identity */
+function commandNameOf(cls) {
+	const property = cls.getStaticProperty("commandName");
+	if (!property || !Node.isPropertyDeclaration(property)) return null;
+	const initializer = property.getInitializer();
+	if (!initializer) return null;
+	if (Node.isStringLiteral(initializer) || Node.isNoSubstitutionTemplateLiteral(initializer)) return initializer.getLiteralValue();
+	return null;
+}
+function importsFaker(file) {
+	return file.getImportDeclarations().some((d) => FAKER.test(d.getModuleSpecifierValue()));
 }
+/** the ace decorators that declare what the operator types: `@flags.string()`, `@args.string()` */
+const INPUT_DECORATORS = new Set(["flags", "args"]);
 /**
-* Leaves of a JSON Schema, by the table in counting-decisions §7.
-*
-*   scalar                  1
-*   nested object           leaves counted individually
-*   array of scalar         1  (repeating group)
-*   array of object         the object's leaves, once
-*   enum / const            1
+* The input DETs of a command: its `@flags.*` and `@args.*`, named as the
+* operator types them — `flagName` / `argumentName` when given, the property
+* otherwise. Returned as `flags.<name>` / `args.<name>` so the counter can say
+* which is which.
 */
-function leavesOf$1(literal, prefix = "") {
-	const properties = literal.getProperty("properties")?.asKind(SyntaxKind.PropertyAssignment);
-	const items = literal.getProperty("items")?.asKind(SyntaxKind.PropertyAssignment);
-	if (properties) {
-		const map = properties.getInitializer()?.asKind(SyntaxKind.ObjectLiteralExpression);
-		if (!map) return [];
-		return map.getProperties().flatMap((property) => {
-			const assignment = property.asKind(SyntaxKind.PropertyAssignment);
-			if (!assignment) return [];
-			const name = assignment.getName().replace(/['"]/g, "");
-			const path = prefix ? `${prefix}.${name}` : name;
-			const nested = unwrap(assignment.getInitializer())?.asKind(SyntaxKind.ObjectLiteralExpression);
-			const inner = nested ? leavesOf$1(nested, path) : [];
-			return inner.length > 0 ? inner : [path];
-		});
-	}
-	if (items) {
-		const element = unwrap(items.getInitializer())?.asKind(SyntaxKind.ObjectLiteralExpression);
-		const inner = element ? leavesOf$1(element, prefix) : [];
-		return inner.length > 0 ? inner : [prefix];
+function commandFieldsOf(cls) {
+	const fields = [];
+	for (const property of cls.getProperties()) for (const decorator of property.getDecorators()) {
+		const call = decorator.getCallExpression();
+		const callee = call?.getExpression();
+		if (!call || !callee || !Node.isPropertyAccessExpression(callee)) continue;
+		const kind = callee.getExpression().getText();
+		if (!INPUT_DECORATORS.has(kind)) continue;
+		const options = call.getArguments()[0];
+		const literal = (options && Node.isObjectLiteralExpression(options) ? ["flagName", "argumentName"].map((key) => options.getProperty(key)).find((p) => p && Node.isPropertyAssignment(p)) : void 0)?.getInitializer();
+		const name = literal && Node.isStringLiteral(literal) ? literal.getLiteralValue() : property.getName();
+		fields.push(`${kind}.${name}`);
 	}
-	return [];
+	return fields;
+}
+/** is this class an ace command? — the graph asks, to read its flags as input */
+function isCommandClass(cls) {
+	const baseCommand = baseCommandNameIn(cls.getSourceFile());
+	return !!baseCommand && cls.getExtends()?.getExpression().getText() === baseCommand;
 }
 //#endregion
 //#region src/inventory/graph/noise.ts
@@ -1148,7 +1187,10 @@ const FRAMEWORK_SERVICES = new Set([
 	"encryption",
 	"i18n",
 	"ally",
-	"bouncer"
+	"bouncer",
+	"ui",
+	"colors",
+	"app"
 ]);
 /** Is this call one that cannot reach a data store? */
 function isNoise(call, owner) {
@@ -1223,6 +1265,814 @@ function isNoiseMember(file, member) {
 	return base !== void 0 && FRAMEWORK_SERVICES.has(base);
 }
 //#endregion
+//#region src/inventory/graph/deliveries.ts
+/** `inertia.render(page, props)`, `inertia.modal(page, props)`, `view.render(view, props)` */
+const RENDERERS = new Set(["inertia", "view"]);
+const RENDER_METHODS = new Set(["render", "modal"]);
+/** `response.json(x)`, `.ok(x)`, `.created(x)`, `.send(x)`, `.accepted(x)` */
+const RESPONSE_METHODS = new Set([
+	"json",
+	"ok",
+	"created",
+	"accepted",
+	"send"
+]);
+/**
+* An ace command prints: `this.ui.table().row([…])`, `this.logger.info(…)`,
+* `console.log(…)`. What a report hands to the terminal is what leaves — every
+* argument is delivered, read like a prop (plan 0.7 §C).
+*/
+const PRINTERS = new Set([
+	"ui",
+	"logger",
+	"console"
+]);
+/** `x.data`, `x.rows` on a paginated / wrapped result hand the collection on */
+const PASSES_THROUGH = new Set([
+	"data",
+	"rows",
+	"all",
+	"toJSON",
+	"serialize"
+]);
+/** keys of a result that carry its rows: picking one of these is not picking one value */
+const PASSES_ROWS = new Set([
+	"data",
+	"rows",
+	"items",
+	"results",
+	"list",
+	"linhas",
+	"itens"
+]);
+/** properties of a result that are one value, not its rows */
+const SCALAR_PROPS = new Set([
+	"length",
+	"size",
+	"total",
+	"count"
+]);
+/**
+* What Lucid's `paginator.getMeta()` says that a page can show. The URLs are
+* navigation and `firstPage` a constant: neither is a user-recognisable attribute.
+*/
+const PAGINATOR_META = [
+	"total",
+	"perPage",
+	"currentPage",
+	"lastPage"
+];
+/** methods that return the same collection, or one of its rows: what leaves is the receiver */
+const SAME_COLLECTION = new Set([
+	"slice",
+	"filter",
+	"sort",
+	"sortBy",
+	"toSorted",
+	"reverse",
+	"toReversed",
+	"concat",
+	"flat",
+	"find",
+	"findLast",
+	"at",
+	"first",
+	"last"
+]);
+/** reads of the request whose result echoes input already counted on entry */
+const ECHOES_INPUT = new Set([
+	"validateUsing",
+	"input",
+	"only",
+	"all",
+	"body",
+	"qs",
+	"params"
+]);
+/** Inertia's lazy props: `inertia.defer(() => q.handle())` — the callback's value is what leaves */
+const INERTIA_LAZY = new Set([
+	"defer",
+	"lazy",
+	"optional",
+	"always",
+	"merge",
+	"scroll",
+	"once"
+]);
+/** a yes/no: an authorisation check, a membership test */
+const BOOLEAN_METHODS = new Set([
+	"allows",
+	"denies",
+	"can",
+	"cannot",
+	"includes",
+	"has",
+	"startsWith",
+	"endsWith",
+	"test"
+]);
+/** a value formatted: still one value */
+const FORMAT_METHODS = new Set([
+	"join",
+	"toString",
+	"toISO",
+	"toISODate",
+	"toISOTime",
+	"toISOString",
+	"toFormat",
+	"toRFC2822",
+	"toHTTP",
+	"toSQL",
+	"toLocaleString",
+	"toLocaleDateString",
+	"toFixed",
+	"toUnixInteger",
+	"toMillis",
+	"trim",
+	"toUpperCase",
+	"toLowerCase",
+	"padStart",
+	"padEnd",
+	"replace",
+	"slice",
+	"substring"
+]);
+/** framework services whose calls hand back one value: a translation, a session key, a URL */
+const SCALAR_SERVICES = new Set([
+	"i18n",
+	"session",
+	"env",
+	"router",
+	"encryption",
+	"hash",
+	"config",
+	"app"
+]);
+/** built-ins whose static calls are one value or a constant list: `Object.values(Enum)`, `JSON.stringify(x)` */
+const NATIVE_GLOBALS = new Set([
+	"Object",
+	"Array",
+	"JSON",
+	"Math",
+	"Number",
+	"String",
+	"Boolean",
+	"Date",
+	"Intl"
+]);
+/**
+* The deliveries of a body: every props argument handed to a renderer or a
+* response method, and what a `return` hands back that is not one of those calls.
+*/
+function deliveriesIn(ctx) {
+	const deliveries = [];
+	const returns = [];
+	let any = false;
+	let anyReturn = false;
+	const seen = /* @__PURE__ */ new Set();
+	for (const call of ctx.body.getDescendantsOfKind(SyntaxKind.CallExpression)) {
+		const callee = call.getExpression();
+		if (!Node.isPropertyAccessExpression(callee)) continue;
+		const method = callee.getName();
+		const receiver = lastSegmentOf(callee.getExpression());
+		let payload;
+		if (RENDERERS.has(receiver) && RENDER_METHODS.has(method)) payload = call.getArguments()[1];
+		else if (receiver === "response" && RESPONSE_METHODS.has(method)) payload = call.getArguments()[0];
+		else if (isPrinter(callee.getExpression(), ctx.body)) {
+			any = true;
+			seen.add(call);
+			for (const argument of call.getArguments()) classify(unwrap$1(argument), "", ctx, deliveries, 0);
+			continue;
+		} else continue;
+		any = true;
+		if (!payload) continue;
+		seen.add(call);
+		classify(unwrap$1(payload), "", ctx, deliveries, 0);
+	}
+	for (const statement of ctx.body.getDescendantsOfKind(SyntaxKind.ReturnStatement)) {
+		if (statement.getFirstAncestor((node) => Node.isArrowFunction(node) || Node.isFunctionExpression(node) || Node.isMethodDeclaration(node) || Node.isFunctionDeclaration(node)) !== ctx.body) continue;
+		const value = unwrap$1(statement.getExpression());
+		if (!value) continue;
+		if (Node.isCallExpression(value)) {
+			if (seen.has(value)) continue;
+			/**
+			* `return response.redirect().toRoute(…)`, `return response.noContent()`,
+			* `return inertia.render(…)` (seen above): a call whose chain is rooted at
+			* the response or a renderer is the response itself, not a value handed
+			* back — nothing to classify.
+			*/
+			const root = chainRootOf(value);
+			if (root && (RENDERERS.has(root) || root === "response")) continue;
+		}
+		anyReturn = true;
+		classify(value, "", ctx, returns, 0);
+	}
+	return {
+		calls: deliveries,
+		anyCall: any,
+		returns,
+		anyReturn
+	};
+}
+/** the identifier a call chain is rooted at: `response.redirect().toRoute(x)` -> 'response' */
+function chainRootOf(node) {
+	let current = node;
+	for (let depth = 0; current && depth < 40; depth++) {
+		if (Node.isCallExpression(current) || Node.isPropertyAccessExpression(current)) {
+			current = current.getExpression();
+			continue;
+		}
+		if (Node.isAwaitExpression(current) || Node.isParenthesizedExpression(current)) {
+			current = current.getExpression();
+			continue;
+		}
+		return Node.isIdentifier(current) ? current.getText() : Node.isThisExpression(current) ? "this" : null;
+	}
+	return null;
+}
+/**
+* `this.ui.table().row(x)`, `this.logger.info(x)`, `console.log(x)`: a chain rooted
+* at a printer — through a variable too (`const table = this.ui.table(); table.row(x)`).
+*/
+function isPrinter(receiver, body, depth = 0) {
+	let current = receiver;
+	for (let steps = 0; current && steps < 20; steps++) {
+		if (Node.isCallExpression(current)) {
+			current = current.getExpression();
+			continue;
+		}
+		if (Node.isPropertyAccessExpression(current)) {
+			const inner = current.getExpression();
+			if (Node.isThisExpression(inner)) return PRINTERS.has(current.getName());
+			current = inner;
+			continue;
+		}
+		if (!Node.isIdentifier(current)) return false;
+		if (current.getText() === "console") return true;
+		const bound = depth < 3 ? bindingOf(current.getText(), body) : null;
+		return !!bound && isPrinter(bound.initializer, body, depth + 1);
+	}
+	return false;
+}
+/** `ctx.inertia` -> 'inertia', `inertia` -> 'inertia', `this.response` -> 'response' */
+function lastSegmentOf(node) {
+	if (Node.isPropertyAccessExpression(node)) return node.getName();
+	return node.getText();
+}
+function classify(value, path, ctx, out, depth) {
+	if (!value || depth > 6) return;
+	if (value.getKind() === SyntaxKind.NullKeyword) return;
+	if (Node.isIdentifier(value) && value.getText() === "undefined") return;
+	/**
+	* A constant with no key — `this.logger.info('done')`, a table's `head(['Nome'])`
+	* — is a label or a message, not a field: AFP counts no message DET (§6). Keyed,
+	* `{ titulo: 'X' }` is a value the page receives, and stays one.
+	*/
+	if (!path && (Node.isStringLiteral(value) || Node.isNoSubstitutionTemplateLiteral(value) || Node.isNumericLiteral(value))) return;
+	if (Node.isObjectLiteralExpression(value)) {
+		for (const property of value.getProperties()) if (Node.isShorthandPropertyAssignment(property)) classify(property.getNameNode(), join(path, property.getName()), ctx, out, depth + 1);
+		else if (Node.isPropertyAssignment(property)) {
+			const name = Node.isComputedPropertyName(property.getNameNode()) ? "*" : property.getName().replace(/^['"]|['"]$/g, "");
+			classify(unwrap$1(property.getInitializer()), join(path, name), ctx, out, depth + 1);
+		} else if (Node.isSpreadAssignment(property)) classify(unwrap$1(property.getExpression()), path, ctx, out, depth + 1);
+		else out.push({
+			kind: "scalar",
+			path: join(path, property.getName?.() ?? "*")
+		});
+		return;
+	}
+	if (Node.isConditionalExpression(value)) {
+		classify(unwrap$1(value.getWhenTrue()), path, ctx, out, depth + 1);
+		classify(unwrap$1(value.getWhenFalse()), path, ctx, out, depth + 1);
+		return;
+	}
+	if (Node.isArrayLiteralExpression(value)) {
+		for (const element of value.getElements()) classify(unwrap$1(Node.isSpreadElement(element) ? element.getExpression() : element), path, ctx, out, depth + 1);
+		return;
+	}
+	if (Node.isElementAccessExpression(value)) {
+		classify(unwrap$1(value.getExpression()), path, ctx, out, depth + 1);
+		return;
+	}
+	if (Node.isIdentifier(value)) {
+		const name = value.getText();
+		if (ctx.symbols.has(name)) {
+			out.push({
+				kind: "store",
+				store: ctx.symbols.get(name),
+				path
+			});
+			return;
+		}
+		const bound = bindingOf(name, ctx.body);
+		if (bound) {
+			if (bound.pick && Node.isCallExpression(bound.initializer)) {
+				classifyCall(bound.initializer, path, ctx, out, depth + 1, bound.pick);
+				return;
+			}
+			if (bound.pick && Node.isObjectLiteralExpression(bound.initializer)) {
+				const picked = bound.initializer.getProperty(bound.pick);
+				if (picked && Node.isPropertyAssignment(picked)) {
+					classify(unwrap$1(picked.getInitializer()), path, ctx, out, depth + 1);
+					return;
+				}
+				if (picked && Node.isShorthandPropertyAssignment(picked)) {
+					classify(picked.getNameNode(), path, ctx, out, depth + 1);
+					return;
+				}
+			}
+			classify(bound.initializer, path, ctx, out, depth + 1);
+			return;
+		}
+		if (isEchoBinding(name, ctx.body)) {
+			out.push({
+				kind: "echo",
+				path
+			});
+			return;
+		}
+		out.push({
+			kind: "scalar",
+			path
+		});
+		return;
+	}
+	if (Node.isCallExpression(value)) {
+		classifyCall(value, path, ctx, out, depth);
+		return;
+	}
+	if (Node.isPropertyAccessExpression(value) || Node.isElementAccessExpression(value)) {
+		classifyAccess(value, path, ctx, out, depth);
+		return;
+	}
+	if (Node.isAwaitExpression(value)) {
+		classify(unwrap$1(value.getExpression()), path, ctx, out, depth + 1);
+		return;
+	}
+	if (Node.isBinaryExpression(value)) {
+		const operator = value.getOperatorToken().getKind();
+		if (operator === SyntaxKind.QuestionQuestionToken || operator === SyntaxKind.BarBarToken) {
+			classify(unwrap$1(value.getLeft()), path, ctx, out, depth + 1);
+			return;
+		}
+		if (operator === SyntaxKind.AmpersandAmpersandToken) {
+			classify(unwrap$1(value.getRight()), path, ctx, out, depth + 1);
+			return;
+		}
+	}
+	if (Node.isTemplateExpression(value)) {
+		for (const span of value.getTemplateSpans()) classify(unwrap$1(span.getExpression()), path, ctx, out, depth + 1);
+		return;
+	}
+	out.push({
+		kind: "scalar",
+		path
+	});
+}
+function classifyCall(value, path, ctx, out, depth, pick) {
+	{
+		const callee = value.getExpression();
+		const method = Node.isPropertyAccessExpression(callee) ? callee.getName() : "";
+		if (Node.isPropertyAccessExpression(callee) && ECHOES_INPUT.has(method) && isRequestLike(callee.getExpression())) {
+			out.push({
+				kind: "echo",
+				path
+			});
+			return;
+		}
+		const mapped = mappedLiteralOf(value);
+		if (mapped) {
+			classify(mapped, path, ctx, out, depth + 1);
+			return;
+		}
+		if (method === "map" && Node.isPropertyAccessExpression(callee)) {
+			classifyMapped(value, callee.getExpression(), path, ctx, out, depth);
+			return;
+		}
+		if (Node.isPropertyAccessExpression(callee) && PASSES_THROUGH.has(method) && value.getArguments().length === 0) {
+			classify(unwrap$1(callee.getExpression()), path, ctx, out, depth + 1);
+			return;
+		}
+		if (method === "getMeta" && value.getArguments().length === 0) {
+			if (pick) out.push({
+				kind: "scalar",
+				path
+			});
+			else for (const key of PAGINATOR_META) out.push({
+				kind: "scalar",
+				path: join(path, key)
+			});
+			return;
+		}
+		if (Node.isPropertyAccessExpression(callee) && SAME_COLLECTION.has(method)) {
+			classify(unwrap$1(callee.getExpression()), path, ctx, out, depth + 1);
+			return;
+		}
+		if (Node.isPropertyAccessExpression(callee) && lastSegmentOf(callee.getExpression()) === "colors") {
+			const coloured = unwrap$1(value.getArguments()[0]);
+			if (coloured) classify(coloured, path, ctx, out, depth + 1);
+			return;
+		}
+		if (Node.isPropertyAccessExpression(callee) && INERTIA_LAZY.has(method) && RENDERERS.has(lastSegmentOf(callee.getExpression()))) {
+			const body = callbackValueOf(unwrap$1(value.getArguments()[0]));
+			if (body) classify(body, path, ctx, out, depth + 1);
+			else out.push({
+				kind: "scalar",
+				path
+			});
+			return;
+		}
+		const args = [];
+		for (const argument of value.getArguments()) classify(unwrap$1(argument), path, ctx, args, depth + 1);
+		/** only what carries rows matters for a fallback: a scalar argument is a parameter, not an output */
+		const carried = args.filter((item) => item.kind === "store" || item.kind === "call");
+		if (Node.isPropertyAccessExpression(callee)) {
+			const root = chainRootOf(callee.getExpression());
+			if (root && SCALAR_SERVICES.has(root)) {
+				out.push({
+					kind: "scalar",
+					path
+				});
+				return;
+			}
+		}
+		const refs = ctx.followed.get(value);
+		if (refs && refs.length > 0) {
+			out.push({
+				kind: "call",
+				refs,
+				path,
+				expression: value.getText().replace(/\s+/g, "").slice(0, 60),
+				args: carried,
+				...pick ? { pick } : {}
+			});
+			return;
+		}
+		const access = detectAccess(value, ctx.symbols, ctx.relations);
+		if (access) {
+			out.push({
+				kind: "store",
+				store: access.store,
+				path
+			});
+			if (access.viaRelation) out.push({
+				kind: "store",
+				store: access.viaRelation,
+				path
+			});
+			return;
+		}
+		if (Node.isIdentifier(callee) && NATIVE_GLOBALS.has(callee.getText())) {
+			out.push({
+				kind: "scalar",
+				path
+			});
+			return;
+		}
+		if (Node.isPropertyAccessExpression(callee) && Node.isIdentifier(callee.getExpression()) && NATIVE_GLOBALS.has(callee.getExpression().getText())) {
+			out.push({
+				kind: "scalar",
+				path
+			});
+			return;
+		}
+		/**
+		* A call nobody followed, over rows: a package's CSV builder, a formatter. The
+		* document it builds carries what was handed into it, so the rows' stores leave.
+		* With nothing flowing in there is nothing to say: one DET, opaque, reported.
+		*/
+		if (carried.length > 0) {
+			out.push(...carried);
+			return;
+		}
+		/**
+		* `startDate?.toISOString()`, `categoria.trim()`: a call ON a value the body
+		* holds is that value formatted — an echo stays an echo, a store's field one
+		* field. Only when the root itself resolves to nothing else is the call read
+		* on its own.
+		*/
+		if (Node.isPropertyAccessExpression(callee)) {
+			const root = chainRootOf(callee.getExpression());
+			if (root && ctx.symbols.has(root)) {
+				out.push({
+					kind: "scalar",
+					path
+				});
+				return;
+			}
+			if (root && root !== "this") {
+				const rootNode = rootIdentifierOf(callee.getExpression());
+				const held = [];
+				if (rootNode) classify(rootNode, path, ctx, held, depth + 1);
+				if (held.length > 0 && held.every((item) => item.kind === "echo")) {
+					out.push({
+						kind: "echo",
+						path
+					});
+					return;
+				}
+			}
+		}
+		/**
+		* `rows.map(…).join('\n')` in a body whose parameter is `rows`: the whole input
+		* transformed, so the input says what leaves — the caller's arguments decide,
+		* and the body itself says nothing. `noticia.publicadaEm?.toISO()` on that
+		* parameter is one FIELD of it, and stays one value below.
+		*/
+		if (Node.isPropertyAccessExpression(callee) && transformsParameter(callee, ctx.body)) {
+			out.push({
+				kind: "opaque",
+				path,
+				expression: value.getText().replace(/\s+/g, "").slice(0, 60)
+			});
+			return;
+		}
+		if (Node.isPropertyAccessExpression(callee)) {
+			/**
+			* `comunicado.enviadoEm!.toISODate()`, `(a ?? b).toRFC2822()`: a FIELD read off
+			* the chain, or an expression, then a method — one value. A chain rooted at
+			* `this` (`this.service.find()`) is a call into a service, and not this.
+			*/
+			if (readsField(callee.getExpression())) {
+				out.push({
+					kind: "scalar",
+					path
+				});
+				return;
+			}
+			if (BOOLEAN_METHODS.has(method) || FORMAT_METHODS.has(method)) {
+				out.push({
+					kind: "scalar",
+					path
+				});
+				return;
+			}
+		}
+		if (returnsPrimitive(value)) {
+			out.push({
+				kind: "scalar",
+				path
+			});
+			return;
+		}
+		out.push({
+			kind: "opaque",
+			path,
+			expression: value.getText().replace(/\s+/g, "").slice(0, 60)
+		});
+	}
+}
+/**
+* `xs.map(cb)` with no literal in the callback: what the callback RETURNS,
+* once — a function passed by reference (`rows.map(paraLinha)`) is a call to
+* that function over the rows; an expression body (`(m) => new T(m).toObject()`)
+* is classified as if it were the value; anything else is one repeating attribute.
+*/
+function classifyMapped(value, receiver, path, ctx, out, depth) {
+	const callback = unwrap$1(value.getArguments()[0]);
+	const refs = ctx.followed.get(value);
+	if (callback && Node.isIdentifier(callback) && refs && refs.length > 0) {
+		const rows = [];
+		classify(unwrap$1(receiver), path, ctx, rows, depth + 1);
+		out.push({
+			kind: "call",
+			refs,
+			path,
+			expression: value.getText().replace(/\s+/g, "").slice(0, 60),
+			args: rows.filter((item) => item.kind === "store" || item.kind === "call")
+		});
+		return;
+	}
+	const body = callbackValueOf(callback);
+	if (body) {
+		classify(body, path, ctx, out, depth + 1);
+		return;
+	}
+	out.push({
+		kind: "scalar",
+		path
+	});
+}
+/** the value a callback hands back: an expression body, or the one `return` of a block */
+function callbackValueOf(callback) {
+	if (!callback || !(Node.isArrowFunction(callback) || Node.isFunctionExpression(callback))) return null;
+	const body = callback.getBody();
+	if (!Node.isBlock(body)) return unwrap$1(body);
+	const returns = body.getStatements().filter(Node.isReturnStatement);
+	return returns.length === 1 ? unwrap$1(returns[0].getExpression()) : null;
+}
+/**
+* Does this chain read a property (not a method) or hold an expression before
+* the method is applied? `comunicado.enviadoEm.toISO()` does; `rows.map(f).join()`
+* does not; a chain rooted at `this` is a service, and does not.
+*/
+function readsField(node) {
+	let current = node;
+	for (let depth = 0; current && depth < 40; depth++) {
+		if (Node.isCallExpression(current)) {
+			const inner = current.getExpression();
+			current = Node.isPropertyAccessExpression(inner) ? inner.getExpression() : inner;
+			continue;
+		}
+		if (Node.isAwaitExpression(current) || Node.isNonNullExpression(current)) {
+			current = current.getExpression();
+			continue;
+		}
+		if (Node.isParenthesizedExpression(current)) {
+			const inner = unwrap$1(current.getExpression());
+			if (!inner) return false;
+			if (Node.isBinaryExpression(inner) || Node.isConditionalExpression(inner)) return true;
+			current = inner;
+			continue;
+		}
+		if (Node.isPropertyAccessExpression(current) || Node.isElementAccessExpression(current)) return chainRootOf(current) !== "this";
+		return false;
+	}
+	return false;
+}
+/**
+* Is this chain a method (or methods) applied to a plain parameter of the body,
+* with no field read in between? `rows.map(f).join(s)` is; `noticia.capa?.toISO()`
+* reads a field first and is not.
+*/
+function transformsParameter(callee, body) {
+	let current = callee.getExpression();
+	for (let depth = 0; current && depth < 40; depth++) {
+		if (Node.isCallExpression(current)) {
+			const inner = current.getExpression();
+			current = Node.isPropertyAccessExpression(inner) ? inner.getExpression() : inner;
+			continue;
+		}
+		if (Node.isAwaitExpression(current) || Node.isParenthesizedExpression(current) || Node.isNonNullExpression(current)) {
+			current = current.getExpression();
+			continue;
+		}
+		if (Node.isPropertyAccessExpression(current) || Node.isElementAccessExpression(current)) return false;
+		if (!Node.isIdentifier(current)) return false;
+		const name = current.getText();
+		return Node.isParametered(body) && body.getParameters().some((p) => Node.isIdentifier(p.getNameNode()) && p.getNameNode().getText() === name);
+	}
+	return false;
+}
+/** the identifier node a chain is rooted at: `startDate?.toISOString` -> `startDate` */
+function rootIdentifierOf(node) {
+	let current = node;
+	for (let depth = 0; current && depth < 40; depth++) {
+		if (Node.isCallExpression(current) || Node.isPropertyAccessExpression(current) || Node.isElementAccessExpression(current) || Node.isAwaitExpression(current) || Node.isParenthesizedExpression(current) || Node.isNonNullExpression(current)) {
+			current = current.getExpression();
+			continue;
+		}
+		return Node.isIdentifier(current) ? current : null;
+	}
+	return null;
+}
+/** the call's declared return type, `Promise<…>` unwrapped, is a boolean, string, number or a union of those */
+function returnsPrimitive(call) {
+	try {
+		let type = call.getReturnType();
+		if (type.getSymbol()?.getName() === "Promise") type = type.getTypeArguments()[0] ?? type;
+		const primitive = (t) => t.isBoolean() || t.isBooleanLiteral() || t.isString() || t.isStringLiteral() || t.isNumber() || t.isNumberLiteral() || t.isEnumLiteral() || t.isNull() || t.isUndefined();
+		if (type.isUnion()) {
+			const members = type.getUnionTypes();
+			return members.length > 0 && members.every(primitive) && !members.every((t) => t.isNull() || t.isUndefined());
+		}
+		return primitive(type);
+	} catch {
+		return false;
+	}
+}
+/**
+* `x.data`, `resultado.linhas`, `rows[0]`: a part of a value the body holds.
+*
+*   on a variable bound to a followed call    that key of what the call returns
+*   on a store-bound variable                 the store (`rows[0]`, `.data`) or a field (scalar)
+*   on the validated payload or the request   an echo of input — counts on entry
+*   anything else                             one value
+*/
+function classifyAccess(value, path, ctx, out, depth) {
+	const root = rootSymbolOf(value);
+	/**
+	* `x.nome`, `x['nome']`: the key named; `x[papel]`: a key the body computes — one
+	* value, unnamed (`*`); `rows[0]`: one row of the collection, the collection.
+	*/
+	const property = Node.isPropertyAccessExpression(value) ? value.getName() : keyOfElementAccess(value);
+	if (root && ctx.symbols.has(root)) {
+		if (!property || PASSES_THROUGH.has(property)) out.push({
+			kind: "store",
+			store: ctx.symbols.get(root),
+			path
+		});
+		else out.push({
+			kind: "scalar",
+			path: path || property.replace(/^\*$/, "")
+		});
+		return;
+	}
+	if (root) {
+		const bound = bindingOf(root, ctx.body);
+		if (bound && Node.isCallExpression(bound.initializer)) {
+			if (SCALAR_PROPS.has(property)) {
+				out.push({
+					kind: "scalar",
+					path
+				});
+				return;
+			}
+			/**
+			* `resultado.linhas`: one key of what the call returns; `meta.pagina` on a
+			* destructured `meta`: the key under the key; `rows[0]`, `.data`: the whole.
+			*/
+			const own = property && !PASSES_THROUGH.has(property) ? property : void 0;
+			const pick = [bound.pick, own].filter(Boolean).join(".") || void 0;
+			if (own && !ctx.followed.has(bound.initializer)) {
+				out.push({
+					kind: "scalar",
+					path
+				});
+				return;
+			}
+			classifyCall(bound.initializer, path, ctx, out, depth + 1, pick);
+			return;
+		}
+		if (bound && Node.isObjectLiteralExpression(bound.initializer) && property) {
+			const picked = bound.initializer.getProperty(property);
+			if (picked && Node.isPropertyAssignment(picked)) {
+				classify(unwrap$1(picked.getInitializer()), path, ctx, out, depth + 1);
+				return;
+			}
+		}
+		if (isEchoBinding(root, ctx.body) || root === "request" || root === "params") {
+			out.push({
+				kind: "echo",
+				path
+			});
+			return;
+		}
+	}
+	out.push({
+		kind: "scalar",
+		path: path || property.replace(/^\*$/, "")
+	});
+}
+function keyOfElementAccess(value) {
+	const argument = unwrap$1(value.getArgumentExpression());
+	if (!argument || Node.isNumericLiteral(argument)) return "";
+	if (Node.isStringLiteral(argument) || Node.isNoSubstitutionTemplateLiteral(argument)) return argument.getLiteralValue();
+	return "*";
+}
+const join = (prefix, name) => prefix ? `${prefix}.${name}` : name;
+/** `await x` binds x: the value, not the promise */
+function unwrapAwait$1(node) {
+	let current = unwrap$1(node);
+	while (current && Node.isAwaitExpression(current)) current = unwrap$1(current.getExpression());
+	return current;
+}
+/**
+* How a local name was bound in this body: `const x = …` gives the initializer;
+* `const { x, y } = …` gives the initializer and the key picked out of it.
+*/
+function bindingOf(name, body) {
+	for (const declaration of body.getDescendantsOfKind(SyntaxKind.VariableDeclaration)) {
+		const nameNode = declaration.getNameNode();
+		if (Node.isIdentifier(nameNode)) {
+			if (nameNode.getText() !== name) continue;
+			const initializer = unwrapAwait$1(declaration.getInitializer());
+			return initializer ? { initializer } : null;
+		}
+		if (Node.isObjectBindingPattern(nameNode)) {
+			const element = nameNode.getElements().find((e) => e.getName() === name);
+			if (!element) continue;
+			const initializer = unwrapAwait$1(declaration.getInitializer());
+			if (!initializer) return null;
+			return {
+				initializer,
+				pick: element.getPropertyNameNode()?.getText() ?? element.getName()
+			};
+		}
+	}
+	return null;
+}
+/**
+* A name bound by destructuring the validated payload or the request:
+* `const { busca } = await request.validateUsing(x)`, `const { id } = params`.
+*/
+function isEchoBinding(name, body) {
+	for (const declaration of body.getDescendantsOfKind(SyntaxKind.VariableDeclaration)) {
+		const binding = declaration.getNameNode();
+		if (!Node.isObjectBindingPattern(binding)) continue;
+		if (!binding.getElements().some((element) => element.getName() === name)) continue;
+		const initializer = unwrap$1(declaration.getInitializer());
+		if (!initializer) continue;
+		if (Node.isIdentifier(initializer) && /^(params|request)$/.test(initializer.getText())) return true;
+		if (Node.isCallExpression(initializer)) {
+			const callee = initializer.getExpression();
+			if (Node.isPropertyAccessExpression(callee) && ECHOES_INPUT.has(callee.getName())) return true;
+		}
+	}
+	return false;
+}
+const isRequestLike = (node) => lastSegmentOf(node) === "request";
+//#endregion
 //#region src/inventory/graph/call_graph.ts
 /**
 * Fields declared by the validators used in this body.
@@ -1255,7 +2105,7 @@ function validatorFieldsIn(body, file, app) {
 		* 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 { leaves, opaque: unreadable } = leavesOf$1(declaration, (ref) => findValidator(ref, declaration.getSourceFile(), app));
 		const isOpaque = new Set(unreadable);
 		for (const leaf of leaves) {
 			const field = `${name}.${leaf}`;
@@ -1398,7 +2248,7 @@ function calleeOwner(call) {
 	const owner = callee.getExpression();
 	return Node.isPropertyAccessExpression(owner) ? owner.getName() : void 0;
 }
-function leavesOf(node, resolveRef) {
+function leavesOf$1(node, resolveRef) {
 	const object = node.getFirstDescendantByKind(SyntaxKind.ObjectLiteralExpression);
 	if (!object) return {
 		leaves: [],
@@ -1511,6 +2361,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,7 +2440,11 @@ function createAnalyzer(app, stores, options = {}) {
 		const accesses = [];
 		const followUps = [];
 		const unresolved = [];
+		const reads = [];
+		/** calls a strategy claimed, and where they lead: a nested transformer's keys arrive through its body */
+		const followedCalls = /* @__PURE__ */ new Map();
 		const validator = validatorFieldsIn(body, file, app);
+		const commandFields = owner && isCommandClass(owner) ? commandFieldsOf(owner) : [];
 		const request = requestFieldsIn(body);
 		const context = {
 			file,
@@ -1616,6 +2476,41 @@ function createAnalyzer(app, stores, options = {}) {
 					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";
+					/**
+					* The select list survives an aggregate shape: `select('categoria').count()`
+					* with a GROUP BY leaves the grouped column as well as the count. Dropping
+					* it left a summary at 1 DET.
+					*/
+					const read = (store, how, via) => reads.push({
+						store,
+						shape: how,
+						columns: how === "whole" ? [] : 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.
@@ -1654,6 +2549,7 @@ function createAnalyzer(app, stores, options = {}) {
 					by: resolved.by,
 					technical
 				});
+				followedCalls.set(call, resolved.refs);
 				continue;
 			}
 			if (isWorthReporting(call, symbols, imports) && !isNoise(call, owner)) unresolved.push({
@@ -1663,14 +2559,33 @@ 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 followed = (c) => followedCalls.has(c);
+		const output = outputFieldsIn(body, owner, storesByName, followed);
+		const deliveries = deliveriesIn({
+			body,
+			file,
+			symbols,
+			relations: relationsByStore,
+			followed: followedCalls
+		});
 		return {
 			accesses,
 			followUps,
 			unresolved,
 			validators: validator.fields,
+			commandFields,
 			opaqueValidators: validator.opaque,
 			requestFields: request.fields,
 			opaqueRequest: request.opaque,
+			outputs: output.outputs,
+			opaqueOutputs: output.opaqueOutputs,
+			transformed: output.resource,
+			reads,
+			deliveries,
 			bodyHash: hashOf(body)
 		};
 	}
@@ -1689,8 +2604,20 @@ 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
@@ -1702,12 +2629,25 @@ function createAnalyzer(app, stores, options = {}) {
 			* depth — because a domain-module layout puts `tests/` and `seeders/` inside
 			* `app/`, where the root filter never looks.
 			*/
-			if (!isApplicationCode(app.root, file.getFilePath())) continue;
+			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.
@@ -1717,12 +2657,27 @@ 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
 	};
@@ -1730,14 +2685,137 @@ function createAnalyzer(app, stores, options = {}) {
 		const touches = /* @__PURE__ */ new Set();
 		const writtenStores = /* @__PURE__ */ new Set();
 		const inputFields = /* @__PURE__ */ new Set();
+		const commandFields = /* @__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 deliveredFields = /* @__PURE__ */ new Set();
+		const deliveredOpaque = /* @__PURE__ */ new Set();
+		const deliveredStores = /* @__PURE__ */ new Set();
+		let anyDelivery = false;
+		const outputReads = /* @__PURE__ */ new Map();
 		const trace = [];
 		const scope = [];
 		const unresolved = [];
 		const visited = /* @__PURE__ */ new Set();
 		let writes = false;
+		/** what a followed body reads, itself and through what it follows — bounded like the walk */
+		const storesReadBy = (ref, depth, seen = /* @__PURE__ */ new Set()) => {
+			const found = /* @__PURE__ */ new Set();
+			const key = `${ref.file}#${ref.member ?? ref.line ?? "*"}`;
+			if (seen.has(key) || depth > maxDepth) return found;
+			seen.add(key);
+			const facts = factsFor(ref);
+			if (!facts) return found;
+			for (const access of facts.accesses) found.add(access.store);
+			for (const followUp of facts.followUps) for (const store of storesReadBy(followUp.ref, depth + 1, seen)) found.add(store);
+			return found;
+		};
+		/**
+		* A delivered call hands on what its body RETURNS — classified, so a returned
+		* `{ data: rows, meta }` delivers the rows' store and the meta's leaves, not
+		* one DET per key. `pick` keeps one key of it: `const { data } = …`,
+		* `resultado.linhas`. Bounded by depth like the walk, and by a seen set so a
+		* body returning itself cannot loop.
+		*/
+		const deliver = (item, depth, seen = /* @__PURE__ */ new Set()) => {
+			switch (item.kind) {
+				case "store":
+					deliveredStores.add(item.store);
+					return;
+				case "scalar":
+					deliveredFields.add(item.path || "<value>");
+					return;
+				case "echo": return;
+				case "opaque":
+					deliveredOpaque.add(`${item.path ? `${item.path}.` : ""}<${item.expression}>`);
+					return;
+				case "call": {
+					if (depth > maxDepth + 2) return;
+					let resolved = false;
+					for (const ref of item.refs) {
+						const key = `${ref.file}#${ref.member ?? ref.line ?? "*"}#${item.pick ?? ""}#${item.path}`;
+						if (seen.has(key)) continue;
+						seen.add(key);
+						const facts = factsFor(ref);
+						if (!facts) continue;
+						if (facts.outputs.length > 0 || facts.transformed) {
+							resolved = true;
+							continue;
+						}
+						const returned = facts.deliveries.returns.filter((r) => !item.pick || r.path === item.pick || r.path.startsWith(`${item.pick}.`));
+						/**
+						* `egresso.curso` where the body returns the row itself (`return
+						* Egresso.query()…first()`, path ''): the pick lands INSIDE a returned
+						* value — one field of a store is one value; one key of a returned call
+						* is that call picked deeper.
+						*/
+						if (item.pick && returned.length === 0) {
+							const above = facts.deliveries.returns.filter((r) => r.path === "" || item.pick.startsWith(`${r.path}.`));
+							for (const r of above) {
+								const rest = r.path ? item.pick.slice(r.path.length + 1) : item.pick;
+								if (r.kind === "call") deliver({
+									...r,
+									path: item.path,
+									pick: rest
+								}, depth + 1, seen);
+								else if (r.kind === "store" || r.kind === "scalar") deliveredFields.add(item.path || "<value>");
+							}
+							if (above.length > 0) {
+								resolved = true;
+								continue;
+							}
+						}
+						/**
+						* A return the classifier could not read at all (`rows.map(…).join(…)`)
+						* says nothing about what leaves; what the body read, or what was handed
+						* into it, says more — so it does not count as resolved.
+						*/
+						if (returned.length > 0 && returned.some((r) => r.kind !== "opaque")) {
+							for (const r of returned) {
+								const rest = item.pick ? r.path.slice(item.pick.length).replace(/^\./, "") : r.path;
+								const path = [item.path, rest].filter(Boolean).join(".");
+								deliver({
+									...r,
+									path
+								}, depth + 1, seen);
+							}
+							resolved = true;
+							continue;
+						}
+						if (item.pick) continue;
+						const read = storesReadBy(ref, depth + 1);
+						if (read.size > 0) {
+							for (const store of read) deliveredStores.add(store);
+							resolved = true;
+						}
+					}
+					if (resolved) return;
+					/**
+					* `const { confidenciais } = await this.contar()` where the body's return
+					* is unreadable: one KEY of it, named — one value, not an opaque floor.
+					* Only a key that carries rows on (`data`, `rows`) stays unreadable.
+					*/
+					if (item.pick && !PASSES_ROWS.has(item.pick.split(".")[0])) {
+						deliveredFields.add(item.path || "<value>");
+						return;
+					}
+					/**
+					* The body returned no literal and read no store — a CSV builder, a
+					* formatter over rows handed in. The document it built carries what it
+					* received, so the rows' stores leave. Nothing handed in: opaque.
+					*/
+					if (item.args.length > 0) {
+						for (const argument of item.args) deliver(argument, depth, seen);
+						return;
+					}
+					deliveredOpaque.add(`${item.path ? `${item.path}.` : ""}<${item.expression}>`);
+				}
+			}
+		};
 		const visit = (ref, depth, technical = false) => {
 			const key = `${ref.file}#${ref.member ?? ref.line ?? "*"}`;
 			if (visited.has(key) || depth > maxDepth) return;
@@ -1776,9 +2854,35 @@ function createAnalyzer(app, stores, options = {}) {
 			}
 			unresolved.push(...facts.unresolved);
 			for (const field of facts.validators) inputFields.add(field);
+			for (const field of facts.commandFields) commandFields.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);
+			/**
+			* Deliveries, resolved here because a delivered CALL leads to a body only
+			* the graph knows: what that body returns is what the value hands on.
+			*/
+			const items = [...facts.deliveries.calls, ...depth === 0 ? facts.deliveries.returns : []];
+			if (facts.deliveries.anyCall || depth === 0 && facts.deliveries.anyReturn) anyDelivery = true;
+			for (const item of items) deliver(item, depth);
+			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,
@@ -1804,9 +2908,26 @@ function createAnalyzer(app, stores, options = {}) {
 			touches: [...touches].sort(),
 			writtenStores: [...writtenStores].sort(),
 			inputFields: [...inputFields].sort(),
+			commandFields: [...commandFields].sort(),
 			opaqueInputFields: [...opaqueInputFields].sort(),
 			requestFields: [...requestFields].sort(),
 			opaqueRequest,
+			outputFields: [...outputFields].sort(),
+			opaqueOutputFields: [...opaqueOutputFields].sort(),
+			transformedStores: [...transformedStores].sort(),
+			delivered: {
+				any: anyDelivery,
+				fields: [...deliveredFields].sort(),
+				opaqueFields: [...deliveredOpaque].sort(),
+				stores: [...deliveredStores].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
@@ -1832,6 +2953,8 @@ function findBody(file, ref) {
 		}
 		const fn = file.getFunction(ref.member);
 		if (fn) return fn;
+		const initializer = file.getVariableDeclaration(ref.member)?.getInitializer();
+		if (initializer && (Node.isArrowFunction(initializer) || Node.isFunctionExpression(initializer))) return initializer;
 		return null;
 	}
 	for (const cls of file.getClasses()) {
@@ -1860,6 +2983,27 @@ function storeSymbolsFor(body, file, app, stores) {
 			if (stores.has(named.getName())) symbols.set(binding, named.getName());
 		}
 	}
+	/**
+	* `const { default: Noticia } = await import('#noticias/models/noticia')`: a
+	* model imported INSIDE the body — an ace command does this to keep the app
+	* from booting for `--help`. The store is the same; only the binding moved.
+	*/
+	const storeByFile = /* @__PURE__ */ new Map();
+	for (const [name, store] of stores) storeByFile.set(toPosix(store.provenance.file), name);
+	for (const declaration of body.getDescendantsOfKind(SyntaxKind.VariableDeclaration)) {
+		const binding = declaration.getNameNode();
+		if (!Node.isObjectBindingPattern(binding)) continue;
+		let initializer = declaration.getInitializer();
+		if (initializer && Node.isAwaitExpression(initializer)) initializer = initializer.getExpression();
+		if (!initializer || !Node.isCallExpression(initializer)) continue;
+		if (initializer.getExpression().getKind() !== SyntaxKind.ImportKeyword) continue;
+		const specifier = initializer.getArguments()[0];
+		if (!specifier || !Node.isStringLiteral(specifier)) continue;
+		const target = app.resolveSpecifier(specifier.getLiteralValue());
+		const store = target ? storeByFile.get(toPosix(target)) : void 0;
+		if (!store) continue;
+		for (const element of binding.getElements()) if ((element.getPropertyNameNode()?.getText() ?? element.getName()) === "default") symbols.set(element.getName(), store);
+	}
 	for (const declaration of body.getDescendantsOfKind(SyntaxKind.VariableDeclaration)) {
 		const initializer = declaration.getInitializer();
 		const name = declaration.getNameNode();
@@ -2025,6 +3169,32 @@ function importMapsOf(file, app) {
 			if (alias) exportedAs.set(alias, named.getName());
 		}
 	}
+	/**
+	* `const { default: SincronizarBulk } = await import('#inpi/actions/sincronizar_bulk')`
+	* `const { execucaoEmAndamento } = await import('#inpi/services/execucao')`
+	*
+	* A module imported INSIDE a body — the shape ace commands use so `--help` does
+	* not boot the application. The binding moved; the body it names did not, and
+	* a command importing its whole action layer this way reached nothing.
+	*/
+	for (const declaration of file.getDescendantsOfKind(SyntaxKind.VariableDeclaration)) {
+		const binding = declaration.getNameNode();
+		if (!Node.isObjectBindingPattern(binding)) continue;
+		let initializer = declaration.getInitializer();
+		if (initializer && Node.isAwaitExpression(initializer)) initializer = initializer.getExpression();
+		if (!initializer || !Node.isCallExpression(initializer)) continue;
+		if (initializer.getExpression().getKind() !== SyntaxKind.ImportKeyword) continue;
+		const specifier = initializer.getArguments()[0];
+		if (!specifier || !Node.isStringLiteral(specifier)) continue;
+		const target = app.resolveSpecifier(specifier.getLiteralValue());
+		if (!target) continue;
+		for (const element of binding.getElements()) {
+			const exported = element.getPropertyNameNode()?.getText() ?? element.getName();
+			const local = element.getName();
+			imports.set(local, target);
+			if (exported !== "default" && exported !== local) exportedAs.set(local, exported);
+		}
+	}
 	return {
 		imports,
 		exportedAs
@@ -2067,15 +3237,163 @@ function unwrapAwait(node) {
 	return current;
 }
 /**
-* Hash of the NORMALISED body: comments and whitespace removed.
+* Hash of the NORMALISED body: comments and whitespace removed.
+*
+* counting-decisions §5 measures modification by a checksum of the
+* implementation scope. If the hash were over the raw bytes, running Prettier
+* would turn into an invoice.
+*/
+function hashOf(body) {
+	const normalized = body.getText().replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/[^\n]*/g, "").replace(/\s+/g, "");
+	return createHash("sha256").update(normalized).digest("hex").slice(0, 16);
+}
+//#endregion
+//#region src/inventory/sources/jobs.ts
+/** `X.schedule({}).cron(…)`: a scheduler's way of dispatching */
+const SCHEDULE_METHODS = new Set(["schedule"]);
+function collectJobs(app) {
+	const project = new Project({
+		skipAddingFilesFromTsConfig: true,
+		skipFileDependencyResolution: true,
+		compilerOptions: { allowJs: false }
+	});
+	const root = toPosix(app.root);
+	for (const dir of app.scanRoots) project.addSourceFilesAtPaths(`${toPosix(dir)}/**/*.ts`);
+	project.addSourceFilesAtPaths(`${root}/start/**/*.ts`);
+	project.addSourceFilesAtPaths(`${root}/commands/**/*.ts`);
+	const jobs = /* @__PURE__ */ new Map();
+	for (const file of project.getSourceFiles()) {
+		const filePath = toPosix(file.getFilePath());
+		if (!isApplicationCode(app.root, filePath) || !inJobsDirectory(filePath)) continue;
+		for (const cls of file.getClasses()) {
+			const name = cls.getName();
+			if (!name || !looksLikeJob(cls)) continue;
+			jobs.set(filePath, {
+				name,
+				file: filePath,
+				dispatchedFrom: [],
+				scheduledFrom: []
+			});
+		}
+	}
+	if (jobs.size === 0) return [];
+	for (const file of project.getSourceFiles()) {
+		const filePath = toPosix(file.getFilePath());
+		if (/\.(spec|test)\.ts$/.test(file.getBaseName())) continue;
+		const { imports } = importMapsOf(file, app);
+		if (imports.size === 0) continue;
+		for (const call of file.getDescendantsOfKind(SyntaxKind.CallExpression)) {
+			const callee = call.getExpression();
+			if (!Node.isPropertyAccessExpression(callee)) continue;
+			const method = callee.getName();
+			const scheduled = SCHEDULE_METHODS.has(method);
+			if (!scheduled && !DISPATCH_METHODS.has(method)) continue;
+			const receiver = callee.getExpression();
+			if (!Node.isIdentifier(receiver)) continue;
+			const target = imports.get(receiver.getText());
+			const job = target ? jobs.get(toPosix(target)) : void 0;
+			if (!job) continue;
+			const sites = scheduled ? job.scheduledFrom : job.dispatchedFrom;
+			if (!sites.includes(filePath)) sites.push(filePath);
+		}
+	}
+	return [...jobs.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+const inJobsDirectory = (filePath) => filePath.split("/").slice(0, -1).some((segment) => segment === "jobs" || segment === "job");
+/** extends something called `…Job`, or declares the method a queue would run */
+function looksLikeJob(cls) {
+	const parent = cls.getExtends()?.getExpression().getText() ?? "";
+	if (/Job$/.test(parent)) return true;
+	return EXECUTION_METHODS.some((method) => cls.getMethod(method) !== void 0);
+}
+//#endregion
+//#region src/inventory/sources/json_schemas.ts
+function collectJsonSchemas(app) {
+	const project = new Project({
+		skipAddingFilesFromTsConfig: true,
+		skipFileDependencyResolution: true,
+		compilerOptions: { allowJs: false }
+	});
+	/**
+	* 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);
+		if (!literal || !isJsonSchema(literal)) continue;
+		const leaves = leavesOf(literal);
+		if (leaves.length === 0) continue;
+		found.set(declaration.getName(), {
+			name: declaration.getName(),
+			fields: leaves.length,
+			leaves,
+			provenance: {
+				file: toPosix(file.getFilePath()),
+				line: declaration.getStartLineNumber(),
+				by: "json-schema"
+			}
+		});
+	}
+	return found;
+}
+/** `{ … } as const` and `{ … } satisfies X` still hold the literal */
+function unwrap(node) {
+	if (!node) return void 0;
+	if (Node.isAsExpression(node) || Node.isSatisfiesExpression(node)) return unwrap(node.getExpression());
+	return node;
+}
+/**
+* Recognised by shape, never by name.
+*
+* A const called `schema` may be anything; an object declaring `type: 'object'`
+* with a `properties` map is a JSON Schema whatever it is called.
+*/
+function isJsonSchema(literal) {
+	return (literal.getProperty("type")?.asKind(SyntaxKind.PropertyAssignment))?.getInitializer()?.asKind(SyntaxKind.StringLiteral)?.getLiteralValue() === "object" && literal.getProperty("properties") !== void 0;
+}
+/**
+* Leaves of a JSON Schema, by the table in counting-decisions §7.
 *
-* counting-decisions §5 measures modification by a checksum of the
-* implementation scope. If the hash were over the raw bytes, running Prettier
-* would turn into an invoice.
+*   scalar                  1
+*   nested object           leaves counted individually
+*   array of scalar         1  (repeating group)
+*   array of object         the object's leaves, once
+*   enum / const            1
 */
-function hashOf(body) {
-	const normalized = body.getText().replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/[^\n]*/g, "").replace(/\s+/g, "");
-	return createHash("sha256").update(normalized).digest("hex").slice(0, 16);
+function leavesOf(literal, prefix = "") {
+	const properties = literal.getProperty("properties")?.asKind(SyntaxKind.PropertyAssignment);
+	const items = literal.getProperty("items")?.asKind(SyntaxKind.PropertyAssignment);
+	if (properties) {
+		const map = properties.getInitializer()?.asKind(SyntaxKind.ObjectLiteralExpression);
+		if (!map) return [];
+		return map.getProperties().flatMap((property) => {
+			const assignment = property.asKind(SyntaxKind.PropertyAssignment);
+			if (!assignment) return [];
+			const name = assignment.getName().replace(/['"]/g, "");
+			const path = prefix ? `${prefix}.${name}` : name;
+			const nested = unwrap(assignment.getInitializer())?.asKind(SyntaxKind.ObjectLiteralExpression);
+			const inner = nested ? leavesOf(nested, path) : [];
+			return inner.length > 0 ? inner : [path];
+		});
+	}
+	if (items) {
+		const element = unwrap(items.getInitializer())?.asKind(SyntaxKind.ObjectLiteralExpression);
+		const inner = element ? leavesOf(element, prefix) : [];
+		return inner.length > 0 ? inner : [prefix];
+	}
+	return [];
 }
 //#endregion
 //#region src/albrecht/tables.ts
@@ -2155,40 +3473,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.
+*/
+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.
 */
-const OPAQUE_TYPE$1 = /^(object|any|unknown|Record<|Json|JSON)/;
+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);
+		/**
+		* 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.
+		* 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,
@@ -2197,9 +3835,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`;
+				})]
 			}
 		});
 	}
@@ -2220,7 +3861,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({
@@ -2236,7 +3889,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)
@@ -2274,7 +3927,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 = [];
@@ -2284,7 +3938,7 @@ function detsFor(entry, behavior, touched, type, options) {
 		counted.add(field);
 		sources.push(source);
 	};
-	for (const param of entry.signature.match(/:[A-Za-z_][\w]*/g) ?? []) add(param.slice(1), `param:${param}`);
+	if (entry.kind === "http") for (const param of entry.signature.match(/:[A-Za-z_][\w]*/g) ?? []) add(param.slice(1), `param:${param}`);
 	/**
 	* `(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
@@ -2304,9 +3958,104 @@ 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}`);
+	for (const field of behavior.commandFields ?? []) {
+		const [kind, ...rest] = field.split(".");
+		const name = rest.join(".");
+		add(name, `${kind === "args" ? "arg" : "flag"}:${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)" : ""}`);
+		/**
+		* Plan 0.7 §A′ — the delivery is the boundary. When the transaction hands
+		* something to a renderer or a response, THAT is what leaves: derived values
+		* and the leaves of literals a followed body returned count 1 each; a store
+		* leaves only if its rows were handed on, raw or through a query object; a
+		* store read to authorise or to decide contributes nothing to the output. A
+		* field that entered and is echoed back counts once, on entry (§7.3) — the
+		* classifier marks it as an echo. Without a delivery point the rule cannot
+		* apply, and every store read leaves, as before.
+		*/
+		const delivered = behavior.delivered;
+		if (delivered.any) {
+			for (const field of delivered.fields) add(`render.${field}`, `render:${field}`);
+			for (const field of delivered.opaqueFields) add(`render.${field}`, `render:${field} (opaque)`);
+		}
+		const deliveredStores = new Set(delivered.stores);
+		for (let changed = true; changed;) {
+			changed = false;
+			for (const [store, read] of Object.entries(behavior.outputReads)) {
+				if (deliveredStores.has(store) || read.direct) continue;
+				if (!read.via.some((parent) => deliveredStores.has(parent))) continue;
+				deliveredStores.add(store);
+				changed = true;
+			}
+		}
+		for (const store of touched) {
+			const read = behavior.outputReads[store];
+			if (delivered.any && !deliveredStores.has(store) && !covered.has(store)) continue;
+			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");
@@ -2318,20 +4067,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."
-*
-* 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 `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.
 *
-* 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 = [
 	{
@@ -2349,11 +4095,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
@@ -2378,15 +4131,23 @@ 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.
+* Three in 1.6.0: an output's DETs are what the transaction DELIVERS (the render
+* props, the response payload, what a command prints) read back to their origin;
+* a function of the same file and a `.map(fn)` by reference are followed, so
+* FTRs move; and ace commands are transactions, with flags as input.
 *
 * 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.4.0";
+const RULESET_VERSION = "1.6.0";
 function count(input, options = {}) {
 	const warnings = [];
 	const usage = usageOf(input);
@@ -2405,7 +4166,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
@@ -2431,50 +4192,83 @@ function count(input, options = {}) {
 		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, {
+	const entryPoints = input.entryPoints.filter((entry) => !ignored.has(entry.identity) && !ignored.has(entry.name ?? ""));
+	const transactionalFunctions = countTransactionalFunctions(entryPoints, 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, reviewed);
-	/**
-	* Reported AFTER the overrides are applied, because the overrides are the answer
-	* to it.
-	*
-	* Computed first, the list kept naming functions whose floor had already been
-	* replaced by `detFromSchema` — telling the reader to go and map something that
-	* was mapped. It cost a real misreading: a report was taken as "two forms still
-	* unmapped" when both were declared, by whoever wrote this code.
-	*/
-	const declared = new Set(functions.filter((fn) => fn.rationale.overrides?.some((o) => o.fields.includes("det"))).map((fn) => fn.name));
-	warnings.push(...opaqueWarnings(countable, input, {
-		reviewed,
-		declared,
-		overrides: options.overrides ?? {}
+	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(...unreadableDeliveryWarnings(input));
+	warnings.push(...commandWarnings(entryPoints, transactionalFunctions));
+	warnings.push(...undispatchedJobWarnings(input));
+	warnings.push(...lookAlikeWarnings(functions));
+	warnings.push(...seededOnlyWarnings(functions, grouping.members, input.seededAnywhere));
 	return {
 		ruleset: "afp",
 		rulesetVersion: RULESET_VERSION,
@@ -2484,160 +4278,118 @@ 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.
+* Transactions that deliver something the analysis cannot read.
 *
-* 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.
+* A generated document (`response.send(gerarCsv(rows))`), a value built by a
+* call nobody followed. Each counts 1 DET — a floor — and the transaction's
+* output is understated by whatever the value carries. Named with the
+* expression, because the fix is usually in the code: return a literal, or a
+* transformer, and the fields become readable.
 */
+function unreadableDeliveryWarnings(input) {
+	const blind = input.entryPoints.map((entry) => ({
+		entry,
+		behavior: input.behaviors.get(entry.id)
+	})).filter(({ behavior }) => behavior && !behavior.writes && behavior.delivered.opaqueFields.length > 0);
+	if (blind.length === 0) return [];
+	return [
+		`${blind.length} transaction(s) deliver a value the analysis cannot read — a generated document, a call nobody followed — counted as 1 DET each, a FLOOR. This UNDERSTATES the output:`,
+		...blind.slice(0, 10).map(({ entry, behavior }) => `  ${entry.trigger} ${entry.signature}: ${behavior.delivered.opaqueFields.join(", ")}`),
+		...blind.length > 10 ? [`  … and ${blind.length - 10} more`] : []
+	];
+}
 /**
-* Opaque DETs someone has declared reviewed, in both spellings a person might use.
+* Jobs no transaction reaches — plan 0.7 §D.
 *
-* Qualified (`Petition.schema`) is unambiguous; bare (`schema`) is what someone reads
-* off the warning line.
+* A job dispatched by a handler is part of that handler's transaction (§9). One
+* that nothing reachable dispatches is either a scheduled process — an elementary
+* process nobody is counting — or dead code, and the code cannot say which. It is
+* reported, never counted: inventing an elementary process is the error this
+* package exists to avoid.
 */
-function reviewedOpaque(overrides) {
-	const reviewed = /* @__PURE__ */ new Set();
-	for (const [name, override] of Object.entries(overrides)) for (const entry of override.opaqueReviewed ?? []) {
-		reviewed.add(entry);
-		reviewed.add(`${name}.${entry}`);
-		/**
-		* The bare field too, because the two sides of this comparison spell things
-		* differently. `opaqueReviewed` is written against the FUNCTION (`Petition.schema`)
-		* while a rationale source carries the TABLE (`ast:petitions.schema`), and the
-		* qualified form cannot be recovered from either. The last segment is what they
-		* share, and without it a correctly written review matched the count and not the
-		* rationale — so `fp:explain` showed no review and the override warning still
-		* claimed five unanswered floors.
-		*/
-		reviewed.add(entry.split(".").pop() ?? entry);
-	}
-	return reviewed;
+function undispatchedJobWarnings(input) {
+	if (!input.jobs?.length) return [];
+	const reached = /* @__PURE__ */ new Set();
+	for (const behavior of input.behaviors.values()) for (const step of behavior.trace) reached.add(toPosix(step.file));
+	const orphans = input.jobs.filter((job) => !reached.has(job.file));
+	if (orphans.length === 0) return [];
+	const where = (file) => relativeTo(input.app.root, file);
+	return [`${orphans.length} job(s) reached by no transaction — a scheduled process nobody counts, or dead code. Reported, not counted: a scheduler is an entry point of its own once one is read (counting-decisions §9):`, ...orphans.map(({ name, file, dispatchedFrom, scheduledFrom }) => {
+		const at = `  ${name} (${where(file)}): `;
+		if (scheduledFrom.length > 0) return `${at}scheduled from ${scheduledFrom.map(where).join(", ")}, outside every transaction`;
+		if (dispatchedFrom.length > 0) return `${at}dispatched from ${dispatchedFrom.map(where).join(", ")}, which no transaction reaches`;
+		return `${at}dispatched by nothing in the application — dead code, or a scheduler this analysis does not read`;
+	})];
 }
 /**
-* The identity of an opaque DET inside a rationale source.
+* Ace commands counted as transactions — plan 0.7 §C.
 *
-* `ast:petitions.schema (opaque)` is the store's TABLE name, and `opaqueReviewed` is
-* written against the FUNCTION name (`Petition.schema`), so the qualified form cannot
-* be recovered from the source alone — the bare field is what both sides share.
+* A batch process an operator starts is an elementary process, and it is counted.
+* Half the commands on the validated applications are development tools — a data
+* generator, a scaffolder — which the CPM does not count and the code cannot tell
+* from an importer: both write the same table. So each one is listed with the FP
+* at stake, the collector's hint beside it, and the way out is a declaration.
 */
-const opaqueNameOf = (source) => source.replace(/^[a-z-]+:/, "").replace(/ \(opaque.*\)$/, "");
-const shortOpaqueNameOf = (source) => opaqueNameOf(source).split(".").pop() ?? "";
-/** `fp:explain` should say which floors someone has already looked at */
-function markReviewed(sources, reviewed) {
-	return sources.map((source) => {
-		if (!source.endsWith("(opaque)")) return source;
-		return reviewed.has(opaqueNameOf(source)) || reviewed.has(shortOpaqueNameOf(source)) ? source.replace("(opaque)", "(opaque, reviewed)") : source;
-	});
+function commandWarnings(entryPoints, functions) {
+	const counted = entryPoints.filter((entry) => entry.kind === "command").map((entry) => ({
+		entry,
+		fn: functions.find((f) => f.id === `tx:${entry.identity}`)
+	})).filter(({ fn }) => fn !== void 0);
+	if (counted.length === 0) return [];
+	return [`${counted.length} ace command(s) counted as elementary processes — a batch process an operator starts is a transaction. A development tool (a data generator, a scaffolder) is not the user's: exclude it with \`boundary.ignoreEntryPoints: ['<commandName>']\`:`, ...counted.map(({ entry, fn }) => `  ${entry.identity}: ${fn.type} ${fn.points} FP` + (entry.hints?.length ? ` — ${entry.hints.join("; ")}` : ""))];
 }
-/** 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.
+* Transactions that look like the same elementary process.
 *
-* Three states per function, and only the third is a request to do something:
+* 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`.
 *
-*   replaced   a `detFromSchema` override stands in for one of them
-*   reviewed   someone looked and 1 is the right answer
-*   floor      still unanswered
+* 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 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,
-			reviewedNames: [],
-			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;
-				entry.reviewedNames.push(attribute.name);
-			} else entry.floor.push(`${attribute.name} (${attribute.type})`);
-		}
-	}
-	for (const point of input.entryPoints) for (const field of input.behaviors.get(point.id)?.opaqueInputFields ?? []) {
-		const entry = tally(point.identity, "input object", 1);
-		if (state.reviewed.has(field) || state.reviewed.has(`${point.identity}.${field}`)) {
-			entry.reviewed += 1;
-			entry.reviewedNames.push(field);
-		} else entry.floor.push(field);
-	}
-	/**
-	* A review that matches nothing is a review that does nothing.
-	*
-	* `detFromSchema` already warns when it names a schema that is not declared, and
-	* `opaqueReviewed` did not — so `['messages.schema']` against a field actually named
-	* `createMessageValidator.messages.schema` reviewed nothing in silence while the
-	* warning kept firing, which reads as the tool ignoring the configuration.
-	*/
-	const seen = /* @__PURE__ */ new Set();
-	for (const [name, entry] of byFunction) for (const field of [...entry.floor, ...entry.reviewedNames]) {
-		const bare = field.replace(/ \(.*\)$/, "");
-		seen.add(bare);
-		seen.add(`${name}.${bare}`);
-		seen.add(bare.split(".").pop() ?? bare);
-	}
-	const unmatched = [];
-	for (const [name, override] of Object.entries(state.overrides)) for (const declaredName of override.opaqueReviewed ?? []) if (![
-		declaredName,
-		`${name}.${declaredName}`,
-		declaredName.split(".").pop() ?? ""
-	].some((spelling) => seen.has(spelling))) unmatched.push(`${name}.opaqueReviewed: ${declaredName}`);
-	const lines = [];
-	let answered = 0;
-	for (const [name, entry] of byFunction) {
-		/** 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(", ")}`);
+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 settled = answered === 0 ? [] : [`  (${answered} more function(s) whose opaque DETs are all accounted for)`];
-	const unmatchedLines = unmatched.length === 0 ? [] : [`${unmatched.length} \`opaqueReviewed\` entr(ies) match no opaque DET, so they review nothing. The name is the one the count prints:`, ...unmatched.map((u) => `  ${u}`)];
-	if (lines.length === 0) return [...unmatchedLines, ...settled];
-	return [
-		`${lines.length} function(s) with a DET the analysis cannot read, counted as 1 each — a FLOOR, not a measurement. Where the fields are declared in the source, name that schema with \`overrides.detFromSchema\`; where 1 is the right answer, record it with \`overrides.<fn>.opaqueReviewed\` — counting-decisions §8:`,
-		...lines,
-		...settled,
-		...unmatchedLines
-	];
+	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)`;
+	})];
+}
+/**
+* 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 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.
@@ -2676,100 +4428,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.
+* `...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 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.
 *
-* 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.
+* 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, schemas, tables, weights, warnings, reviewed) {
+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 {
-					/**
-					* Only the placeholders nobody has answered are worth reporting.
-					*
-					* The message used to count every opaque DET of the function and say "names
-					* one schema" whatever it was given. With four of five columns in
-					* `opaqueReviewed` and a LIST of two schemas, it still fired, still said
-					* "one schema", and still counted the four already answered — a warning
-					* wrong on all three counts, about a configuration that was complete.
-					*/
-					const unanswered = placeholders.filter((source) => !reviewed.has(opaqueNameOf(source)) && !reviewed.has(shortOpaqueNameOf(source)));
-					if (unanswered.length > 1) warnings.push(`override for "${fn.name}" names ${named.length === 1 ? "one schema" : `${named.length} schemas`} and the function has ${unanswered.length} unanswered opaque DETs (${unanswered.join(", ")}). One was replaced; the others still count 1 each — declare them or record them with \`opaqueReviewed\`.`);
-				}
-			}
-		}
+		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);
-		/**
-		* A review is recorded with NO fields, and the reporter's "declared by override"
-		* share counts only entries that declared one.
-		*
-		* Dropping it entirely lost the `reason`, so an `opaqueReviewed`-only decision
-		* appeared nowhere — not in `fp:explain`, not anywhere — which defeats the point
-		* of requiring a reason. Counting it in the share was the opposite error: it read
-		* as "1 function, 7 FP, 35% of the total declared by override" when no number had
-		* been declared at all.
-		*/
-		const marked = markReviewed(fn.rationale.detSources, reviewed);
 		return {
 			...fn,
 			det,
@@ -2778,9 +4493,8 @@ function applyOverrides(functions, overrides, schemas, tables, weights, warnings
 			points: pointsOf(fn.type, complexity, weights),
 			rationale: {
 				...fn.rationale,
-				detSources: marked,
 				overrides: [...fn.rationale.overrides ?? [], {
-					by,
+					by: `config:overrides.${fn.name}`,
 					reason: override.reason,
 					fields
 				}]
@@ -2946,7 +4660,9 @@ var CoverageTooLowError = class extends Error {
 async function analyze(root, options = {}) {
 	const app = await discoverApp(root);
 	const { stores, unresolved: storeProblems } = await collectDataStores(app);
-	const { entryPoints, unresolved: routeProblems } = await collectEntryPoints(app);
+	const routes = await collectEntryPoints(app);
+	const routeProblems = routes.unresolved;
+	const entryPoints = [...routes.entryPoints, ...collectCommands(app)];
 	/** only read when an override names one — but collected once, like everything else */
 	const jsonSchemas = collectJsonSchemas(app);
 	const analyzer = createAnalyzer(app, stores, {
@@ -3028,8 +4744,31 @@ async function analyze(root, options = {}) {
 					by: "request"
 				}
 			})),
+			...behavior.commandFields.length ? { commandFields: behavior.commandFields.map((name) => ({
+				name,
+				provenance: {
+					file: emit(app.root),
+					by: "ace-commands"
+				}
+			})) } : {},
 			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,
+			delivered: behavior.delivered,
+			outputReads: behavior.outputReads,
 			trace: behavior.trace.map((step) => ({
 				...step,
 				file: emit(step.file)
@@ -3057,11 +4796,14 @@ async function analyze(root, options = {}) {
 				entryPoints,
 				behaviors,
 				jsonSchemas,
-				writtenAnywhere: analyzer.writtenAnywhere()
+				jobs: collectJobs(app),
+				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 };