@filipebraida/adonis-function-points 0.4.0 → 0.6.0

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-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 { t as CoverageTooLowError } from "../pipeline-Cq4dNTNE.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-FYmPIPub.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

@@ -30,6 +30,16 @@ export type Behavior = {
     writes: boolean;
     /** data stores reached */
     touches: string[];
+    /**
+     * Of those, the ones this transaction WRITES.
+     *
+     * `writes` is a property of the transaction — it decides EI against EO — and was
+     * being read as a property of every store the transaction touched: a table merely
+     * read by a route that writes something else counted as maintained, so almost
+     * nothing could be an EIF. §6.5.4 asks who maintains THIS store, which is a
+     * question about the access, not about the request.
+     */
+    writtenStores: string[];
     /**
      * Declared input fields: `request.validateUsing(x)` resolved down to the
      * fields of the VineJS schema — counting-decisions §7.
@@ -45,6 +55,33 @@ export type Behavior = {
     requestFields: 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[];
+    }>;
     trace: TraceStep[];
     /** bodies reached, for `fp:diff` */
     scope: ScopeEntry[];
@@ -78,6 +115,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;
 };

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

@@ -0,0 +1,99 @@
+import { Node } from 'ts-morph';
+import type { CallExpression, ClassDeclaration } from 'ts-morph';
+import type { CollectedDataStore } from '../sources/data_stores.js';
+/**
+ * What an output transaction actually EMITS — counting-decisions §6.
+ *
+ * AFP §7.3 counts one DET per unique field that leaves the boundary. Without
+ * reading what leaves, the only repeatable answer is "every column of every
+ * table read", and that is what the count did: a detail screen passing through
+ * three transformers came out at 67 DET. The transformer is where the
+ * application says which fields cross, so it is read here.
+ *
+ * Two facts are extracted, and both are about the BODY, so they are cached with
+ * the rest of its facts:
+ *
+ *   outputs   the keys a transformer method returns — `LivroTransformer.titulo`
+ *   selected  the columns a query names in `.select()` — per store
+ *
+ * Everything the walker cannot read is a placeholder, never a guess: an
+ * unreadable spread counts 1 DET as a floor and is reported, the same treatment
+ * an open `vine.object` gets on the input side (§9).
+ */
+export type OutputFacts = {
+    /** qualified keys emitted by this transformer body */
+    outputs: string[];
+    /** of those, the placeholders: a spread the walker could not read */
+    opaqueOutputs: string[];
+    /**
+     * The store this transformer is FOR — `BaseTransformer<Livro>` — when it is a
+     * known store. A transformer decides what leaves for its resource, not for the
+     * page: a store read beside it and passed raw is not covered.
+     */
+    resource: string | null;
+};
+/** how a body reads a store, per chain — what leaves when nothing transforms it */
+export type StoreRead = {
+    store: string;
+    shape: 'whole' | 'select' | 'aggregate';
+    /** for `select`: the columns named */
+    columns: string[];
+    /**
+     * The store this one was preloaded THROUGH (`Livro.query().preload('autor')`),
+     * when it was not read by a chain of its own. A relation loaded for a
+     * transformer is consumed by it, not shown.
+     */
+    via?: string;
+};
+/**
+ * Does this class extend a transformer base from a package?
+ *
+ * Decided by the base's name AND by its import being a bare specifier, so an
+ * application class that merely happens to own a `transform` method is not
+ * mistaken for one. Shared with the `transformer` resolver: one definition of
+ * what a transformer is, or the resolver follows a body this walker refuses.
+ */
+export declare function isTransformerClass(cls: ClassDeclaration): boolean;
+/** `class X extends BaseTransformer<Livro>` -> 'Livro' */
+export declare function transformerResourceOf(cls: ClassDeclaration): string | null;
+/**
+ * The keys a transformer method returns.
+ *
+ * `followed` says whether a call inside the literal is a body the graph walks —
+ * `AutorTransformer.transform(x)`, `this.toObject()` — in which case its keys
+ * arrive through that body and the key holding it is not a DET of its own: the
+ * user sees the author's name, not an "autor" field.
+ *
+ *   { titulo: l.titulo }                 1 — `titulo`
+ *   { autor: AutorTransformer.transform } 0 here; the nested body contributes
+ *   { endereco: { rua, cidade } }        leaves individually
+ *   { tags: xs.map((t) => t.nome) }      1 — a repeating group of one attribute
+ *   { itens: xs.map((i) => ({ a, b })) } the leaves, once
+ *   ...this.pick(this.resource, [...])   the listed names
+ *   ...this.toObject()                   0 here; the followed body contributes
+ *   ...anythingElse                      1, opaque, reported
+ *
+ * A key that is the identifier of the transformer's resource is not a DET, for
+ * the same reason `isPrimary` is not one on the data function.
+ */
+export declare function outputFieldsIn(body: Node, owner: ClassDeclaration | undefined, stores: Map<string, CollectedDataStore>, followed: (call: CallExpression) => boolean): OutputFacts;
+/**
+ * The shape of the chain an access belongs to — read from the WHOLE chain, root
+ * to end, because every call on it is detected as an access and each must reach
+ * the same answer: `Livro.query().where(…).count()` is an aggregate whether the
+ * detector is looking at `query` or at `count`.
+ *
+ *   whole      rows leave: every column of the store (unless a transformer covers it)
+ *   select     only the columns named
+ *   aggregate  `.count()`, `.exists()`: one derived scalar leaves, not the table
+ */
+export type ChainShape = {
+    selected: string[];
+    aggregate: boolean;
+    /** a `.select()` whose column list is not literal */
+    unreadable: {
+        line: number;
+        expression: string;
+    }[];
+};
+export declare function chainShapeOf(access: CallExpression): ChainShape;

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

@@ -37,3 +37,6 @@ export declare const toPosix: (value: string) => string;
 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;
+/** a seeder, by the directory `make:seeder` writes to — scaffolding, but a fact the report uses */
+export declare function isSeeder(root: string, file: string): boolean;
+export declare function isApplicationCode(root: string, file: string): boolean;

package/build/src/inventory/resolvers/index.d.ts

@@ -17,7 +17,35 @@ export declare const BUILTIN_CALL_RESOLVERS: CallResolver[];
  * 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.
+ */
+export declare function isTechnicalWrite(call: import('ts-morph').CallExpression, ctx: import('./types.js').ResolverContext, resolvers?: CallResolver[]): boolean;
 export declare function resolveCall(call: import('ts-morph').CallExpression, ctx: import('./types.js').ResolverContext, resolvers?: CallResolver[]): {
     by: string;
     refs: import('../../types.js').HandlerRef[];
 } | null;
+export type IgnoreCallsOptions = {
+    /** the strategy's name — printed in the report beside the volume it declared data-free */
+    name: string;
+    /** method names, matched on the callee: `getUrl` matches `x.getUrl(...)` */
+    methods?: string[];
+    /** a pattern over the callee's text: `/\bauthz\.can$/` */
+    matching?: RegExp;
+    /** lower runs first; defaults to 1, before every built-in */
+    order?: number;
+};
+/**
+ * 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.
+ */
+export declare function ignoreCalls(options: IgnoreCallsOptions): CallResolver;

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

@@ -1,2 +1,2 @@
-import { n as resolveCall, t as BUILTIN_CALL_RESOLVERS } from "../../../resolvers-vMahHkAd.js";
-export { BUILTIN_CALL_RESOLVERS, resolveCall };
+import { i as resolveCall, n as ignoreCalls, r as isTechnicalWrite, t as BUILTIN_CALL_RESOLVERS } from "../../../resolvers-DlKJOZnk.js";
+export { BUILTIN_CALL_RESOLVERS, ignoreCalls, isTechnicalWrite, resolveCall };

package/build/src/inventory/resolvers/types.d.ts

@@ -97,4 +97,23 @@ export interface CallResolver {
      * defect this package can have, whoever writes it.
      */
     ignores?(call: CallExpression, ctx: ResolverContext): boolean;
+    /**
+     * "This call writes, and the write is not what the transaction is FOR."
+     *
+     * AFP §6.5.3 decides EI against EO mechanically: a transaction that modifies a data
+     * store is an EI. That is deliberate — repeatability over CPM fidelity — and it
+     * misreads one shape: a screen that records a visit, a last-seen organisation, a
+     * view counter. The CPM asks what the elementary process is PRIMARILY for, and for a
+     * `GET` that shows a record while noting the visit, the answer is presentation.
+     *
+     * So the fact is declared about the CALL, not about each transaction that reaches it:
+     * `persistOrganizationVisit` is called from several screens and saying it once covers
+     * all of them.
+     *
+     * It does NOT hide the write. The store is still maintained by this application —
+     * still an ILF, still an FTR of the transaction — and only the transaction's
+     * classification changes. A resolver that wanted the write to disappear would use
+     * `ignores`, and would be wrong to.
+     */
+    technicalWrite?(call: CallExpression, ctx: ResolverContext): boolean;
 }

package/build/src/pipeline.js

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