@filipebraida/adonis-function-points 0.4.0 → 0.6.0

package/build/{resolvers-vMahHkAd.js → resolvers-DlKJOZnk.js}

@@ -40,6 +40,48 @@ const toPosix = (value) => value.split("\\").join("/");
 const relativeTo = (root, value) => toPosix(path.relative(toPosix(root), toPosix(value))) || ".";
 /** Compares two paths that may have come from different sources. */
 const samePath = (a, b) => a !== void 0 && b !== void 0 && toPosix(a) === toPosix(b);
+/**
+* Is this file the application's own code, as opposed to the scaffolding around it?
+*
+* The top-level filter on `scanRoots` already drops `tests/`, `database/` and the
+* rest — but only at the ROOT. Applications organised by domain module put both
+* inside `app/`:
+*
+*     app/billing/tests/functional/invoice.spec.ts
+*     app/billing/seeders/plan_seeder.ts
+*
+* so they land in the project, and `writtenAnywhere()` read a seeder's inserts as
+* the application maintaining the table. A reference table only the seed populates
+* came out as an ILF — which the CPM does not allow: data maintained by the
+* development team is at most an EIF, and code data is not counted at all.
+*
+* The segments are AdonisJS's own: `make:test` writes to a suite directory,
+* `make:seeder` to `seeders`, `make:migration` to `migrations`, `make:factory` to
+* `factories`. The `.spec`/`.test` suffixes come from the suite globs in
+* `adonisrc.ts`.
+*/
+const SCAFFOLDING = new Set([
+	"tests",
+	"test",
+	"seeders",
+	"seeder",
+	"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;
+	const parts = relative.split("/");
+	const name = parts.at(-1) ?? "";
+	if (/\.(spec|test)\.[jt]s$/.test(name)) return false;
+	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 */
@@ -714,81 +756,284 @@ const staticServiceResolver = {
 	}
 };
 //#endregion
-//#region src/inventory/resolvers/transformer.ts
-/** BaseTransformer's public API; all of it funnels through `toObject` */
-const TRANSFORMER_METHODS = new Set([
-	"transform",
-	"paginate",
-	"toJSON",
-	"useVariant",
-	"withVariant"
-]);
-/** what the application-side body is called */
-const APPLICATION_BODY = "toObject";
+//#region src/inventory/graph/output_fields.ts
 /**
-* "Transformer" pattern: the package supplies the API, the application
-* supplies the body.
-*
-*     class InviteTransformer extends BaseTransformer<Invite> {
-*       toObject() { … }
-*     }
+* Does this class extend a transformer base from a package?
 *
-*     InviteTransformer.transform(invite)
+* 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.
 *
-* `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.
+* `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.
 *
-* It is the same shape as `job-dispatch`, where `dispatch` enqueues and
-* `handle` executes.
+*   { 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
 *
-* 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.
+* 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.
 */
-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 [];
+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 outputs = /* @__PURE__ */ new Set();
+	const opaque = /* @__PURE__ */ new Set();
+	const leaf = (prefix, name) => {
+		if (prefix === "" && excluded.has(name)) return;
+		outputs.add(`${qualifier}.${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 = 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;
+		}
 		/**
-		* 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.
+		* `...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 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
-		}] : [];
+		const placeholder = `${qualifier}.${prefix ? `${prefix}.` : ""}<${value.getText().replace(/\s+/g, "")}>`;
+		outputs.add(placeholder);
+		opaque.add(placeholder);
+	};
+	for (const literal of returnedLiteralsOf(body)) walk(literal, "");
+	return {
+		outputs: [...outputs],
+		opaqueOutputs: [...opaque],
+		resource: resource && stores.has(resource) ? resource : null
+	};
+}
+/**
+* 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;
+}
 /**
-* Does a class here extend a transformer base from a package?
+* The columns a fluent chain names in `.select()`, walking UP from the access
+* the detector recognised (`Livro.query()`) through the chain it belongs to.
 *
-* 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.
+* 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.
 */
-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;
+/** 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;
 	}
-	return false;
+	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([
+	"transform",
+	"paginate",
+	"toJSON",
+	"useVariant",
+	"withVariant"
+]);
+/** what the application-side body is called */
+const APPLICATION_BODY = "toObject";
 //#endregion
 //#region src/inventory/resolvers/index.ts
 /**
@@ -803,7 +1048,35 @@ const BUILTIN_CALL_RESOLVERS = [
 	actionObjectResolver,
 	eventDispatchResolver,
 	jobDispatchResolver,
-	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 [];
+			/**
+			* 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 [];
+			return declared.getClasses().find((cls) => cls.getMethod(APPLICATION_BODY)) ? [{
+				file,
+				member: APPLICATION_BODY
+			}] : [];
+		}
+	},
 	staticServiceResolver,
 	propertyServiceResolver,
 	moduleFunctionResolver
@@ -817,6 +1090,15 @@ const BUILTIN_CALL_RESOLVERS = [
 * them apart. Hence specific strategies declare a lower `order` than generic
 * ones, and `module-function` comes last — it would match almost anything.
 */
+/**
+* Does any strategy call this a technical write?
+*
+* Asked separately from resolution, because the strategy that recognises the call as
+* incidental is not necessarily the one that knows where it goes.
+*/
+function isTechnicalWrite(call, ctx, resolvers = BUILTIN_CALL_RESOLVERS) {
+	return resolvers.some((resolver) => resolver.technicalWrite?.(call, ctx) === true);
+}
 function resolveCall(call, ctx, resolvers = BUILTIN_CALL_RESOLVERS) {
 	for (const resolver of resolvers) {
 		/**
@@ -836,5 +1118,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 { rootSymbolOf as a, samePath as c, hooksFiredBy as i, toPosix as l, resolveCall as n, collectEventBindings as o, detectAccess as r, relativeTo as s, BUILTIN_CALL_RESOLVERS as t };
+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 };

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

@@ -1,6 +1,6 @@
-import { c as diffCounts, i as measureStructure, l as DEFAULTS, n as parseSamples, o as IncomparableRulesetsError, r as measureConformance, s as IncomparableSourcesError, t as calibrate, u as defineConfig } from "./calibration-8eV8CEix.js";
-import { l as toPosix } from "./resolvers-vMahHkAd.js";
-import { n as analyze } from "./pipeline-Dm9KvUvF.js";
+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 { readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { existsSync } from "node:fs";
@@ -91,7 +91,12 @@ function renderCount(result) {
 	* habit: if it grows, the count comes from a spreadsheet and the tool loses
 	* its reason to exist. Printing the share is what keeps that visible.
 	*/
-	const overridden = result.functions.filter((fn) => fn.rationale.overrides?.length);
+	/**
+	* Only entries that DECLARED a number. A review records a decision and declares
+	* nothing, so counting it here would read as "35% of the total declared by
+	* override" about a count nobody touched.
+	*/
+	const overridden = result.functions.filter((fn) => fn.rationale.overrides?.some((o) => o.fields.length > 0));
 	if (overridden.length > 0) {
 		const points = overridden.reduce((total, fn) => total + fn.points, 0);
 		const share = (points / (result.totals.unadjusted || 1) * 100).toFixed(1);
@@ -220,6 +225,8 @@ function renderDiff(diff) {
 	}
 	lines.push("");
 	lines.push(`Billable FP: ${diff.billable}`);
+	/** the total is quoted under a set of factors, so the set is named beside it */
+	lines.push(`Factors: ${diff.preset} — ${FACTOR_PRESETS[diff.preset].label}`);
 	/**
 	* Before the per-function list, not after it.
 	*
@@ -410,6 +417,7 @@ async function runDiff(options) {
 					from: options.previous,
 					to
 				},
+				preset: config.diff?.preset,
 				factors: config.diff?.factors,
 				reasonFactors: config.diff?.reasonFactors
 			}))

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

@@ -3,9 +3,12 @@ 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 { OpaqueDeclaration } from './opaque.js';
 import type { Complexity, CountResult, FunctionType } from '../types.js';
 import type { FunctionOverride } from '../define_config.js';
 import type { ComplexityTable } from './tables.js';
+import type { GroupingStrategy } from './data_functions.js';
+import type { TechnicalPattern } from './technical_filter.js';
 /**
  * Assembles the count from the inventory.
  *
@@ -26,15 +29,19 @@ export declare const RULESET = "afp";
  * that is easy to forget. Four such changes landed in 1.1.0 — maintenance read
  * across the whole project rather than from routes alone, a job followed into
  * `process`, an event followed into its listeners, and `request.input(…)` counted
- * as a DET — and three more in 1.2.0: an open input object counting 1 instead of 0,
+ * as a DET — three more in 1.2.0: an open input object counting 1 instead of 0,
  * `detFromSchema` no longer subtracting a placeholder that was not there, and a
- * write through `related(…)` maintaining the related table.
+ * write through `related(…)` maintaining the related table — and six in 1.5.0:
+ * output DETs read from transformers, selects and aggregates instead of every
+ * 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.
  *
  * 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.3.0";
+export declare const RULESET_VERSION = "1.5.0";
 export type CountInput = {
     app: AppContext;
     stores: CollectedDataStore[];
@@ -49,16 +56,35 @@ export type CountInput = {
      * seeder is this application just as much as a route is.
      */
     writtenAnywhere?: Set<string>;
+    /**
+     * Stores the application addresses DIRECTLY somewhere in its code — as opposed
+     * to reaching only through a parent's relation. Decides which composition
+     * children fold into their parent as a RET (counting-decisions §10).
+     */
+    addressedAnywhere?: Set<string>;
+    /**
+     * Stores written by a SEEDER — scaffolding, so not maintenance — kept apart
+     * because an EIF only a seed populates is one of two things the code cannot
+     * tell: code data the team maintains (not counted, CPM) or a mirror of data
+     * another system maintains in production (a legitimate EIF). Reported.
+     */
+    seededAnywhere?: Set<string>;
 };
 export type CountOptions = {
-    retStrategy?: 'constant' | 'composition';
-    /** declared DET/RET for what static analysis cannot read — see §8 */
+    dataFunctions?: {
+        grouping?: GroupingStrategy;
+    };
+    /** what a person declared about a DET the analysis cannot read, by origin — §8 */
+    opaque?: Record<string, OpaqueDeclaration>;
+    /** a declared DET or RET for one function — the last resort, see §8 */
     overrides?: Record<string, FunctionOverride>;
     boundary?: {
         infrastructure?: string[];
         externallyMaintained?: string[];
         /** restores what the AFP naming filter caught by accident */
         business?: string[];
+        /** replaces the filter's naming conventions — §6.5.2.1.3 treats them as user input */
+        technicalPatterns?: TechnicalPattern[];
         ignoreEntryPoints?: string[];
     };
     messageDet?: number;

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

@@ -13,7 +13,9 @@ import type { ComplexityTable } from './tables.js';
  *    application's Transactional Functions, the Data Function shall not be
  *    counted in the application."  — AFP §6.5.4
  *
- * That is why this module takes usage, not just the stores.
+ * That is why this module takes usage, not just the stores. And the same
+ * question — how does the application use it? — decides whether a table is a
+ * data function at all or a RET of another one (counting-decisions §10).
  */
 export type StoreUsage = {
     /** does any transaction of the application write to this store? */
@@ -21,9 +23,53 @@ export type StoreUsage = {
     /** does any transaction reach it at all, reading or writing? */
     used: boolean;
 };
+export type GroupingStrategy = 'usage' | 'none';
+export type GroupingOptions = {
+    /**
+     * `usage` folds a composition child nobody addresses directly into its parent
+     * as a RET; `none` keeps every table its own data function, RET 1 — the
+     * behaviour of rule sets before 1.5.0, for comparing with an old count.
+     */
+    grouping: GroupingStrategy;
+    /**
+     * Stores the application addresses directly anywhere in its own code —
+     * `C.query()`, `C.create()`, `new C()` — as opposed to reaching only through
+     * a parent's relation. Same pass as `writtenAnywhere`, same exclusions.
+     */
+    addressedAnywhere: Set<string>;
+};
+/**
+ * How the stores fold into data functions.
+ *
+ *   rootOf        every counted store -> the store whose data function it belongs to
+ *   members       root -> [root, ...children folded in]
+ *   linkColumns   store -> the foreign keys that are the subgroup's LINK to its
+ *                 parent, and therefore not DETs of the group
+ */
+export type StoreGrouping = {
+    strategy: GroupingStrategy;
+    rootOf: Map<string, string>;
+    members: Map<string, string[]>;
+    linkColumns: Map<string, Set<string>>;
+    warnings: string[];
+};
+/**
+ * A store `C` is a RET of `P` when, and only when:
+ *
+ *   1. `P` declares `hasMany` / `hasOne` -> `C` (collected as `subgroups`);
+ *   2. no application code addresses `C` directly — the user only ever reaches
+ *      it through `P`, so under the CPM it is not a logical file of its own;
+ *   3. exactly one `P` satisfies (1). More than one: `C` stays apart, reported.
+ *
+ * Cascade delete was measured and rejected as the signal: on a real application
+ * 11 of 13 cascades pointed at the tenant table. Usage is the rule the rest of
+ * the count already runs on.
+ */
+export declare function groupStores(stores: CollectedDataStore[], options: GroupingOptions): StoreGrouping;
+/** the DET attributes of one store: not the key, not a system stamp, not a link to its parent */
+export declare function detAttributesOf(store: CollectedDataStore, links?: Set<string>): import("../types.js").Attribute[];
 export type DataFunctionOptions = {
-    /** `constant` pins RET at 1; `composition` derives it from composition relations */
-    retStrategy: 'constant' | 'composition';
+    grouping: StoreGrouping;
     /** stores maintained by another system, by boundary decision */
     externallyMaintained: Set<string>;
     /**