@filipebraida/adonis-function-points 0.6.0 → 0.8.0

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

@@ -1,10 +1,10 @@
-import { a as chainShapeOf, c as hooksFiredBy, d as isApplicationCode, f as isSeeder, h as toPosix, i as resolveCall, l as rootSymbolOf, m as samePath, o as outputFieldsIn, p as relativeTo, r as isTechnicalWrite, s as detectAccess, t as BUILTIN_CALL_RESOLVERS, u as collectEventBindings } from "./resolvers-DlKJOZnk.js";
+import { _ 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-DhJO-qvQ.js";
 import fs from "node:fs/promises";
-import path from "node:path";
+import path, { dirname, join, resolve } from "node:path";
 import { Node, Project, SyntaxKind } from "ts-morph";
 import { createHash } from "node:crypto";
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
 import { execFileSync } from "node:child_process";
-import { readFileSync } from "node:fs";
 //#region src/inventory/app_context.ts
 /** folders naming an artefact TYPE, in either layout */
 const ARTIFACT_KINDS = new Set([
@@ -965,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
@@ -1164,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) {
@@ -1239,6 +1265,1336 @@ 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$1 = 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;
+		let via;
+		if (RENDERERS.has(receiver) && RENDER_METHODS.has(method)) {
+			payload = call.getArguments()[1];
+			const name = unwrap$1(call.getArguments()[0]);
+			if (name && Node.isStringLiteral(name)) via = {
+				engine: receiver === "view" ? "edge" : "inertia",
+				page: name.getLiteralValue()
+			};
+		} 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);
+		const before = deliveries.length;
+		classify(unwrap$1(payload), "", ctx, deliveries, 0);
+		if (via) for (let i = before; i < deliveries.length; i++) deliveries[i].via = via;
+	}
+	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$1(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$1(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$1(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$1.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$1(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)) {
+				if (readsField(callee.getExpression())) out.push({
+					kind: "scalar",
+					path
+				});
+				else out.push({
+					kind: "store",
+					store: ctx.symbols.get(root),
+					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$1.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$1.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$1 = (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/pages.ts
+/** array methods whose callback receives one row */
+const ITERATES_ROWS$1 = new Set([
+	"map",
+	"forEach",
+	"filter",
+	"find",
+	"findLast",
+	"some",
+	"every",
+	"flatMap"
+]);
+/** array methods that hand back one row, or the same rows */
+const SAME_ROWS = new Set([
+	"filter",
+	"slice",
+	"sort",
+	"toSorted",
+	"reverse",
+	"concat",
+	"flat",
+	"find",
+	"findLast",
+	"at"
+]);
+/** wrappers whose property hands the rows on */
+const PASSES_THROUGH = new Set([
+	"data",
+	"rows",
+	"all"
+]);
+/** how deep the reader follows a row into child components */
+const MAX_COMPONENT_DEPTH = 1;
+function readPages(deliveries, env) {
+	const reading = {
+		columns: /* @__PURE__ */ new Map(),
+		unreadable: /* @__PURE__ */ new Map(),
+		unknownMembers: /* @__PURE__ */ new Map()
+	};
+	if (deliveries.length === 0) return reading;
+	const byPage = /* @__PURE__ */ new Map();
+	for (const delivery of deliveries) {
+		const key = `${delivery.engine}:${delivery.page}`;
+		byPage.set(key, [...byPage.get(key) ?? [], delivery]);
+	}
+	for (const group of byPage.values()) {
+		const { engine, page } = group[0];
+		const candidates = engine === "inertia" ? inertiaPageFiles(env.root, page) : edgeFiles(env.root, page);
+		if (candidates.length !== 1) {
+			const reason = candidates.length === 0 ? `page "${page}" not found under the ${engine === "inertia" ? "pages" : "views"} conventions` : `two files answer to the page "${page}": ${candidates.map((c) => toPosix(c).replace(`${toPosix(env.root)}/`, "")).join(", ")}`;
+			for (const delivery of group) markUnreadable(reading, delivery.store, reason);
+			continue;
+		}
+		/**
+		* One prop carrying several stores — a query object whose unreadable result
+		* made every store it read leave under `atuacao` — cannot be told apart by the
+		* page: `atuacao.total` belongs to none of them. Whole, all of them, and said so.
+		*/
+		const byPath = /* @__PURE__ */ new Map();
+		for (const d of group) byPath.set(d.path, new Set([...byPath.get(d.path) ?? [], d.store]));
+		const readable = group.filter((d) => {
+			const stores = byPath.get(d.path);
+			if (stores.size === 1) return true;
+			markUnreadable(reading, d.store, `page "${page}": prop \`${d.path || "(props)"}\` carries ${stores.size} stores (${[...stores].join(", ")}) — what the page reads off it belongs to no one of them`);
+			return false;
+		});
+		if (readable.length === 0) continue;
+		const reader = new PageReader(env, reading);
+		if (engine === "inertia") reader.readTsx(candidates[0], readable);
+		else reader.readEdge(candidates[0], readable);
+		/**
+		* The page was read and no column of the store came out of it: either the page
+		* never touches the rows, or it reads members that are not columns — a row the
+		* controller serialised on the way, or computed getters. Whole, and said so.
+		*/
+		for (const { store } of readable) {
+			if (reading.columns.has(store) || reading.unreadable.has(store)) continue;
+			const members = [...reading.unknownMembers.get(store) ?? []];
+			markUnreadable(reading, store, members.length > 0 ? `page "${page}" reads ${members.slice(0, 4).map((m) => `\`${m}\``).join(", ")} off ${store}, none of them a column of it` : `page "${page}" never reads ${store}`);
+		}
+	}
+	return reading;
+}
+function markUnreadable(reading, store, reason) {
+	if (!reading.unreadable.has(store)) reading.unreadable.set(store, reason);
+}
+const SKIPPED_DIRS = new Set([
+	"node_modules",
+	"dist",
+	"build",
+	".git",
+	"coverage",
+	"tmp",
+	".adonisjs"
+]);
+/**
+* `inertia.render('livros/index')` → `inertia/pages/livros/index.tsx` (the default),
+* `app/<first>/ui/pages/<rest>.tsx` (a domain-module layout), or any `pages/` directory
+* under the root holding that path. The `resolve` function of the front-end is not
+* run — a convention is read, a function is not.
+*/
+function inertiaPageFiles(root, page) {
+	const found = /* @__PURE__ */ new Set();
+	const [first, ...rest] = page.split("/");
+	if (rest.length > 0) for (const extension of [
+		".tsx",
+		".jsx",
+		".vue",
+		".svelte"
+	]) {
+		const file = join(root, "app", first, "ui", "pages", `${rest.join("/")}${extension}`);
+		if (existsSync(file)) found.add(file);
+	}
+	for (const dir of pagesDirectories(root)) for (const extension of [
+		".tsx",
+		".jsx",
+		".vue",
+		".svelte"
+	]) {
+		const file = join(dir, `${page}${extension}`);
+		if (existsSync(file)) found.add(file);
+		const index = join(dir, page, `index${extension}`);
+		if (existsSync(index)) found.add(index);
+	}
+	return [...found].sort();
+}
+let pagesDirsCache = /* @__PURE__ */ new Map();
+function pagesDirectories(root) {
+	const cached = pagesDirsCache.get(root);
+	if (cached) return cached;
+	const dirs = [];
+	const walk = (dir, depth) => {
+		if (depth > 6) return;
+		let entries;
+		try {
+			entries = readdirSync(dir);
+		} catch {
+			return;
+		}
+		for (const entry of entries) {
+			if (SKIPPED_DIRS.has(entry) || entry.startsWith(".")) continue;
+			const full = join(dir, entry);
+			let isDirectory = false;
+			try {
+				isDirectory = statSync(full).isDirectory();
+			} catch {
+				continue;
+			}
+			if (!isDirectory) continue;
+			if (entry === "pages") dirs.push(full);
+			else walk(full, depth + 1);
+		}
+	};
+	walk(root, 0);
+	pagesDirsCache.set(root, dirs);
+	return dirs;
+}
+/** `view.render('catalogo')` → `resources/views/catalogo.edge` */
+function edgeFiles(root, page) {
+	const file = join(root, "resources", "views", `${page.replace(/\./g, "/")}.edge`);
+	return existsSync(file) ? [file] : [];
+}
+/** tsconfig `paths` of the application, for the page's own imports (`~/components/x`) */
+function aliasesOf(root) {
+	const aliases = /* @__PURE__ */ new Map();
+	for (const config of [join(root, "tsconfig.json"), join(root, "inertia", "tsconfig.json")]) {
+		if (!existsSync(config)) continue;
+		try {
+			const text = readFileSync(config, "utf8").replace(/\/\*[\s\S]*?\*\/|\/\/.*$/gm, "");
+			const paths = JSON.parse(text)?.compilerOptions?.paths;
+			for (const [alias, targets] of Object.entries(paths ?? {})) {
+				const target = targets[0];
+				if (!target) continue;
+				aliases.set(alias.replace(/\*$/, ""), resolve(dirname(config), target.replace(/\*$/, "")));
+			}
+		} catch {}
+	}
+	if (!aliases.has("~/")) aliases.set("~/", join(root, "inertia"));
+	return aliases;
+}
+var PageReader = class {
+	aliases;
+	constructor(env, reading) {
+		this.env = env;
+		this.reading = reading;
+		this.aliases = aliasesOf(env.root);
+	}
+	readTsx(file, deliveries) {
+		const source = this.env.project.addSourceFileAtPathIfExists(file);
+		const component = source ? defaultComponentOf(source) : null;
+		if (!source || !component) {
+			for (const d of deliveries) this.fail(d.store, `page "${deliveries[0].page}" has no default-exported component the reader can open`);
+			return;
+		}
+		const scope = this.bindProps(component, deliveries.map((d) => ({
+			name: d.path.split(".")[0],
+			entity: {
+				store: d.store,
+				rest: d.path.split(".").slice(1)
+			}
+		})));
+		this.readComponent(component, scope, 0, deliveries[0].page);
+	}
+	/** the component's first parameter: `{ livros }`, `{ livros: rows }`, or `props` */
+	bindProps(component, props) {
+		const scope = /* @__PURE__ */ new Map();
+		if (!Node.isParametered(component)) return scope;
+		const parameter = component.getParameters()[0];
+		if (!parameter) return scope;
+		const nameNode = parameter.getNameNode();
+		if (Node.isObjectBindingPattern(nameNode)) for (const element of nameNode.getElements()) {
+			const property = element.getPropertyNameNode()?.getText() ?? element.getName();
+			const prop = props.find((p) => p.name === property);
+			if (prop) scope.set(element.getName(), prop.entity);
+		}
+		else if (Node.isIdentifier(nameNode)) for (const prop of props) scope.set(`${nameNode.getText()}.${prop.name}`, prop.entity);
+		return scope;
+	}
+	readComponent(component, scope, depth, page) {
+		const body = Node.isParametered(component) && "getBody" in component ? component.getBody() ?? component : component;
+		const file = component.getSourceFile();
+		/** the entity an expression holds, recording a column when the expression IS one */
+		const entityOf = (node, visiting = 0) => {
+			if (!node || visiting > 12) return null;
+			let current = node;
+			while (Node.isParenthesizedExpression(current) || Node.isNonNullExpression(current) || Node.isAsExpression(current) || Node.isAwaitExpression(current)) current = current.getExpression();
+			if (Node.isIdentifier(current)) return scope.get(current.getText()) ?? null;
+			if (Node.isPropertyAccessExpression(current)) {
+				const receiver = current.getExpression();
+				if (Node.isIdentifier(receiver)) {
+					const asPath = scope.get(`${receiver.getText()}.${current.getName()}`);
+					if (asPath) return asPath;
+				}
+				const holder = entityOf(receiver, visiting + 1);
+				if (!holder) return null;
+				return this.member(holder, current.getName());
+			}
+			if (Node.isElementAccessExpression(current)) {
+				const holder = entityOf(current.getExpression(), visiting + 1);
+				if (!holder) return null;
+				const argument = current.getArgumentExpression();
+				if (argument && Node.isStringLiteral(argument)) return this.member(holder, argument.getLiteralValue());
+				return holder;
+			}
+			if (Node.isCallExpression(current)) {
+				const callee = current.getExpression();
+				if (Node.isPropertyAccessExpression(callee)) {
+					const holder = entityOf(callee.getExpression(), visiting + 1);
+					if (holder && holder.rest.length === 0 && SAME_ROWS.has(callee.getName())) return holder;
+					if (holder && holder.rest.length === 0 && ITERATES_ROWS$1.has(callee.getName())) return null;
+					if (holder && holder.rest.length === 0 && callee.getName() === "length") return null;
+					if (holder) return null;
+				}
+				return null;
+			}
+			if (Node.isConditionalExpression(current)) {
+				entityOf(current.getCondition(), visiting + 1);
+				return entityOf(current.getWhenTrue(), visiting + 1) ?? entityOf(current.getWhenFalse(), visiting + 1);
+			}
+			if (Node.isBinaryExpression(current)) {
+				const operator = current.getOperatorToken().getKind();
+				if (operator === SyntaxKind.AmpersandAmpersandToken) {
+					entityOf(current.getLeft(), visiting + 1);
+					return entityOf(current.getRight(), visiting + 1);
+				}
+				if (operator === SyntaxKind.QuestionQuestionToken || operator === SyntaxKind.BarBarToken) return entityOf(current.getLeft(), visiting + 1) ?? entityOf(current.getRight(), visiting + 1);
+				entityOf(current.getLeft(), visiting + 1);
+				entityOf(current.getRight(), visiting + 1);
+				return null;
+			}
+			if (Node.isTemplateExpression(current)) {
+				for (const span of current.getTemplateSpans()) entityOf(span.getExpression(), visiting + 1);
+				return null;
+			}
+			return null;
+		};
+		const escape = (entity, reason) => {
+			const store = entity.rest.length === 0 ? entity.store : entity.store;
+			this.fail(store, `page "${page}": ${reason}`);
+		};
+		body.forEachDescendant((node) => {
+			if (Node.isVariableDeclaration(node)) {
+				const initializer = node.getInitializer();
+				const nameNode = node.getNameNode();
+				if (!initializer) return;
+				const entity = entityOf(initializer);
+				if (!entity) return;
+				if (Node.isIdentifier(nameNode)) scope.set(nameNode.getText(), entity);
+				else if (Node.isObjectBindingPattern(nameNode)) for (const element of nameNode.getElements()) {
+					const property = element.getPropertyNameNode()?.getText() ?? element.getName();
+					const member = this.member(entity, property);
+					if (member) scope.set(element.getName(), member);
+				}
+				return;
+			}
+			if (Node.isCallExpression(node)) {
+				const callee = node.getExpression();
+				if (Node.isPropertyAccessExpression(callee) && ITERATES_ROWS$1.has(callee.getName())) {
+					const holder = entityOf(callee.getExpression());
+					const callback = node.getArguments()[0];
+					if (holder && holder.rest.length === 0 && callback && (Node.isArrowFunction(callback) || Node.isFunctionExpression(callback))) {
+						const parameter = callback.getParameters()[0]?.getNameNode();
+						if (parameter && Node.isIdentifier(parameter)) scope.set(parameter.getText(), holder);
+					}
+					return;
+				}
+				for (const argument of node.getArguments()) {
+					const entity = entityOf(argument);
+					if (entity && !Node.isPropertyAccessExpression(unwrapParens(argument))) escape(entity, `\`${node.getExpression().getText()}(…)\` receives the rows and the reader cannot follow a function`);
+					else if (entity) escape(entity, `\`${node.getExpression().getText()}(…)\` receives the rows and the reader cannot follow a function`);
+				}
+				return;
+			}
+			if (Node.isForOfStatement(node)) {
+				const declared = node.getInitializer();
+				const entity = entityOf(node.getExpression());
+				if (entity && Node.isVariableDeclarationList(declared)) {
+					const nameNode = declared.getDeclarations()[0]?.getNameNode();
+					if (nameNode && Node.isIdentifier(nameNode)) scope.set(nameNode.getText(), entity);
+				}
+				return;
+			}
+			if (Node.isSpreadAssignment(node) || Node.isJsxSpreadAttribute(node) || Node.isSpreadElement(node)) {
+				const entity = entityOf(node.getExpression());
+				if (entity) escape(entity, "a spread hands the whole row on");
+				return;
+			}
+			if (Node.isJsxExpression(node)) {
+				const expression = node.getExpression();
+				const parent = node.getParent();
+				if (!expression || Node.isJsxAttribute(parent)) return;
+				const entity = entityOf(expression);
+				if (entity) escape(entity, `\`{${expression.getText().replace(/\s+/g, " ").slice(0, 60)}}\` renders the row itself`);
+				return;
+			}
+			if (Node.isJsxAttribute(node)) {
+				const initializer = node.getInitializer();
+				const entity = entityOf(initializer && Node.isJsxExpression(initializer) ? initializer.getExpression() : void 0);
+				if (!entity) return;
+				const element = node.getFirstAncestor((n) => Node.isJsxOpeningElement(n) || Node.isJsxSelfClosingElement(n));
+				const tag = element && (Node.isJsxOpeningElement(element) || Node.isJsxSelfClosingElement(element)) ? element.getTagNameNode().getText() : "";
+				if (!/^[A-Z]/.test(tag)) return;
+				if (depth >= MAX_COMPONENT_DEPTH) {
+					escape(entity, `\`<${tag} ${node.getNameNode().getText()}={…} />\` is a second level of components; the reader follows one`);
+					return;
+				}
+				const child = this.componentOf(tag, file);
+				if (!child) {
+					escape(entity, `\`<${tag} />\` is not a component of the application the reader can open`);
+					return;
+				}
+				const childScope = this.bindProps(child, [{
+					name: node.getNameNode().getText(),
+					entity
+				}]);
+				this.readComponent(child, childScope, depth + 1, page);
+				return;
+			}
+			if (Node.isReturnStatement(node) && depth === 0) {
+				const expression = node.getExpression();
+				if (expression && !Node.isJsxElement(expression) && !Node.isJsxFragment(expression) && !Node.isJsxSelfClosingElement(expression) && !Node.isParenthesizedExpression(expression)) {
+					const entity = entityOf(expression);
+					if (entity) escape(entity, `\`return ${expression.getText().replace(/\s+/g, " ").slice(0, 60)}\` hands the rows back as they came`);
+				}
+			}
+		});
+	}
+	/** `entity.name`: one column (recorded), a relation (the target), a wrapper key, or nothing */
+	member(entity, name) {
+		if (entity.rest.length > 0) return entity.rest[0] === name ? {
+			store: entity.store,
+			rest: entity.rest.slice(1)
+		} : null;
+		if (PASSES_THROUGH.has(name)) return entity;
+		if (this.env.stores.get(entity.store)?.attributes.some((a) => a.name === name)) {
+			this.column(entity.store, name);
+			return null;
+		}
+		const target = this.env.relations.get(entity.store)?.[name];
+		if (target) return {
+			store: target,
+			rest: []
+		};
+		if (![
+			"length",
+			"id",
+			"map",
+			"filter",
+			"find",
+			"some",
+			"every",
+			"forEach",
+			"slice",
+			"sort"
+		].includes(name)) {
+			const members = this.reading.unknownMembers.get(entity.store) ?? /* @__PURE__ */ new Set();
+			members.add(name);
+			this.reading.unknownMembers.set(entity.store, members);
+		}
+		return null;
+	}
+	/** the component a JSX tag names, in this file or through its imports (tsconfig paths, relative) */
+	componentOf(tag, file) {
+		const local = file.getFunction(tag) ?? functionVariable(file, tag);
+		if (local) return local;
+		for (const declaration of file.getImportDeclarations()) {
+			if (![declaration.getDefaultImport()?.getText(), ...declaration.getNamedImports().map((n) => n.getAliasNode()?.getText() ?? n.getName())].includes(tag)) continue;
+			const target = this.resolveImport(declaration.getModuleSpecifierValue(), file.getFilePath());
+			if (!target) return null;
+			const source = this.env.project.addSourceFileAtPathIfExists(target);
+			if (!source) return null;
+			const exported = declaration.getNamedImports().find((n) => (n.getAliasNode()?.getText() ?? n.getName()) === tag)?.getName() ?? tag;
+			return source.getFunction(exported) ?? functionVariable(source, exported) ?? (declaration.getDefaultImport()?.getText() === tag ? defaultComponentOf(source) : null);
+		}
+		return null;
+	}
+	resolveImport(specifier, from) {
+		let base = this.env.resolveSpecifier(specifier);
+		if (base) base = base.replace(/\.(ts|tsx|js|jsx)$/, "");
+		if (!base && specifier.startsWith(".")) base = resolve(dirname(from), specifier);
+		else for (const [alias, dir] of this.aliases) if (specifier.startsWith(alias)) base = join(dir, specifier.slice(alias.length));
+		if (!base) return null;
+		for (const candidate of [
+			base,
+			`${base}.tsx`,
+			`${base}.ts`,
+			`${base}.jsx`,
+			join(base, "index.tsx"),
+			join(base, "index.ts")
+		]) if (existsSync(candidate) && statSync(candidate).isFile()) return candidate;
+		return null;
+	}
+	readEdge(file, deliveries, depth = 0, scope) {
+		const text = readFileSync(file, "utf8");
+		const page = deliveries[0].page;
+		const bound = scope ?? /* @__PURE__ */ new Map();
+		if (!scope) for (const d of deliveries) bound.set(d.path.split(".")[0], {
+			store: d.store,
+			rest: d.path.split(".").slice(1)
+		});
+		const entityOf = (expression) => {
+			const parts = expression.trim().replace(/\?\./g, ".").split(".");
+			let entity = bound.get(parts[0]) ?? null;
+			for (const part of parts.slice(1)) {
+				if (!entity) return null;
+				entity = this.member(entity, part.replace(/\(.*$/, ""));
+			}
+			return entity;
+		};
+		const read = (expression) => {
+			for (const chain of expression.match(/[A-Za-z_$][\w$]*(?:\??\.[A-Za-z_$][\w$]*)+/g) ?? []) {
+				const entity = entityOf(chain);
+				if (entity) this.fail(entity.store, `page "${page}": \`${chain}\` is a row handed on, not a column`);
+			}
+			const bare = expression.trim();
+			if (/^[A-Za-z_$][\w$]*$/.test(bare) && bound.has(bare)) this.fail(bound.get(bare).store, `page "${page}": \`{{ ${bare} }}\` renders the rows themselves`);
+		};
+		for (const match of text.matchAll(/@each\(\s*\(?\s*([A-Za-z_$][\w$]*)(?:\s*,\s*[A-Za-z_$][\w$]*)?\s*\)?\s+in\s+([^)]+)\)/g)) {
+			const entity = entityOf(match[2]);
+			if (entity) bound.set(match[1], entity);
+		}
+		for (const match of text.matchAll(/\{\{\{?\s*([\s\S]*?)\s*\}?\}\}/g)) read(match[1]);
+		for (const match of text.matchAll(/@(?:if|elseif|unless)\(([^)]*)\)/g)) read(match[1]);
+		for (const match of text.matchAll(/@!?(?:include|component|layout)\(\s*['"]([^'"]+)['"]/g)) {
+			const included = join(this.env.root, "resources", "views", `${match[1].replace(/\./g, "/")}.edge`);
+			if (!existsSync(included)) continue;
+			if (depth >= MAX_COMPONENT_DEPTH) {
+				for (const entity of bound.values()) this.fail(entity.store, `page "${page}": \`@${match[0].slice(1).split("(")[0]}('${match[1]}')\` is a second level; the reader follows one`);
+				continue;
+			}
+			this.readEdge(included, deliveries, depth + 1, new Map(bound));
+		}
+	}
+	column(store, name) {
+		const columns = this.reading.columns.get(store) ?? /* @__PURE__ */ new Set();
+		columns.add(name);
+		this.reading.columns.set(store, columns);
+	}
+	fail(store, reason) {
+		markUnreadable(this.reading, store, reason);
+	}
+};
+function unwrapParens(node) {
+	let current = node;
+	while (Node.isParenthesizedExpression(current) || Node.isNonNullExpression(current)) current = current.getExpression();
+	return current;
+}
+/** `export default function Page(…)`, or `export default Page` naming a function or an arrow */
+function defaultComponentOf(file) {
+	const declared = file.getFunctions().find((f) => f.isDefaultExport());
+	if (declared) return declared;
+	for (const assignment of file.getExportAssignments()) {
+		const expression = assignment.getExpression();
+		if (Node.isIdentifier(expression)) return file.getFunction(expression.getText()) ?? functionVariable(file, expression.getText());
+		if (Node.isArrowFunction(expression) || Node.isFunctionExpression(expression)) return expression;
+		if (Node.isCallExpression(expression)) {
+			const inner = expression.getArguments()[0];
+			if (inner && Node.isIdentifier(inner)) return file.getFunction(inner.getText()) ?? functionVariable(file, inner.getText());
+		}
+	}
+	return null;
+}
+/** `const Page = (props) => …` / `function (…) {}` */
+function functionVariable(file, name) {
+	const initializer = file.getVariableDeclaration(name)?.getInitializer();
+	return initializer && (Node.isArrowFunction(initializer) || Node.isFunctionExpression(initializer)) ? initializer : null;
+}
+//#endregion
 //#region src/inventory/graph/call_graph.ts
 /**
 * Fields declared by the validators used in this body.
@@ -1271,7 +2627,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}`;
@@ -1414,7 +2770,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: [],
@@ -1593,23 +2949,196 @@ function createAnalyzer(app, stores, options = {}) {
 		factsCache.set(key, facts);
 		return facts;
 	};
+	/** store name by the posix path of the model that declares it */
+	const storeByFile = /* @__PURE__ */ new Map();
+	for (const [name, store] of storesByName) storeByFile.set(toPosix(store.provenance.file), name);
+	/**
+	* The guard's user: `auth.user`, `auth.getUserOrFail()` are rows of the model
+	* `config/auth.ts` names in its provider (`model: () => import('#models/user')`).
+	* Read, never assumed — an application with no such config binds nothing.
+	*/
+	const authUserStore = (() => {
+		const config = project.addSourceFileAtPathIfExists(`${toPosix(app.root)}/config/auth.ts`);
+		if (!config) return null;
+		for (const call of config.getDescendantsOfKind(SyntaxKind.CallExpression)) {
+			if (call.getExpression().getKind() !== SyntaxKind.ImportKeyword) continue;
+			if (call.getFirstAncestorByKind(SyntaxKind.PropertyAssignment)?.getName() !== "model") continue;
+			const specifier = call.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) return store;
+		}
+		return null;
+	})();
+	/**
+	* What a body's locals ARE — plan 0.8 §A. `storeSymbolsFor` binds what the
+	* parameters and the static imports say; this pass, run in source order before
+	* the accesses are detected, binds what the body's own statements say:
+	*
+	*   const s = await this.sessoes.ativa(d)        the followed body's return type,
+	*                                                or its returns when unannotated
+	*   const n = id ? await N.find(id) : new N()    a conditional, both branches N
+	*   const p = (await P.first()) ?? new P()       a default, both operands P
+	*   const u = auth.getUserOrFail()               the guard's model, per config/auth.ts
+	*   const pasta = documento.pasta                a relation read off a loaded row
+	*   for (const d of pasta.documentos)            a row of the relation's target
+	*   rows.map(async (d) => …)                     the callback's parameter, a row
+	*
+	* Every one is a reading of what the code declares; none is a guess. A `save()`
+	* on a local none of this can type is reported as unresolved — not dropped.
+	*/
+	function bindLocals(body, symbols, context, strategies) {
+		const returnedStoreOf = (call, from = context, depth = 0) => {
+			if (depth > 2) return null;
+			const resolved = resolveCall(call, from, strategies);
+			if (!resolved || resolved.refs.length === 0) return null;
+			const found = /* @__PURE__ */ new Set();
+			for (const target of resolved.refs) {
+				const source = sourceFile(target.file);
+				const resolvedBody = source ? findBody(source, target) : null;
+				if (!resolvedBody) continue;
+				const annotation = Node.isReturnTyped(resolvedBody) ? resolvedBody.getReturnTypeNode()?.getText() : void 0;
+				if (annotation) {
+					const store = storeNamedBy(annotation, storesByName);
+					if (store) found.add(store);
+					else return null;
+					continue;
+				}
+				const own = storeSymbolsFor(resolvedBody, source, app, storesByName, relationsByStore);
+				const returns = resolvedBody.getDescendantsOfKind(SyntaxKind.ReturnStatement).filter((r) => r.getFirstAncestor((n) => Node.isMethodDeclaration(n) || Node.isFunctionDeclaration(n) || Node.isArrowFunction(n) || Node.isFunctionExpression(n)) === resolvedBody);
+				if (returns.length === 0) return null;
+				for (const statement of returns) {
+					const value = statement.getExpression();
+					if (!value) return null;
+					const unwrapped = unwrapAwait(value);
+					if (unwrapped.getKind() === SyntaxKind.NullKeyword) continue;
+					if (Node.isCallExpression(unwrapped) && !detectAccess(unwrapped, own, relationsByStore)) {
+						const store = returnedStoreOf(unwrapped, {
+							...context,
+							file: source,
+							...importsFor(source),
+							injected: injectedFor(resolvedBody.getFirstAncestorByKind(SyntaxKind.ClassDeclaration), source, app)
+						}, depth + 1);
+						if (!store) return null;
+						found.add(store);
+						continue;
+					}
+					const store = Node.isNewExpression(unwrapped) ? storesByName.has(unwrapped.getExpression().getText()) ? unwrapped.getExpression().getText() : null : own.get(rootSymbolOf(unwrapped) ?? "") ?? (storesByName.has(rootSymbolOf(unwrapped) ?? "") ? rootSymbolOf(unwrapped) : null);
+					if (!store) return null;
+					found.add(store);
+				}
+			}
+			return found.size === 1 ? [...found][0] : null;
+		};
+		const isAuthUser = (node) => {
+			if (!authUserStore) return false;
+			const chain = Node.isCallExpression(node) ? node.getExpression() : node;
+			if (!Node.isPropertyAccessExpression(chain)) return false;
+			if (rootSymbolOf(chain) !== "auth" && lastSegmentText(chain.getExpression()) !== "auth") return false;
+			const last = chain.getName();
+			return last === "user" || last === "getUserOrFail" || last === "authenticate";
+		};
+		/** the store a value is rows (or one row) of, by what the code says — or nothing */
+		const storeOfValue = (value, depth = 0) => {
+			if (!value || depth > 6) return null;
+			const node = unwrapAwait(value);
+			if (node.getKind() === SyntaxKind.NullKeyword) return null;
+			if (Node.isIdentifier(node)) {
+				if (node.getText() === "undefined") return null;
+				return symbols.get(node.getText()) ?? null;
+			}
+			if (Node.isNewExpression(node)) {
+				const name = node.getExpression().getText();
+				return storesByName.has(name) ? name : null;
+			}
+			if (Node.isConditionalExpression(node)) return sameStore(storeOfValue(node.getWhenTrue(), depth + 1), storeOfValue(node.getWhenFalse(), depth + 1), node.getWhenTrue(), node.getWhenFalse());
+			if (Node.isBinaryExpression(node)) {
+				const operator = node.getOperatorToken().getKind();
+				if (operator === SyntaxKind.QuestionQuestionToken || operator === SyntaxKind.BarBarToken) return sameStore(storeOfValue(node.getLeft(), depth + 1), storeOfValue(node.getRight(), depth + 1), node.getLeft(), node.getRight());
+				return null;
+			}
+			if (Node.isElementAccessExpression(node)) return storeOfValue(node.getExpression(), depth + 1);
+			if (isAuthUser(node)) return authUserStore;
+			if (Node.isPropertyAccessExpression(node)) return storeOfExpression(node, symbols, relationsByStore);
+			if (Node.isCallExpression(node)) {
+				const access = detectAccess(node, symbols, relationsByStore);
+				if (access) return access.method === "related" && access.viaRelation ? access.viaRelation : access.store;
+				const callee = node.getExpression();
+				if (Node.isPropertyAccessExpression(callee) && ONE_OF_ROWS.has(callee.getName())) return storeOfValue(callee.getExpression(), depth + 1);
+				return returnedStoreOf(node);
+			}
+			return null;
+		};
+		const isNullish = (node) => {
+			const inner = unwrapAwait(node);
+			return inner.getKind() === SyntaxKind.NullKeyword || Node.isIdentifier(inner) && inner.getText() === "undefined";
+		};
+		const sameStore = (a, b, left, right) => {
+			if (a && b) return a === b ? a : null;
+			if (a && isNullish(right)) return a;
+			if (b && isNullish(left)) return b;
+			return null;
+		};
+		body.forEachDescendant((node) => {
+			if (Node.isVariableDeclaration(node)) {
+				const initializer = node.getInitializer();
+				const nameNode = node.getNameNode();
+				if (!initializer) return;
+				if (Node.isIdentifier(nameNode)) {
+					if (symbols.has(nameNode.getText())) return;
+					const store = storeOfValue(initializer);
+					if (store) symbols.set(nameNode.getText(), store);
+				}
+				return;
+			}
+			if (Node.isForOfStatement(node)) {
+				const declared = node.getInitializer();
+				if (!Node.isVariableDeclarationList(declared)) return;
+				const nameNode = declared.getDeclarations()[0]?.getNameNode();
+				if (!nameNode || !Node.isIdentifier(nameNode) || symbols.has(nameNode.getText())) return;
+				const store = storeOfValue(node.getExpression());
+				if (store) symbols.set(nameNode.getText(), store);
+				return;
+			}
+			if (Node.isCallExpression(node)) {
+				const callee = node.getExpression();
+				if (!Node.isPropertyAccessExpression(callee) || !ITERATES_ROWS.has(callee.getName())) return;
+				const callback = node.getArguments()[0];
+				if (!callback || !(Node.isArrowFunction(callback) || Node.isFunctionExpression(callback))) return;
+				const parameter = callback.getParameters()[0]?.getNameNode();
+				if (!parameter || !Node.isIdentifier(parameter) || symbols.has(parameter.getText())) return;
+				const store = storeOfValue(callee.getExpression());
+				if (store) symbols.set(parameter.getText(), store);
+			}
+		});
+	}
 	function computeFacts(ref) {
 		const file = sourceFile(ref.file);
 		if (!file) return null;
 		const body = findBody(file, ref);
 		if (!body) return null;
 		const { imports, exportedAs } = importsFor(file);
+		/** locals imported from packages, not from the application: their objects are not stores */
+		const packageImports = /* @__PURE__ */ new Set();
+		for (const declaration of file.getImportDeclarations()) {
+			if (app.resolveSpecifier(declaration.getModuleSpecifierValue())) continue;
+			const defaultImport = declaration.getDefaultImport()?.getText();
+			if (defaultImport) packageImports.add(defaultImport);
+			for (const named of declaration.getNamedImports()) packageImports.add(named.getAliasNode()?.getText() ?? named.getName());
+		}
 		/** the class this body belongs to: how `this.something` resolves */
 		const owner = body.getFirstAncestorByKind(SyntaxKind.ClassDeclaration);
 		const injected = injectedFor(owner, file, app);
-		const symbols = storeSymbolsFor(body, file, app, storesByName);
+		const symbols = storeSymbolsFor(body, file, app, storesByName, relationsByStore);
 		const accesses = [];
 		const followUps = [];
 		const unresolved = [];
 		const reads = [];
-		/** calls a strategy claimed: a nested transformer's keys arrive through its body */
-		const followedCalls = /* @__PURE__ */ new Set();
+		/** 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,
@@ -1622,6 +3151,7 @@ function createAnalyzer(app, stores, options = {}) {
 			resolveSpecifier: app.resolveSpecifier,
 			sourceFile
 		};
+		bindLocals(body, symbols, context, resolvers);
 		for (const call of body.getDescendantsOfKind(SyntaxKind.CallExpression)) {
 			const access = detectAccess(call, symbols, relationsByStore);
 			if (access) {
@@ -1652,10 +3182,15 @@ function createAnalyzer(app, stores, options = {}) {
 				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 === "select" ? chain.selected : [],
+						columns: how === "whole" ? [] : chain.selected,
 						...via ? { via } : {}
 					});
 					if (access.method === "related" && access.viaRelation) read(access.viaRelation, shape);
@@ -1709,7 +3244,22 @@ function createAnalyzer(app, stores, options = {}) {
 					by: resolved.by,
 					technical
 				});
-				followedCalls.add(call);
+				followedCalls.set(call, resolved.refs);
+				continue;
+			}
+			/**
+			* `alvo.save()` on a receiver nobody could type. Not a write the count can
+			* attribute — and not silence either: the reviewed application had six EIs
+			* counted as EOs under a coverage of 99.5%, because a write on an unknown
+			* local was dropped without a word. It lowers coverage and is named.
+			*/
+			if (isUnreadableWrite(call, symbols, imports, packageImports, body) && !isNoise(call, owner)) {
+				unresolved.push({
+					file: ref.file,
+					line: call.getStartLineNumber(),
+					expression: call.getExpression().getText().replace(/\s+/g, ""),
+					reason: "write on a receiver whose type the analysis cannot read"
+				});
 				continue;
 			}
 			if (isWorthReporting(call, symbols, imports) && !isNoise(call, owner)) unresolved.push({
@@ -1723,12 +3273,21 @@ function createAnalyzer(app, stores, options = {}) {
 		* Read after the loop: whether a key holds a nested transformer is known only
 		* once the strategies have said which calls they follow.
 		*/
-		const output = outputFieldsIn(body, owner, storesByName, (c) => followedCalls.has(c));
+		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,
@@ -1736,6 +3295,7 @@ function createAnalyzer(app, stores, options = {}) {
 			opaqueOutputs: output.opaqueOutputs,
 			transformed: output.resource,
 			reads,
+			deliveries,
 			bodyHash: hashOf(body)
 		};
 	}
@@ -1781,7 +3341,7 @@ function createAnalyzer(app, stores, options = {}) {
 			*/
 			if (!isApplicationCode(app.root, file.getFilePath())) {
 				if (isSeeder(app.root, file.getFilePath())) {
-					const symbols = storeSymbolsFor(file, file, app, storesByName);
+					const symbols = storeSymbolsFor(file, file, app, storesByName, relationsByStore);
 					for (const call of file.getDescendantsOfKind(SyntaxKind.CallExpression)) {
 						const access = symbols.size > 0 ? detectAccess(call, symbols, relationsByStore) : null;
 						if (access?.mode !== "write") continue;
@@ -1791,7 +3351,7 @@ function createAnalyzer(app, stores, options = {}) {
 				}
 				continue;
 			}
-			const symbols = storeSymbolsFor(file, file, app, storesByName);
+			const symbols = storeSymbolsFor(file, file, app, storesByName, relationsByStore);
 			if (symbols.size === 0) continue;
 			for (const call of file.getDescendantsOfKind(SyntaxKind.CallExpression)) {
 				const access = detectAccess(call, symbols, relationsByStore);
@@ -1835,18 +3395,156 @@ 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();
+		/** stores handed raw to a page: what the page shows of them is read after the walk */
+		const rawDeliveries = [];
+		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);
+					if (item.via) rawDeliveries.push({
+						...item.via,
+						store: item.store,
+						path: item.path
+					});
+					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,
+									via: item.via
+								}, 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,
+									via: item.via
+								}, 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);
+								if (item.via) rawDeliveries.push({
+									...item.via,
+									store,
+									path: item.path
+								});
+							}
+							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,
+							via: item.via
+						}, 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;
@@ -1885,12 +3583,20 @@ 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,
@@ -1926,17 +3632,38 @@ function createAnalyzer(app, stores, options = {}) {
 			}
 		};
 		visit(handler, 0);
+		/**
+		* What each page shows of the stores handed to it raw — read once the walk is
+		* done, because a query object's rows reach the page through the delivery of a
+		* call, not of a variable (plan 0.8 §D).
+		*/
+		const pages = readPages(rawDeliveries.filter((d) => !transformedStores.has(d.store)), {
+			root: app.root,
+			project,
+			stores: storesByName,
+			relations: relationsByStore,
+			resolveSpecifier: app.resolveSpecifier
+		});
 		return {
 			writes,
 			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()
+			},
+			pageReads: Object.fromEntries([...pages.columns.entries()].map(([store, columns]) => [store, [...columns].sort()])),
+			unreadablePages: Object.fromEntries(pages.unreadable),
 			outputReads: Object.fromEntries([...outputReads.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([store, read]) => [store, {
 				whole: read.whole,
 				selected: [...read.selected].sort(),
@@ -1969,6 +3696,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()) {
@@ -1986,7 +3715,7 @@ function findBody(file, ref) {
 * from them: `const invite = await Invite.findOrFail(...)` makes `invite.save()`
 * count as a write to `Invite`.
 */
-function storeSymbolsFor(body, file, app, stores) {
+function storeSymbolsFor(body, file, app, stores, relations = /* @__PURE__ */ new Map()) {
 	const symbols = /* @__PURE__ */ new Map();
 	for (const declaration of file.getImportDeclarations()) {
 		if (!app.resolveSpecifier(declaration.getModuleSpecifierValue())) continue;
@@ -1997,10 +3726,48 @@ 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();
-		if (!initializer || !Node.isIdentifier(name)) continue;
+		if (!Node.isIdentifier(name)) continue;
+		const declared = storeNamedBy(declaration.getTypeNode()?.getText(), stores);
+		if (declared) {
+			symbols.set(name.getText(), declared);
+			continue;
+		}
+		if (!initializer) continue;
+		/**
+		* `const pasta = documento.pasta`: a RELATION read off a row is the relation's
+		* target, not the row's store — `pasta.save()` had been billed to `Documento`.
+		* A plain field (`documento.nome`) is no store at all.
+		*/
+		const plain = unwrapAwait(initializer);
+		if (Node.isPropertyAccessExpression(plain)) {
+			const target = storeOfExpression(plain, symbols, relations);
+			if (target) symbols.set(name.getText(), target);
+			continue;
+		}
 		const root = rootSymbolOf(initializer);
 		const store = root ? symbols.get(root) : void 0;
 		if (store) symbols.set(name.getText(), store);
@@ -2008,8 +3775,8 @@ function storeSymbolsFor(body, file, app, stores) {
 	if (Node.isMethodDeclaration(body) || Node.isFunctionDeclaration(body)) for (const parameter of body.getParameters()) {
 		const typeNode = parameter.getTypeNode();
 		const nameNode = parameter.getNameNode();
-		const typeName = typeNode?.getText();
-		if (typeName && stores.has(typeName) && Node.isIdentifier(nameNode)) {
+		const typeName = storeNamedBy(typeNode?.getText(), stores);
+		if (typeName && Node.isIdentifier(nameNode)) {
 			symbols.set(nameNode.getText(), typeName);
 			continue;
 		}
@@ -2020,32 +3787,56 @@ function storeSymbolsFor(body, file, app, stores) {
 		* Registers the PATH `input.invite`, because that is how the write
 		* appears: `input.invite.save()`.
 		*/
-		if (typeNode && Node.isIdentifier(nameNode)) {
-			for (const [property, propertyType] of membersOfType(typeNode, file, app)) if (stores.has(propertyType)) symbols.set(`${nameNode.getText()}.${property}`, propertyType);
+		if (typeNode && Node.isIdentifier(nameNode)) for (const [property, propertyType] of membersOfType(typeNode, file, app)) {
+			const named = storeNamedBy(propertyType, stores);
+			if (named) symbols.set(`${nameNode.getText()}.${property}`, named);
 		}
 		/**
-		* Destructured form: `handle({ invite }: { invite: Invite })`.
-		*
-		* This is the dominant shape in the action-object pattern — the action
-		* receives a named payload. Without it, `invite.save()` inside the action
-		* does not count as a write, and the whole transaction becomes an EO
-		* instead of an EI.
+		* Destructured form: `handle({ invite }: { invite: Invite })`, and
+		* `handle({ document, name }: RenameDocumentInput)` with the interface named
+		* — in this file or imported. The second is the dominant shape on a reviewed
+		* application, and only the inline literal was read: every `document.save()`
+		* behind it was invisible, and the transaction an EO (plan 0.8 §A).
 		*/
 		const binding = nameNode.asKind(SyntaxKind.ObjectBindingPattern);
-		const literal = typeNode?.asKind(SyntaxKind.TypeLiteral);
-		if (!binding || !literal) continue;
-		const propertyTypes = /* @__PURE__ */ new Map();
-		for (const member of literal.getMembers()) {
-			if (!Node.isPropertySignature(member)) continue;
-			const memberType = member.getTypeNode()?.getText();
-			if (memberType) propertyTypes.set(member.getName(), memberType);
+		if (!binding || !typeNode) continue;
+		const propertyTypes = membersOfType(typeNode, file, app);
+		for (const element of binding.getElements()) {
+			const property = element.getPropertyNameNode()?.getText() ?? element.getName();
+			const resolved = storeNamedBy(propertyTypes.get(property), stores);
+			if (resolved) symbols.set(element.getName(), resolved);
 		}
+	}
+	/**
+	* `const { preIntake } = input` where `input.preIntake` is a registered path:
+	* each element inherits the store of its path. Read AFTER the parameters, which
+	* is where the paths come from.
+	*/
+	for (const declaration of body.getDescendantsOfKind(SyntaxKind.VariableDeclaration)) {
+		const binding = declaration.getNameNode();
+		const initializer = declaration.getInitializer();
+		if (!Node.isObjectBindingPattern(binding) || !initializer) continue;
+		const root = Node.isIdentifier(initializer) ? initializer.getText() : null;
+		if (!root) continue;
 		for (const element of binding.getElements()) {
 			const property = element.getPropertyNameNode()?.getText() ?? element.getName();
-			const resolved = propertyTypes.get(property);
-			if (resolved && stores.has(resolved)) symbols.set(element.getName(), resolved);
+			const store = symbols.get(`${root}.${property}`);
+			if (store) symbols.set(element.getName(), store);
 		}
 	}
+	/**
+	* `for (const documento of pasta.documentos)`, `for (const row of rows)`: the
+	* loop variable is a row of the relation's target, or of the rows' store. A
+	* `delete()` inside such a loop was invisible; read last, after the parameters that name the parent — plan 0.8 §A.
+	*/
+	for (const loop of body.getDescendantsOfKind(SyntaxKind.ForOfStatement)) {
+		const declared = loop.getInitializer();
+		if (!Node.isVariableDeclarationList(declared)) continue;
+		const nameNode = declared.getDeclarations()[0]?.getNameNode();
+		if (!nameNode || !Node.isIdentifier(nameNode)) continue;
+		const store = storeOfExpression(unwrapAwait(loop.getExpression()), symbols, relations);
+		if (store) symbols.set(nameNode.getText(), store);
+	}
 	return symbols;
 }
 /**
@@ -2109,6 +3900,67 @@ function resolveTypeToFile(typeName, file, app) {
 * Accepts an inline type literal and a named type declared in this file or
 * imported from the application. Anything else yields empty — no guessing.
 */
+/**
+* The store a type annotation names, or nothing: `Sessao`, `Sessao | null`,
+* `Promise<Sessao | null>`, `Sessao[]`, `Promise<Sessao[]>`. Two different stores
+* in one union name nothing — a guess is not a binding.
+*/
+function storeNamedBy(typeText, stores) {
+	if (!typeText) return null;
+	let text = typeText.trim();
+	const promise = text.match(/^Promise<([\s\S]*)>$/);
+	if (promise) text = promise[1];
+	const named = new Set(text.split("|").map((part) => part.trim().replace(/\[\]$/, "").replace(/^Array<(.*)>$/, "$1").trim()).filter((part) => part && part !== "null" && part !== "undefined"));
+	if (named.size !== 1) return null;
+	const [only] = named;
+	return stores.has(only) ? only : null;
+}
+/** array methods that hand back one row, or the same rows, of the receiver */
+const ONE_OF_ROWS = new Set([
+	"find",
+	"findLast",
+	"at",
+	"filter",
+	"slice",
+	"sort",
+	"toSorted",
+	"reverse",
+	"toReversed",
+	"concat",
+	"flat",
+	"first",
+	"last"
+]);
+/** array methods whose callback receives one row of the receiver */
+const ITERATES_ROWS = new Set([
+	"map",
+	"forEach",
+	"filter",
+	"find",
+	"findLast",
+	"some",
+	"every",
+	"flatMap",
+	"reduce"
+]);
+const lastSegmentText = (node) => Node.isPropertyAccessExpression(node) ? node.getName() : node.getText();
+/** the store an expression is rows of: a store symbol, or `parent.relation` with the relation declared */
+function storeOfExpression(expression, symbols, relations) {
+	if (!expression) return null;
+	if (Node.isIdentifier(expression)) return symbols.get(expression.getText()) ?? null;
+	if (Node.isPropertyAccessExpression(expression)) {
+		const receiver = expression.getExpression();
+		if (Node.isIdentifier(receiver)) {
+			const byPath = symbols.get(`${receiver.getText()}.${expression.getName()}`);
+			if (byPath) return byPath;
+		}
+		const parent = symbols.get(rootSymbolOf(receiver) ?? "");
+		if (!parent) return null;
+		return relations.get(parent)?.[expression.getName()] ?? null;
+	}
+	const root = rootSymbolOf(expression);
+	return root ? symbols.get(root) ?? null : null;
+}
 function membersOfType(typeNode, file, app) {
 	const members = /* @__PURE__ */ new Map();
 	const collect = (node) => {
@@ -2162,6 +4014,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
@@ -2197,6 +4075,77 @@ function isWorthReporting(call, symbols, imports) {
 	if (root === "this") return true;
 	return imports.has(root);
 }
+/** Lucid's persistence on an instance, with no arguments: `x.save()`, `x.delete()` — a `Map#delete(key)` has one */
+const INSTANCE_WRITES = new Set([
+	"save",
+	"delete",
+	"forceDelete"
+]);
+/** persistence through a relation or a merge: `x.related('y').create(…)`, `x.merge(p).save()` */
+const CHAINED_WRITES = new Set([
+	"create",
+	"createMany",
+	"save",
+	"saveMany",
+	"attach",
+	"detach",
+	"sync",
+	"updateOrCreate",
+	"firstOrCreate",
+	"delete"
+]);
+const WRITE_CHAINS = new Set([
+	"related",
+	"merge",
+	"fill",
+	"useTransaction"
+]);
+/**
+* A persistence call on a receiver the body cannot type: a local that is neither a
+* store, nor an import, nor `this`, nor the result of a call on one of those.
+* Reported as unresolved — the count must not stay silent where an EI may hide.
+*/
+function isUnreadableWrite(call, symbols, imports, packageImports, body) {
+	const expression = call.getExpression();
+	if (!Node.isPropertyAccessExpression(expression)) return false;
+	const method = expression.getName();
+	const receiver = unwrapAwait(expression.getExpression());
+	if (Node.isCallExpression(receiver)) {
+		const inner = receiver.getExpression();
+		if (!Node.isPropertyAccessExpression(inner) || !WRITE_CHAINS.has(inner.getName())) return false;
+		if (!CHAINED_WRITES.has(method)) return false;
+	} else if (!INSTANCE_WRITES.has(method) || call.getArguments().length > 0) return false;
+	const root = rootSymbolOf(expression.getExpression());
+	if (!root || root === "this") return false;
+	if (symbols.has(root) || imports.has(root) || packageImports.has(root)) return false;
+	if (!Node.isIdentifier(unwrapAwait(rootNodeOf(expression.getExpression())))) return false;
+	/**
+	* `const pdfDoc = await PDFDocument.create()` from `pdf-lib`, then `pdfDoc.save()`:
+	* a package's object with a method called `save`. Its declaration says where it
+	* came from, and it is not a store — nothing to report.
+	*/
+	for (const declaration of body.getDescendantsOfKind(SyntaxKind.VariableDeclaration)) {
+		const nameNode = declaration.getNameNode();
+		if (!Node.isIdentifier(nameNode) || nameNode.getText() !== root) continue;
+		const initializer = declaration.getInitializer();
+		const origin = initializer ? rootSymbolOf(unwrapAwait(initializer)) : null;
+		if (origin && packageImports.has(origin)) return false;
+	}
+	return true;
+}
+/** the leftmost node of a chain */
+function rootNodeOf(node) {
+	let current = node;
+	for (let depth = 0; depth < 40; depth++) {
+		const next = unwrapAwait(current);
+		if (Node.isPropertyAccessExpression(next) || Node.isCallExpression(next) || Node.isElementAccessExpression(next)) {
+			current = next.getExpression();
+			continue;
+		}
+		return next;
+	}
+	return current;
+}
 /** `(await x())` and `x()` are the same receiver for this purpose. */
 function unwrapAwait(node) {
 	let current = node;
@@ -2215,6 +4164,154 @@ function hashOf(body) {
 	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.
+*
+*   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 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
 /** shared grid: [ref band][DET band] -> complexity */
 const GRID = [
@@ -2757,7 +4854,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
@@ -2777,6 +4874,11 @@ function detsFor(entry, behavior, touched, type, options) {
 	* paid for twice.
 	*/
 	for (const field of behavior.requestFields) add(field, `request:${field}`);
+	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:
@@ -2812,8 +4914,34 @@ function detsFor(entry, behavior, touched, type, options) {
 			}
 		}
 		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;
@@ -2839,6 +4967,19 @@ function detsFor(entry, behavior, touched, type, options) {
 				}
 				continue;
 			}
+			/**
+			* Handed raw to a page the reader could open: the columns the page reads off
+			* the rows are what the user sees (§6, plan 0.8 §D). A page it could not read
+			* leaves the store whole below, and the count says why.
+			*/
+			const shown = behavior.pageReads?.[store];
+			if (shown && !behavior.unreadablePages?.[store]) {
+				for (const column of shown) {
+					if (excluded.has(column)) continue;
+					add(`${store}.${column}`, `page:${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)}`);
@@ -2926,12 +5067,20 @@ const RULESET = "afp";
 * 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. One in
+* 1.7.0, wide: a write binds to what the variable IS — a destructured named
+* interface, a followed method's return, a relation off a row, a loop over rows,
+* the guard's user, a service the container made — and a write nobody can type is
+* an unresolved call instead of silence.
 *
 * 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.5.0";
+const RULESET_VERSION = "1.7.0";
 function count(input, options = {}) {
 	const warnings = [];
 	const usage = usageOf(input);
@@ -3013,7 +5162,8 @@ function count(input, options = {}) {
 	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,
@@ -3047,6 +5197,10 @@ function count(input, options = {}) {
 	}));
 	warnings.push(...unreadableInputWarnings(input));
 	warnings.push(...unreadableOutputWarnings(input));
+	warnings.push(...unreadableDeliveryWarnings(input));
+	warnings.push(...commandWarnings(entryPoints, transactionalFunctions));
+	warnings.push(...undispatchedJobWarnings(input));
+	warnings.push(...unreadablePageWarnings(input));
 	warnings.push(...lookAlikeWarnings(functions));
 	warnings.push(...seededOnlyWarnings(functions, grouping.members, input.seededAnywhere));
 	return {
@@ -3058,6 +5212,88 @@ function count(input, options = {}) {
 	};
 }
 /**
+* Transactions that deliver something the analysis cannot read.
+*
+* 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`] : []
+	];
+}
+/**
+* Pages the reader could not open for a store handed to them raw — plan 0.8 §D.
+*
+* The store leaves whole, as it always did; this says which page, and why: a
+* second level of components, a spread, a package's component, two files answering
+* to one name. Overestimating in the open — the fix is usually in the page.
+*/
+function unreadablePageWarnings(input) {
+	const lines = [];
+	for (const entry of input.entryPoints) {
+		const behavior = input.behaviors.get(entry.id);
+		if (!behavior || behavior.writes) continue;
+		for (const [store, reason] of Object.entries(behavior.unreadablePages ?? {})) lines.push(`  ${entry.trigger} ${entry.signature}: ${store} leaves whole — ${reason}`);
+	}
+	if (lines.length === 0) return [];
+	return [
+		`${lines.length} store(s) handed raw to a page the analysis could not read: every column counted. What the page shows would be less:`,
+		...lines.slice(0, 12),
+		...lines.length > 12 ? [`  … and ${lines.length - 12} more`] : []
+	];
+}
+/**
+* Jobs no transaction reaches — plan 0.7 §D.
+*
+* 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 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`;
+	})];
+}
+/**
+* Ace commands counted as transactions — plan 0.7 §C.
+*
+* 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.
+*/
+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("; ")}` : ""))];
+}
+/**
 * Transactions that look like the same elementary process.
 *
 * The CPM counts identical processing logic once. `GET /perfil` and
@@ -3379,7 +5615,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, {
@@ -3461,6 +5699,13 @@ 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: behavior.outputFields.map((name) => ({
 				name,
@@ -3477,6 +5722,9 @@ async function analyze(root, options = {}) {
 				}
 			})),
 			transformedStores: behavior.transformedStores,
+			delivered: behavior.delivered,
+			pageReads: behavior.pageReads,
+			unreadablePages: behavior.unreadablePages,
 			outputReads: behavior.outputReads,
 			trace: behavior.trace.map((step) => ({
 				...step,
@@ -3505,6 +5753,7 @@ async function analyze(root, options = {}) {
 				entryPoints,
 				behaviors,
 				jsonSchemas,
+				jobs: collectJobs(app),
 				writtenAnywhere: analyzer.writtenAnywhere(),
 				addressedAnywhere: analyzer.addressedAnywhere(),
 				seededAnywhere: analyzer.seededAnywhere()