labre-mcp 0.1.0

package/dist/lib/patent/patent-data-source.d.mts

@@ -0,0 +1,176 @@
+/**
+ * CPC subclass distribution entry.
+ * @typedef {Object} CpcDistributionEntry
+ * @property {string} cpc   - 4-char CPC sub-class code (e.g. 'H04L')
+ * @property {number} count - Number of patents assigned to this subclass
+ */
+/**
+ * Yearly CPC classification snapshot.
+ * @typedef {Object} YearlyClassification
+ * @property {number}   year     - Calendar year
+ * @property {string[]} cpcCodes - CPC sub-class codes used in patents that year
+ */
+/**
+ * Forward citation data for a CPC class.
+ * @typedef {Object} CitationData
+ * @property {number} totalForwardCitations - Total forward citations received
+ * @property {number} patentCount           - Number of patents in the class
+ */
+/**
+ * Claims timeline entry for narrowing analysis.
+ * @typedef {Object} ClaimsTimelineEntry
+ * @property {number} year                  - Calendar year
+ * @property {number} avgIndependentClaims  - Average independent claims per patent
+ */
+/**
+ * Assignee diversity data.
+ * @typedef {Object} AssigneeData
+ * @property {number} uniqueAssignees - Count of unique patent assignees (holders)
+ * @property {number} totalPatents    - Total patents in the class
+ */
+/**
+ * Geographic filing coverage data.
+ * @typedef {Object} GeoData
+ * @property {number}   jurisdictionCount - Number of unique patent jurisdictions
+ * @property {string[]} [jurisdictions]   - Optional list of jurisdiction codes (e.g. ['US', 'EP', 'CN'])
+ */
+/**
+ * Cross-sector diffusion data.
+ * @typedef {Object} SectorData
+ * @property {number} uniqueSections - Number of unique CPC sections (A-H, Y; max 9)
+ * @property {number} uniqueClasses  - Number of unique CPC main classes
+ */
+/**
+ * Patent expiration data for commoditization analysis.
+ * @typedef {Object} ExpirationData
+ * @property {number} expiredCount - Number of expired patents
+ * @property {number} totalPatents - Total patents (expired + active)
+ */
+/**
+ * Complete patent data for a set of CPC codes.
+ *
+ * This is the canonical return shape of fetchByCpc() and the input shape
+ * consumed by computeAllIndicators() from patent-indicators.mjs.
+ *
+ * All fields feed one or more of the 8 patent indicators:
+ *
+ * Certitude axis:
+ *   cpcDistribution          -> convergenceHHI (indicator 1)
+ *   yearlyClassifications    -> stabiliteTaxonomique (indicator 2)
+ *   citationData             -> densiteCitation (indicator 3)
+ *   claimsTimeline           -> retrecissementClaims (indicator 4)
+ *
+ * Ubiquity axis:
+ *   assigneeData             -> diversiteAssignees (indicator 5)
+ *   geoData                  -> couvertureGeo (indicator 6)
+ *   sectorData               -> diffusionSectorielle (indicator 7)
+ *   expirationData           -> ratioExpires (indicator 8)
+ *
+ * @typedef {Object} PatentData
+ * @property {number}                   totalPatents            - Total patent count (used for confidence scoring)
+ * @property {CpcDistributionEntry[]}   cpcDistribution         - CPC subclass distribution
+ * @property {YearlyClassification[]}   yearlyClassifications   - Yearly CPC code snapshots
+ * @property {CitationData}             citationData            - Forward citation aggregates
+ * @property {ClaimsTimelineEntry[]}    claimsTimeline          - Independent claims over time
+ * @property {AssigneeData}             assigneeData            - Assignee diversity
+ * @property {GeoData}                  geoData                 - Geographic filing breadth
+ * @property {SectorData}               sectorData              - Cross-sector diffusion
+ * @property {ExpirationData}           expirationData          - Patent expiration ratios
+ */
+/**
+ * Computed indicator results for both axes.
+ * Returned by fetchIndicators() convenience method.
+ *
+ * @typedef {Object} IndicatorResults
+ * @property {{ value: number, breakdown: Array, enabledCount: number }} certitude  - Aggregated certitude axis
+ * @property {{ value: number, breakdown: Array, enabledCount: number }} ubiquite   - Aggregated ubiquity axis
+ * @property {Record<string, number>}                                    scores     - All 8 individual indicator scores
+ */
+/**
+ * Canonical empty PatentData shape.
+ * Used as fallback when no data is available (e.g. CPC codes not found,
+ * BigQuery returns zero results, or data source is unavailable).
+ *
+ * All indicator functions handle empty/zero inputs gracefully, returning 0.
+ *
+ * @returns {PatentData}
+ */
+import type { PatentData, IndicatorResults } from '../../types/patent.mjs';
+export type { PatentData, IndicatorResults };
+export declare function emptyPatentData(): PatentData;
+/**
+ * Abstract interface for patent data access.
+ *
+ * All patent data providers must extend this class and implement fetchByCpc().
+ * The fetchIndicators() convenience method has a default implementation that
+ * composes fetchByCpc() with computeAllIndicators().
+ *
+ * Concrete implementations:
+ *   - BigQueryPatentSource — queries Google BigQuery Patents Public Dataset
+ *   - Mock sources in tests — return static fixture data
+ *
+ * Usage in CpcEvolutionStrategy:
+ *   const source = new BigQueryPatentSource({ projectId: '...' });
+ *   const patentData = await source.fetchByCpc(['H04L', 'G06F']);
+ *   // patentData is a PatentData object ready for computeAllIndicators()
+ *
+ * @abstract
+ */
+export declare class PatentDataSource {
+    /**
+     * Fetch raw patent data for the given CPC sub-class codes.
+     *
+     * This is the core contract method that all implementations MUST override.
+     * Returns a PatentData object containing all fields needed by the 8 patent
+     * indicators in patent-indicators.mjs.
+     *
+     * Implementations should:
+     *   - Accept 1–5 CPC sub-class codes (4-char format, e.g. 'H04L')
+     *   - Return a complete PatentData object (use emptyPatentData() for missing fields)
+     *   - Handle network/query errors gracefully (throw or return empty)
+     *   - Be safe to call concurrently (stateless queries)
+     *
+     * @abstract
+     * @param {string[]} cpcCodes - Array of 4-char CPC sub-class codes (e.g. ['H04L', 'G06F'])
+     * @returns {Promise<PatentData>} Patent data for the given CPC codes
+     * @throws {Error} If not implemented by subclass
+     */
+    fetchByCpc(cpcCodes: string[]): Promise<PatentData>;
+    /**
+     * Convenience method: fetch patent data and compute all 8 indicators.
+     *
+     * Default implementation composes fetchByCpc() with computeAllIndicators()
+     * from patent-indicators.mjs. Subclasses may override this to provide
+     * pre-computed indicators (e.g. from a cache or a specialized API).
+     *
+     * @param {string[]} cpcCodes - Array of 4-char CPC sub-class codes
+     * @param {Object} [options]
+     * @param {Array<{key: string, weight: number, enabled: boolean}>} [options.certitudeConfig]
+     *   Custom certitude indicator config (for toggling/reweighting)
+     * @param {Array<{key: string, weight: number, enabled: boolean}>} [options.ubiquiteConfig]
+     *   Custom ubiquity indicator config (for toggling/reweighting)
+     * @returns {Promise<IndicatorResults>} Computed indicator results for both axes
+     */
+    fetchIndicators(cpcCodes: string[], options?: Record<string, unknown>): Promise<IndicatorResults>;
+    /**
+     * Optional lifecycle method: release resources (connections, caches).
+     * Implementations that hold resources (connection pools, timers) should
+     * override this to clean up gracefully.
+     *
+     * @returns {Promise<void>}
+     */
+    close(): Promise<void>;
+}
+/**
+ * Validate that an object conforms to the PatentData shape.
+ * Checks for required fields and correct types. Used by tests and cache
+ * to ensure data integrity after deserialization.
+ *
+ * @param {*} data - Object to validate
+ * @returns {{ valid: boolean, errors: string[] }}
+ */
+export declare function validatePatentData(data: unknown): {
+    valid: boolean;
+    errors: string[];
+};
+//# sourceMappingURL=patent-data-source.d.mts.map

package/dist/lib/patent/patent-data-source.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"patent-data-source.d.mts","sourceRoot":"","sources":["../../../src/lib/patent/patent-data-source.mts"],"names":[],"mappings":"AAuBA;;;;;GAKG;AAEH;;;;;GAKG;AAEH;;;;;GAKG;AAEH;;;;;GAKG;AAEH;;;;;GAKG;AAEH;;;;;GAKG;AAEH;;;;;GAKG;AAEH;;;;;GAKG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH;;;;;;;;GAQG;AAIH;;;;;;;;GAQG;AACH,OAAO,KAAK,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAE3E,YAAY,EAAE,UAAU,EAAE,gBAAgB,EAAE,CAAC;AAE7C,wBAAgB,eAAe,IAAI,UAAU,CAY5C;AAID;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,gBAAgB;IAE3B;;;;;;;;;;;;;;;;;OAiBG;IACG,UAAU,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,UAAU,CAAC;IAMzD;;;;;;;;;;;;;;OAcG;IACG,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,OAAO,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAS3G;;;;;;OAMG;IACG,KAAK;CAGZ;AAID;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,OAAO,GAAG;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE,CAKtF"}

package/dist/lib/patent/patent-data-source.mjs

@@ -0,0 +1,124 @@
+// PatentDataSource: abstract interface for patent data access.
+//
+// Defines the contract that all patent data providers must implement.
+// The CPC Evolution Strategy depends on this interface, not on any
+// concrete implementation (BigQuery, mock, CSV, etc.).
+//
+// Implementations:
+//   - BigQueryPatentSource (bigquery-patent-source.mjs) — production
+//   - Mock objects in tests ({ fetchByCpc: async () => data })
+//
+// The interface specifies two contract methods:
+//   1. fetchByCpc(cpcCodes)      — fetch raw patent data by CPC sub-class codes
+//   2. fetchIndicators(cpcCodes) — convenience: fetch + compute all 8 indicators
+//
+// Method (2) has a default implementation that composes fetchByCpc() with
+// computeAllIndicators() from patent-indicators.mjs, so concrete classes
+// only MUST implement fetchByCpc().
+//
+// Return shapes are documented via JSDoc typedefs below to serve as the
+// single source of truth for all consumers (strategy, cache, tests).
+import { PatentDataSchema } from '../../schemas/patent.schema.mjs';
+export function emptyPatentData() {
+    return {
+        totalPatents: 0,
+        cpcDistribution: [],
+        yearlyClassifications: [],
+        citationData: { totalForwardCitations: 0, patentCount: 0 },
+        claimsTimeline: [],
+        assigneeData: { uniqueAssignees: 0, totalPatents: 0 },
+        geoData: { jurisdictionCount: 0, jurisdictions: [] },
+        sectorData: { uniqueSections: 0, uniqueClasses: 0 },
+        expirationData: { expiredCount: 0, totalPatents: 0 },
+    };
+}
+// ─── Abstract base class ───────────────────────────────────────────────────────
+/**
+ * Abstract interface for patent data access.
+ *
+ * All patent data providers must extend this class and implement fetchByCpc().
+ * The fetchIndicators() convenience method has a default implementation that
+ * composes fetchByCpc() with computeAllIndicators().
+ *
+ * Concrete implementations:
+ *   - BigQueryPatentSource — queries Google BigQuery Patents Public Dataset
+ *   - Mock sources in tests — return static fixture data
+ *
+ * Usage in CpcEvolutionStrategy:
+ *   const source = new BigQueryPatentSource({ projectId: '...' });
+ *   const patentData = await source.fetchByCpc(['H04L', 'G06F']);
+ *   // patentData is a PatentData object ready for computeAllIndicators()
+ *
+ * @abstract
+ */
+export class PatentDataSource {
+    /**
+     * Fetch raw patent data for the given CPC sub-class codes.
+     *
+     * This is the core contract method that all implementations MUST override.
+     * Returns a PatentData object containing all fields needed by the 8 patent
+     * indicators in patent-indicators.mjs.
+     *
+     * Implementations should:
+     *   - Accept 1–5 CPC sub-class codes (4-char format, e.g. 'H04L')
+     *   - Return a complete PatentData object (use emptyPatentData() for missing fields)
+     *   - Handle network/query errors gracefully (throw or return empty)
+     *   - Be safe to call concurrently (stateless queries)
+     *
+     * @abstract
+     * @param {string[]} cpcCodes - Array of 4-char CPC sub-class codes (e.g. ['H04L', 'G06F'])
+     * @returns {Promise<PatentData>} Patent data for the given CPC codes
+     * @throws {Error} If not implemented by subclass
+     */
+    async fetchByCpc(cpcCodes) {
+        throw new Error(`${this.constructor.name}.fetchByCpc() must be implemented by subclass`);
+    }
+    /**
+     * Convenience method: fetch patent data and compute all 8 indicators.
+     *
+     * Default implementation composes fetchByCpc() with computeAllIndicators()
+     * from patent-indicators.mjs. Subclasses may override this to provide
+     * pre-computed indicators (e.g. from a cache or a specialized API).
+     *
+     * @param {string[]} cpcCodes - Array of 4-char CPC sub-class codes
+     * @param {Object} [options]
+     * @param {Array<{key: string, weight: number, enabled: boolean}>} [options.certitudeConfig]
+     *   Custom certitude indicator config (for toggling/reweighting)
+     * @param {Array<{key: string, weight: number, enabled: boolean}>} [options.ubiquiteConfig]
+     *   Custom ubiquity indicator config (for toggling/reweighting)
+     * @returns {Promise<IndicatorResults>} Computed indicator results for both axes
+     */
+    async fetchIndicators(cpcCodes, options = {}) {
+        const patentData = await this.fetchByCpc(cpcCodes);
+        // Lazy-load to avoid circular dependencies and keep base class lightweight
+        const { computeAllIndicators } = await import('./patent-indicators.mjs');
+        return computeAllIndicators(patentData, options);
+    }
+    /**
+     * Optional lifecycle method: release resources (connections, caches).
+     * Implementations that hold resources (connection pools, timers) should
+     * override this to clean up gracefully.
+     *
+     * @returns {Promise<void>}
+     */
+    async close() {
+        // Default: no-op. Subclasses override if needed.
+    }
+}
+// ─── Validation helpers ────────────────────────────────────────────────────────
+/**
+ * Validate that an object conforms to the PatentData shape.
+ * Checks for required fields and correct types. Used by tests and cache
+ * to ensure data integrity after deserialization.
+ *
+ * @param {*} data - Object to validate
+ * @returns {{ valid: boolean, errors: string[] }}
+ */
+export function validatePatentData(data) {
+    const result = PatentDataSchema.safeParse(data);
+    if (result.success)
+        return { valid: true, errors: [] };
+    const errors = result.error.issues.map(i => `${i.path.join('.') || '(root)'}: ${i.message}`);
+    return { valid: false, errors };
+}
+//# sourceMappingURL=patent-data-source.mjs.map

package/dist/lib/patent/patent-data-source.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"patent-data-source.mjs","sourceRoot":"","sources":["../../../src/lib/patent/patent-data-source.mts"],"names":[],"mappings":"AAAA,+DAA+D;AAC/D,EAAE;AACF,sEAAsE;AACtE,mEAAmE;AACnE,uDAAuD;AACvD,EAAE;AACF,mBAAmB;AACnB,qEAAqE;AACrE,+DAA+D;AAC/D,EAAE;AACF,gDAAgD;AAChD,gFAAgF;AAChF,iFAAiF;AACjF,EAAE;AACF,0EAA0E;AAC1E,yEAAyE;AACzE,oCAAoC;AACpC,EAAE;AACF,wEAAwE;AACxE,qEAAqE;AAkHrE,OAAO,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AAGnE,MAAM,UAAU,eAAe;IAC7B,OAAO;QACL,YAAY,EAAE,CAAC;QACf,eAAe,EAAE,EAAE;QACnB,qBAAqB,EAAE,EAAE;QACzB,YAAY,EAAE,EAAE,qBAAqB,EAAE,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE;QAC1D,cAAc,EAAE,EAAE;QAClB,YAAY,EAAE,EAAE,eAAe,EAAE,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE;QACrD,OAAO,EAAE,EAAE,iBAAiB,EAAE,CAAC,EAAE,aAAa,EAAE,EAAE,EAAE;QACpD,UAAU,EAAE,EAAE,cAAc,EAAE,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE;QACnD,cAAc,EAAE,EAAE,YAAY,EAAE,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE;KACrD,CAAC;AACJ,CAAC;AAED,kFAAkF;AAElF;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,OAAO,gBAAgB;IAE3B;;;;;;;;;;;;;;;;;OAiBG;IACH,KAAK,CAAC,UAAU,CAAC,QAAkB;QACjC,MAAM,IAAI,KAAK,CACb,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,+CAA+C,CACxE,CAAC;IACJ,CAAC;IAED;;;;;;;;;;;;;;OAcG;IACH,KAAK,CAAC,eAAe,CAAC,QAAkB,EAAE,UAAmC,EAAE;QAC7E,MAAM,UAAU,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC;QAEnD,2EAA2E;QAC3E,MAAM,EAAE,oBAAoB,EAAE,GAAG,MAAM,MAAM,CAAC,yBAAyB,CAAC,CAAC;QAEzE,OAAO,oBAAoB,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;IACnD,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,KAAK;QACT,iDAAiD;IACnD,CAAC;CACF;AAED,kFAAkF;AAElF;;;;;;;GAOG;AACH,MAAM,UAAU,kBAAkB,CAAC,IAAa;IAC9C,MAAM,MAAM,GAAG,gBAAgB,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;IAChD,IAAI,MAAM,CAAC,OAAO;QAAE,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC;IACvD,MAAM,MAAM,GAAG,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,QAAQ,KAAK,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC;IAC7F,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC;AAClC,CAAC"}

package/dist/lib/patent/patent-indicators.d.mts

@@ -0,0 +1,162 @@
+import type { PatentData, CpcDistributionEntry, YearlyClassification, CitationData, ClaimsTimelineEntry, AssigneeData, GeoData, SectorData, ExpirationData, IndicatorConfig, IndicatorResults, WeightedAggregateResult } from '../../types/patent.mjs';
+export declare const CERTITUDE_INDICATORS: IndicatorConfig[];
+export declare const UBIQUITE_INDICATORS: IndicatorConfig[];
+/**
+ * 1. Convergence HHI — Herfindahl-Hirschman Index of CPC subclass distribution.
+ *
+ * High HHI → patents concentrate in few subclasses → technology is converging
+ * toward a well-understood domain → high certitude.
+ *
+ * @param {Array<{cpc: string, count: number}>} cpcDistribution
+ *   Each entry: CPC subclass code and patent count assigned to it.
+ *   Example: [{ cpc: 'H04L', count: 120 }, { cpc: 'G06F', count: 80 }]
+ * @returns {number} Score in [0, 1]. Higher = more concentrated = higher certitude.
+ */
+export declare function convergenceHHI(cpcDistribution: CpcDistributionEntry[]): number;
+/**
+ * 2. Stabilité taxonomique — year-over-year stability of CPC codes used.
+ *
+ * Low churn in CPC codes across years → taxonomy is settled → high certitude.
+ * Measured as 1 − average Jaccard distance between consecutive year CPC sets.
+ *
+ * @param {Array<{year: number, cpcCodes: string[]}>} yearlyClassifications
+ *   Sorted by year ascending. Each entry: year + set of CPC codes used that year.
+ *   Example: [{ year: 2018, cpcCodes: ['H04L', 'G06F'] }, { year: 2019, cpcCodes: ['H04L', 'G06F', 'H04W'] }]
+ * @returns {number} Score in [0, 1]. Higher = more stable = higher certitude.
+ */
+export declare function stabiliteTaxonomique(yearlyClassifications: YearlyClassification[]): number;
+/**
+ * 3. Densité citation — forward citation density (citations received per patent).
+ *
+ * High forward citations → widely referenced → well-understood technology
+ * → high certitude. Normalized via sigmoid to handle heavy-tailed distributions.
+ *
+ * @param {Object} citationData
+ * @param {number} citationData.totalForwardCitations - Total forward citations received
+ * @param {number} citationData.patentCount - Number of patents in the CPC class
+ * @returns {number} Score in [0, 1]. Higher = more cited = higher certitude.
+ */
+export declare function densiteCitation(citationData: CitationData): number;
+/**
+ * 4. Rétrécissement claims — narrowing of independent claims over time.
+ *
+ * When average independent claim count per patent DECREASES over time,
+ * technology is maturing (moving from broad exploration to narrow specifics).
+ * Higher narrowing → higher certitude.
+ *
+ * @param {Array<{year: number, avgIndependentClaims: number}>} claimsTimeline
+ *   Sorted by year ascending. Each entry: year + average independent claims per patent.
+ *   Example: [{ year: 2015, avgIndependentClaims: 8.5 }, { year: 2020, avgIndependentClaims: 4.2 }]
+ * @returns {number} Score in [0, 1]. Higher = more narrowing = higher certitude.
+ */
+export declare function retrecissementClaims(claimsTimeline: ClaimsTimelineEntry[]): number;
+/**
+ * 5. Diversité assignees — unique assignee (patent holder) diversity.
+ *
+ * More unique assignees → technology widely adopted across organizations
+ * → higher ubiquity.
+ *
+ * @param {Object} assigneeData
+ * @param {number} assigneeData.uniqueAssignees - Count of unique assignees
+ * @param {number} assigneeData.totalPatents - Total patents in the class
+ * @returns {number} Score in [0, 1]. Higher = more diverse = higher ubiquity.
+ */
+export declare function diversiteAssignees(assigneeData: AssigneeData): number;
+/**
+ * 6. Couverture géographique — geographic filing breadth.
+ *
+ * More jurisdictions → technology is globally relevant → higher ubiquity.
+ *
+ * @param {Object} geoData
+ * @param {number} geoData.jurisdictionCount - Number of unique patent jurisdictions
+ * @param {string[]} [geoData.jurisdictions] - Optional list of jurisdiction codes
+ * @returns {number} Score in [0, 1]. Higher = broader coverage = higher ubiquity.
+ */
+export declare function couvertureGeo(geoData: GeoData): number;
+/**
+ * 7. Diffusion sectorielle — cross-sector CPC group diversity.
+ *
+ * Patents spanning multiple CPC sections (A–H) → technology diffuses across
+ * industries → higher ubiquity.
+ *
+ * @param {Object} sectorData
+ * @param {number} sectorData.uniqueSections - Number of unique CPC sections (A–H, max 9)
+ * @param {number} sectorData.uniqueClasses - Number of unique CPC main classes
+ * @returns {number} Score in [0, 1]. Higher = more cross-sector = higher ubiquity.
+ */
+export declare function diffusionSectorielle(sectorData: SectorData): number;
+/**
+ * 8. Ratio expirés — proportion of expired patents in the CPC class.
+ *
+ * A high ratio of expired patents indicates mature, commoditized technology:
+ * patents have expired, so the technology is freely available to all → higher ubiquity.
+ * Low ratio → most patents still active → technology still proprietary → lower ubiquity.
+ *
+ * @param {Object} expirationData
+ * @param {number} expirationData.expiredCount - Number of expired patents
+ * @param {number} expirationData.totalPatents - Total patents (expired + active)
+ * @returns {number} Score in [0, 1]. Higher = more expired = higher ubiquity.
+ */
+export declare function ratioExpires(expirationData: ExpirationData): number;
+/**
+ * Compute weighted mean from indicator scores, respecting enabled/disabled toggles.
+ * Disabled indicators are excluded and weights are automatically renormalized.
+ *
+ * @param {Object} scores - Map of indicator key → score (each in [0, 1])
+ * @param {Array<{key: string, weight: number, enabled: boolean}>} indicatorConfig
+ *   Indicator definitions with weights and enabled flags.
+ * @returns {{ value: number, breakdown: Array<{key: string, score: number, weight: number, weightNormalized: number}>, enabledCount: number }}
+ */
+export declare function weightedMean(scores: Record<string, number>, indicatorConfig: IndicatorConfig[]): WeightedAggregateResult;
+/**
+ * Aggregate 4 certitude indicator scores into a single certitude value.
+ *
+ * Indicators and default weights:
+ *   convergenceHHI:       0.30
+ *   stabiliteTaxonomique: 0.20
+ *   densiteCitation:      0.25
+ *   retrecissementClaims: 0.25
+ *
+ * @param {Object} scores - Map of certitude indicator key → score (each in [0, 1])
+ * @param {Array<{key: string, weight: number, enabled: boolean}>} [config]
+ *   Optional custom indicator config (for toggling/reweighting). Defaults to CERTITUDE_INDICATORS.
+ * @returns {{ value: number, breakdown: Array, enabledCount: number }}
+ */
+export declare function aggregateCertitude(scores: Record<string, number>, config?: IndicatorConfig[]): WeightedAggregateResult;
+/**
+ * Aggregate 4 ubiquité indicator scores into a single ubiquité value.
+ *
+ * Indicators and default weights:
+ *   diversiteAssignees:    0.30
+ *   couvertureGeo:         0.25
+ *   diffusionSectorielle:  0.25
+ *   ratioExpires:           0.20
+ *
+ * @param {Object} scores - Map of ubiquité indicator key → score (each in [0, 1])
+ * @param {Array<{key: string, weight: number, enabled: boolean}>} [config]
+ *   Optional custom indicator config (for toggling/reweighting). Defaults to UBIQUITE_INDICATORS.
+ * @returns {{ value: number, breakdown: Array, enabledCount: number }}
+ */
+export declare function aggregateUbiquite(scores: Record<string, number>, config?: IndicatorConfig[]): WeightedAggregateResult;
+/**
+ * Compute all 8 indicators from raw patent data and return both axis aggregates.
+ *
+ * @param {Object} patentData - Pre-fetched patent data containing all needed fields
+ * @param {Array} patentData.cpcDistribution - For convergenceHHI
+ * @param {Array} patentData.yearlyClassifications - For stabiliteTaxonomique
+ * @param {Object} patentData.citationData - For densiteCitation
+ * @param {Array} patentData.claimsTimeline - For retrecissementClaims
+ * @param {Object} patentData.assigneeData - For diversiteAssignees
+ * @param {Object} patentData.geoData - For couvertureGeo
+ * @param {Object} patentData.sectorData - For diffusionSectorielle
+ * @param {Object} patentData.expirationData - For ratioExpires
+ * @param {Object} [options]
+ * @param {Array} [options.certitudeConfig] - Custom certitude indicator config
+ * @param {Array} [options.ubiquiteConfig] - Custom ubiquité indicator config
+ * @returns {{ certitude: {value, breakdown, enabledCount}, ubiquite: {value, breakdown, enabledCount}, scores: Object }}
+ */
+export declare function computeAllIndicators(patentData: PatentData, options?: {
+    certitudeConfig?: IndicatorConfig[];
+    ubiquiteConfig?: IndicatorConfig[];
+}): IndicatorResults;
+//# sourceMappingURL=patent-indicators.d.mts.map

package/dist/lib/patent/patent-indicators.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"patent-indicators.d.mts","sourceRoot":"","sources":["../../../src/lib/patent/patent-indicators.mts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EACV,UAAU,EACV,oBAAoB,EACpB,oBAAoB,EACpB,YAAY,EACZ,mBAAmB,EACnB,YAAY,EACZ,OAAO,EACP,UAAU,EACV,cAAc,EACd,eAAe,EAEf,gBAAgB,EAChB,uBAAuB,EACxB,MAAM,wBAAwB,CAAC;AAIhC,eAAO,MAAM,oBAAoB,EAAE,eAAe,EAKjD,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,eAAe,EAKhD,CAAC;AAkBF;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAAC,eAAe,EAAE,oBAAoB,EAAE,GAAG,MAAM,CAqB9E;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAAC,qBAAqB,EAAE,oBAAoB,EAAE,GAAG,MAAM,CA4B1F;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,YAAY,EAAE,YAAY,GAAG,MAAM,CAalE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAAC,cAAc,EAAE,mBAAmB,EAAE,GAAG,MAAM,CAgClF;AAMD;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,YAAY,EAAE,YAAY,GAAG,MAAM,CAWrE;AAED;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAWtD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,UAAU,GAAG,MAAM,CAgBnE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAAC,cAAc,EAAE,cAAc,GAAG,MAAM,CAcnE;AAMD;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,eAAe,EAAE,eAAe,EAAE,GAAG,uBAAuB,CA8BxH;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAE,eAAe,EAAyB,GAAG,uBAAuB,CAE5I;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAE,eAAe,EAAwB,GAAG,uBAAuB,CAE1I;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,UAAU,EAAE,OAAO,GAAE;IAAE,eAAe,CAAC,EAAE,eAAe,EAAE,CAAC;IAAC,cAAc,CAAC,EAAE,eAAe,EAAE,CAAA;CAAO,GAAG,gBAAgB,CAyBxK"}