@filipebraida/adonis-function-points 0.7.0 → 0.9.0

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

@@ -1,10 +1,10 @@
-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 { _ 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-CneCj3sT.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([
@@ -969,7 +969,7 @@ const problemAt = (call, expression, reason) => ({
 /**
 * Ace commands as entry points — counting-decisions §5, plan 0.7 §C.
 *
-* IFPUG counts batch processes an operator starts. `node ace noticias:importar`
+* IFPUG counts batch processes an operator starts. `node ace articles:import`
 * 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.
@@ -1036,7 +1036,7 @@ function baseCommandNameIn(file) {
 	}
 	return null;
 }
-/** `static commandName = 'noticias:importar'` — a literal; a computed name is nobody's identity */
+/** `static commandName = 'articles:import'` — a literal; a computed name is nobody's identity */
 function commandNameOf(cls) {
 	const property = cls.getStaticProperty("commandName");
 	if (!property || !Node.isPropertyDeclaration(property)) return null;
@@ -1190,7 +1190,8 @@ const FRAMEWORK_SERVICES = new Set([
 	"bouncer",
 	"ui",
 	"colors",
-	"app"
+	"app",
+	"prompt"
 ]);
 /** Is this call one that cannot reach a data store? */
 function isNoise(call, owner) {
@@ -1288,22 +1289,24 @@ const PRINTERS = new Set([
 	"console"
 ]);
 /** `x.data`, `x.rows` on a paginated / wrapped result hand the collection on */
-const PASSES_THROUGH = new Set([
+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 */
+/**
+* Keys under which a paginator or a wrapper hands its rows on: picking one of these
+* is not picking one value. Framework and JavaScript conventions only — a key named
+* in one application's language is that application's, not a rule.
+*/
 const PASSES_ROWS = new Set([
 	"data",
 	"rows",
 	"items",
 	"results",
-	"list",
-	"linhas",
-	"itens"
+	"records"
 ]);
 /** properties of a result that are one value, not its rows */
 const SCALAR_PROPS = new Set([
@@ -1436,8 +1439,15 @@ function deliveriesIn(ctx) {
 		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];
+		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);
@@ -1447,7 +1457,9 @@ function deliveriesIn(ctx) {
 		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;
@@ -1530,14 +1542,14 @@ function classify(value, path, ctx, out, depth) {
 	*/
 	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);
+		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(path, name), ctx, out, depth + 1);
+			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(path, property.getName?.() ?? "*")
+			path: join$1(path, property.getName?.() ?? "*")
 		});
 		return;
 	}
@@ -1649,7 +1661,7 @@ function classifyCall(value, path, ctx, out, depth, pick) {
 			classifyMapped(value, callee.getExpression(), path, ctx, out, depth);
 			return;
 		}
-		if (Node.isPropertyAccessExpression(callee) && PASSES_THROUGH.has(method) && value.getArguments().length === 0) {
+		if (Node.isPropertyAccessExpression(callee) && PASSES_THROUGH$1.has(method) && value.getArguments().length === 0) {
 			classify(unwrap$1(callee.getExpression()), path, ctx, out, depth + 1);
 			return;
 		}
@@ -1660,7 +1672,7 @@ function classifyCall(value, path, ctx, out, depth, pick) {
 			});
 			else for (const key of PAGINATOR_META) out.push({
 				kind: "scalar",
-				path: join(path, key)
+				path: join$1(path, key)
 			});
 			return;
 		}
@@ -1754,10 +1766,15 @@ function classifyCall(value, path, ctx, out, depth, pick) {
 		if (Node.isPropertyAccessExpression(callee)) {
 			const root = chainRootOf(callee.getExpression());
 			if (root && ctx.symbols.has(root)) {
-				out.push({
+				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") {
@@ -1776,7 +1793,7 @@ function classifyCall(value, path, ctx, out, depth, pick) {
 		/**
 		* `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
+		* and the body itself says nothing. `article.publicadaEm?.toISO()` on that
 		* parameter is one FIELD of it, and stays one value below.
 		*/
 		if (Node.isPropertyAccessExpression(callee) && transformsParameter(callee, ctx.body)) {
@@ -1789,7 +1806,7 @@ function classifyCall(value, path, ctx, out, depth, pick) {
 		}
 		if (Node.isPropertyAccessExpression(callee)) {
 			/**
-			* `comunicado.enviadoEm!.toISODate()`, `(a ?? b).toRFC2822()`: a FIELD read off
+			* `notice.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.
 			*/
@@ -1824,7 +1841,7 @@ function classifyCall(value, path, ctx, out, depth, pick) {
 }
 /**
 * `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
+* once — a function passed by reference (`rows.map(toRow)`) 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.
 */
@@ -1863,7 +1880,7 @@ function callbackValueOf(callback) {
 }
 /**
 * 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()`
+* the method is applied? `notice.enviadoEm.toISO()` does; `rows.map(f).join()`
 * does not; a chain rooted at `this` is a service, and does not.
 */
 function readsField(node) {
@@ -1892,7 +1909,7 @@ function readsField(node) {
 }
 /**
 * 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()`
+* with no field read in between? `rows.map(f).join(s)` is; `article.capa?.toISO()`
 * reads a field first and is not.
 */
 function transformsParameter(callee, body) {
@@ -1942,7 +1959,7 @@ function returnsPrimitive(call) {
 	}
 }
 /**
-* `x.data`, `resultado.linhas`, `rows[0]`: a part of a value the body holds.
+* `x.data`, `result.rows`, `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)
@@ -1957,7 +1974,7 @@ function classifyAccess(value, path, ctx, out, depth) {
 	*/
 	const property = Node.isPropertyAccessExpression(value) ? value.getName() : keyOfElementAccess(value);
 	if (root && ctx.symbols.has(root)) {
-		if (!property || PASSES_THROUGH.has(property)) out.push({
+		if (!property || PASSES_THROUGH$1.has(property)) out.push({
 			kind: "store",
 			store: ctx.symbols.get(root),
 			path
@@ -1979,10 +1996,10 @@ function classifyAccess(value, path, ctx, out, depth) {
 				return;
 			}
 			/**
-			* `resultado.linhas`: one key of what the call returns; `meta.pagina` on a
+			* `result.rows`: 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 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({
@@ -2020,7 +2037,7 @@ function keyOfElementAccess(value) {
 	if (Node.isStringLiteral(argument) || Node.isNoSubstitutionTemplateLiteral(argument)) return argument.getLiteralValue();
 	return "*";
 }
-const join = (prefix, name) => prefix ? `${prefix}.${name}` : name;
+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);
@@ -2073,6 +2090,518 @@ function isEchoBinding(name, body) {
 }
 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), or any
+* `pages/` directory under the root holding that path — a module-scoped one included. 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();
+	/**
+	* `orders/show` → `<…>/orders/<…>/pages/show.tsx`: a front-end that keeps one `pages/`
+	* directory per module names the module in the page name's first segment. Read
+	* structurally — a `pages/` directory whose path carries that segment — never as a
+	* fixed layout: the default is `inertia/pages/<name>`, and anything else is one
+	* application's convention.
+	*/
+	const [first, ...rest] = page.split("/");
+	for (const dir of pagesDirectories(root)) {
+		const scopedToModule = rest.length > 0 && toPosix(dir).split("/").includes(first);
+		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);
+			if (scopedToModule) {
+				const scoped = join(dir, `${rest.join("/")}${extension}`);
+				if (existsSync(scoped)) found.add(scoped);
+			}
+		}
+	}
+	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.
@@ -2427,16 +2956,236 @@ 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;
+		};
+		/**
+		* `order.pendingItems({ client })`: a method declared on the model class, returning
+		* `Item.query()…`. The model file is application code, and the method's annotation
+		* (`typeof Item` names the store) or its returns say what it hands back (plan 0.9 §B).
+		*/
+		const modelMethodStore = (callee, scope) => {
+			const root = rootSymbolOf(callee.getExpression());
+			const store = root ? scope.get(root) : void 0;
+			if (!store) return null;
+			const declared = storesByName.get(store);
+			const method = (declared ? sourceFile(declared.provenance.file) : null)?.getClasses().flatMap((c) => c.getMethods()).find((m) => m.getName() === callee.getName());
+			if (!method) return null;
+			const annotation = method.getReturnTypeNode()?.getText();
+			if (annotation) {
+				const named = annotation.match(/typeof\s+([A-Za-z_]\w*)/)?.[1];
+				return storeNamedBy(named ?? annotation, storesByName);
+			}
+			const found = /* @__PURE__ */ new Set();
+			for (const statement of method.getDescendantsOfKind(SyntaxKind.ReturnStatement)) {
+				const value = statement.getExpression();
+				if (!value) return null;
+				const returnedRoot = rootSymbolOf(unwrapAwait(value));
+				if (returnedRoot && storesByName.has(returnedRoot)) found.add(returnedRoot);
+				else return null;
+			}
+			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 callee = node.getExpression();
+				if (Node.isPropertyAccessExpression(callee)) {
+					/**
+					* `q.forUpdate()`, `q.where(…)`: a query-builder chain hands the same rows on —
+					* read from the innermost call outwards, so a model's method at the root of
+					* the chain is seen before Lucid's API is assumed for the whole chain. An
+					* aggregate (`.count()`) hands back a number.
+					*/
+					const receiver = unwrapAwait(callee.getExpression());
+					if (Node.isCallExpression(receiver)) {
+						if (AGGREGATES.has(callee.getName())) return null;
+						const inner = storeOfValue(receiver, depth + 1);
+						if (inner) return inner;
+					}
+					const fromModel = modelMethodStore(callee, symbols);
+					if (fromModel) return fromModel;
+				}
+				const access = detectAccess(node, symbols, relationsByStore);
+				if (access) return access.method === "related" && access.viaRelation ? access.viaRelation : access.store;
+				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)) {
+					/**
+					* Re-read even when the parameter pass already bound the name by the chain's
+					* root: `const items = await order.pendingItems().forUpdate()` is rooted at
+					* `order` and holds `Item` rows — what the model's method returns wins over
+					* where the chain started.
+					*/
+					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)) 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)) 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 = [];
@@ -2457,6 +3206,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) {
@@ -2481,8 +3231,8 @@ function createAnalyzer(app, stores, options = {}) {
 				* A select list that is not literal is reported, and the store falls back
 				* to every column, which overestimates in the open.
 				*
-				* `related('itens').query().count()` reads the RELATION target, and the
-				* parent only as a receiver; `preload('itens')` reads the target whole.
+				* `related('items').query().count()` reads the RELATION target, and the
+				* parent only as a receiver; `preload('items')` reads the target whole.
 				*/
 				if (access.mode === "read") {
 					const chain = chainShapeOf(call);
@@ -2552,6 +3302,21 @@ function createAnalyzer(app, stores, options = {}) {
 				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({
 				file: ref.file,
 				line: call.getStartLineNumber(),
@@ -2608,7 +3373,7 @@ function createAnalyzer(app, stores, options = {}) {
 	* Both project-wide facts come from one pass, computed once: which stores the
 	* application WRITES (maintenance, §6.5.4) and which it ADDRESSES directly
 	* (grouping, counting-decisions §10). A store reached only through a relation
-	* — `preload('itens')`, `related('itens').create()` — is read or written, but
+	* — `preload('items')`, `related('items').create()` — is read or written, but
 	* not addressed: the user never sees it outside its parent.
 	*/
 	let projectWide;
@@ -2631,7 +3396,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;
@@ -2641,7 +3406,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);
@@ -2695,6 +3460,8 @@ function createAnalyzer(app, stores, options = {}) {
 		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 = [];
@@ -2725,6 +3492,11 @@ function createAnalyzer(app, stores, options = {}) {
 			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>");
@@ -2748,8 +3520,8 @@ function createAnalyzer(app, stores, options = {}) {
 						}
 						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
+						* `member.curso` where the body returns the row itself (`return
+						* Member.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.
 						*/
@@ -2760,7 +3532,8 @@ function createAnalyzer(app, stores, options = {}) {
 								if (r.kind === "call") deliver({
 									...r,
 									path: item.path,
-									pick: rest
+									pick: rest,
+									via: item.via
 								}, depth + 1, seen);
 								else if (r.kind === "store" || r.kind === "scalar") deliveredFields.add(item.path || "<value>");
 							}
@@ -2780,7 +3553,8 @@ function createAnalyzer(app, stores, options = {}) {
 								const path = [item.path, rest].filter(Boolean).join(".");
 								deliver({
 									...r,
-									path
+									path,
+									via: item.via
 								}, depth + 1, seen);
 							}
 							resolved = true;
@@ -2789,7 +3563,14 @@ function createAnalyzer(app, stores, options = {}) {
 						if (item.pick) continue;
 						const read = storesReadBy(ref, depth + 1);
 						if (read.size > 0) {
-							for (const store of read) deliveredStores.add(store);
+							for (const store of read) {
+								deliveredStores.add(store);
+								if (item.via) rawDeliveries.push({
+									...item.via,
+									store,
+									path: item.path
+								});
+							}
 							resolved = true;
 						}
 					}
@@ -2809,7 +3590,10 @@ function createAnalyzer(app, stores, options = {}) {
 					* 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);
+						for (const argument of item.args) deliver({
+							...argument,
+							via: item.via
+						}, depth, seen);
 						return;
 					}
 					deliveredOpaque.add(`${item.path ? `${item.path}.` : ""}<${item.expression}>`);
@@ -2903,6 +3687,18 @@ 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(),
@@ -2921,6 +3717,8 @@ function createAnalyzer(app, stores, options = {}) {
 				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(),
@@ -2972,7 +3770,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;
@@ -2984,7 +3782,7 @@ function storeSymbolsFor(body, file, app, stores) {
 		}
 	}
 	/**
-	* `const { default: Noticia } = await import('#noticias/models/noticia')`: a
+	* `const { default: Article } = await import('#articles/models/article')`: 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.
 	*/
@@ -3007,7 +3805,24 @@ function storeSymbolsFor(body, file, app, stores) {
 	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);
@@ -3015,8 +3830,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;
 		}
@@ -3027,32 +3842,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 { order } = input` where `input.order` 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;
 }
 /**
@@ -3116,6 +3955,78 @@ 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"
+]);
+/** query-builder terminals that hand back one number or one yes/no, never rows */
+const AGGREGATES = new Set([
+	"count",
+	"sum",
+	"avg",
+	"min",
+	"max",
+	"exists",
+	"pojo",
+	"pluck"
+]);
+/** 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) => {
@@ -3170,8 +4081,8 @@ function importMapsOf(file, app) {
 		}
 	}
 	/**
-	* `const { default: SincronizarBulk } = await import('#inpi/actions/sincronizar_bulk')`
-	* `const { execucaoEmAndamento } = await import('#inpi/services/execucao')`
+	* `const { default: SyncCatalog } = await import('#catalog/actions/sync_catalog')`
+	* `const { runInProgress } = await import('#catalog/services/runs')`
 	*
 	* 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
@@ -3230,6 +4141,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;
@@ -4051,6 +5033,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)}`);
@@ -4141,13 +5136,19 @@ const RULESET = "afp";
 * 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.
+* 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. Two in 1.8.0: a method the model
+* declares names the store its caller writes, and a listener written inline on a
+* string event is followed like a listener class.
 *
 * 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.6.0";
+const RULESET_VERSION = "1.8.0";
 function count(input, options = {}) {
 	const warnings = [];
 	const usage = usageOf(input);
@@ -4267,6 +5268,7 @@ function count(input, options = {}) {
 	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 {
@@ -4299,6 +5301,27 @@ function unreadableDeliveryWarnings(input) {
 	];
 }
 /**
+* 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
@@ -4582,20 +5605,32 @@ function totalsOf(functions) {
 * reader must see that without having to go looking.
 */
 function confidenceOf(input, warnings) {
-	let unresolvedCalls = 0;
 	let withoutHandler = 0;
+	const sites = /* @__PURE__ */ new Map();
+	for (const site of input.unresolved ?? []) sites.set(`${site.file}:${site.line}:${site.expression}`, { ...site });
 	for (const entry of input.entryPoints) {
 		const behavior = input.behaviors.get(entry.id);
 		if (!behavior) {
 			withoutHandler++;
 			continue;
 		}
-		unresolvedCalls += behavior.unresolved.length;
+		if (input.unresolved) continue;
+		for (const call of behavior.unresolved) {
+			const key = `${call.file}:${call.line}:${call.expression}`;
+			const site = sites.get(key);
+			if (site) site.transactions++;
+			else sites.set(key, {
+				...call,
+				transactions: 1
+			});
+		}
 	}
+	const unresolved = [...sites.values()].sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line);
 	return {
-		unresolvedCalls,
+		unresolvedCalls: unresolved.length,
 		entryPointsWithoutHandler: withoutHandler,
-		warnings
+		warnings,
+		unresolved
 	};
 }
 //#endregion
@@ -4672,7 +5707,27 @@ async function analyze(root, options = {}) {
 	});
 	const behaviors = new Map(entryPoints.filter((entry) => entry.handler).map((entry) => [entry.id, analyzer.analyze(entry.handler)]));
 	const resolved = [...behaviors.values()].filter((behavior) => behavior.unresolved.length === 0).length;
-	const unresolvedCalls = storeProblems.length + routeProblems.length + [...behaviors.values()].reduce((total, behavior) => total + behavior.unresolved.length, 0);
+	/**
+	* One site, however many transactions reach it: a body five routes walk is one gap
+	* to close, not five. The count shows the same number — a reviewing team found 10
+	* in one report and 13 in the other and could act on neither.
+	*/
+	const sites = /* @__PURE__ */ new Map();
+	for (const problem of [...storeProblems, ...routeProblems]) sites.set(`${problem.file}:${problem.line}:${problem.expression}`, {
+		...problem,
+		transactions: 0
+	});
+	for (const behavior of behaviors.values()) for (const call of behavior.unresolved) {
+		const key = `${call.file}:${call.line}:${call.expression}`;
+		const site = sites.get(key);
+		if (site) site.transactions++;
+		else sites.set(key, {
+			...call,
+			transactions: 1
+		});
+	}
+	const unresolvedSites = [...sites.values()].sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line);
+	const unresolvedCalls = unresolvedSites.length;
 	/**
 	* Every path that LEAVES is relative to the application root.
 	*
@@ -4768,6 +5823,8 @@ 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,
@@ -4783,7 +5840,11 @@ async function analyze(root, options = {}) {
 			entryPointsResolved: resolved,
 			unresolvedCalls,
 			ratio: entryPoints.length === 0 ? 1 : resolved / entryPoints.length
-		}
+		},
+		unresolved: unresolvedSites.map((site) => ({
+			...site,
+			file: emit(site.file)
+		}))
 	};
 	const minimum = options.minCoverage ?? 0;
 	if (inventory.coverage.ratio < minimum) throw new CoverageTooLowError(inventory.coverage.ratio, minimum);
@@ -4797,6 +5858,7 @@ async function analyze(root, options = {}) {
 				behaviors,
 				jsonSchemas,
 				jobs: collectJobs(app),
+				unresolved: inventory.unresolved,
 				writtenAnywhere: analyzer.writtenAnywhere(),
 				addressedAnywhere: analyzer.addressedAnywhere(),
 				seededAnywhere: analyzer.seededAnywhere()