@filipebraida/adonis-function-points 0.6.0 → 0.8.0

package/build/{resolvers-DlKJOZnk.js → resolvers-DhJO-qvQ.js}

@@ -83,129 +83,6 @@ function isApplicationCode(root, file) {
 	return !parts.slice(0, -1).some((segment) => SCAFFOLDING.has(segment));
 }
 //#endregion
-//#region src/inventory/sources/event_bindings.ts
-/** the method a listener declares; AdonisJS calls `handle` unless told otherwise */
-const LISTENER_METHOD = "handle";
-function collectEventBindings(app) {
-	const project = new Project({
-		skipAddingFilesFromTsConfig: true,
-		skipFileDependencyResolution: true,
-		compilerOptions: { allowJs: false }
-	});
-	for (const root of app.scanRoots) project.addSourceFilesAtPaths(`${root}/**/*.ts`);
-	const bindings = /* @__PURE__ */ new Map();
-	for (const file of project.getSourceFiles()) for (const call of file.getDescendantsOfKind(SyntaxKind.CallExpression)) {
-		const expression = call.getExpression();
-		if (!Node.isPropertyAccessExpression(expression)) continue;
-		if (expression.getName() !== "on") continue;
-		const [event, handlers] = call.getArguments();
-		if (!event || !handlers) continue;
-		const eventFile = resolveEventClass(event, file, app);
-		if (!eventFile) continue;
-		const refs = listenersOf(handlers, file, app);
-		if (refs.length === 0) continue;
-		bindings.set(eventFile, [...bindings.get(eventFile) ?? [], ...refs]);
-	}
-	return bindings;
-}
-/**
-* The event class a dispatch or a binding names.
-*
-* Two shapes reach here: the class imported directly, and the generated
-* registry (`events.OrderPlaced`), which is what `node ace make:event` produces
-* and therefore the common one. Exported because the resolver has to ask the
-* same question of a call site, and two implementations of "which event is
-* this" would drift.
-*/
-function resolveEventClass(expression, from, app) {
-	if (Node.isIdentifier(expression)) {
-		const target = importedFrom(expression.getText(), from, app);
-		return target ? toPosix(target) : null;
-	}
-	if (!Node.isPropertyAccessExpression(expression)) return null;
-	const root = expression.getExpression();
-	if (!Node.isIdentifier(root)) return null;
-	const registry = importedFrom(root.getText(), from, app);
-	if (!registry) return null;
-	return registryEntry(registry, expression.getName(), from.getProject(), app);
-}
-/** listener bodies named by the second argument of `emitter.on` */
-function listenersOf(handlers, from, app) {
-	const entries = handlers.isKind(SyntaxKind.ArrayLiteralExpression) ? handlers.getElements() : [handlers];
-	const refs = [];
-	for (const entry of entries) {
-		/**
-		* `[SomeListener, 'method']`: AdonisJS lets the binding name the method,
-		* and taking `handle` on faith there would look for a body that is not
-		* the one bound.
-		*/
-		if (entry.isKind(SyntaxKind.ArrayLiteralExpression)) {
-			const [target, member] = entry.getElements();
-			const file = target ? listenerFile(target, from, app) : null;
-			if (!file) continue;
-			const named = member?.asKind(SyntaxKind.StringLiteral)?.getLiteralValue();
-			refs.push({
-				file,
-				member: named ?? LISTENER_METHOD
-			});
-			continue;
-		}
-		const file = listenerFile(entry, from, app);
-		if (file) refs.push({
-			file,
-			member: LISTENER_METHOD
-		});
-	}
-	return refs;
-}
-function listenerFile(entry, from, app) {
-	if (Node.isPropertyAccessExpression(entry)) {
-		const root = entry.getExpression();
-		if (!Node.isIdentifier(root)) return null;
-		const registry = importedFrom(root.getText(), from, app);
-		return registry ? registryEntry(registry, entry.getName(), from.getProject(), app) : null;
-	}
-	if (Node.isIdentifier(entry)) {
-		const target = importedFrom(entry.getText(), from, app);
-		return target ? toPosix(target) : null;
-	}
-	return null;
-}
-/** where a local identifier was imported from, resolved through the alias map */
-function importedFrom(local, from, app) {
-	for (const declaration of from.getImportDeclarations()) {
-		const named = declaration.getNamedImports().some((entry) => (entry.getAliasNode()?.getText() ?? entry.getName()) === local);
-		const isDefault = declaration.getDefaultImport()?.getText() === local;
-		if (!named && !isDefault) continue;
-		return app.resolveSpecifier(declaration.getModuleSpecifierValue());
-	}
-	return null;
-}
-/**
-* The file a key of a generated registry points at.
-*
-* Both shapes the generators emit are handled: a direct reference to an
-* imported class (`events.ts`) and a lazy importer (`listeners.ts`). They differ
-* per artefact and per framework version, and reading only one of them silently
-* lost half the graph.
-*/
-function registryEntry(registryFile, key, project, app) {
-	const file = project.getSourceFile(registryFile) ?? project.addSourceFileAtPathIfExists(registryFile);
-	if (!file) return null;
-	for (const declaration of file.getVariableDeclarations()) {
-		const value = ((declaration.getInitializer()?.asKind(SyntaxKind.ObjectLiteralExpression))?.getProperty(key)?.asKind(SyntaxKind.PropertyAssignment))?.getInitializer();
-		if (!value) continue;
-		if (Node.isIdentifier(value)) {
-			const target = importedFrom(value.getText(), file, app);
-			return target ? toPosix(target) : null;
-		}
-		const specifier = value.getFirstDescendantByKind(SyntaxKind.CallExpression)?.getArguments()[0]?.asKind(SyntaxKind.StringLiteral)?.getLiteralValue();
-		const target = specifier ? app.resolveSpecifier(specifier) : null;
-		return target ? toPosix(target) : null;
-	}
-	return null;
-}
-//#endregion
 //#region src/inventory/detectors/lucid.ts
 const WRITE_METHODS = new Set([
 	"save",
@@ -503,11 +380,149 @@ function classOfReceiver(receiver) {
 		return target.isKind(SyntaxKind.Identifier) ? target.getText() : null;
 	}
 	if (receiver.isKind(SyntaxKind.Identifier)) {
-		const init = (receiver.getSymbol()?.getDeclarations().find((d) => d.isKind(SyntaxKind.VariableDeclaration)))?.asKind(SyntaxKind.VariableDeclaration)?.getInitializer();
+		let init = (receiver.getSymbol()?.getDeclarations().find((d) => d.isKind(SyntaxKind.VariableDeclaration)))?.asKind(SyntaxKind.VariableDeclaration)?.getInitializer();
+		while (init?.isKind(SyntaxKind.AwaitExpression) || init?.isKind(SyntaxKind.ParenthesizedExpression)) init = init.getExpression();
 		if (init?.isKind(SyntaxKind.NewExpression)) {
 			const target = init.getExpression();
 			return target.isKind(SyntaxKind.Identifier) ? target.getText() : null;
 		}
+		/**
+		* `const svc = await app.container.make(IntakeService)`: the container hands
+		* back an instance of the class named — the same binding as `new`, written the
+		* way a controller writes it when the service has dependencies of its own. On a
+		* reviewed application this shape carried the write of `POST /gestao/atribuicao`
+		* and 31 more sites, and none was followed (plan 0.8 §B).
+		*/
+		if (init?.isKind(SyntaxKind.CallExpression)) {
+			const callee = init.getExpression();
+			if (callee.isKind(SyntaxKind.PropertyAccessExpression) && callee.getName() === "make" && callee.getExpression().isKind(SyntaxKind.PropertyAccessExpression) && callee.getExpression().asKind(SyntaxKind.PropertyAccessExpression).getName() === "container") {
+				const made = init.getArguments()[0];
+				return made?.isKind(SyntaxKind.Identifier) ? made.getText() : null;
+			}
+		}
+	}
+	return null;
+}
+//#endregion
+//#region src/inventory/sources/event_bindings.ts
+/** the method a listener declares; AdonisJS calls `handle` unless told otherwise */
+const LISTENER_METHOD = "handle";
+function collectEventBindings(app) {
+	const project = new Project({
+		skipAddingFilesFromTsConfig: true,
+		skipFileDependencyResolution: true,
+		compilerOptions: { allowJs: false }
+	});
+	for (const root of app.scanRoots) project.addSourceFilesAtPaths(`${root}/**/*.ts`);
+	const bindings = /* @__PURE__ */ new Map();
+	for (const file of project.getSourceFiles()) for (const call of file.getDescendantsOfKind(SyntaxKind.CallExpression)) {
+		const expression = call.getExpression();
+		if (!Node.isPropertyAccessExpression(expression)) continue;
+		if (expression.getName() !== "on") continue;
+		const [event, handlers] = call.getArguments();
+		if (!event || !handlers) continue;
+		const eventFile = resolveEventClass(event, file, app);
+		if (!eventFile) continue;
+		const refs = listenersOf(handlers, file, app);
+		if (refs.length === 0) continue;
+		bindings.set(eventFile, [...bindings.get(eventFile) ?? [], ...refs]);
+	}
+	return bindings;
+}
+/**
+* The event class a dispatch or a binding names.
+*
+* Two shapes reach here: the class imported directly, and the generated
+* registry (`events.OrderPlaced`), which is what `node ace make:event` produces
+* and therefore the common one. Exported because the resolver has to ask the
+* same question of a call site, and two implementations of "which event is
+* this" would drift.
+*/
+function resolveEventClass(expression, from, app) {
+	if (Node.isIdentifier(expression)) {
+		const target = importedFrom(expression.getText(), from, app);
+		return target ? toPosix(target) : null;
+	}
+	if (!Node.isPropertyAccessExpression(expression)) return null;
+	const root = expression.getExpression();
+	if (!Node.isIdentifier(root)) return null;
+	const registry = importedFrom(root.getText(), from, app);
+	if (!registry) return null;
+	return registryEntry(registry, expression.getName(), from.getProject(), app);
+}
+/** listener bodies named by the second argument of `emitter.on` */
+function listenersOf(handlers, from, app) {
+	const entries = handlers.isKind(SyntaxKind.ArrayLiteralExpression) ? handlers.getElements() : [handlers];
+	const refs = [];
+	for (const entry of entries) {
+		/**
+		* `[SomeListener, 'method']`: AdonisJS lets the binding name the method,
+		* and taking `handle` on faith there would look for a body that is not
+		* the one bound.
+		*/
+		if (entry.isKind(SyntaxKind.ArrayLiteralExpression)) {
+			const [target, member] = entry.getElements();
+			const file = target ? listenerFile(target, from, app) : null;
+			if (!file) continue;
+			const named = member?.asKind(SyntaxKind.StringLiteral)?.getLiteralValue();
+			refs.push({
+				file,
+				member: named ?? LISTENER_METHOD
+			});
+			continue;
+		}
+		const file = listenerFile(entry, from, app);
+		if (file) refs.push({
+			file,
+			member: LISTENER_METHOD
+		});
+	}
+	return refs;
+}
+function listenerFile(entry, from, app) {
+	if (Node.isPropertyAccessExpression(entry)) {
+		const root = entry.getExpression();
+		if (!Node.isIdentifier(root)) return null;
+		const registry = importedFrom(root.getText(), from, app);
+		return registry ? registryEntry(registry, entry.getName(), from.getProject(), app) : null;
+	}
+	if (Node.isIdentifier(entry)) {
+		const target = importedFrom(entry.getText(), from, app);
+		return target ? toPosix(target) : null;
+	}
+	return null;
+}
+/** where a local identifier was imported from, resolved through the alias map */
+function importedFrom(local, from, app) {
+	for (const declaration of from.getImportDeclarations()) {
+		const named = declaration.getNamedImports().some((entry) => (entry.getAliasNode()?.getText() ?? entry.getName()) === local);
+		const isDefault = declaration.getDefaultImport()?.getText() === local;
+		if (!named && !isDefault) continue;
+		return app.resolveSpecifier(declaration.getModuleSpecifierValue());
+	}
+	return null;
+}
+/**
+* The file a key of a generated registry points at.
+*
+* Both shapes the generators emit are handled: a direct reference to an
+* imported class (`events.ts`) and a lazy importer (`listeners.ts`). They differ
+* per artefact and per framework version, and reading only one of them silently
+* lost half the graph.
+*/
+function registryEntry(registryFile, key, project, app) {
+	const file = project.getSourceFile(registryFile) ?? project.addSourceFileAtPathIfExists(registryFile);
+	if (!file) return null;
+	for (const declaration of file.getVariableDeclarations()) {
+		const value = ((declaration.getInitializer()?.asKind(SyntaxKind.ObjectLiteralExpression))?.getProperty(key)?.asKind(SyntaxKind.PropertyAssignment))?.getInitializer();
+		if (!value) continue;
+		if (Node.isIdentifier(value)) {
+			const target = importedFrom(value.getText(), file, app);
+			return target ? toPosix(target) : null;
+		}
+		const specifier = value.getFirstDescendantByKind(SyntaxKind.CallExpression)?.getArguments()[0]?.asKind(SyntaxKind.StringLiteral)?.getLiteralValue();
+		const target = specifier ? app.resolveSpecifier(specifier) : null;
+		return target ? toPosix(target) : null;
 	}
 	return null;
 }
@@ -619,6 +634,68 @@ const jobDispatchResolver = {
 	}
 };
 //#endregion
+//#region src/inventory/resolvers/local_function.ts
+/**
+* "Local function" pattern: a helper declared in the same file, not imported.
+*
+*     const lista = await proximos(id)          // function proximos() { … }
+*     return rows.map(paraLinha)                // const paraLinha = (row) => …
+*
+* A query object that keeps its helpers beside it is common, and before this
+* every such call was unresolved: the store a helper read was reached by nobody
+* from that route, and a value built by it left as a whole table handed in.
+*
+* Only module-level declarations: a closure declared inside a body is part of
+* that body, and the graph already walks it.
+*/
+const localFunctionResolver = {
+	name: "local-function",
+	order: 45,
+	resolve(call, ctx) {
+		const named = calledFunctionOf(call);
+		if (!named) return [];
+		const name = named.getText();
+		if (ctx.imports.has(name)) return [];
+		if (!declaresFunction(ctx.file, name)) return [];
+		return [{
+			file: ctx.file.getFilePath(),
+			member: name
+		}];
+	}
+};
+/** callbacks that apply a function to each element: `rows.map(paraLinha)` calls `paraLinha` */
+const APPLIES_CALLBACK = new Set([
+	"map",
+	"flatMap",
+	"forEach",
+	"filter",
+	"find",
+	"some",
+	"every",
+	"sort",
+	"reduce"
+]);
+/**
+* The function a call names: `proximos(id)` names `proximos`; `rows.map(paraLinha)`
+* names `paraLinha`, called once per row — the body the graph must read is the
+* same, whichever way it was reached.
+*/
+function calledFunctionOf(call) {
+	const expression = call.getExpression();
+	if (Node.isIdentifier(expression)) return expression;
+	if (Node.isPropertyAccessExpression(expression) && APPLIES_CALLBACK.has(expression.getName())) {
+		const callback = call.getArguments()[0];
+		if (callback && Node.isIdentifier(callback)) return callback;
+	}
+	return null;
+}
+/** `function name() {}` or `const name = () => {}` / `function () {}` at module level */
+function declaresFunction(file, name) {
+	if (file.getFunction(name)) return true;
+	const initializer = file.getVariableDeclaration(name)?.getInitializer();
+	return !!initializer && (Node.isArrowFunction(initializer) || Node.isFunctionExpression(initializer));
+}
+//#endregion
 //#region src/inventory/resolvers/module_function.ts
 /**
 * "Module function" pattern: no class at all.
@@ -633,8 +710,8 @@ const moduleFunctionResolver = {
 	name: "module-function",
 	order: 50,
 	resolve(call, ctx) {
-		const expr = call.getExpression();
-		if (!expr.isKind(SyntaxKind.Identifier)) return [];
+		const expr = calledFunctionOf(call);
+		if (!expr) return [];
 		const local = expr.getText();
 		const file = ctx.imports.get(local);
 		if (!file) return [];
@@ -809,11 +886,37 @@ function outputFieldsIn(body, owner, stores, followed) {
 	* data function applies (§6).
 	*/
 	const excluded = new Set((resource ? stores.get(resource)?.attributes : void 0)?.filter((attribute) => attribute.isIdentifier || attribute.system).map((attribute) => attribute.name) ?? []);
+	const { leaves, opaque } = collectLeaves(returnedLiteralsOf(body), {
+		qualifier,
+		excluded,
+		followed
+	});
+	return {
+		outputs: leaves,
+		opaqueOutputs: opaque,
+		resource: resource && stores.has(resource) ? resource : null
+	};
+}
+/**
+* The leaves of object literals, by the §7 rules:
+*
+*   { titulo: l.titulo }                 1 — `titulo`
+*   { autor: AutorTransformer.transform } 0 here; the followed body contributes
+*   { endereco: { rua, cidade } }        leaves individually
+*   { tags: xs.map((t) => t.nome) }      1 — a repeating group of one attribute
+*   { itens: xs.map((i) => ({ a, b })) } the leaves, once
+*   ...this.pick(this.resource, [...])   the listed names
+*   ...this.toObject()                   0 here; the followed body contributes
+*   ...anythingElse                      1, opaque, reported
+*/
+function collectLeaves(literals, options) {
+	const { qualifier, excluded, followed } = options;
 	const outputs = /* @__PURE__ */ new Set();
 	const opaque = /* @__PURE__ */ new Set();
+	const q = qualifier ? `${qualifier}.` : "";
 	const leaf = (prefix, name) => {
 		if (prefix === "" && excluded.has(name)) return;
-		outputs.add(`${qualifier}.${prefix ? `${prefix}.${name}` : name}`);
+		outputs.add(`${q}${prefix ? `${prefix}.${name}` : name}`);
 	};
 	const walk = (literal, prefix) => {
 		for (const property of literal.getProperties()) {
@@ -830,7 +933,7 @@ function outputFieldsIn(body, owner, stores, followed) {
 				continue;
 			}
 			if (!Node.isPropertyAssignment(property)) continue;
-			const name = property.getName().replace(/^['"]|['"]$/g, "");
+			const name = Node.isComputedPropertyName(property.getNameNode()) ? "*" : property.getName().replace(/^['"]|['"]$/g, "");
 			const value = unwrap(property.getInitializer());
 			if (!value) {
 				leaf(prefix, name);
@@ -874,15 +977,14 @@ function outputFieldsIn(body, owner, stores, followed) {
 		* One DET as a floor, and reported — the placeholder carries the expression
 		* so the report can name what could not be read.
 		*/
-		const placeholder = `${qualifier}.${prefix ? `${prefix}.` : ""}<${value.getText().replace(/\s+/g, "")}>`;
+		const placeholder = `${q}${prefix ? `${prefix}.` : ""}<${value.getText().replace(/\s+/g, "")}>`;
 		outputs.add(placeholder);
 		opaque.add(placeholder);
 	};
-	for (const literal of returnedLiteralsOf(body)) walk(literal, "");
+	for (const literal of literals) walk(literal, "");
 	return {
-		outputs: [...outputs],
-		opaqueOutputs: [...opaque],
-		resource: resource && stores.has(resource) ? resource : null
+		leaves: [...outputs],
+		opaque: [...opaque]
 	};
 }
 /**
@@ -1034,6 +1136,76 @@ const TRANSFORMER_METHODS = new Set([
 ]);
 /** what the application-side body is called */
 const APPLICATION_BODY = "toObject";
+/** the variant named in these is a method of the transformer, and part of what leaves */
+const VARIANT_METHODS = new Set(["useVariant", "withVariant"]);
+/**
+* "Transformer" pattern: the package supplies the API, the application
+* supplies the body.
+*
+*     class InviteTransformer extends BaseTransformer<Invite> {
+*       toObject() { … }
+*     }
+*
+*     InviteTransformer.transform(invite)
+*
+* `transform()` and `paginate()` live in `@adonisjs/core`, so resolving the
+* symbol lands on the application file and finds no body there. The naive
+* reading is that the tracer must step into node_modules; it does not. Those
+* methods call BACK into `toObject()`, which the application writes, so the
+* body worth analysing was in the application all along.
+*
+* It is the same shape as `job-dispatch`, where `dispatch` enqueues and
+* `handle` executes.
+*
+* COUNTING DECISION: the write a transformer performs belongs to the
+* transaction that serialised through it. Without this, a table written only
+* inside `toObject()` is reached by nobody and drops out under AFP §6.5.4.
+*/
+/** is `.useVariant('x')` / `.withVariant('x')` the next link of this call's chain? */
+function variantFollows(call) {
+	let node = call;
+	for (let depth = 0; depth < 20; depth++) {
+		const parent = node.getParent();
+		if (!parent) return false;
+		if (Node.isAwaitExpression(parent) || Node.isParenthesizedExpression(parent)) {
+			node = parent;
+			continue;
+		}
+		if (!Node.isPropertyAccessExpression(parent) || parent.getExpression() !== node) return false;
+		const next = parent.getParent();
+		if (!next || !Node.isCallExpression(next) || next.getExpression() !== parent) return false;
+		if (VARIANT_METHODS.has(parent.getName())) return next.getArguments()[0]?.getKind() === SyntaxKind.StringLiteral;
+		node = next;
+	}
+	return false;
+}
+/** the transformer class a chain call is on, if it is one: `X.transform(p)`, `X.transform(p).useVariant(v)` */
+function transformerOf(call, ctx) {
+	const expression = call.getExpression();
+	if (!Node.isPropertyAccessExpression(expression)) return null;
+	if (!TRANSFORMER_METHODS.has(expression.getName())) return null;
+	/**
+	* The root of the chain, so `X.transform(p).useVariant(v)` resolves as
+	* well as `X.transform(p)`. Analysing the same body twice is free: the
+	* graph dedupes by file and member.
+	*/
+	const symbol = rootSymbolOf(expression.getExpression());
+	if (!symbol) return null;
+	const file = ctx.imports.get(symbol) ?? ctx.injected.get(symbol);
+	if (!file) return null;
+	/**
+	* One definition of what a transformer is, shared with the output walker
+	* (`graph/output_fields.ts`): the resolver must not follow a body whose keys
+	* the walker would refuse to read, or the other way round.
+	*/
+	const declared = ctx.sourceFile(file);
+	if (!declared || !declared.getClasses().some(isTransformerClass)) return null;
+	const owner = declared.getClasses().find((cls) => cls.getMethod(APPLICATION_BODY));
+	return owner ? {
+		file,
+		owner
+	} : null;
+}
 //#endregion
 //#region src/inventory/resolvers/index.ts
 /**
@@ -1051,34 +1223,50 @@ const BUILTIN_CALL_RESOLVERS = [
 	{
 		name: "transformer",
 		order: 18,
+		/**
+		* The `transform` before a `useVariant`: claimed and followed nowhere, or
+		* `static-service` would take it next, look for a `transform` body in the
+		* application file and report the package method as a gap.
+		*/
+		ignores(call, ctx) {
+			const expression = call.getExpression();
+			if (!Node.isPropertyAccessExpression(expression)) return false;
+			if (VARIANT_METHODS.has(expression.getName()) || !variantFollows(call)) return false;
+			return transformerOf(call, ctx) !== null;
+		},
 		resolve(call, ctx) {
 			const expression = call.getExpression();
 			if (!Node.isPropertyAccessExpression(expression)) return [];
-			if (!TRANSFORMER_METHODS.has(expression.getName())) return [];
-			/**
-			* The root of the chain, so `X.transform(p).useVariant(v)` resolves as
-			* well as `X.transform(p)`. Analysing the same body twice is free: the
-			* graph dedupes by file and member.
-			*/
-			const symbol = rootSymbolOf(expression.getExpression());
-			if (!symbol) return [];
-			const file = ctx.imports.get(symbol) ?? ctx.injected.get(symbol);
-			if (!file) return [];
+			const found = transformerOf(call, ctx);
+			if (!found) return [];
+			const { file, owner } = found;
 			/**
-			* One definition of what a transformer is, shared with the output walker
-			* (`graph/output_fields.ts`): the resolver must not follow a body whose keys
-			* the walker would refuse to read, or the other way round.
+			* `X.transform(p).useVariant('forEgresso')`: the variant is a METHOD of the
+			* transformer, named after it, and it REPLACES `toObject()` — the shape that
+			* leaves is the variant's. The chain is visited call by call: the `useVariant`
+			* call resolves the variant's body, and the `transform` call before it resolves
+			* nothing, or both shapes would leave and the page would count twice.
 			*/
-			const declared = ctx.sourceFile(file);
-			if (!declared || !declared.getClasses().some(isTransformerClass)) return [];
-			return declared.getClasses().find((cls) => cls.getMethod(APPLICATION_BODY)) ? [{
+			if (VARIANT_METHODS.has(expression.getName())) {
+				const variant = call.getArguments()[0]?.asKind(SyntaxKind.StringLiteral)?.getLiteralValue();
+				return variant && owner.getMethod(variant) ? [{
+					file,
+					member: variant
+				}] : [{
+					file,
+					member: APPLICATION_BODY
+				}];
+			}
+			if (variantFollows(call)) return [];
+			return [{
 				file,
 				member: APPLICATION_BODY
-			}] : [];
+			}];
 		}
 	},
 	staticServiceResolver,
 	propertyServiceResolver,
+	localFunctionResolver,
 	moduleFunctionResolver
 ];
 /**
@@ -1147,4 +1335,4 @@ function ignoreCalls(options) {
 	};
 }
 //#endregion
-export { chainShapeOf as a, hooksFiredBy as c, isApplicationCode as d, isSeeder as f, toPosix as h, resolveCall as i, rootSymbolOf as l, samePath as m, ignoreCalls as n, outputFieldsIn as o, relativeTo as p, isTechnicalWrite as r, detectAccess as s, BUILTIN_CALL_RESOLVERS as t, collectEventBindings as u };
+export { relativeTo as _, chainShapeOf as a, unwrap as c, collectEventBindings as d, detectAccess as f, isSeeder as g, isApplicationCode as h, resolveCall as i, DISPATCH_METHODS as l, rootSymbolOf as m, ignoreCalls as n, mappedLiteralOf as o, hooksFiredBy as p, isTechnicalWrite as r, outputFieldsIn as s, BUILTIN_CALL_RESOLVERS as t, EXECUTION_METHODS as u, samePath as v, toPosix as y };

package/build/{runners-FYmPIPub.js → runners-BpBJsGMj.js}

@@ -1,6 +1,6 @@
 import { c as IncomparableSourcesError, d as DEFAULTS, f as defineConfig, i as measureStructure, n as parseSamples, o as FACTOR_PRESETS, r as measureConformance, s as IncomparableRulesetsError, t as calibrate, u as diffCounts } from "./calibration-DVIf8hcE.js";
-import { h as toPosix } from "./resolvers-DlKJOZnk.js";
-import { n as analyze } from "./pipeline-Cq4dNTNE.js";
+import { y as toPosix } from "./resolvers-DhJO-qvQ.js";
+import { n as analyze } from "./pipeline-C6kHKB9-.js";
 import { readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { existsSync } from "node:fs";

package/build/src/albrecht/counter.d.ts

@@ -3,6 +3,7 @@ import type { CollectedDataStore } from '../inventory/sources/data_stores.js';
 import type { CollectedEntryPoint } from '../inventory/sources/routes_ast.js';
 import type { Behavior } from '../inventory/graph/call_graph.js';
 import type { DiscoveredSchema } from '../inventory/sources/json_schemas.js';
+import type { CollectedJob } from '../inventory/sources/jobs.js';
 import type { OpaqueDeclaration } from './opaque.js';
 import type { Complexity, CountResult, FunctionType } from '../types.js';
 import type { FunctionOverride } from '../define_config.js';
@@ -36,12 +37,20 @@ export declare const RULESET = "afp";
  * column; system timestamps and `serializeAs: null` columns leaving the DETs;
  * master-detail folded into one data function; identity by table; token tables
  * technical; and opaque declarations reaching every function carrying the origin.
+ * Three in 1.6.0: an output's DETs are what the transaction DELIVERS (the render
+ * props, the response payload, what a command prints) read back to their origin;
+ * a function of the same file and a `.map(fn)` by reference are followed, so
+ * FTRs move; and ace commands are transactions, with flags as input. One in
+ * 1.7.0, wide: a write binds to what the variable IS — a destructured named
+ * interface, a followed method's return, a relation off a row, a loop over rows,
+ * the guard's user, a service the container made — and a write nobody can type is
+ * an unresolved call instead of silence.
  *
  * Without the bump, a baseline saved by the previous version compares cleanly
  * against this one and bills the tool's own improvement as work done. The guard
  * exists for exactly that, and only this constant arms it.
  */
-export declare const RULESET_VERSION = "1.5.0";
+export declare const RULESET_VERSION = "1.7.0";
 export type CountInput = {
     app: AppContext;
     stores: CollectedDataStore[];
@@ -50,6 +59,8 @@ export type CountInput = {
     behaviors: Map<string, Behavior>;
     /** JSON Schema literals found in the code, for `detFromSchema` — §8 */
     jsonSchemas?: Map<string, DiscoveredSchema>;
+    /** the queue jobs and who dispatches each — a job no transaction reaches is reported (plan 0.7 §D) */
+    jobs?: CollectedJob[];
     /**
      * Stores written anywhere in the application's code, reachable from an entry
      * point or not — AFP §6.5.4 asks who MAINTAINS the store, and a job or a

package/build/src/cli.js

@@ -1,5 +1,5 @@
-import { t as CoverageTooLowError } from "../pipeline-Cq4dNTNE.js";
-import { a as runInventory, c as ConfigLoadError, i as runExplain, n as runCount, o as runMetrics, r as runDiff, s as printResult, t as runCalibrate } from "../runners-FYmPIPub.js";
+import { t as CoverageTooLowError } from "../pipeline-C6kHKB9-.js";
+import { a as runInventory, c as ConfigLoadError, i as runExplain, n as runCount, o as runMetrics, r as runDiff, s as printResult, t as runCalibrate } from "../runners-BpBJsGMj.js";
 import path from "node:path";
 import { existsSync, readFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";

package/build/src/inventory/graph/call_graph.d.ts

@@ -53,6 +53,8 @@ export type Behavior = {
      * not a validator.
      */
     requestFields: string[];
+    /** an ace command's `@flags.*` / `@args.*`: `flags.limite`, `args.name` — its input DETs */
+    commandFields: string[];
     /** the transaction reads the request in a way that enumerates nothing */
     opaqueRequest: boolean;
     /**
@@ -82,6 +84,26 @@ export type Behavior = {
         /** stores it was preloaded through */
         via: string[];
     }>;
+    /**
+     * What the transaction DELIVERS — plan 0.7 §A′. `any` says a delivery point was
+     * found at all; without one the output falls back to the stores read. `fields`
+     * are derived values and the leaves of literals a followed body returned,
+     * `render:total`; `stores` are the ones whose rows were handed on, raw or through
+     * a query object; `opaqueFields` are values nobody could read, 1 DET each.
+     */
+    delivered: {
+        any: boolean;
+        fields: string[];
+        opaqueFields: string[];
+        stores: string[];
+    };
+    /**
+     * Of the stores delivered raw to a page, the columns the page reads off them
+     * (plan 0.8 §D). A store absent here leaves whole; one in `unreadablePages` leaves
+     * whole because the page could not be read, and says why.
+     */
+    pageReads: Record<string, string[]>;
+    unreadablePages: Record<string, string>;
     trace: TraceStep[];
     /** bodies reached, for `fp:diff` */
     scope: ScopeEntry[];