@filipebraida/adonis-function-points 0.6.0 → 0.7.0

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

@@ -1,4 +1,4 @@
-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-DaU4uAqT.js";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { Node, Project, SyntaxKind } from "ts-morph";
@@ -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) {
@@ -1194,50 +1220,858 @@ function isNoise(call, owner) {
 * costs nothing and is not the same as silencing an unresolved call: nothing
 * was ever there to resolve.
 */
-function isIterationCall(call) {
-	const expression = call.getExpression();
-	if (!Node.isPropertyAccessExpression(expression)) return false;
-	return isIteration(expression.getName(), call);
+function isIterationCall(call) {
+	const expression = call.getExpression();
+	if (!Node.isPropertyAccessExpression(expression)) return false;
+	return isIteration(expression.getName(), call);
+}
+/** An iteration method whose first argument is an inline callback. */
+function isIteration(method, call) {
+	if (!ITERATION_METHODS.has(method)) return false;
+	const first = call.getArguments()[0];
+	return first !== void 0 && (Node.isArrowFunction(first) || Node.isFunctionExpression(first));
+}
+/** Does the receiver resolve to a built-in, by its declaration? */
+function isNativeReceiver(receiver, owner) {
+	if (Node.isArrayLiteralExpression(receiver) || Node.isStringLiteral(receiver)) return true;
+	if (Node.isPropertyAccessExpression(receiver) && receiver.getExpression().getKind()) {
+		const inner = receiver.getExpression();
+		if (Node.isThisExpression(inner) && owner) return isNativeProperty(owner, receiver.getName());
+	}
+	return false;
+}
+function isNativeProperty(owner, name) {
+	/**
+	* Both shapes declare a field: a class property, and a constructor parameter
+	* property. Reading only the first missed every `Map` handed in through the
+	* constructor, which is how a transformer usually receives its lookups.
+	*/
+	const property = owner.getProperty(name) ?? owner.getConstructors()[0]?.getParameters().find((parameter) => parameter.getName() === name);
+	if (!property) return false;
+	const typeNode = property.getTypeNode()?.getText();
+	if (typeNode && NATIVE_TYPES.has(typeNode.replace(/<.*/, "").trim())) return true;
+	const initializer = property.getInitializer();
+	if (initializer && Node.isNewExpression(initializer)) return NATIVE_TYPES.has(initializer.getExpression().getText());
+	return initializer !== void 0 && (Node.isArrayLiteralExpression(initializer) || Node.isStringLiteral(initializer));
+}
+/**
+* The body-not-found path: a symbol resolved to an application file whose
+* member is not there. For a framework service that is expected — the
+* implementation is in the package — and says nothing about tracing quality.
+*/
+function isNoiseMember(file, member) {
+	if (member && NEVER_DATA_METHODS.has(member)) return true;
+	const base = file.split("/").pop()?.replace(/\.[jt]s$/, "");
+	return base !== void 0 && FRAMEWORK_SERVICES.has(base);
+}
+//#endregion
+//#region src/inventory/graph/deliveries.ts
+/** `inertia.render(page, props)`, `inertia.modal(page, props)`, `view.render(view, props)` */
+const RENDERERS = new Set(["inertia", "view"]);
+const RENDER_METHODS = new Set(["render", "modal"]);
+/** `response.json(x)`, `.ok(x)`, `.created(x)`, `.send(x)`, `.accepted(x)` */
+const RESPONSE_METHODS = new Set([
+	"json",
+	"ok",
+	"created",
+	"accepted",
+	"send"
+]);
+/**
+* An ace command prints: `this.ui.table().row([…])`, `this.logger.info(…)`,
+* `console.log(…)`. What a report hands to the terminal is what leaves — every
+* argument is delivered, read like a prop (plan 0.7 §C).
+*/
+const PRINTERS = new Set([
+	"ui",
+	"logger",
+	"console"
+]);
+/** `x.data`, `x.rows` on a paginated / wrapped result hand the collection on */
+const PASSES_THROUGH = new Set([
+	"data",
+	"rows",
+	"all",
+	"toJSON",
+	"serialize"
+]);
+/** keys of a result that carry its rows: picking one of these is not picking one value */
+const PASSES_ROWS = new Set([
+	"data",
+	"rows",
+	"items",
+	"results",
+	"list",
+	"linhas",
+	"itens"
+]);
+/** properties of a result that are one value, not its rows */
+const SCALAR_PROPS = new Set([
+	"length",
+	"size",
+	"total",
+	"count"
+]);
+/**
+* What Lucid's `paginator.getMeta()` says that a page can show. The URLs are
+* navigation and `firstPage` a constant: neither is a user-recognisable attribute.
+*/
+const PAGINATOR_META = [
+	"total",
+	"perPage",
+	"currentPage",
+	"lastPage"
+];
+/** methods that return the same collection, or one of its rows: what leaves is the receiver */
+const SAME_COLLECTION = new Set([
+	"slice",
+	"filter",
+	"sort",
+	"sortBy",
+	"toSorted",
+	"reverse",
+	"toReversed",
+	"concat",
+	"flat",
+	"find",
+	"findLast",
+	"at",
+	"first",
+	"last"
+]);
+/** reads of the request whose result echoes input already counted on entry */
+const ECHOES_INPUT = new Set([
+	"validateUsing",
+	"input",
+	"only",
+	"all",
+	"body",
+	"qs",
+	"params"
+]);
+/** Inertia's lazy props: `inertia.defer(() => q.handle())` — the callback's value is what leaves */
+const INERTIA_LAZY = new Set([
+	"defer",
+	"lazy",
+	"optional",
+	"always",
+	"merge",
+	"scroll",
+	"once"
+]);
+/** a yes/no: an authorisation check, a membership test */
+const BOOLEAN_METHODS = new Set([
+	"allows",
+	"denies",
+	"can",
+	"cannot",
+	"includes",
+	"has",
+	"startsWith",
+	"endsWith",
+	"test"
+]);
+/** a value formatted: still one value */
+const FORMAT_METHODS = new Set([
+	"join",
+	"toString",
+	"toISO",
+	"toISODate",
+	"toISOTime",
+	"toISOString",
+	"toFormat",
+	"toRFC2822",
+	"toHTTP",
+	"toSQL",
+	"toLocaleString",
+	"toLocaleDateString",
+	"toFixed",
+	"toUnixInteger",
+	"toMillis",
+	"trim",
+	"toUpperCase",
+	"toLowerCase",
+	"padStart",
+	"padEnd",
+	"replace",
+	"slice",
+	"substring"
+]);
+/** framework services whose calls hand back one value: a translation, a session key, a URL */
+const SCALAR_SERVICES = new Set([
+	"i18n",
+	"session",
+	"env",
+	"router",
+	"encryption",
+	"hash",
+	"config",
+	"app"
+]);
+/** built-ins whose static calls are one value or a constant list: `Object.values(Enum)`, `JSON.stringify(x)` */
+const NATIVE_GLOBALS = new Set([
+	"Object",
+	"Array",
+	"JSON",
+	"Math",
+	"Number",
+	"String",
+	"Boolean",
+	"Date",
+	"Intl"
+]);
+/**
+* The deliveries of a body: every props argument handed to a renderer or a
+* response method, and what a `return` hands back that is not one of those calls.
+*/
+function deliveriesIn(ctx) {
+	const deliveries = [];
+	const returns = [];
+	let any = false;
+	let anyReturn = false;
+	const seen = /* @__PURE__ */ new Set();
+	for (const call of ctx.body.getDescendantsOfKind(SyntaxKind.CallExpression)) {
+		const callee = call.getExpression();
+		if (!Node.isPropertyAccessExpression(callee)) continue;
+		const method = callee.getName();
+		const receiver = lastSegmentOf(callee.getExpression());
+		let payload;
+		if (RENDERERS.has(receiver) && RENDER_METHODS.has(method)) payload = call.getArguments()[1];
+		else if (receiver === "response" && RESPONSE_METHODS.has(method)) payload = call.getArguments()[0];
+		else if (isPrinter(callee.getExpression(), ctx.body)) {
+			any = true;
+			seen.add(call);
+			for (const argument of call.getArguments()) classify(unwrap$1(argument), "", ctx, deliveries, 0);
+			continue;
+		} else continue;
+		any = true;
+		if (!payload) continue;
+		seen.add(call);
+		classify(unwrap$1(payload), "", ctx, deliveries, 0);
+	}
+	for (const statement of ctx.body.getDescendantsOfKind(SyntaxKind.ReturnStatement)) {
+		if (statement.getFirstAncestor((node) => Node.isArrowFunction(node) || Node.isFunctionExpression(node) || Node.isMethodDeclaration(node) || Node.isFunctionDeclaration(node)) !== ctx.body) continue;
+		const value = unwrap$1(statement.getExpression());
+		if (!value) continue;
+		if (Node.isCallExpression(value)) {
+			if (seen.has(value)) continue;
+			/**
+			* `return response.redirect().toRoute(…)`, `return response.noContent()`,
+			* `return inertia.render(…)` (seen above): a call whose chain is rooted at
+			* the response or a renderer is the response itself, not a value handed
+			* back — nothing to classify.
+			*/
+			const root = chainRootOf(value);
+			if (root && (RENDERERS.has(root) || root === "response")) continue;
+		}
+		anyReturn = true;
+		classify(value, "", ctx, returns, 0);
+	}
+	return {
+		calls: deliveries,
+		anyCall: any,
+		returns,
+		anyReturn
+	};
+}
+/** the identifier a call chain is rooted at: `response.redirect().toRoute(x)` -> 'response' */
+function chainRootOf(node) {
+	let current = node;
+	for (let depth = 0; current && depth < 40; depth++) {
+		if (Node.isCallExpression(current) || Node.isPropertyAccessExpression(current)) {
+			current = current.getExpression();
+			continue;
+		}
+		if (Node.isAwaitExpression(current) || Node.isParenthesizedExpression(current)) {
+			current = current.getExpression();
+			continue;
+		}
+		return Node.isIdentifier(current) ? current.getText() : Node.isThisExpression(current) ? "this" : null;
+	}
+	return null;
+}
+/**
+* `this.ui.table().row(x)`, `this.logger.info(x)`, `console.log(x)`: a chain rooted
+* at a printer — through a variable too (`const table = this.ui.table(); table.row(x)`).
+*/
+function isPrinter(receiver, body, depth = 0) {
+	let current = receiver;
+	for (let steps = 0; current && steps < 20; steps++) {
+		if (Node.isCallExpression(current)) {
+			current = current.getExpression();
+			continue;
+		}
+		if (Node.isPropertyAccessExpression(current)) {
+			const inner = current.getExpression();
+			if (Node.isThisExpression(inner)) return PRINTERS.has(current.getName());
+			current = inner;
+			continue;
+		}
+		if (!Node.isIdentifier(current)) return false;
+		if (current.getText() === "console") return true;
+		const bound = depth < 3 ? bindingOf(current.getText(), body) : null;
+		return !!bound && isPrinter(bound.initializer, body, depth + 1);
+	}
+	return false;
+}
+/** `ctx.inertia` -> 'inertia', `inertia` -> 'inertia', `this.response` -> 'response' */
+function lastSegmentOf(node) {
+	if (Node.isPropertyAccessExpression(node)) return node.getName();
+	return node.getText();
+}
+function classify(value, path, ctx, out, depth) {
+	if (!value || depth > 6) return;
+	if (value.getKind() === SyntaxKind.NullKeyword) return;
+	if (Node.isIdentifier(value) && value.getText() === "undefined") return;
+	/**
+	* A constant with no key — `this.logger.info('done')`, a table's `head(['Nome'])`
+	* — is a label or a message, not a field: AFP counts no message DET (§6). Keyed,
+	* `{ titulo: 'X' }` is a value the page receives, and stays one.
+	*/
+	if (!path && (Node.isStringLiteral(value) || Node.isNoSubstitutionTemplateLiteral(value) || Node.isNumericLiteral(value))) return;
+	if (Node.isObjectLiteralExpression(value)) {
+		for (const property of value.getProperties()) if (Node.isShorthandPropertyAssignment(property)) classify(property.getNameNode(), join(path, property.getName()), ctx, out, depth + 1);
+		else if (Node.isPropertyAssignment(property)) {
+			const name = Node.isComputedPropertyName(property.getNameNode()) ? "*" : property.getName().replace(/^['"]|['"]$/g, "");
+			classify(unwrap$1(property.getInitializer()), join(path, name), ctx, out, depth + 1);
+		} else if (Node.isSpreadAssignment(property)) classify(unwrap$1(property.getExpression()), path, ctx, out, depth + 1);
+		else out.push({
+			kind: "scalar",
+			path: join(path, property.getName?.() ?? "*")
+		});
+		return;
+	}
+	if (Node.isConditionalExpression(value)) {
+		classify(unwrap$1(value.getWhenTrue()), path, ctx, out, depth + 1);
+		classify(unwrap$1(value.getWhenFalse()), path, ctx, out, depth + 1);
+		return;
+	}
+	if (Node.isArrayLiteralExpression(value)) {
+		for (const element of value.getElements()) classify(unwrap$1(Node.isSpreadElement(element) ? element.getExpression() : element), path, ctx, out, depth + 1);
+		return;
+	}
+	if (Node.isElementAccessExpression(value)) {
+		classify(unwrap$1(value.getExpression()), path, ctx, out, depth + 1);
+		return;
+	}
+	if (Node.isIdentifier(value)) {
+		const name = value.getText();
+		if (ctx.symbols.has(name)) {
+			out.push({
+				kind: "store",
+				store: ctx.symbols.get(name),
+				path
+			});
+			return;
+		}
+		const bound = bindingOf(name, ctx.body);
+		if (bound) {
+			if (bound.pick && Node.isCallExpression(bound.initializer)) {
+				classifyCall(bound.initializer, path, ctx, out, depth + 1, bound.pick);
+				return;
+			}
+			if (bound.pick && Node.isObjectLiteralExpression(bound.initializer)) {
+				const picked = bound.initializer.getProperty(bound.pick);
+				if (picked && Node.isPropertyAssignment(picked)) {
+					classify(unwrap$1(picked.getInitializer()), path, ctx, out, depth + 1);
+					return;
+				}
+				if (picked && Node.isShorthandPropertyAssignment(picked)) {
+					classify(picked.getNameNode(), path, ctx, out, depth + 1);
+					return;
+				}
+			}
+			classify(bound.initializer, path, ctx, out, depth + 1);
+			return;
+		}
+		if (isEchoBinding(name, ctx.body)) {
+			out.push({
+				kind: "echo",
+				path
+			});
+			return;
+		}
+		out.push({
+			kind: "scalar",
+			path
+		});
+		return;
+	}
+	if (Node.isCallExpression(value)) {
+		classifyCall(value, path, ctx, out, depth);
+		return;
+	}
+	if (Node.isPropertyAccessExpression(value) || Node.isElementAccessExpression(value)) {
+		classifyAccess(value, path, ctx, out, depth);
+		return;
+	}
+	if (Node.isAwaitExpression(value)) {
+		classify(unwrap$1(value.getExpression()), path, ctx, out, depth + 1);
+		return;
+	}
+	if (Node.isBinaryExpression(value)) {
+		const operator = value.getOperatorToken().getKind();
+		if (operator === SyntaxKind.QuestionQuestionToken || operator === SyntaxKind.BarBarToken) {
+			classify(unwrap$1(value.getLeft()), path, ctx, out, depth + 1);
+			return;
+		}
+		if (operator === SyntaxKind.AmpersandAmpersandToken) {
+			classify(unwrap$1(value.getRight()), path, ctx, out, depth + 1);
+			return;
+		}
+	}
+	if (Node.isTemplateExpression(value)) {
+		for (const span of value.getTemplateSpans()) classify(unwrap$1(span.getExpression()), path, ctx, out, depth + 1);
+		return;
+	}
+	out.push({
+		kind: "scalar",
+		path
+	});
+}
+function classifyCall(value, path, ctx, out, depth, pick) {
+	{
+		const callee = value.getExpression();
+		const method = Node.isPropertyAccessExpression(callee) ? callee.getName() : "";
+		if (Node.isPropertyAccessExpression(callee) && ECHOES_INPUT.has(method) && isRequestLike(callee.getExpression())) {
+			out.push({
+				kind: "echo",
+				path
+			});
+			return;
+		}
+		const mapped = mappedLiteralOf(value);
+		if (mapped) {
+			classify(mapped, path, ctx, out, depth + 1);
+			return;
+		}
+		if (method === "map" && Node.isPropertyAccessExpression(callee)) {
+			classifyMapped(value, callee.getExpression(), path, ctx, out, depth);
+			return;
+		}
+		if (Node.isPropertyAccessExpression(callee) && PASSES_THROUGH.has(method) && value.getArguments().length === 0) {
+			classify(unwrap$1(callee.getExpression()), path, ctx, out, depth + 1);
+			return;
+		}
+		if (method === "getMeta" && value.getArguments().length === 0) {
+			if (pick) out.push({
+				kind: "scalar",
+				path
+			});
+			else for (const key of PAGINATOR_META) out.push({
+				kind: "scalar",
+				path: join(path, key)
+			});
+			return;
+		}
+		if (Node.isPropertyAccessExpression(callee) && SAME_COLLECTION.has(method)) {
+			classify(unwrap$1(callee.getExpression()), path, ctx, out, depth + 1);
+			return;
+		}
+		if (Node.isPropertyAccessExpression(callee) && lastSegmentOf(callee.getExpression()) === "colors") {
+			const coloured = unwrap$1(value.getArguments()[0]);
+			if (coloured) classify(coloured, path, ctx, out, depth + 1);
+			return;
+		}
+		if (Node.isPropertyAccessExpression(callee) && INERTIA_LAZY.has(method) && RENDERERS.has(lastSegmentOf(callee.getExpression()))) {
+			const body = callbackValueOf(unwrap$1(value.getArguments()[0]));
+			if (body) classify(body, path, ctx, out, depth + 1);
+			else out.push({
+				kind: "scalar",
+				path
+			});
+			return;
+		}
+		const args = [];
+		for (const argument of value.getArguments()) classify(unwrap$1(argument), path, ctx, args, depth + 1);
+		/** only what carries rows matters for a fallback: a scalar argument is a parameter, not an output */
+		const carried = args.filter((item) => item.kind === "store" || item.kind === "call");
+		if (Node.isPropertyAccessExpression(callee)) {
+			const root = chainRootOf(callee.getExpression());
+			if (root && SCALAR_SERVICES.has(root)) {
+				out.push({
+					kind: "scalar",
+					path
+				});
+				return;
+			}
+		}
+		const refs = ctx.followed.get(value);
+		if (refs && refs.length > 0) {
+			out.push({
+				kind: "call",
+				refs,
+				path,
+				expression: value.getText().replace(/\s+/g, "").slice(0, 60),
+				args: carried,
+				...pick ? { pick } : {}
+			});
+			return;
+		}
+		const access = detectAccess(value, ctx.symbols, ctx.relations);
+		if (access) {
+			out.push({
+				kind: "store",
+				store: access.store,
+				path
+			});
+			if (access.viaRelation) out.push({
+				kind: "store",
+				store: access.viaRelation,
+				path
+			});
+			return;
+		}
+		if (Node.isIdentifier(callee) && NATIVE_GLOBALS.has(callee.getText())) {
+			out.push({
+				kind: "scalar",
+				path
+			});
+			return;
+		}
+		if (Node.isPropertyAccessExpression(callee) && Node.isIdentifier(callee.getExpression()) && NATIVE_GLOBALS.has(callee.getExpression().getText())) {
+			out.push({
+				kind: "scalar",
+				path
+			});
+			return;
+		}
+		/**
+		* A call nobody followed, over rows: a package's CSV builder, a formatter. The
+		* document it builds carries what was handed into it, so the rows' stores leave.
+		* With nothing flowing in there is nothing to say: one DET, opaque, reported.
+		*/
+		if (carried.length > 0) {
+			out.push(...carried);
+			return;
+		}
+		/**
+		* `startDate?.toISOString()`, `categoria.trim()`: a call ON a value the body
+		* holds is that value formatted — an echo stays an echo, a store's field one
+		* field. Only when the root itself resolves to nothing else is the call read
+		* on its own.
+		*/
+		if (Node.isPropertyAccessExpression(callee)) {
+			const root = chainRootOf(callee.getExpression());
+			if (root && ctx.symbols.has(root)) {
+				out.push({
+					kind: "scalar",
+					path
+				});
+				return;
+			}
+			if (root && root !== "this") {
+				const rootNode = rootIdentifierOf(callee.getExpression());
+				const held = [];
+				if (rootNode) classify(rootNode, path, ctx, held, depth + 1);
+				if (held.length > 0 && held.every((item) => item.kind === "echo")) {
+					out.push({
+						kind: "echo",
+						path
+					});
+					return;
+				}
+			}
+		}
+		/**
+		* `rows.map(…).join('\n')` in a body whose parameter is `rows`: the whole input
+		* transformed, so the input says what leaves — the caller's arguments decide,
+		* and the body itself says nothing. `noticia.publicadaEm?.toISO()` on that
+		* parameter is one FIELD of it, and stays one value below.
+		*/
+		if (Node.isPropertyAccessExpression(callee) && transformsParameter(callee, ctx.body)) {
+			out.push({
+				kind: "opaque",
+				path,
+				expression: value.getText().replace(/\s+/g, "").slice(0, 60)
+			});
+			return;
+		}
+		if (Node.isPropertyAccessExpression(callee)) {
+			/**
+			* `comunicado.enviadoEm!.toISODate()`, `(a ?? b).toRFC2822()`: a FIELD read off
+			* the chain, or an expression, then a method — one value. A chain rooted at
+			* `this` (`this.service.find()`) is a call into a service, and not this.
+			*/
+			if (readsField(callee.getExpression())) {
+				out.push({
+					kind: "scalar",
+					path
+				});
+				return;
+			}
+			if (BOOLEAN_METHODS.has(method) || FORMAT_METHODS.has(method)) {
+				out.push({
+					kind: "scalar",
+					path
+				});
+				return;
+			}
+		}
+		if (returnsPrimitive(value)) {
+			out.push({
+				kind: "scalar",
+				path
+			});
+			return;
+		}
+		out.push({
+			kind: "opaque",
+			path,
+			expression: value.getText().replace(/\s+/g, "").slice(0, 60)
+		});
+	}
+}
+/**
+* `xs.map(cb)` with no literal in the callback: what the callback RETURNS,
+* once — a function passed by reference (`rows.map(paraLinha)`) is a call to
+* that function over the rows; an expression body (`(m) => new T(m).toObject()`)
+* is classified as if it were the value; anything else is one repeating attribute.
+*/
+function classifyMapped(value, receiver, path, ctx, out, depth) {
+	const callback = unwrap$1(value.getArguments()[0]);
+	const refs = ctx.followed.get(value);
+	if (callback && Node.isIdentifier(callback) && refs && refs.length > 0) {
+		const rows = [];
+		classify(unwrap$1(receiver), path, ctx, rows, depth + 1);
+		out.push({
+			kind: "call",
+			refs,
+			path,
+			expression: value.getText().replace(/\s+/g, "").slice(0, 60),
+			args: rows.filter((item) => item.kind === "store" || item.kind === "call")
+		});
+		return;
+	}
+	const body = callbackValueOf(callback);
+	if (body) {
+		classify(body, path, ctx, out, depth + 1);
+		return;
+	}
+	out.push({
+		kind: "scalar",
+		path
+	});
+}
+/** the value a callback hands back: an expression body, or the one `return` of a block */
+function callbackValueOf(callback) {
+	if (!callback || !(Node.isArrowFunction(callback) || Node.isFunctionExpression(callback))) return null;
+	const body = callback.getBody();
+	if (!Node.isBlock(body)) return unwrap$1(body);
+	const returns = body.getStatements().filter(Node.isReturnStatement);
+	return returns.length === 1 ? unwrap$1(returns[0].getExpression()) : null;
+}
+/**
+* Does this chain read a property (not a method) or hold an expression before
+* the method is applied? `comunicado.enviadoEm.toISO()` does; `rows.map(f).join()`
+* does not; a chain rooted at `this` is a service, and does not.
+*/
+function readsField(node) {
+	let current = node;
+	for (let depth = 0; current && depth < 40; depth++) {
+		if (Node.isCallExpression(current)) {
+			const inner = current.getExpression();
+			current = Node.isPropertyAccessExpression(inner) ? inner.getExpression() : inner;
+			continue;
+		}
+		if (Node.isAwaitExpression(current) || Node.isNonNullExpression(current)) {
+			current = current.getExpression();
+			continue;
+		}
+		if (Node.isParenthesizedExpression(current)) {
+			const inner = unwrap$1(current.getExpression());
+			if (!inner) return false;
+			if (Node.isBinaryExpression(inner) || Node.isConditionalExpression(inner)) return true;
+			current = inner;
+			continue;
+		}
+		if (Node.isPropertyAccessExpression(current) || Node.isElementAccessExpression(current)) return chainRootOf(current) !== "this";
+		return false;
+	}
+	return false;
+}
+/**
+* Is this chain a method (or methods) applied to a plain parameter of the body,
+* with no field read in between? `rows.map(f).join(s)` is; `noticia.capa?.toISO()`
+* reads a field first and is not.
+*/
+function transformsParameter(callee, body) {
+	let current = callee.getExpression();
+	for (let depth = 0; current && depth < 40; depth++) {
+		if (Node.isCallExpression(current)) {
+			const inner = current.getExpression();
+			current = Node.isPropertyAccessExpression(inner) ? inner.getExpression() : inner;
+			continue;
+		}
+		if (Node.isAwaitExpression(current) || Node.isParenthesizedExpression(current) || Node.isNonNullExpression(current)) {
+			current = current.getExpression();
+			continue;
+		}
+		if (Node.isPropertyAccessExpression(current) || Node.isElementAccessExpression(current)) return false;
+		if (!Node.isIdentifier(current)) return false;
+		const name = current.getText();
+		return Node.isParametered(body) && body.getParameters().some((p) => Node.isIdentifier(p.getNameNode()) && p.getNameNode().getText() === name);
+	}
+	return false;
 }
-/** An iteration method whose first argument is an inline callback. */
-function isIteration(method, call) {
-	if (!ITERATION_METHODS.has(method)) return false;
-	const first = call.getArguments()[0];
-	return first !== void 0 && (Node.isArrowFunction(first) || Node.isFunctionExpression(first));
+/** 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;
 }
-/** Does the receiver resolve to a built-in, by its declaration? */
-function isNativeReceiver(receiver, owner) {
-	if (Node.isArrayLiteralExpression(receiver) || Node.isStringLiteral(receiver)) return true;
-	if (Node.isPropertyAccessExpression(receiver) && receiver.getExpression().getKind()) {
-		const inner = receiver.getExpression();
-		if (Node.isThisExpression(inner) && owner) return isNativeProperty(owner, receiver.getName());
+/** 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;
 	}
-	return false;
 }
-function isNativeProperty(owner, name) {
+/**
+* `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);
 	/**
-	* Both shapes declare a field: a class property, and a constructor parameter
-	* property. Reading only the first missed every `Map` handed in through the
-	* constructor, which is how a transformer usually receives its lookups.
+	* `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 = owner.getProperty(name) ?? owner.getConstructors()[0]?.getParameters().find((parameter) => parameter.getName() === name);
-	if (!property) return false;
-	const typeNode = property.getTypeNode()?.getText();
-	if (typeNode && NATIVE_TYPES.has(typeNode.replace(/<.*/, "").trim())) return true;
-	const initializer = property.getInitializer();
-	if (initializer && Node.isNewExpression(initializer)) return NATIVE_TYPES.has(initializer.getExpression().getText());
-	return initializer !== void 0 && (Node.isArrayLiteralExpression(initializer) || Node.isStringLiteral(initializer));
+	const property = Node.isPropertyAccessExpression(value) ? value.getName() : keyOfElementAccess(value);
+	if (root && ctx.symbols.has(root)) {
+		if (!property || PASSES_THROUGH.has(property)) out.push({
+			kind: "store",
+			store: ctx.symbols.get(root),
+			path
+		});
+		else out.push({
+			kind: "scalar",
+			path: path || property.replace(/^\*$/, "")
+		});
+		return;
+	}
+	if (root) {
+		const bound = bindingOf(root, ctx.body);
+		if (bound && Node.isCallExpression(bound.initializer)) {
+			if (SCALAR_PROPS.has(property)) {
+				out.push({
+					kind: "scalar",
+					path
+				});
+				return;
+			}
+			/**
+			* `resultado.linhas`: one key of what the call returns; `meta.pagina` on a
+			* destructured `meta`: the key under the key; `rows[0]`, `.data`: the whole.
+			*/
+			const own = property && !PASSES_THROUGH.has(property) ? property : void 0;
+			const pick = [bound.pick, own].filter(Boolean).join(".") || void 0;
+			if (own && !ctx.followed.has(bound.initializer)) {
+				out.push({
+					kind: "scalar",
+					path
+				});
+				return;
+			}
+			classifyCall(bound.initializer, path, ctx, out, depth + 1, pick);
+			return;
+		}
+		if (bound && Node.isObjectLiteralExpression(bound.initializer) && property) {
+			const picked = bound.initializer.getProperty(property);
+			if (picked && Node.isPropertyAssignment(picked)) {
+				classify(unwrap$1(picked.getInitializer()), path, ctx, out, depth + 1);
+				return;
+			}
+		}
+		if (isEchoBinding(root, ctx.body) || root === "request" || root === "params") {
+			out.push({
+				kind: "echo",
+				path
+			});
+			return;
+		}
+	}
+	out.push({
+		kind: "scalar",
+		path: path || property.replace(/^\*$/, "")
+	});
+}
+function keyOfElementAccess(value) {
+	const argument = unwrap$1(value.getArgumentExpression());
+	if (!argument || Node.isNumericLiteral(argument)) return "";
+	if (Node.isStringLiteral(argument) || Node.isNoSubstitutionTemplateLiteral(argument)) return argument.getLiteralValue();
+	return "*";
+}
+const join = (prefix, name) => prefix ? `${prefix}.${name}` : name;
+/** `await x` binds x: the value, not the promise */
+function unwrapAwait$1(node) {
+	let current = unwrap$1(node);
+	while (current && Node.isAwaitExpression(current)) current = unwrap$1(current.getExpression());
+	return current;
 }
 /**
-* The body-not-found path: a symbol resolved to an application file whose
-* member is not there. For a framework service that is expected — the
-* implementation is in the package — and says nothing about tracing quality.
+* 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 isNoiseMember(file, member) {
-	if (member && NEVER_DATA_METHODS.has(member)) return true;
-	const base = file.split("/").pop()?.replace(/\.[jt]s$/, "");
-	return base !== void 0 && FRAMEWORK_SERVICES.has(base);
+function bindingOf(name, body) {
+	for (const declaration of body.getDescendantsOfKind(SyntaxKind.VariableDeclaration)) {
+		const nameNode = declaration.getNameNode();
+		if (Node.isIdentifier(nameNode)) {
+			if (nameNode.getText() !== name) continue;
+			const initializer = unwrapAwait$1(declaration.getInitializer());
+			return initializer ? { initializer } : null;
+		}
+		if (Node.isObjectBindingPattern(nameNode)) {
+			const element = nameNode.getElements().find((e) => e.getName() === name);
+			if (!element) continue;
+			const initializer = unwrapAwait$1(declaration.getInitializer());
+			if (!initializer) return null;
+			return {
+				initializer,
+				pick: element.getPropertyNameNode()?.getText() ?? element.getName()
+			};
+		}
+	}
+	return null;
+}
+/**
+* A name bound by destructuring the validated payload or the request:
+* `const { busca } = await request.validateUsing(x)`, `const { id } = params`.
+*/
+function isEchoBinding(name, body) {
+	for (const declaration of body.getDescendantsOfKind(SyntaxKind.VariableDeclaration)) {
+		const binding = declaration.getNameNode();
+		if (!Node.isObjectBindingPattern(binding)) continue;
+		if (!binding.getElements().some((element) => element.getName() === name)) continue;
+		const initializer = unwrap$1(declaration.getInitializer());
+		if (!initializer) continue;
+		if (Node.isIdentifier(initializer) && /^(params|request)$/.test(initializer.getText())) return true;
+		if (Node.isCallExpression(initializer)) {
+			const callee = initializer.getExpression();
+			if (Node.isPropertyAccessExpression(callee) && ECHOES_INPUT.has(callee.getName())) return true;
+		}
+	}
+	return false;
 }
+const isRequestLike = (node) => lastSegmentOf(node) === "request";
 //#endregion
 //#region src/inventory/graph/call_graph.ts
 /**
@@ -1271,7 +2105,7 @@ function validatorFieldsIn(body, file, app) {
 		* validator and is usually not exported, so looking for it where the call site
 		* is finds nothing — which is how five fields stayed invisible.
 		*/
-		const { leaves, opaque: unreadable } = leavesOf(declaration, (ref) => findValidator(ref, declaration.getSourceFile(), app));
+		const { leaves, opaque: unreadable } = leavesOf$1(declaration, (ref) => findValidator(ref, declaration.getSourceFile(), app));
 		const isOpaque = new Set(unreadable);
 		for (const leaf of leaves) {
 			const field = `${name}.${leaf}`;
@@ -1414,7 +2248,7 @@ function calleeOwner(call) {
 	const owner = callee.getExpression();
 	return Node.isPropertyAccessExpression(owner) ? owner.getName() : void 0;
 }
-function leavesOf(node, resolveRef) {
+function leavesOf$1(node, resolveRef) {
 	const object = node.getFirstDescendantByKind(SyntaxKind.ObjectLiteralExpression);
 	if (!object) return {
 		leaves: [],
@@ -1607,9 +2441,10 @@ function createAnalyzer(app, stores, options = {}) {
 		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,
@@ -1652,10 +2487,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 +2549,7 @@ function createAnalyzer(app, stores, options = {}) {
 					by: resolved.by,
 					technical
 				});
-				followedCalls.add(call);
+				followedCalls.set(call, resolved.refs);
 				continue;
 			}
 			if (isWorthReporting(call, symbols, imports) && !isNoise(call, owner)) unresolved.push({
@@ -1723,12 +2563,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 +2585,7 @@ function createAnalyzer(app, stores, options = {}) {
 			opaqueOutputs: output.opaqueOutputs,
 			transformed: output.resource,
 			reads,
+			deliveries,
 			bodyHash: hashOf(body)
 		};
 	}
@@ -1835,18 +2685,137 @@ function createAnalyzer(app, stores, options = {}) {
 		const touches = /* @__PURE__ */ new Set();
 		const writtenStores = /* @__PURE__ */ new Set();
 		const inputFields = /* @__PURE__ */ new Set();
+		const commandFields = /* @__PURE__ */ new Set();
 		const opaqueInputFields = /* @__PURE__ */ new Set();
 		const requestFields = /* @__PURE__ */ new Set();
 		let opaqueRequest = false;
 		const outputFields = /* @__PURE__ */ new Set();
 		const opaqueOutputFields = /* @__PURE__ */ new Set();
 		const transformedStores = /* @__PURE__ */ new Set();
+		const deliveredFields = /* @__PURE__ */ new Set();
+		const deliveredOpaque = /* @__PURE__ */ new Set();
+		const deliveredStores = /* @__PURE__ */ new Set();
+		let anyDelivery = false;
 		const outputReads = /* @__PURE__ */ new Map();
 		const trace = [];
 		const scope = [];
 		const unresolved = [];
 		const visited = /* @__PURE__ */ new Set();
 		let writes = false;
+		/** what a followed body reads, itself and through what it follows — bounded like the walk */
+		const storesReadBy = (ref, depth, seen = /* @__PURE__ */ new Set()) => {
+			const found = /* @__PURE__ */ new Set();
+			const key = `${ref.file}#${ref.member ?? ref.line ?? "*"}`;
+			if (seen.has(key) || depth > maxDepth) return found;
+			seen.add(key);
+			const facts = factsFor(ref);
+			if (!facts) return found;
+			for (const access of facts.accesses) found.add(access.store);
+			for (const followUp of facts.followUps) for (const store of storesReadBy(followUp.ref, depth + 1, seen)) found.add(store);
+			return found;
+		};
+		/**
+		* A delivered call hands on what its body RETURNS — classified, so a returned
+		* `{ data: rows, meta }` delivers the rows' store and the meta's leaves, not
+		* one DET per key. `pick` keeps one key of it: `const { data } = …`,
+		* `resultado.linhas`. Bounded by depth like the walk, and by a seen set so a
+		* body returning itself cannot loop.
+		*/
+		const deliver = (item, depth, seen = /* @__PURE__ */ new Set()) => {
+			switch (item.kind) {
+				case "store":
+					deliveredStores.add(item.store);
+					return;
+				case "scalar":
+					deliveredFields.add(item.path || "<value>");
+					return;
+				case "echo": return;
+				case "opaque":
+					deliveredOpaque.add(`${item.path ? `${item.path}.` : ""}<${item.expression}>`);
+					return;
+				case "call": {
+					if (depth > maxDepth + 2) return;
+					let resolved = false;
+					for (const ref of item.refs) {
+						const key = `${ref.file}#${ref.member ?? ref.line ?? "*"}#${item.pick ?? ""}#${item.path}`;
+						if (seen.has(key)) continue;
+						seen.add(key);
+						const facts = factsFor(ref);
+						if (!facts) continue;
+						if (facts.outputs.length > 0 || facts.transformed) {
+							resolved = true;
+							continue;
+						}
+						const returned = facts.deliveries.returns.filter((r) => !item.pick || r.path === item.pick || r.path.startsWith(`${item.pick}.`));
+						/**
+						* `egresso.curso` where the body returns the row itself (`return
+						* Egresso.query()…first()`, path ''): the pick lands INSIDE a returned
+						* value — one field of a store is one value; one key of a returned call
+						* is that call picked deeper.
+						*/
+						if (item.pick && returned.length === 0) {
+							const above = facts.deliveries.returns.filter((r) => r.path === "" || item.pick.startsWith(`${r.path}.`));
+							for (const r of above) {
+								const rest = r.path ? item.pick.slice(r.path.length + 1) : item.pick;
+								if (r.kind === "call") deliver({
+									...r,
+									path: item.path,
+									pick: rest
+								}, depth + 1, seen);
+								else if (r.kind === "store" || r.kind === "scalar") deliveredFields.add(item.path || "<value>");
+							}
+							if (above.length > 0) {
+								resolved = true;
+								continue;
+							}
+						}
+						/**
+						* A return the classifier could not read at all (`rows.map(…).join(…)`)
+						* says nothing about what leaves; what the body read, or what was handed
+						* into it, says more — so it does not count as resolved.
+						*/
+						if (returned.length > 0 && returned.some((r) => r.kind !== "opaque")) {
+							for (const r of returned) {
+								const rest = item.pick ? r.path.slice(item.pick.length).replace(/^\./, "") : r.path;
+								const path = [item.path, rest].filter(Boolean).join(".");
+								deliver({
+									...r,
+									path
+								}, depth + 1, seen);
+							}
+							resolved = true;
+							continue;
+						}
+						if (item.pick) continue;
+						const read = storesReadBy(ref, depth + 1);
+						if (read.size > 0) {
+							for (const store of read) deliveredStores.add(store);
+							resolved = true;
+						}
+					}
+					if (resolved) return;
+					/**
+					* `const { confidenciais } = await this.contar()` where the body's return
+					* is unreadable: one KEY of it, named — one value, not an opaque floor.
+					* Only a key that carries rows on (`data`, `rows`) stays unreadable.
+					*/
+					if (item.pick && !PASSES_ROWS.has(item.pick.split(".")[0])) {
+						deliveredFields.add(item.path || "<value>");
+						return;
+					}
+					/**
+					* The body returned no literal and read no store — a CSV builder, a
+					* formatter over rows handed in. The document it built carries what it
+					* received, so the rows' stores leave. Nothing handed in: opaque.
+					*/
+					if (item.args.length > 0) {
+						for (const argument of item.args) deliver(argument, depth, seen);
+						return;
+					}
+					deliveredOpaque.add(`${item.path ? `${item.path}.` : ""}<${item.expression}>`);
+				}
+			}
+		};
 		const visit = (ref, depth, technical = false) => {
 			const key = `${ref.file}#${ref.member ?? ref.line ?? "*"}`;
 			if (visited.has(key) || depth > maxDepth) return;
@@ -1885,12 +2854,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,
@@ -1931,12 +2908,19 @@ function createAnalyzer(app, stores, options = {}) {
 			touches: [...touches].sort(),
 			writtenStores: [...writtenStores].sort(),
 			inputFields: [...inputFields].sort(),
+			commandFields: [...commandFields].sort(),
 			opaqueInputFields: [...opaqueInputFields].sort(),
 			requestFields: [...requestFields].sort(),
 			opaqueRequest,
 			outputFields: [...outputFields].sort(),
 			opaqueOutputFields: [...opaqueOutputFields].sort(),
 			transformedStores: [...transformedStores].sort(),
+			delivered: {
+				any: anyDelivery,
+				fields: [...deliveredFields].sort(),
+				opaqueFields: [...deliveredOpaque].sort(),
+				stores: [...deliveredStores].sort()
+			},
 			outputReads: Object.fromEntries([...outputReads.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([store, read]) => [store, {
 				whole: read.whole,
 				selected: [...read.selected].sort(),
@@ -1969,6 +2953,8 @@ function findBody(file, ref) {
 		}
 		const fn = file.getFunction(ref.member);
 		if (fn) return fn;
+		const initializer = file.getVariableDeclaration(ref.member)?.getInitializer();
+		if (initializer && (Node.isArrowFunction(initializer) || Node.isFunctionExpression(initializer))) return initializer;
 		return null;
 	}
 	for (const cls of file.getClasses()) {
@@ -1997,6 +2983,27 @@ function storeSymbolsFor(body, file, app, stores) {
 			if (stores.has(named.getName())) symbols.set(binding, named.getName());
 		}
 	}
+	/**
+	* `const { default: Noticia } = await import('#noticias/models/noticia')`: a
+	* model imported INSIDE the body — an ace command does this to keep the app
+	* from booting for `--help`. The store is the same; only the binding moved.
+	*/
+	const storeByFile = /* @__PURE__ */ new Map();
+	for (const [name, store] of stores) storeByFile.set(toPosix(store.provenance.file), name);
+	for (const declaration of body.getDescendantsOfKind(SyntaxKind.VariableDeclaration)) {
+		const binding = declaration.getNameNode();
+		if (!Node.isObjectBindingPattern(binding)) continue;
+		let initializer = declaration.getInitializer();
+		if (initializer && Node.isAwaitExpression(initializer)) initializer = initializer.getExpression();
+		if (!initializer || !Node.isCallExpression(initializer)) continue;
+		if (initializer.getExpression().getKind() !== SyntaxKind.ImportKeyword) continue;
+		const specifier = initializer.getArguments()[0];
+		if (!specifier || !Node.isStringLiteral(specifier)) continue;
+		const target = app.resolveSpecifier(specifier.getLiteralValue());
+		const store = target ? storeByFile.get(toPosix(target)) : void 0;
+		if (!store) continue;
+		for (const element of binding.getElements()) if ((element.getPropertyNameNode()?.getText() ?? element.getName()) === "default") symbols.set(element.getName(), store);
+	}
 	for (const declaration of body.getDescendantsOfKind(SyntaxKind.VariableDeclaration)) {
 		const initializer = declaration.getInitializer();
 		const name = declaration.getNameNode();
@@ -2162,6 +3169,32 @@ function importMapsOf(file, app) {
 			if (alias) exportedAs.set(alias, named.getName());
 		}
 	}
+	/**
+	* `const { default: SincronizarBulk } = await import('#inpi/actions/sincronizar_bulk')`
+	* `const { execucaoEmAndamento } = await import('#inpi/services/execucao')`
+	*
+	* A module imported INSIDE a body — the shape ace commands use so `--help` does
+	* not boot the application. The binding moved; the body it names did not, and
+	* a command importing its whole action layer this way reached nothing.
+	*/
+	for (const declaration of file.getDescendantsOfKind(SyntaxKind.VariableDeclaration)) {
+		const binding = declaration.getNameNode();
+		if (!Node.isObjectBindingPattern(binding)) continue;
+		let initializer = declaration.getInitializer();
+		if (initializer && Node.isAwaitExpression(initializer)) initializer = initializer.getExpression();
+		if (!initializer || !Node.isCallExpression(initializer)) continue;
+		if (initializer.getExpression().getKind() !== SyntaxKind.ImportKeyword) continue;
+		const specifier = initializer.getArguments()[0];
+		if (!specifier || !Node.isStringLiteral(specifier)) continue;
+		const target = app.resolveSpecifier(specifier.getLiteralValue());
+		if (!target) continue;
+		for (const element of binding.getElements()) {
+			const exported = element.getPropertyNameNode()?.getText() ?? element.getName();
+			const local = element.getName();
+			imports.set(local, target);
+			if (exported !== "default" && exported !== local) exportedAs.set(local, exported);
+		}
+	}
 	return {
 		imports,
 		exportedAs
@@ -2215,6 +3248,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 +3938,7 @@ function detsFor(entry, behavior, touched, type, options) {
 		counted.add(field);
 		sources.push(source);
 	};
-	for (const param of entry.signature.match(/:[A-Za-z_][\w]*/g) ?? []) add(param.slice(1), `param:${param}`);
+	if (entry.kind === "http") for (const param of entry.signature.match(/:[A-Za-z_][\w]*/g) ?? []) add(param.slice(1), `param:${param}`);
 	/**
 	* `(opaque)` is not decoration: `detFromSchema` replaces the opaque placeholder
 	* with a schema's fields, and it used to assume there was exactly one and that
@@ -2777,6 +3958,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 +3998,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;
@@ -2926,12 +4138,16 @@ 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.
 *
 * 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.6.0";
 function count(input, options = {}) {
 	const warnings = [];
 	const usage = usageOf(input);
@@ -3013,7 +4229,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 +4264,9 @@ 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(...lookAlikeWarnings(functions));
 	warnings.push(...seededOnlyWarnings(functions, grouping.members, input.seededAnywhere));
 	return {
@@ -3058,6 +4278,67 @@ 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`] : []
+	];
+}
+/**
+* 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 +4660,9 @@ var CoverageTooLowError = class extends Error {
 async function analyze(root, options = {}) {
 	const app = await discoverApp(root);
 	const { stores, unresolved: storeProblems } = await collectDataStores(app);
-	const { entryPoints, unresolved: routeProblems } = await collectEntryPoints(app);
+	const routes = await collectEntryPoints(app);
+	const routeProblems = routes.unresolved;
+	const entryPoints = [...routes.entryPoints, ...collectCommands(app)];
 	/** only read when an override names one — but collected once, like everything else */
 	const jsonSchemas = collectJsonSchemas(app);
 	const analyzer = createAnalyzer(app, stores, {
@@ -3461,6 +4744,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 +4767,7 @@ async function analyze(root, options = {}) {
 				}
 			})),
 			transformedStores: behavior.transformedStores,
+			delivered: behavior.delivered,
 			outputReads: behavior.outputReads,
 			trace: behavior.trace.map((step) => ({
 				...step,
@@ -3505,6 +4796,7 @@ async function analyze(root, options = {}) {
 				entryPoints,
 				behaviors,
 				jsonSchemas,
+				jobs: collectJobs(app),
 				writtenAnywhere: analyzer.writtenAnywhere(),
 				addressedAnywhere: analyzer.addressedAnywhere(),
 				seededAnywhere: analyzer.seededAnywhere()