@filipebraida/adonis-function-points 0.2.0 → 0.4.0

package/build/{runners-DpMd-yZM.js → runners-DetZGfh5.js}

@@ -1,6 +1,6 @@
-import { n as defineConfig, t as DEFAULTS } from "./define_config-DOqWyPwV.js";
-import { c as toPosix } from "./resolvers-MFjRl2ef.js";
-import { n as analyze } from "./pipeline-DySlMWcN.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 { l as toPosix } from "./resolvers-vMahHkAd.js";
+import { n as analyze } from "./pipeline-Dm9KvUvF.js";
 import { readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { existsSync } from "node:fs";
@@ -61,390 +61,6 @@ function printResult(result, printer) {
 	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$1(bucket.manual / bucket.automatic),
-		meanAbsoluteDeviation: round$1(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$1((automaticTotal - manualTotal) / manualTotal),
-			exactMatches: exactTotal
-		},
-		unmatched,
-		warnings
-	};
-}
-const round$1 = (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
-/**
-* 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:
-*
-* 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.
-*
-* 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.
-*/
-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";
-	}
-};
-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
-	};
-	const reasonFactors = options.reasonFactors ?? {};
-	/** the factor a single entry is billed at, which is the per-reason one when set */
-	const factorFor = (entry) => entry.change === "changed" && entry.reason ? reasonFactors[entry.reason] ?? factors.changed : factors[entry.change];
-	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.`);
-	}
-	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.`);
-	/**
-	* Quantified, because the generic sentence was not actionable.
-	*
-	* On a real pair of releases this warning sat under 118 lines of per-function
-	* output, saying only that the factor was pinned. What a client disputes is
-	* the amount, so the amount is what it has to say.
-	*/
-	const changedPoints = entries.filter((entry) => entry.change === "changed").reduce((total, entry) => total + entry.function.points, 0);
-	if (changedPoints > 0 && factors.changed === 1 && reasonFactors.implementation === void 0) {
-		const byReason = changedByReasonOf(entries);
-		const billable = round2(entries.reduce((total, entry) => total + entry.function.points * factorFor(entry), 0));
-		const share = billable === 0 ? 0 : Math.round(changedPoints / billable * 100);
-		warnings.push(`${changedPoints} of ${billable} billable FP (${share}%) are modified functions at a factor pinned to 1. AEP grades it from 0.25 to 1.75 through Effort Complexity variation, which needs cyclomatic complexity — not measured yet. Of those, ${byReason.implementation.points} FP changed implementation only (same type, DET and FTR): set \`reasonFactors\` to price that differently.`);
-	}
-	return {
-		from: options.labels?.from ?? "previous",
-		to: options.labels?.to ?? "current",
-		entries: entries.sort(byChangeThenName),
-		totals: totalsOf(entries),
-		changedByReason: changedByReasonOf(entries),
-		/**
-		* Rounded to cents at the source, not at the print.
-		*
-		* `485.00000000000006` appeared on the first real diff. It is arithmetically
-		* the same number and it is not the same document: this value is quoted in
-		* an invoice, and a reader who sees that tail stops trusting the rest.
-		*/
-		billable: round2(entries.reduce((total, entry) => total + entry.function.points * factorFor(entry), 0)),
-		factors,
-		reasonFactors,
-		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
-		}
-	};
-	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;
-	}
-	return totals;
-}
-/** two decimals: this number is quoted in an invoice */
-const round2 = (value) => Math.round(value * 100) / 100;
-//#endregion
-//#region src/metrics/structure.ts
-function measureStructure(inventory, count) {
-	/** store -> module that declares it */
-	const storeModule = new Map(inventory.dataStores.map((store) => [store.name, store.module]));
-	/** entry point -> module */
-	const entryModule = new Map(inventory.entryPoints.map((entry) => [entry.id, entry.module]));
-	const modules = new Set([...storeModule.values(), ...entryModule.values()]);
-	const dependsOn = /* @__PURE__ */ new Map();
-	for (const module of modules) dependsOn.set(module, /* @__PURE__ */ new Set());
-	/**
-	* The dependency that matters is USE, not import: module A depends on B when
-	* a transaction of A reaches a store declared in B. A type-only import
-	* creates no functional coupling.
-	*/
-	for (const behavior of inventory.behaviors) {
-		const from = entryModule.get(behavior.entryPointId);
-		if (!from) continue;
-		for (const store of behavior.touches) {
-			const to = storeModule.get(store);
-			if (!to || to === from) continue;
-			dependsOn.get(from)?.add(to);
-		}
-	}
-	const dependedOnBy = /* @__PURE__ */ new Map();
-	for (const module of modules) dependedOnBy.set(module, /* @__PURE__ */ new Set());
-	for (const [from, targets] of dependsOn) for (const to of targets) dependedOnBy.get(to)?.add(from);
-	const transactionsPerModule = /* @__PURE__ */ new Map();
-	for (const module of entryModule.values()) transactionsPerModule.set(module, (transactionsPerModule.get(module) ?? 0) + 1);
-	const storesPerModule = /* @__PURE__ */ new Map();
-	for (const module of storeModule.values()) storesPerModule.set(module, (storesPerModule.get(module) ?? 0) + 1);
-	const moduleMetrics = [...modules].map((module) => {
-		const ce = dependsOn.get(module).size;
-		const ca = dependedOnBy.get(module).size;
-		return {
-			module,
-			functionPoints: count.totals.byModule[module] ?? 0,
-			transactions: transactionsPerModule.get(module) ?? 0,
-			dataStores: storesPerModule.get(module) ?? 0,
-			dependsOn: [...dependsOn.get(module)].sort(),
-			dependedOnBy: [...dependedOnBy.get(module)].sort(),
-			instability: ca + ce === 0 ? 0 : round(ce / (ca + ce))
-		};
-	}).sort((a, b) => b.functionPoints - a.functionPoints);
-	const mutual = [];
-	for (const [from, targets] of dependsOn) for (const to of targets) if (from < to && dependsOn.get(to)?.has(from)) mutual.push([from, to]);
-	const stores = inventory.dataStores.length || 1;
-	return {
-		modules: moduleMetrics,
-		mutualDependencies: mutual.sort(),
-		pointsPerDataStore: round(count.totals.unadjusted / stores),
-		transactionsPerDataStore: round(inventory.entryPoints.length / stores)
-	};
-}
-function measureConformance(inventory) {
-	const behaviors = inventory.behaviors;
-	const takesInput = behaviors.filter((behavior) => behavior.inputFields.length > 0 || behavior.requestFields.length > 0 || behavior.opaqueRequest);
-	const withValidator = takesInput.filter((behavior) => behavior.inputFields.length > 0);
-	const withHandler = inventory.entryPoints.filter((entry) => entry.handler !== null);
-	const reached = new Set(behaviors.flatMap((behavior) => behavior.touches));
-	return {
-		inputsWithValidator: ratio(withValidator.length, takesInput.length),
-		entryPointsWithHandler: ratio(withHandler.length, inventory.entryPoints.length),
-		dataStoresReached: ratio(reached.size, inventory.dataStores.length)
-	};
-}
-const ratio = (ok, total) => ({
-	ok,
-	total,
-	ratio: total === 0 ? 1 : round(ok / total)
-});
-const round = (value) => Math.round(value * 1e3) / 1e3;
-//#endregion
 //#region src/reporters/table.ts
 /**
 * Text reports.
@@ -743,7 +359,17 @@ async function runMetrics(options) {
 async function runExplain(options) {
 	const { config, notes } = await configFor(options.root);
 	const { count } = await analyze(options.root, config);
-	const matched = count.functions.filter((fn) => fn.name.toLowerCase().includes(options.name.toLowerCase()));
+	/**
+	* An exact name wins outright; the substring search is the fallback.
+	*
+	* `fp:explain "POST /orders/:param/submit"` returned four functions, because
+	* `/submit`, `/submit-ready` and `/submit-ready/return` all contain it. Asking
+	* about a function by its exact name and being handed its neighbours makes the
+	* command useless for the thing it exists for — defending one number.
+	*/
+	const wanted = options.name.toLowerCase();
+	const exact = count.functions.filter((fn) => fn.name.toLowerCase() === wanted);
+	const matched = exact.length > 0 ? exact : count.functions.filter((fn) => fn.name.toLowerCase().includes(wanted));
 	if (matched.length === 0) return {
 		output: "",
 		notes,

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

@@ -23,14 +23,18 @@ export declare const RULESET = "afp";
  * 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
+ * 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. Without the bump, a baseline saved by the previous version would have
- * compared cleanly against this one and billed the tool's own improvement as work
- * done. The guard exists for exactly that, and only this constant arms it.
+ * 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.1.0";
+export declare const RULESET_VERSION = "1.3.0";
 export type CountInput = {
     app: AppContext;
     stores: CollectedDataStore[];

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

@@ -31,5 +31,14 @@ export type TransactionOptions = {
     messageDet: number;
     tables: Record<FunctionType, ComplexityTable>;
     weights: Record<FunctionType, Record<Complexity, number>>;
+    /**
+     * Application root, used only to relativise the paths that LEAVE in the trace.
+     *
+     * `CountSource.app` is documented as never being the absolute path, because it
+     * says where the machine keeps its files and travels with every count sent
+     * anywhere. The trace shipped the absolute path regardless — 858 times in a
+     * single production count, which is most of the artefact a ledger would store.
+     */
+    root: string;
 };
 export declare function countTransactionalFunctions(entryPoints: CollectedEntryPoint[], behaviors: Map<string, Behavior>, options: TransactionOptions): CountedFunction[];

package/build/src/cli.js

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

package/build/src/define_config.d.ts

@@ -161,9 +161,34 @@ export type FunctionOverride = {
      *
      * A name that matches no schema is a warning, never a silent fallback.
      */
-    detFromSchema?: string;
+    /**
+     * Name of a declared schema, or several whose fields are UNIONED.
+     *
+     * An ILF's DETs are the fields the user recognises in the file, and an
+     * application with one schema per template recognises the fields of all of them.
+     * Pointing at the largest and justifying it in `reason` gives the same answer
+     * only while they land in the same complexity band — which is a piece of
+     * reasoning the configuration should not have to carry.
+     *
+     * Unioned by leaf path, so a field two templates share counts once.
+     */
+    detFromSchema?: string | string[];
     /** declared RET (data function) or FTR (transaction) */
     refs?: number;
+    /**
+     * Opaque DETs someone has looked at and decided are correct at 1.
+     *
+     * `fp:count` reports every opaque column and open input object, because 1 DET is
+     * a floor rather than a measurement. But some of them ARE one field — a copy, a
+     * checksum, a bag of metadata — and there was no way to say so, so the warning
+     * fired on every run forever. A warning that cannot be answered is a warning the
+     * team learns to scroll past, which costs more than the one it reports.
+     *
+     * It silences nothing else: the count does not move, and `fp:count` still says
+     * how many were reviewed. Names are matched bare (`schema`) or qualified
+     * (`Petition.schema`).
+     */
+    opaqueReviewed?: string[];
     /** why — required, and printed by `fp:explain` beside the number */
     reason: string;
 };

package/build/src/inventory/detectors/lucid.d.ts

@@ -31,6 +31,14 @@ export type PersistenceAccess = {
      * relation out of the count (§6.5.4) when it is a legitimate EIF.
      */
     viaRelation?: string;
+    /**
+     * Whether the access WRITES the related table.
+     *
+     * `preload('author')` reads it; `related('files').create(…)` writes it. Treating
+     * every relation access as a read made a table written only through a relation
+     * look externally maintained.
+     */
+    relationWritten?: boolean;
     /**
      * Does this access fire the model's hooks?
      *

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

@@ -35,6 +35,8 @@ export type Behavior = {
      * fields of the VineJS schema — counting-decisions §7.
      */
     inputFields: string[];
+    /** input fields that enumerate nothing: an open `vine.object` */
+    opaqueInputFields: string[];
     /**
      * Fields read straight off the request. Kept apart from `inputFields` so the
      * conformance metric keeps meaning what it says: these are DETs, and they are

package/build/src/inventory/paths.d.ts

@@ -18,5 +18,22 @@
  * it to each comparison costs vigilance forever.
  */
 export declare const toPosix: (value: string) => string;
+/**
+ * A path as it should appear in an EMITTED artefact: relative to the application.
+ *
+ * `CountSource.app` is documented as never being the absolute path, because that
+ * says where the machine keeps its files and travels with every count sent
+ * anywhere. One field below it, `config` shipped the absolute path — and so did
+ * every `trace[].file`, 858 times in a single production count. The rule was
+ * stated and then applied to one field.
+ *
+ * Internally the absolute path is the right thing: it is what ts-morph resolves
+ * and what the call graph keys its caches on. So this converts at the boundary
+ * where a path LEAVES, and nowhere else.
+ *
+ * A path outside the root keeps its `../` prefix, which describes where it is
+ * without naming the home directory.
+ */
+export declare const relativeTo: (root: string, value: string) => string;
 /** Compares two paths that may have come from different sources. */
 export declare const samePath: (a: string | undefined, b: string | undefined) => boolean;

package/build/src/inventory/resolvers/index.js

@@ -1,2 +1,2 @@
-import { n as resolveCall, t as BUILTIN_CALL_RESOLVERS } from "../../../resolvers-MFjRl2ef.js";
+import { n as resolveCall, t as BUILTIN_CALL_RESOLVERS } from "../../../resolvers-vMahHkAd.js";
 export { BUILTIN_CALL_RESOLVERS, resolveCall };

package/build/src/inventory/source.d.ts

@@ -33,7 +33,14 @@ export type CountSource = {
      */
     dirty?: boolean;
     countedAt: string;
-    /** configuration file that shaped the count, or null for the defaults */
+    /**
+     * Configuration file that shaped the count, RELATIVE to the application root,
+     * or null for the defaults.
+     *
+     * Relative for the same reason `app` is a name: an absolute path says where the
+     * machine keeps its files, and this artefact is what goes into a ledger and to
+     * whoever receives the invoice.
+     */
     config: string | null;
 };
 export declare function describeSource(root: string, config: string | null): CountSource;

package/build/src/pipeline.js

@@ -1,2 +1,2 @@
-import { n as analyze, t as CoverageTooLowError } from "../pipeline-DySlMWcN.js";
+import { n as analyze, t as CoverageTooLowError } from "../pipeline-Dm9KvUvF.js";
 export { CoverageTooLowError, analyze };

package/build/src/types.d.ts

@@ -86,6 +86,13 @@ export type HandlerBehavior = {
     touches: string[];
     /** declared input fields (validators) */
     inputFields: Field[];
+    /**
+     * Input fields that enumerate nothing — an open `vine.object`.
+     *
+     * They count 1 DET each, like an opaque column, and are reported: the number
+     * is a floor, not a measurement.
+     */
+    opaqueInputFields: Field[];
     /**
      * Input fields read straight off the request, with no validator.
      *

package/build/stubs/config.stub

@@ -42,7 +42,13 @@ export default defineConfig({
    * here.
    */
   // overrides: {
-  //   'POST /forms': { det: 42, reason: 'JSON Schema form; 42 user fields' },
+  //   // one schema, or several whose fields are unioned by leaf path
+  //   Form: { detFromSchema: ['intakeSchema', 'reviewSchema'], reason: 'one per template' },
+  //
+  //   // 1 DET is a floor, and `fp:count` says so on every run. When 1 IS the right
+  //   // answer, record that someone checked — otherwise the warning becomes noise
+  //   // the team learns to scroll past. It moves no number.
+  //   Petition: { opaqueReviewed: ['schema', 'uiSchema'], reason: 'metadata; one field each' },
   // },
 
   /**

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@filipebraida/adonis-function-points",
   "description": "Automated function point counting and code metrics for AdonisJS applications.",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "engines": {
     "node": ">=24.0.0"
   },

package/build/define_config-DOqWyPwV.js

@@ -1,19 +0,0 @@
-//#region src/define_config.ts
-const DEFAULTS = {
-	boundary: {},
-	retStrategy: "constant",
-	maxDepth: 3,
-	messageDet: 0
-};
-function defineConfig(config) {
-	return {
-		...DEFAULTS,
-		...config,
-		boundary: {
-			...DEFAULTS.boundary,
-			...config.boundary
-		}
-	};
-}
-//#endregion
-export { defineConfig as n, DEFAULTS as t };