@filipebraida/adonis-function-points 0.5.0 → 0.7.0

package/build/{resolvers-PJwo2Z8R.js → resolvers-DaU4uAqT.js}

@@ -68,6 +68,12 @@ const SCAFFOLDING = new Set([
 	"migrations",
 	"factories"
 ]);
+/** a seeder, by the directory `make:seeder` writes to — scaffolding, but a fact the report uses */
+function isSeeder(root, file) {
+	const relative = relativeTo(root, file);
+	if (relative.startsWith("..")) return false;
+	return relative.split("/").slice(0, -1).some((segment) => segment === "seeders" || segment === "seeder");
+}
 function isApplicationCode(root, file) {
 	const relative = relativeTo(root, file);
 	if (relative.startsWith("..")) return false;
@@ -77,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",
@@ -506,6 +389,129 @@ function classOfReceiver(receiver) {
 	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;
+}
+//#endregion
 //#region src/inventory/resolvers/event_dispatch.ts
 /**
 * "Event" pattern: the handler announces, and listeners act.
@@ -613,6 +619,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.
@@ -627,8 +695,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 [];
@@ -750,6 +818,298 @@ const staticServiceResolver = {
 	}
 };
 //#endregion
+//#region src/inventory/graph/output_fields.ts
+/**
+* Does this class extend a transformer base from a package?
+*
+* Decided by the base's name AND by its import being a bare specifier, so an
+* application class that merely happens to own a `transform` method is not
+* mistaken for one. Shared with the `transformer` resolver: one definition of
+* what a transformer is, or the resolver follows a body this walker refuses.
+*/
+function isTransformerClass(cls) {
+	const name = (cls.getExtends()?.getExpression())?.asKind(SyntaxKind.Identifier)?.getText();
+	if (!name?.endsWith("Transformer")) return false;
+	const imported = cls.getSourceFile().getImportDeclarations().find((declaration) => declaration.getNamedImports().some((named) => named.getName() === name));
+	return imported !== void 0 && !imported.getModuleSpecifierValue().startsWith("#");
+}
+/** `class X extends BaseTransformer<Livro>` -> 'Livro' */
+function transformerResourceOf(cls) {
+	return (cls.getExtends()?.getTypeArguments()[0])?.asKind(SyntaxKind.TypeReference)?.getTypeName().getText() ?? null;
+}
+/**
+* The keys a transformer method returns.
+*
+* `followed` says whether a call inside the literal is a body the graph walks —
+* `AutorTransformer.transform(x)`, `this.toObject()` — in which case its keys
+* arrive through that body and the key holding it is not a DET of its own: the
+* user sees the author's name, not an "autor" field.
+*
+*   { titulo: l.titulo }                 1 — `titulo`
+*   { autor: AutorTransformer.transform } 0 here; the nested 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
+*
+* A key that is the identifier of the transformer's resource is not a DET, for
+* the same reason `isPrimary` is not one on the data function.
+*/
+function outputFieldsIn(body, owner, stores, followed) {
+	if (!owner || !isTransformerClass(owner)) return {
+		outputs: [],
+		opaqueOutputs: [],
+		resource: null
+	};
+	const qualifier = owner.getName() ?? "Transformer";
+	const resource = transformerResourceOf(owner);
+	/**
+	* The resource's key and its system timestamps: re-emitted for links and
+	* sorting, and not something the user recognises — the same two exclusions the
+	* 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(`${q}${prefix ? `${prefix}.${name}` : name}`);
+	};
+	const walk = (literal, prefix) => {
+		for (const property of literal.getProperties()) {
+			if (Node.isShorthandPropertyAssignment(property)) {
+				leaf(prefix, property.getName());
+				continue;
+			}
+			if (Node.isMethodDeclaration(property) || Node.isGetAccessorDeclaration(property)) {
+				leaf(prefix, property.getName());
+				continue;
+			}
+			if (Node.isSpreadAssignment(property)) {
+				spread(property.getExpression(), prefix);
+				continue;
+			}
+			if (!Node.isPropertyAssignment(property)) continue;
+			const name = Node.isComputedPropertyName(property.getNameNode()) ? "*" : property.getName().replace(/^['"]|['"]$/g, "");
+			const value = unwrap(property.getInitializer());
+			if (!value) {
+				leaf(prefix, name);
+				continue;
+			}
+			if (Node.isObjectLiteralExpression(value)) {
+				walk(value, prefix ? `${prefix}.${name}` : name);
+				continue;
+			}
+			if (Node.isCallExpression(value) && followed(value)) continue;
+			const mapped = mappedLiteralOf(value);
+			if (mapped) {
+				walk(mapped, prefix ? `${prefix}.${name}` : name);
+				continue;
+			}
+			leaf(prefix, name);
+		}
+	};
+	const spread = (expression, prefix) => {
+		const value = unwrap(expression);
+		if (!value) return;
+		if (Node.isObjectLiteralExpression(value)) {
+			walk(value, prefix);
+			return;
+		}
+		if (Node.isConditionalExpression(value)) {
+			spread(value.getWhenTrue(), prefix);
+			spread(value.getWhenFalse(), prefix);
+			return;
+		}
+		if (Node.isCallExpression(value)) {
+			const picked = pickedNamesOf(value);
+			if (picked) {
+				for (const name of picked) leaf(prefix, name);
+				return;
+			}
+			if (followed(value)) return;
+		}
+		/**
+		* `...this.resource.serialize()`, `...this.extras`: whatever the model has.
+		* One DET as a floor, and reported — the placeholder carries the expression
+		* so the report can name what could not be read.
+		*/
+		const placeholder = `${q}${prefix ? `${prefix}.` : ""}<${value.getText().replace(/\s+/g, "")}>`;
+		outputs.add(placeholder);
+		opaque.add(placeholder);
+	};
+	for (const literal of literals) walk(literal, "");
+	return {
+		leaves: [...outputs],
+		opaque: [...opaque]
+	};
+}
+/**
+* Object literals the body itself returns — not the ones returned by arrow
+* functions inside it, which belong to `.map()` callbacks and are read as
+* repeating groups where they occur.
+*/
+function returnedLiteralsOf(body) {
+	const literals = [];
+	for (const statement of body.getDescendantsOfKind(SyntaxKind.ReturnStatement)) {
+		if (statement.getFirstAncestor((node) => Node.isArrowFunction(node) || Node.isFunctionExpression(node) || Node.isMethodDeclaration(node) || Node.isFunctionDeclaration(node)) !== body) continue;
+		const value = unwrap(statement.getExpression());
+		if (value && Node.isObjectLiteralExpression(value)) literals.push(value);
+	}
+	return literals;
+}
+/** `this.pick(this.resource, ['a', 'b'])` -> ['a', 'b']; null when it is not that call */
+function pickedNamesOf(call) {
+	const callee = call.getExpression();
+	if (!Node.isPropertyAccessExpression(callee)) return null;
+	if (callee.getName() !== "pick") return null;
+	if (callee.getExpression().getKind() !== SyntaxKind.ThisKeyword) return null;
+	const list = call.getArguments()[1]?.asKind(SyntaxKind.ArrayLiteralExpression);
+	if (!list) return null;
+	const names = [];
+	for (const element of list.getElements()) {
+		const name = element.asKind(SyntaxKind.StringLiteral)?.getLiteralValue();
+		if (name === void 0) return null;
+		names.push(name);
+	}
+	return names;
+}
+/** `xs.map((x) => ({ a, b }))` -> the literal; null for a scalar map or anything else */
+function mappedLiteralOf(value) {
+	if (!Node.isCallExpression(value)) return null;
+	const callee = value.getExpression();
+	if (!Node.isPropertyAccessExpression(callee) || callee.getName() !== "map") return null;
+	const callback = value.getArguments()[0];
+	if (!callback || !Node.isArrowFunction(callback)) return null;
+	const returned = unwrap(callback.getBody().asKind(SyntaxKind.Block) ? null : callback.getBody());
+	if (returned && Node.isObjectLiteralExpression(returned)) return returned;
+	for (const statement of callback.getDescendantsOfKind(SyntaxKind.ReturnStatement)) {
+		const expression = unwrap(statement.getExpression());
+		if (expression && Node.isObjectLiteralExpression(expression)) return expression;
+	}
+	return null;
+}
+/** strips parentheses, `as`, `satisfies` and non-null assertions */
+function unwrap(node) {
+	let current = node;
+	while (current && (Node.isParenthesizedExpression(current) || Node.isAsExpression(current) || Node.isSatisfiesExpression(current) || Node.isNonNullExpression(current))) current = current.getExpression();
+	return current && Node.isExpression(current) ? current : null;
+}
+/**
+* The columns a fluent chain names in `.select()`, walking UP from the access
+* the detector recognised (`Livro.query()`) through the chain it belongs to.
+*
+* Only calls on the chain itself qualify. A `q.select('nome')` inside a
+* `preload('autor', (q) => …)` callback narrows the related store, not this
+* one, and reading every descendant would have attributed it here.
+*
+* Both spellings count: `.select(['a', 'b'])` and `.select('a', 'b')`. Anything
+* that is not a string literal — a variable, a raw expression — is unreadable:
+* the store falls back to every column, and the chain is reported.
+*/
+/** methods that leave ONE derived scalar rather than rows */
+const AGGREGATES = new Set([
+	"count",
+	"countDistinct",
+	"exists",
+	"sum",
+	"avg",
+	"min",
+	"max"
+]);
+function chainShapeOf(access) {
+	const selected = /* @__PURE__ */ new Set();
+	const unreadable = [];
+	let aggregate = false;
+	const inspect = (call) => {
+		const callee = call.getExpression();
+		if (!Node.isPropertyAccessExpression(callee)) return;
+		const name = callee.getName();
+		if (AGGREGATES.has(name)) aggregate = true;
+		if (name !== "select") return;
+		const literal = literalColumnsOf(call);
+		if (literal) for (const column of literal) selected.add(column);
+		else unreadable.push({
+			line: call.getStartLineNumber(),
+			expression: call.getText().replace(/\s+/g, "")
+		});
+	};
+	let node = access;
+	for (let depth = 0; node && depth < 40; depth++) {
+		if (Node.isCallExpression(node)) inspect(node);
+		node = Node.isCallExpression(node) || Node.isPropertyAccessExpression(node) ? node.getExpression() : void 0;
+	}
+	node = access;
+	for (let depth = 0; depth < 40; depth++) {
+		const parent = node.getParent();
+		if (!parent) break;
+		if (Node.isAwaitExpression(parent) || Node.isParenthesizedExpression(parent)) {
+			node = parent;
+			continue;
+		}
+		if (!Node.isPropertyAccessExpression(parent) || parent.getExpression() !== node) break;
+		const call = parent.getParent();
+		if (!call || !Node.isCallExpression(call) || call.getExpression() !== parent) break;
+		inspect(call);
+		node = call;
+	}
+	return {
+		selected: [...selected],
+		aggregate,
+		unreadable
+	};
+}
+/** string-literal columns of one `.select(...)`; null when any is not a literal */
+function literalColumnsOf(call) {
+	const columns = [];
+	const read = (node) => {
+		const value = node.asKind(SyntaxKind.StringLiteral)?.getLiteralValue();
+		if (value === void 0) return false;
+		const bare = value.includes(".") ? value.split(".").pop() : value;
+		if (bare !== "*") columns.push(camelCase(bare));
+		return true;
+	};
+	for (const argument of call.getArguments()) {
+		const list = argument.asKind(SyntaxKind.ArrayLiteralExpression);
+		if (list) {
+			for (const element of list.getElements()) if (!read(element)) return null;
+			continue;
+		}
+		if (!read(argument)) return null;
+	}
+	return columns;
+}
+/** `created_at` -> `createdAt`, to match the model's attribute names */
+const camelCase = (value) => value.replace(/_([a-z0-9])/g, (_, c) => c.toUpperCase());
+//#endregion
 //#region src/inventory/resolvers/transformer.ts
 /** BaseTransformer's public API; all of it funnels through `toObject` */
 const TRANSFORMER_METHODS = new Set([
@@ -761,6 +1121,8 @@ 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.
@@ -784,47 +1146,51 @@ const APPLICATION_BODY = "toObject";
 * 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.
 */
-const transformerResolver = {
-	name: "transformer",
-	order: 18,
-	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 declared = ctx.sourceFile(file);
-		if (!declared || !extendsTransformer(declared)) return [];
-		return declared.getClasses().find((cls) => cls.getMethod(APPLICATION_BODY)) ? [{
-			file,
-			member: APPLICATION_BODY
-		}] : [];
-	}
-};
-/**
-* Does a class here extend a transformer base from a package?
-*
-* Checked by the base's name and by its import being a bare specifier, so an
-* application class that merely happens to own a `transform` method is not
-* mistaken for one.
-*/
-function extendsTransformer(file) {
-	if (!file) return false;
-	for (const cls of file.getClasses()) {
-		const name = (cls.getExtends()?.getExpression())?.asKind(SyntaxKind.Identifier)?.getText();
-		if (!name?.endsWith("Transformer")) continue;
-		const imported = file.getImportDeclarations().find((declaration) => declaration.getNamedImports().some((named) => named.getName() === name));
-		if (imported && !imported.getModuleSpecifierValue().startsWith("#")) return true;
+/** 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
 /**
@@ -839,9 +1205,53 @@ const BUILTIN_CALL_RESOLVERS = [
 	actionObjectResolver,
 	eventDispatchResolver,
 	jobDispatchResolver,
-	transformerResolver,
+	{
+		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 [];
+			const found = transformerOf(call, ctx);
+			if (!found) return [];
+			const { file, owner } = found;
+			/**
+			* `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.
+			*/
+			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
 ];
 /**
@@ -881,5 +1291,33 @@ function resolveCall(call, ctx, resolvers = BUILTIN_CALL_RESOLVERS) {
 	}
 	return null;
 }
+/**
+* A strategy that recognises a family of calls and knows they reach no data
+* store — a rate limiter, an attachment's URL, an authorisation check.
+*
+* Read from a real configuration, every such strategy was the same eight lines:
+* a helper to get the method name off the ts-morph node (the app does not depend
+* on ts-morph), a `resolve` that returns nothing, and one comparison. What the
+* design wants is kept — it is still a NAMED strategy, and `fp:count` still
+* reports the volume it declared data-free — and the ceremony is not.
+*/
+function ignoreCalls(options) {
+	if (!options.methods?.length && !options.matching) throw new Error(`ignoreCalls("${options.name}"): say what it ignores — \`methods\` or \`matching\``);
+	const methods = new Set(options.methods ?? []);
+	return {
+		name: options.name,
+		order: options.order ?? 1,
+		/** follows nothing: the whole point */
+		resolve: () => [],
+		ignores(call) {
+			const callee = call.getExpression();
+			const text = callee.getText();
+			if (options.matching?.test(text)) return true;
+			if (methods.size === 0) return false;
+			const method = callee.getKindName() === "PropertyAccessExpression" ? text.split(".").pop() : text;
+			return method !== void 0 && methods.has(method);
+		}
+	};
+}
 //#endregion
-export { hooksFiredBy as a, isApplicationCode as c, toPosix as d, detectAccess as i, relativeTo as l, isTechnicalWrite as n, rootSymbolOf as o, resolveCall as r, collectEventBindings as s, BUILTIN_CALL_RESOLVERS as t, samePath 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 };