@filipebraida/adonis-function-points 0.5.0 → 0.7.0

package/build/{runners-DIt1G85i.js → runners-Dm7cWGa-.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 { d as toPosix } from "./resolvers-PJwo2Z8R.js";
-import { n as analyze } from "./pipeline-CNTBhs6o.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 { y as toPosix } from "./resolvers-DaU4uAqT.js";
+import { n as analyze } from "./pipeline-DO2301fV.js";
 import { readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { existsSync } from "node:fs";
@@ -225,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.
 	*
@@ -415,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,13 @@ import type { CollectedDataStore } from '../inventory/sources/data_stores.js';
 import type { CollectedEntryPoint } from '../inventory/sources/routes_ast.js';
 import type { Behavior } from '../inventory/graph/call_graph.js';
 import type { DiscoveredSchema } from '../inventory/sources/json_schemas.js';
+import type { CollectedJob } from '../inventory/sources/jobs.js';
+import type { OpaqueDeclaration } from './opaque.js';
 import type { Complexity, CountResult, FunctionType } from '../types.js';
 import type { FunctionOverride } from '../define_config.js';
 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 +30,23 @@ 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.
+ * Three in 1.6.0: an output's DETs are what the transaction DELIVERS (the render
+ * props, the response payload, what a command prints) read back to their origin;
+ * a function of the same file and a `.map(fn)` by reference are followed, so
+ * FTRs move; and ace commands are transactions, with flags as input.
  *
  * 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.4.0";
+export declare const RULESET_VERSION = "1.6.0";
 export type CountInput = {
     app: AppContext;
     stores: CollectedDataStore[];
@@ -43,22 +55,43 @@ export type CountInput = {
     behaviors: Map<string, Behavior>;
     /** JSON Schema literals found in the code, for `detFromSchema` — §8 */
     jsonSchemas?: Map<string, DiscoveredSchema>;
+    /** the queue jobs and who dispatches each — a job no transaction reaches is reported (plan 0.7 §D) */
+    jobs?: CollectedJob[];
     /**
      * Stores written anywhere in the application's code, reachable from an entry
      * point or not — AFP §6.5.4 asks who MAINTAINS the store, and a job or a
      * 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>;
     /**

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

@@ -37,6 +37,29 @@ export declare class IncomparableRulesetsError extends Error {
  */
 export type ChangeFactors = Record<ChangeType, number>;
 export declare const AEP_FACTORS: ChangeFactors;
+/**
+ * The Roteiro de Métricas de Software do SISP, v3.0 (Portaria SGD/MGI nº 3656,
+ * de 2026), §7.3 "Projeto de Melhoria" — what a Brazilian public contract names
+ * instead of AEP:
+ *
+ *   PF_MELHORIA = PF_INCLUÍDO + FI × PF_ALTERADO + 0,50 × PF_EXCLUÍDO + PF_CONVERSÃO
+ *
+ * where FI, the impact factor on an altered function, is 63% when the contractor
+ * developed or already maintains the function, and 84% when it did not (and must
+ * document it). This preset carries the 63% — a factory billing maintenance of
+ * its own work — and `diff.factors: { changed: 0.84 }` is the other case.
+ * PF_CONVERSÃO is data conversion, which this package does not count.
+ *
+ * Read from the guide's own PDF, not from memory: an earlier draft of this
+ * preset said 0,50 / 0,30, and v2.0 (2012) priced exclusion at 0,40. A contract
+ * binds to a revision, so the report prints which preset priced the total.
+ */
+export declare const SISP_FACTORS: ChangeFactors;
+export type FactorPreset = 'aep' | 'sisp';
+export declare const FACTOR_PRESETS: Record<FactorPreset, {
+    label: string;
+    factors: ChangeFactors;
+}>;
 /**
  * Factors for a modified function, by WHAT changed about it.
  *
@@ -52,6 +75,8 @@ export declare const AEP_FACTORS: ChangeFactors;
  */
 export type ChangeReasonFactors = Partial<Record<ChangeReason, number>>;
 export type DiffOptions = {
+    /** which published set of factors to start from; `factors` overrides it field by field */
+    preset?: FactorPreset;
     factors?: Partial<ChangeFactors>;
     /** per-reason factors for modified functions; each falls back to `factors.changed` */
     reasonFactors?: ChangeReasonFactors;
@@ -64,6 +89,8 @@ export type DiffOptions = {
 export type FunctionPointDiff = DiffResult & {
     /** function points weighted by the factors — this is what gets billed */
     billable: number;
+    /** the preset the factors started from — printed, because the total is quoted under it */
+    preset: FactorPreset;
     factors: ChangeFactors;
     /** what the modified functions were actually billed at, by reason */
     reasonFactors: ChangeReasonFactors;

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

@@ -8,6 +8,7 @@
  * Normative reference: OMG Automated Function Points 1.0 / ISO/IEC 19515.
  */
 export * from './tables.js';
+export * from './technical_filter.js';
 export * from './counter.js';
 export * from './diff.js';
 export * from './calibration.js';

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

@@ -0,0 +1,90 @@
+import type { CollectedDataStore } from '../inventory/sources/data_stores.js';
+import type { DiscoveredSchema } from '../inventory/sources/json_schemas.js';
+import type { CollectedEntryPoint } from '../inventory/sources/routes_ast.js';
+import type { Behavior } from '../inventory/graph/call_graph.js';
+import type { Complexity, CountedFunction, FunctionType } from '../types.js';
+import type { ComplexityTable } from './tables.js';
+/**
+ * DETs the analysis cannot read, and what a person declared about them —
+ * counting-decisions §8 and §9.
+ *
+ * Three shapes are opaque: a JSON column (`ast:surveys.answers`), an open
+ * input object (`validator:answerSurveyValidator.answers`), and a spread a
+ * transformer emits (`transformer:X.<this.resource.serialize()>`). Each counts
+ * 1 DET — a floor, never a zero — and is marked `(opaque)` in the rationale.
+ *
+ * A declaration is about the ORIGIN of the placeholder, not about a function,
+ * and it applies to every function that carries the DET: the data function and
+ * each transaction that takes or shows the column. Keyed by function it had to
+ * be written twice and still missed the third place, so the same column was
+ * worth two numbers in one count — and matching by bare name meant reviewing
+ * `Attachment.metadata` reviewed every `metadata` column of every table.
+ */
+export declare const OPAQUE_TYPE: RegExp;
+export declare const isOpaqueType: (type?: string) => boolean;
+export type OpaqueDeclaration = {
+    /**
+     * Name(s) of a JSON Schema declared in the application's code, whose fields
+     * are counted by the §7 leaf rules and replace the single DET the placeholder
+     * contributed. Several are unioned by leaf path: a field two templates share
+     * counts once.
+     *
+     * Prefer this to `overrides.<fn>.det`. A declared number freezes; naming the
+     * schema keeps the number coming from the code, and the only thing maintained
+     * by hand is the mapping — which changes when a form is born, not when a field
+     * is. A name that matches no schema is a warning, never a silent fallback.
+     */
+    schemas?: string | string[];
+    /**
+     * Someone looked, and 1 is the right answer — a copy, a checksum, a bag of
+     * metadata. Moves no number; stops the warning for this origin; is printed by
+     * `fp:explain` with its reason, and is not counted in the "declared by override"
+     * share, because nothing was declared.
+     */
+    reviewed?: true;
+    /** why — required, and printed beside the number */
+    reason: string;
+};
+export type ApplyOpaqueOptions = {
+    declarations: Record<string, OpaqueDeclaration>;
+    stores: CollectedDataStore[];
+    schemas: Map<string, DiscoveredSchema>;
+    tables: Record<FunctionType, ComplexityTable>;
+    weights: Record<FunctionType, Record<Complexity, number>>;
+};
+export type AppliedOpaque = {
+    functions: CountedFunction[];
+    /** origin -> how it was answered */
+    answered: Map<string, 'replaced' | 'reviewed'>;
+    warnings: string[];
+};
+/**
+ * Applies the declarations to every function carrying the origin they name.
+ *
+ *   schemas    the placeholder's 1 DET becomes the schema's leaves, and the line
+ *              says which schema stood in
+ *   reviewed   the placeholder stays 1, marked reviewed; the warning stops
+ *
+ * A declaration keyed by the physical table (`surveys.answers`) is accepted
+ * as well as one keyed by the model (`Survey.answers`): the count prints
+ * the model, `fp:explain` prints the table, and a person copies from either.
+ */
+export declare function applyOpaque(functions: CountedFunction[], options: ApplyOpaqueOptions): AppliedOpaque;
+export type OpaqueReportInput = {
+    functions: CountedFunction[];
+    stores: CollectedDataStore[];
+    entryPoints: CollectedEntryPoint[];
+    behaviors: Map<string, Behavior>;
+    answered: Map<string, 'replaced' | 'reviewed'>;
+};
+/**
+ * The floors still standing, by origin — the one blind spot this package used
+ * to keep to itself.
+ *
+ * Grouped by origin because that is what a declaration answers: one line for
+ * `Form.definition` however many transactions show it. A transformer's spread has
+ * its own warning and is not repeated here. Only what is unanswered is a request
+ * to do something; what was answered is counted at the end so the fact is
+ * recorded rather than erased.
+ */
+export declare function opaqueWarnings(input: OpaqueReportInput): string[];

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

@@ -9,17 +9,24 @@ import type { CollectedDataStore } from '../inventory/sources/data_stores.js';
  * Returns the reason when a table is technical, `null` otherwise: the report
  * must say WHY something was excluded, not merely that it was.
  */
+export type TechnicalPattern = {
+    /** printed in the report beside the exclusion */
+    label: string;
+    /** tested against the physical table name; a string is compiled case-insensitively */
+    pattern: RegExp | string;
+};
 /**
- * Naming conventions, with the defaults given by the spec itself (§6.5.2.1.3).
+ * Naming conventions, with the defaults given by the spec itself (§6.5.2.1.3)
+ * plus the one AdonisJS asks for.
+ *
+ * The standard treats these as user-provided inputs, so `boundary.technicalPatterns`
+ * REPLACES this list when set — a team that finds `.+types?` catching its
+ * business data drops it there — and `boundary.business` restores one table.
  *
- * The standard treats these as user-provided inputs, so they stay overridable
- * through the boundary configuration.
+ * `token` is not in the spec's list and is here because the framework's own
+ * tables are: `auth_access_tokens`, `remember_me_tokens`, `password_reset_tokens`.
+ * A token is the machinery of authentication, not data the user maintains, and
+ * on two applications it came out as an ILF at 7 PF each.
  */
-export declare const DEFAULT_TECHNICAL_PATTERNS: {
-    label: string;
-    pattern: RegExp;
-}[];
-export declare function isTechnical(store: CollectedDataStore, patterns?: {
-    label: string;
-    pattern: RegExp;
-}[]): string | null;
+export declare const DEFAULT_TECHNICAL_PATTERNS: TechnicalPattern[];
+export declare function isTechnical(store: CollectedDataStore, patterns?: TechnicalPattern[]): string | null;

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

@@ -3,6 +3,7 @@ import type { CollectedEntryPoint } from '../inventory/sources/routes_ast.js';
 import type { Behavior } from '../inventory/graph/call_graph.js';
 import type { Complexity, CountedFunction, FunctionType } from '../types.js';
 import type { ComplexityTable } from './tables.js';
+import type { StoreGrouping } from './data_functions.js';
 /**
  * Transactional functions: EI and EO.
  *
@@ -21,6 +22,12 @@ import type { ComplexityTable } from './tables.js';
 export type TransactionOptions = {
     /** stores that are counted; anything else contributes no FTR */
     countedStores: Map<string, CollectedDataStore>;
+    /**
+     * How the stores fold into data functions — counting-decisions §10. A
+     * transaction touching a detail and its master touches ONE logical file: one
+     * FTR, and the detail's link to the master is not an output DET.
+     */
+    grouping: StoreGrouping;
     /**
      * Extra DET for the confirmation or error message.
      *

package/build/src/cli.js

@@ -1,5 +1,5 @@
-import { t as CoverageTooLowError } from "../pipeline-CNTBhs6o.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-DIt1G85i.js";
+import { t as CoverageTooLowError } from "../pipeline-DO2301fV.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-Dm7cWGa-.js";
 import path from "node:path";
 import { existsSync, readFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";

package/build/src/define_config.d.ts

@@ -1,5 +1,7 @@
 import type { ComplexityTable } from './albrecht/tables.js';
-import type { ChangeFactors, ChangeReasonFactors } from './albrecht/diff.js';
+import type { ChangeFactors, ChangeReasonFactors, FactorPreset } from './albrecht/diff.js';
+import type { TechnicalPattern } from './albrecht/technical_filter.js';
+import type { OpaqueDeclaration } from './albrecht/opaque.js';
 import type { CallResolver } from './inventory/resolvers/types.js';
 import type { Complexity, FunctionType } from './types.js';
 /**
@@ -50,6 +52,16 @@ export type FunctionPointsConfig = {
          * filter missed, this one restores what it caught by accident.
          */
         business?: string[];
+        /**
+         * The naming conventions of the technical-data filter (AFP §6.5.2.1.3),
+         * tested against the physical table name.
+         *
+         * When set, this list REPLACES the defaults — the spec treats the patterns
+         * as user input, and a team whose business tables end in `_types` needs to
+         * drop that one, not add to it. `DEFAULT_TECHNICAL_PATTERNS` is exported to
+         * start from. Every exclusion still appears in the report with its label.
+         */
+        technicalPatterns?: TechnicalPattern[];
         /**
          * Entry points with no functional value to the user, by route name or by
          * identity (`GET /health`).
@@ -61,14 +73,17 @@ export type FunctionPointsConfig = {
         ignoreEntryPoints?: string[];
     };
     /**
-     * Strategy for RET, the logical subgroups of an ILF/EIF.
+     * How tables fold into data functions — counting-decisions §10.
      *
-     * `constant` pins it at 1, which is honest: what a user recognises as a
-     * subgroup is not derivable from code. `composition` derives it from
-     * composition relations; less accurate in general, but captures real
-     * aggregates.
+     * `usage` (the default): a composition child (`hasMany` / `hasOne`) that no
+     * application code addresses directly is a RET of its parent, not an ILF of
+     * its own — the user only ever sees it inside the parent. `none` keeps every
+     * table its own data function at RET 1, which is what rule sets before 1.5.0
+     * did; it exists to compare against an old count, not as a preference.
      */
-    retStrategy: 'constant' | 'composition';
+    dataFunctions?: {
+        grouping?: 'usage' | 'none';
+    };
     /**
      * Maximum depth in the call graph, starting at the handler.
      *
@@ -103,6 +118,16 @@ export type FunctionPointsConfig = {
      * this package invented would be worse. So the number comes from the contract.
      */
     diff?: {
+        /**
+         * Which published set of factors prices the change: `aep` (the default —
+         * added 1, changed 1, removed 0.4) or `sisp` (Roteiro de Métricas do SISP
+         * v3.0 §7.3 — inclusão 1,00, alteração × FI 0,63, exclusão 0,50; what a
+         * Brazilian public contract usually names). The FI is 0,84 when the
+         * contractor did not develop or maintain the function: set it with
+         * `factors: { changed: 0.84 }`. A contract binds to a revision of the guide
+         * — v2.0 priced exclusion at 0,40 — so check yours and override if it differs.
+         */
+        preset?: FactorPreset;
         factors?: Partial<ChangeFactors>;
         reasonFactors?: ChangeReasonFactors;
     };
@@ -126,71 +151,44 @@ export type FunctionPointsConfig = {
      */
     minCoverage?: number;
     /**
-     * Declared DET or RET/FTR for a function the analysis cannot read, keyed by
-     * the name it has in the count (`Invoice`, `POST /books`).
+     * What a person declares about a DET the analysis cannot read, keyed by its
+     * ORIGIN — counting-decisions §8:
+     *
+     *   'Survey.answers'                a JSON column (model or table name)
+     *   'answerSurveyValidator.answers' an open field of a validator
      *
-     * The case this exists for is a schema-driven application: when the fields a
-     * user fills live in a JSON column whose schema is stored in the database,
-     * there is nothing for static analysis to read and the column counts as 1 DET
-     * (counting-decisions §8). The person who knows the form knows the number.
+     * A declaration applies to every function carrying that DET: the data
+     * function and each transaction that takes or shows the column. Keyed by
+     * function it had to be repeated, and still left the transactions nobody
+     * wrote it for at the floor — the same column worth two numbers in one count.
+     *
+     * `schemas` names the JSON Schema(s) in the code whose fields replace the
+     * floor; `reviewed` records that 1 is the right answer. Both require `reason`,
+     * and `fp:count` reports how much of the total came from a declaration so it
+     * cannot grow unnoticed.
+     */
+    opaque?: Record<string, OpaqueDeclaration>;
+    /**
+     * A declared DET or RET for ONE function, keyed by the name it has in the
+     * count (`Invoice`, `POST /books`) — the last resort, for a fact that is not
+     * in the code at all (a schema that lives only in the database).
      *
      * `reason` is required, and that is the whole point. A declared number is
      * reproducible — it lives in a versioned file, so the same revision yields
      * the same count — and auditable, because `fp:explain` prints it with its
-     * justification. A number the tool guessed would be neither.
-     *
-     * Use sparingly. If overriding becomes a habit the count stops coming from
-     * the code, and the report says how much of the total came from here so that
-     * cannot grow unnoticed.
+     * justification. But it freezes: prefer `opaque.<origin>.schemas` whenever the
+     * fields are declared anywhere in the code.
      */
     overrides?: Record<string, FunctionOverride>;
 };
 export type FunctionOverride = {
     /** declared DET count, replacing what the analysis found */
     det?: number;
-    /**
-     * Name of a JSON Schema declared in the application's code, whose fields are
-     * counted by the §7 leaf rules and replace the single DET the opaque column
-     * contributed.
-     *
-     * Prefer this to `det`. A declared number freezes: someone adds a field, the
-     * count does not move, and `fp:diff` reports no change for real functional
-     * growth — undercounting silently and progressively. Naming the schema keeps
-     * the number coming from the code; the only thing maintained by hand is the
-     * mapping, which changes when a form is born rather than when a field is.
-     *
-     * A name that matches no schema is a warning, never a silent fallback.
-     */
-    /**
-     * 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;
 };
+export type { OpaqueDeclaration };
 export declare const DEFAULTS: FunctionPointsConfig;
 export declare function defineConfig(config: Partial<FunctionPointsConfig>): FunctionPointsConfig;

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

@@ -53,8 +53,50 @@ export type Behavior = {
      * not a validator.
      */
     requestFields: string[];
+    /** an ace command's `@flags.*` / `@args.*`: `flags.limite`, `args.name` — its input DETs */
+    commandFields: string[];
     /** the transaction reads the request in a way that enumerates nothing */
     opaqueRequest: boolean;
+    /**
+     * What leaves the boundary, when a transformer on the path says so —
+     * counting-decisions §6. Qualified by the transformer: `LivroTransformer.titulo`.
+     *
+     * Empty means no transformer was reached, and the output DETs fall back to the
+     * columns of the stores read. It does NOT mean the transaction emits nothing.
+     */
+    outputFields: string[];
+    /** of those, the spreads the walker could not read: 1 DET each, a floor, reported */
+    opaqueOutputFields: string[];
+    /** stores a transformer on the path is FOR: their columns are not output DETs, their keys are */
+    transformedStores: string[];
+    /**
+     * How each store was read, over every chain on the path: whether rows left
+     * whole, which columns a `.select()` named, and whether an aggregate
+     * (`.count()`, `.exists()`) left one scalar. What an output shows when no
+     * transformer covers the store.
+     */
+    outputReads: Record<string, {
+        whole: boolean;
+        selected: string[];
+        aggregate: boolean;
+        /** read by a chain of its own, not only preloaded through another store */
+        direct: boolean;
+        /** stores it was preloaded through */
+        via: string[];
+    }>;
+    /**
+     * What the transaction DELIVERS — plan 0.7 §A′. `any` says a delivery point was
+     * found at all; without one the output falls back to the stores read. `fields`
+     * are derived values and the leaves of literals a followed body returned,
+     * `render:total`; `stores` are the ones whose rows were handed on, raw or through
+     * a query object; `opaqueFields` are values nobody could read, 1 DET each.
+     */
+    delivered: {
+        any: boolean;
+        fields: string[];
+        opaqueFields: string[];
+        stores: string[];
+    };
     trace: TraceStep[];
     /** bodies reached, for `fp:diff` */
     scope: ScopeEntry[];
@@ -88,6 +130,8 @@ export type GraphOptions = {
 export declare function createAnalyzer(app: AppContext, stores: CollectedDataStore[], options?: GraphOptions): {
     analyze: (handler: HandlerRef) => Behavior;
     writtenAnywhere: () => Set<string>;
+    addressedAnywhere: () => Set<string>;
+    seededAnywhere: () => Set<string>;
     /** how many files the project loaded — used to prove it does not grow */
     fileCount: () => number;
 };