@filipebraida/adonis-function-points 0.1.0 → 0.3.0

package/build/{runners-Bt8tbISi.js → runners-CmxNHuuq.js}

@@ -1,305 +1,64 @@
-import { n as defineConfig, t as DEFAULTS } from "./define_config-DOqWyPwV.js";
-import { n as analyze, r as toPosix } from "./pipeline-BzP-ITGN.js";
+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 { c as toPosix } from "./resolvers-CRB6lXoo.js";
+import { n as analyze } from "./pipeline-CIAydCcT.js";
 import { readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { existsSync } from "node:fs";
 import { pathToFileURL } from "node:url";
 import { createJiti } from "jiti";
-//#region src/cli/print.ts
-function printResult(result, printer) {
-	for (const note of result.notes ?? []) printer.note(note);
-	if (result.errors?.length) {
-		for (const message of result.errors) printer.error(message);
-		return 1;
-	}
-	if (result.output) printer.log(result.output);
-	return 0;
-}
-//#endregion
-//#region src/albrecht/calibration.ts
-/**
-* Minimum sample size per type for a factor to mean anything.
-*
-* Below this, the "factor" is noise from one or two functions, and using it to
-* correct a count is worse than not correcting at all.
-*/
-const MIN_SAMPLES_PER_TYPE = 10;
-function calibrate(result, samples) {
-	const byIdentity = new Map(result.functions.map((fn) => [fn.name, fn]));
-	const grouped = /* @__PURE__ */ new Map();
-	const unmatched = [];
-	let manualTotal = 0;
-	let automaticTotal = 0;
-	let exactTotal = 0;
-	for (const sample of samples) {
-		const counted = byIdentity.get(sample.function);
-		if (!counted) {
-			unmatched.push(sample.function);
-			continue;
-		}
-		const bucket = grouped.get(counted.type) ?? {
-			manual: 0,
-			automatic: 0,
-			deviations: [],
-			exact: 0
-		};
-		bucket.manual += sample.manual;
-		bucket.automatic += counted.points;
-		bucket.deviations.push(Math.abs(counted.points - sample.manual));
-		if (counted.points === sample.manual) bucket.exact++;
-		grouped.set(counted.type, bucket);
-		manualTotal += sample.manual;
-		automaticTotal += counted.points;
-		if (counted.points === sample.manual) exactTotal++;
-	}
-	const byType = [...grouped.entries()].map(([type, bucket]) => ({
-		type,
-		samples: bucket.deviations.length,
-		manualPoints: bucket.manual,
-		automaticPoints: bucket.automatic,
-		factor: bucket.automatic === 0 ? 1 : round(bucket.manual / bucket.automatic),
-		meanAbsoluteDeviation: round(bucket.deviations.reduce((total, value) => total + value, 0) / bucket.deviations.length),
-		exactMatches: bucket.exact
-	})).sort((a, b) => a.type.localeCompare(b.type));
-	const warnings = [];
-	for (const calibration of byType) if (calibration.samples < MIN_SAMPLES_PER_TYPE) warnings.push(`${calibration.type}: ${calibration.samples} samples, below the minimum of ${MIN_SAMPLES_PER_TYPE}. The factor ${calibration.factor} is noise from a handful of functions — do not use it to correct a count.`);
-	if (unmatched.length > 0) warnings.push(`${unmatched.length} samples matched no counted function. Check the identity: it is "VERB /pattern" with parameters written as ":param".`);
-	const matched = samples.length - unmatched.length;
-	if (matched > 0 && exactTotal === matched) warnings.push("every sample matched exactly. Check that the manual count was not derived from the automatic one — calibrating against itself measures nothing.");
-	return {
-		byType,
-		overall: {
-			samples: matched,
-			manualPoints: manualTotal,
-			automaticPoints: automaticTotal,
-			deviation: manualTotal === 0 ? 0 : round((automaticTotal - manualTotal) / manualTotal),
-			exactMatches: exactTotal
-		},
-		unmatched,
-		warnings
-	};
-}
-const round = (value) => Math.round(value * 1e3) / 1e3;
-/**
-* Reads samples from CSV: `function,fp` with a header row.
-*
-* Deliberately plain. A metrics analyst exports from a spreadsheet, and
-* demanding JSON would add friction where none is needed.
-*/
-function parseSamples(csv) {
-	const samples = [];
-	for (const [index, line] of csv.split(/\r?\n/).entries()) {
-		const trimmed = line.trim();
-		if (trimmed === "" || trimmed.startsWith("#")) continue;
-		const separator = trimmed.lastIndexOf(",");
-		if (separator === -1) continue;
-		const name = trimmed.slice(0, separator).trim().replace(/^"|"$/g, "");
-		const manual = Number(trimmed.slice(separator + 1).trim());
-		if (!Number.isFinite(manual)) {
-			if (index > 0 && ![
-				"function",
-				"funcao",
-				"função"
-			].includes(name)) throw new Error(`line ${index + 1}: unreadable function points in "${trimmed}"`);
-			continue;
-		}
-		samples.push({
-			function: name,
-			manual
-		});
-	}
-	return samples;
-}
-//#endregion
-//#region src/albrecht/diff.ts
+//#region src/cli/load_config.ts
 /**
-* Added, changed and removed functions between two counts — what becomes an
-* invoice.
-*
-* Normative base: **OMG Automated Enhancement Points 1.0**, the sibling of AFP,
-* written to size maintenance between two revisions.
-*
-*   "Each Artifact shall be analyzed in both revisions to determine whether it
-*    is: Added — when it exists in revision ToRevision while it didn't exist in
-*    FromRevision. […] Modified — when it exists in both revisions but whose
-*    source code changed."  — AEP §6.3
-*
-* Two decisions make this workable:
+* Loads `config/function_points.ts` from the application being analysed.
 *
-* 1. **It operates on two saved counts**, never on two checkouts. Booting the
-*    older revision, with possibly different dependencies, is the kind of
-*    problem not worth solving.
-* 2. **It refuses to compare different rule sets.** If the rules changed in
-*    between, the difference measures the rule change, not the work — and the
-*    result would go into an invoice.
-*/
-var IncomparableRulesetsError = class extends Error {
-	constructor(from, to) {
-		super(`counts from different rule sets are not comparable: ${from} vs ${to}. The rules changed between the two measurements, so the difference does not measure work — it measures the rule change.`);
-		this.name = "IncomparableRulesetsError";
-	}
-};
-const AEP_FACTORS = {
-	added: 1,
-	changed: 1,
-	removed: .4,
-	unchanged: 0
-};
-/**
-* Two counts of DIFFERENT applications compare cleanly and mean nothing.
+* Both front-ends need this and neither could do it alone: the ace commands run
+* with `startApp: false`, so there is no booted container to read config from;
+* and the standalone CLI has no container at all. The file is therefore
+* imported directly, through jiti, which transforms the whole module graph —
+* a config may import a resolver from the application, and that resolver may
+* import files using decorators, which Node's type stripping cannot handle.
 *
-* The ruleset guard already refuses counts produced by different rules. This
-* refuses counts produced over different subjects, which is the same class of
-* error and the easier one to make in CI, where both files arrive as paths.
+* **A config that exists and fails to load is an error, never a fallback.**
+* Falling back to defaults with a warning would silently change the count, and
+* the count becomes an invoice. Absence of a config file is a different thing,
+* and is legitimate: it means the defaults.
 */
-var IncomparableSourcesError = class extends Error {
-	constructor(from, to) {
-		super(`refusing to compare counts of different applications: "${from}" and "${to}". The difference would not measure work, it would measure that the two files are about different things.`);
-		this.from = from;
-		this.to = to;
-		this.name = "IncomparableSourcesError";
+const CONFIG_PATHS = ["config/function_points.ts", "config/function_points.js"];
+var ConfigLoadError = class extends Error {
+	constructor(file, cause) {
+		super(`failed to load ${file}: ${cause instanceof Error ? cause.message : String(cause)}\nThe count was NOT produced. Fix the configuration, or remove the file to use the defaults — falling back silently would change the number without telling you.`);
+		this.file = file;
+		this.cause = cause;
+		this.name = "ConfigLoadError";
 	}
 };
-function diffCounts(from, to, options = {}) {
-	if (from.rulesetVersion !== to.rulesetVersion || from.ruleset !== to.ruleset) throw new IncomparableRulesetsError(`${from.ruleset}@${from.rulesetVersion}`, `${to.ruleset}@${to.rulesetVersion}`);
-	if (from.source && to.source && from.source.app !== to.source.app) throw new IncomparableSourcesError(from.source.app, to.source.app);
-	const factors = {
-		...AEP_FACTORS,
-		...options.factors
+async function loadConfig(root) {
+	const found = CONFIG_PATHS.map((candidate) => path.join(root, candidate)).find((candidate) => existsSync(candidate));
+	if (!found) return {
+		config: { ...DEFAULTS },
+		file: null
 	};
-	const before = new Map(from.functions.map((fn) => [fn.id, fn]));
-	const after = new Map(to.functions.map((fn) => [fn.id, fn]));
-	const entries = [];
-	for (const [id, fn] of after) {
-		const previous = before.get(id);
-		if (!previous) {
-			entries.push({
-				function: fn,
-				change: "added"
-			});
-			continue;
-		}
-		const reason = reasonBetween(previous, fn);
-		entries.push({
-			function: fn,
-			change: reason ? "changed" : "unchanged",
-			previous,
-			...reason ? { reason } : {}
-		});
-	}
-	for (const [id, fn] of before) if (!after.has(id)) entries.push({
-		function: fn,
-		change: "removed"
-	});
-	const warnings = [];
-	/**
-	* Provenance warnings. None of them stops the comparison — they qualify the
-	* number that comes out of it, which is what goes onto an invoice.
-	*/
-	for (const [side, count] of [["from", from], ["to", to]]) {
-		if (!count.source) {
-			warnings.push(`the "${side}" count records no source: it cannot be tied to a revision, so this difference cannot be reproduced or audited later.`);
-			continue;
-		}
-		if (count.source.dirty) warnings.push(`the "${side}" count was taken over a tree with uncommitted changes (${count.source.app}${count.source.revision ? ` at ${count.source.revision.slice(0, 8)}` : ""}): no revision reproduces it.`);
+	let loaded;
+	try {
+		loaded = await createJiti(pathToFileURL(path.join(root, "noop.js")).href, { interopDefault: true }).import(found, { default: true });
+	} catch (error) {
+		throw new ConfigLoadError(found, error);
 	}
-	if (from.source?.revision && from.source.revision === to.source?.revision && !from.source.dirty && !to.source.dirty) warnings.push(`both counts are of the same revision (${from.source.revision.slice(0, 8)}): any difference here comes from the tool or its configuration, not from work done.`);
-	if (entries.some((entry) => entry.change === "changed") && factors.changed === 1) warnings.push("change factor pinned at 1: AEP grades it from 0.25 to 1.75 through Effort Complexity variation, which requires cyclomatic complexity — not measured yet. Changed functions are being billed at full value.");
+	if (!loaded || typeof loaded !== "object") throw new ConfigLoadError(found, /* @__PURE__ */ new Error("the default export is not a configuration object"));
 	return {
-		from: options.labels?.from ?? "previous",
-		to: options.labels?.to ?? "current",
-		entries: entries.sort(byChangeThenName),
-		totals: totalsOf(entries),
-		changedByReason: changedByReasonOf(entries),
-		billable: entries.reduce((total, entry) => total + entry.function.points * factors[entry.change], 0),
-		factors,
-		warnings
-	};
-}
-/**
-* What counts as a change.
-*
-* A change in the implementation scope (checksum of the normalised AST) **or**
-* in the functional size. Formatting and comments do not count: the hash
-* already ignores them.
-*
-* Renaming a route does not show up here because identity is
-* `(verb, pattern)` — and neither does moving a controller between modules,
-* which is implementation.
-*/
-/**
-* Why the function changed, or null when it did not.
-*
-* Reported by the most consequential cause: a reclassification usually moves
-* the size too, and naming the type is the fact that explains the rest. The
-* rendered line carries the DET and FTR movement, so nothing is hidden behind
-* the label.
-*/
-function reasonBetween(previous, current) {
-	if (previous.type !== current.type) return "type";
-	if (previous.det !== current.det || previous.refs !== current.refs) return "size";
-	if ((previous.scopeHash ?? "") !== (current.scopeHash ?? "")) return "implementation";
-	return null;
-}
-/**
-* Where an invoice actually comes from.
-*
-* `changed` is usually the largest line, and until this split it said nothing
-* about whether it was paying for growth or for refactoring.
-*/
-function changedByReasonOf(entries) {
-	const byReason = {
-		type: {
-			count: 0,
-			points: 0
-		},
-		size: {
-			count: 0,
-			points: 0
-		},
-		implementation: {
-			count: 0,
-			points: 0
-		}
+		config: defineConfig(loaded),
+		file: toPosix(found)
 	};
-	for (const entry of entries) {
-		if (entry.change !== "changed" || !entry.reason) continue;
-		byReason[entry.reason].count++;
-		byReason[entry.reason].points += entry.function.points;
-	}
-	return byReason;
 }
-const ORDER = {
-	added: 0,
-	changed: 1,
-	removed: 2,
-	unchanged: 3
-};
-const byChangeThenName = (a, b) => ORDER[a.change] - ORDER[b.change] || a.function.name.localeCompare(b.function.name);
-function totalsOf(entries) {
-	const totals = {
-		added: {
-			count: 0,
-			points: 0
-		},
-		changed: {
-			count: 0,
-			points: 0
-		},
-		removed: {
-			count: 0,
-			points: 0
-		},
-		unchanged: {
-			count: 0,
-			points: 0
-		}
-	};
-	for (const entry of entries) {
-		totals[entry.change].count++;
-		totals[entry.change].points += entry.function.points;
+//#endregion
+//#region src/cli/print.ts
+function printResult(result, printer) {
+	for (const note of result.notes ?? []) printer.note(note);
+	if (result.errors?.length) {
+		for (const message of result.errors) printer.error(message);
+		return 1;
 	}
-	return totals;
+	if (result.output) printer.log(result.output);
+	return 0;
 }
 //#endregion
 //#region src/reporters/table.ts
@@ -355,6 +114,41 @@ function renderCount(result) {
 	return lines.join("\n");
 }
 /** `fp:explain`: a function's provenance, which is what supports a dispute */
+/**
+* Structure and conformance, beside the count and never instead of it.
+*
+* If function points pay, the team optimises function points — more models, more
+* endpoints, less reuse. Density and coupling on the same report are the
+* counterweight, which is why this shares the inventory rather than collecting
+* anything of its own.
+*/
+function renderMetrics(structure, conformance, coverage) {
+	const lines = [];
+	lines.push("Density");
+	lines.push(`  FP per data store:            ${structure.pointsPerDataStore.toFixed(1)}`);
+	lines.push(`  transactions per data store:  ${structure.transactionsPerDataStore.toFixed(1)}`);
+	lines.push("");
+	lines.push("Conformance");
+	for (const [label, value] of [
+		["inputs with a validator", conformance.inputsWithValidator],
+		["entry points with a handler", conformance.entryPointsWithHandler],
+		["data stores reached", conformance.dataStoresReached]
+	]) lines.push(`  ${pad(label, 28)}${padStart(`${(value.ratio * 100).toFixed(1)}%`, 7)}   (${value.ok}/${value.total})`);
+	lines.push(`  ${pad("tracing coverage", 28)}${padStart(`${(coverage.ratio * 100).toFixed(1)}%`, 7)}   (${coverage.unresolvedCalls} unresolved calls)`);
+	lines.push("");
+	lines.push(`${pad("module", 20)}${padStart("FP", 6)}${padStart("trans", 7)}${padStart("stores", 7)}${padStart("I", 6)}  depends on`);
+	for (const module of structure.modules) lines.push(`${pad(module.module.slice(0, 19), 20)}${padStart(module.functionPoints, 6)}${padStart(module.transactions, 7)}${padStart(module.dataStores, 7)}${padStart(module.instability.toFixed(2), 6)}  ${module.dependsOn.join(", ")}`);
+	/**
+	* Reported, not scored. A cycle between two modules is a fact about the code
+	* that a number would hide, and the decision about it is the team's.
+	*/
+	if (structure.mutualDependencies.length > 0) {
+		lines.push("");
+		lines.push("Mutual dependencies (cycle candidates)");
+		for (const [a, b] of structure.mutualDependencies) lines.push(`  ${a} <-> ${b}`);
+	}
+	return lines.join("\n");
+}
 function renderExplain(fn) {
 	const lines = [];
 	lines.push(`${fn.name}  —  ${fn.type}, ${fn.complexity} complexity, ${fn.points} FP`);
@@ -415,70 +209,40 @@ function renderDiff(diff) {
 		*/
 		if (change === "changed") for (const [reason, split] of Object.entries(diff.changedByReason)) {
 			if (split.count === 0) continue;
-			lines.push(`  ${pad(reason, 16)}${padStart(split.count, 3)} functions${padStart(split.points, 6)} FP`);
+			/**
+			* The effective factor, per reason. Printing only the `changed` factor
+			* hid that `implementation` — no change in type, DET or FTR — was being
+			* billed at the same rate as a functional one.
+			*/
+			const effective = diff.reasonFactors[reason];
+			lines.push(`  ${pad(reason, 16)}${padStart(split.count, 3)} functions${padStart(split.points, 6)} FP` + (effective === void 0 ? "" : `  × ${effective}`));
 		}
 	}
 	lines.push("");
 	lines.push(`Billable FP: ${diff.billable}`);
-	const mudou = diff.entries.filter((entry) => entry.change !== "unchanged");
-	if (mudou.length > 0) {
+	/**
+	* Before the per-function list, not after it.
+	*
+	* On a real pair of releases the list is over a hundred lines, and a caveat
+	* about how most of the total was priced sat below all of them. A warning that
+	* has to be scrolled to is not a warning — and this particular number becomes
+	* an invoice.
+	*/
+	for (const warning of diff.warnings) {
+		lines.push("");
+		lines.push(`Warning: ${warning}`);
+	}
+	const moved = diff.entries.filter((entry) => entry.change !== "unchanged");
+	if (moved.length > 0) {
 		lines.push("");
-		for (const entry of mudou) {
+		for (const entry of moved) {
 			const label = entry.reason ? `${entry.change} (${entry.reason})` : entry.change;
 			lines.push(`  ${pad(label, 26)} ${pad(entry.function.name.slice(0, 40), 41)}${padStart(entry.function.points, 4)} PF${movementOf(entry)}`);
 		}
 	}
-	for (const warning of diff.warnings) {
-		lines.push("");
-		lines.push(`Warning: ${warning}`);
-	}
 	return lines.join("\n");
 }
 //#endregion
-//#region src/cli/load_config.ts
-/**
-* Loads `config/function_points.ts` from the application being analysed.
-*
-* Both front-ends need this and neither could do it alone: the ace commands run
-* with `startApp: false`, so there is no booted container to read config from;
-* and the standalone CLI has no container at all. The file is therefore
-* imported directly, through jiti, which transforms the whole module graph —
-* a config may import a resolver from the application, and that resolver may
-* import files using decorators, which Node's type stripping cannot handle.
-*
-* **A config that exists and fails to load is an error, never a fallback.**
-* Falling back to defaults with a warning would silently change the count, and
-* the count becomes an invoice. Absence of a config file is a different thing,
-* and is legitimate: it means the defaults.
-*/
-const CONFIG_PATHS = ["config/function_points.ts", "config/function_points.js"];
-var ConfigLoadError = class extends Error {
-	constructor(file, cause) {
-		super(`failed to load ${file}: ${cause instanceof Error ? cause.message : String(cause)}\nThe count was NOT produced. Fix the configuration, or remove the file to use the defaults — falling back silently would change the number without telling you.`);
-		this.file = file;
-		this.cause = cause;
-		this.name = "ConfigLoadError";
-	}
-};
-async function loadConfig(root) {
-	const found = CONFIG_PATHS.map((candidate) => path.join(root, candidate)).find((candidate) => existsSync(candidate));
-	if (!found) return {
-		config: { ...DEFAULTS },
-		file: null
-	};
-	let loaded;
-	try {
-		loaded = await createJiti(pathToFileURL(path.join(root, "noop.js")).href, { interopDefault: true }).import(found, { default: true });
-	} catch (error) {
-		throw new ConfigLoadError(found, error);
-	}
-	if (!loaded || typeof loaded !== "object") throw new ConfigLoadError(found, /* @__PURE__ */ new Error("the default export is not a configuration object"));
-	return {
-		config: defineConfig(loaded),
-		file: toPosix(found)
-	};
-}
-//#endregion
 //#region src/cli/runners.ts
 /**
 * An empty inventory is never a number.
@@ -556,6 +320,42 @@ async function runCount(options) {
 		output: options.json ? JSON.stringify(count, null, 2) : renderCount(count)
 	};
 }
+/**
+* Structure and conformance, from the same inventory as the count.
+*
+* These were implemented and tested and reachable from no front-end at all,
+* which is the recurring defect of this package: a capability that exists,
+* typed and covered, and that nobody can run. A metric nobody can run is not a
+* metric.
+*/
+async function runMetrics(options) {
+	const { config, notes } = await configFor(options.root);
+	const { inventory, count } = await analyze(options.root, config);
+	const empty = refuseIfEmpty(options.root, inventory.dataStores.length, inventory.entryPoints.length);
+	if (empty) return {
+		output: "",
+		notes,
+		errors: empty
+	};
+	const structure = measureStructure(inventory, count);
+	const conformance = measureConformance(inventory);
+	if (options.out) {
+		await writeFile(options.out, JSON.stringify({
+			source: count.source,
+			structure,
+			conformance
+		}, null, 2));
+		notes.push(`metrics written to ${options.out}`);
+	}
+	return {
+		notes,
+		output: options.json ? JSON.stringify({
+			source: count.source,
+			structure,
+			conformance
+		}, null, 2) : renderMetrics(structure, conformance, inventory.coverage)
+	};
+}
 async function runExplain(options) {
 	const { config, notes } = await configFor(options.root);
 	const { count } = await analyze(options.root, config);
@@ -595,10 +395,14 @@ async function runDiff(options) {
 	try {
 		return {
 			notes,
-			output: renderDiff(diffCounts(previous, current, { labels: {
-				from: options.previous,
-				to
-			} }))
+			output: renderDiff(diffCounts(previous, current, {
+				labels: {
+					from: options.previous,
+					to
+				},
+				factors: config.diff?.factors,
+				reasonFactors: config.diff?.reasonFactors
+			}))
 		};
 	} catch (error) {
 		if (error instanceof IncomparableRulesetsError || error instanceof IncomparableSourcesError) return {
@@ -627,4 +431,4 @@ async function runCalibrate(options) {
 	};
 }
 //#endregion
-export { runInventory as a, runExplain as i, runCount as n, ConfigLoadError as o, runDiff as r, printResult as s, runCalibrate as t };
+export { runInventory as a, ConfigLoadError as c, runExplain as i, runCount as n, runMetrics as o, runDiff as r, printResult as s, runCalibrate as t };

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

@@ -21,8 +21,20 @@ export declare const RULESET = "afp";
  * It appears in every report, and `fp:diff` refuses to compare counts produced
  * by different versions — otherwise the difference would measure the rule
  * change rather than the work.
+ *
+ * It must be bumped by ANY change that moves the number for unchanged code, and
+ * 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,
+ * `detFromSchema` no longer subtracting a placeholder that was not there, and a
+ * write through `related(…)` maintaining the related table.
+ *
+ * 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.0.0";
+export declare const RULESET_VERSION = "1.2.0";
 export type CountInput = {
     app: AppContext;
     stores: CollectedDataStore[];
@@ -31,6 +43,12 @@ export type CountInput = {
     behaviors: Map<string, Behavior>;
     /** JSON Schema literals found in the code, for `detFromSchema` — §8 */
     jsonSchemas?: Map<string, DiscoveredSchema>;
+    /**
+     * 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
+     * seeder is this application just as much as a route is.
+     */
+    writtenAnywhere?: Set<string>;
 };
 export type CountOptions = {
     retStrategy?: 'constant' | 'composition';
@@ -39,6 +57,8 @@ export type CountOptions = {
     boundary?: {
         infrastructure?: string[];
         externallyMaintained?: string[];
+        /** restores what the AFP naming filter caught by accident */
+        business?: string[];
         ignoreEntryPoints?: string[];
     };
     messageDet?: number;

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

@@ -26,6 +26,12 @@ export type DataFunctionOptions = {
     retStrategy: 'constant' | 'composition';
     /** stores maintained by another system, by boundary decision */
     externallyMaintained: Set<string>;
+    /**
+     * Stores the application writes anywhere in its code — a job, a seeder, a
+     * command — whether or not a route reaches that write. §6.5.4 asks who
+     * maintains the store, not which route does.
+     */
+    writtenAnywhere: Set<string>;
     tables: Record<FunctionType, ComplexityTable>;
     weights: Record<FunctionType, Record<Complexity, number>>;
 };

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

@@ -1,4 +1,4 @@
-import type { ChangeType, CountResult, DiffResult } from '../types.js';
+import type { ChangeReason, ChangeType, CountResult, DiffResult } from '../types.js';
 /**
  * Added, changed and removed functions between two counts — what becomes an
  * invoice.
@@ -37,8 +37,24 @@ export declare class IncomparableRulesetsError extends Error {
  */
 export type ChangeFactors = Record<ChangeType, number>;
 export declare const AEP_FACTORS: ChangeFactors;
+/**
+ * Factors for a modified function, by WHAT changed about it.
+ *
+ * The distinction is already measured — `type`, `size` and `implementation` come
+ * out of the same comparison — and pricing all three at 1 throws that away. It
+ * showed up on a real pair of releases: of 378 FP billed as changed, 151 came
+ * from functions whose type, DET and FTR were all identical and only the body
+ * differed. Charging a refactor at full functional value is not defensible, and
+ * charging it at a number this package invented would be worse.
+ *
+ * So no default changes: each reason falls back to `factors.changed`, and the
+ * contract sets what it agreed to price. What the tool owes is the split.
+ */
+export type ChangeReasonFactors = Partial<Record<ChangeReason, number>>;
 export type DiffOptions = {
     factors?: Partial<ChangeFactors>;
+    /** per-reason factors for modified functions; each falls back to `factors.changed` */
+    reasonFactors?: ChangeReasonFactors;
     /** labels for the two measurements, for the report only */
     labels?: {
         from: string;
@@ -49,6 +65,8 @@ export type FunctionPointDiff = DiffResult & {
     /** function points weighted by the factors — this is what gets billed */
     billable: number;
     factors: ChangeFactors;
+    /** what the modified functions were actually billed at, by reason */
+    reasonFactors: ChangeReasonFactors;
     warnings: string[];
 };
 /**

package/build/src/cli/runners.d.ts

@@ -30,6 +30,18 @@ export declare function runCount(options: Common & {
     json?: boolean;
     minCoverage?: number;
 }): Promise<RunResult>;
+/**
+ * Structure and conformance, from the same inventory as the count.
+ *
+ * These were implemented and tested and reachable from no front-end at all,
+ * which is the recurring defect of this package: a capability that exists,
+ * typed and covered, and that nobody can run. A metric nobody can run is not a
+ * metric.
+ */
+export declare function runMetrics(options: Common & {
+    out?: string;
+    json?: boolean;
+}): Promise<RunResult>;
 export declare function runExplain(options: Common & {
     name: string;
 }): Promise<RunResult>;