@dollhousemcp/mcp-server 2.0.0-rc.6 → 2.0.1

package/dist/metrics/collectors/SecurityMonitorCollector.js

@@ -0,0 +1,56 @@
+/**
+ * Collects aggregate security-event counts from SecurityMonitor, broken down
+ * by severity and event type. Accepts an injectable report function so the
+ * collector can be tested without a live SecurityMonitor singleton.
+ */
+import { SecurityMonitor } from '../../security/securityMonitor.js';
+const SOURCE = 'SecurityMonitor';
+export class SecurityMonitorCollector {
+    name = 'security-monitor';
+    description = 'Total security events and per-severity/per-type breakdowns from SecurityMonitor';
+    reportFn;
+    constructor(reportFn) {
+        this.reportFn = reportFn ?? (() => SecurityMonitor.generateSecurityReport());
+    }
+    collect() {
+        try {
+            const report = this.reportFn();
+            const entries = [];
+            entries.push({
+                type: 'counter',
+                name: 'security.monitor.events_total',
+                source: SOURCE,
+                unit: 'count',
+                description: 'Total number of security events recorded',
+                value: report.totalEvents,
+            });
+            for (const [severity, count] of Object.entries(report.eventsBySeverity)) {
+                entries.push({
+                    type: 'gauge',
+                    name: 'security.monitor.events_by_severity',
+                    source: SOURCE,
+                    unit: 'count',
+                    description: 'Security event count grouped by severity level',
+                    labels: { severity },
+                    value: count,
+                });
+            }
+            for (const [type, count] of Object.entries(report.eventsByType)) {
+                entries.push({
+                    type: 'gauge',
+                    name: 'security.monitor.events_by_type',
+                    source: SOURCE,
+                    unit: 'count',
+                    description: 'Security event count grouped by event type',
+                    labels: { type },
+                    value: count,
+                });
+            }
+            return entries;
+        }
+        catch {
+            return [];
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiU2VjdXJpdHlNb25pdG9yQ29sbGVjdG9yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL21ldHJpY3MvY29sbGVjdG9ycy9TZWN1cml0eU1vbml0b3JDb2xsZWN0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7R0FJRztBQUdILE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSxtQ0FBbUMsQ0FBQztBQUVwRSxNQUFNLE1BQU0sR0FBRyxpQkFBMEIsQ0FBQztBQVMxQyxNQUFNLE9BQU8sd0JBQXdCO0lBQzFCLElBQUksR0FBRyxrQkFBa0IsQ0FBQztJQUMxQixXQUFXLEdBQ2xCLGlGQUFpRixDQUFDO0lBRW5FLFFBQVEsQ0FBdUI7SUFFaEQsWUFBWSxRQUErQjtRQUN6QyxJQUFJLENBQUMsUUFBUSxHQUFHLFFBQVEsSUFBSSxDQUFDLEdBQUcsRUFBRSxDQUFDLGVBQWUsQ0FBQyxzQkFBc0IsRUFBRSxDQUFDLENBQUM7SUFDL0UsQ0FBQztJQUVELE9BQU87UUFDTCxJQUFJLENBQUM7WUFDSCxNQUFNLE1BQU0sR0FBRyxJQUFJLENBQUMsUUFBUSxFQUFFLENBQUM7WUFDL0IsTUFBTSxPQUFPLEdBQWtCLEVBQUUsQ0FBQztZQUVsQyxPQUFPLENBQUMsSUFBSSxDQUFDO2dCQUNYLElBQUksRUFBRSxTQUFrQjtnQkFDeEIsSUFBSSxFQUFFLCtCQUErQjtnQkFDckMsTUFBTSxFQUFFLE1BQU07Z0JBQ2QsSUFBSSxFQUFFLE9BQWdCO2dCQUN0QixXQUFXLEVBQUUsMENBQTBDO2dCQUN2RCxLQUFLLEVBQUUsTUFBTSxDQUFDLFdBQVc7YUFDMUIsQ0FBQyxDQUFDO1lBRUgsS0FBSyxNQUFNLENBQUMsUUFBUSxFQUFFLEtBQUssQ0FBQyxJQUFJLE1BQU0sQ0FBQyxPQUFPLENBQUMsTUFBTSxDQUFDLGdCQUFnQixDQUFDLEVBQUUsQ0FBQztnQkFDeEUsT0FBTyxDQUFDLElBQUksQ0FBQztvQkFDWCxJQUFJLEVBQUUsT0FBZ0I7b0JBQ3RCLElBQUksRUFBRSxxQ0FBcUM7b0JBQzNDLE1BQU0sRUFBRSxNQUFNO29CQUNkLElBQUksRUFBRSxPQUFnQjtvQkFDdEIsV0FBVyxFQUFFLGdEQUFnRDtvQkFDN0QsTUFBTSxFQUFFLEVBQUUsUUFBUSxFQUFFO29CQUNwQixLQUFLLEVBQUUsS0FBSztpQkFDYixDQUFDLENBQUM7WUFDTCxDQUFDO1lBRUQsS0FBSyxNQUFNLENBQUMsSUFBSSxFQUFFLEtBQUssQ0FBQyxJQUFJLE1BQU0sQ0FBQyxPQUFPLENBQUMsTUFBTSxDQUFDLFlBQVksQ0FBQyxFQUFFLENBQUM7Z0JBQ2hFLE9BQU8sQ0FBQyxJQUFJLENBQUM7b0JBQ1gsSUFBSSxFQUFFLE9BQWdCO29CQUN0QixJQUFJLEVBQUUsaUNBQWlDO29CQUN2QyxNQUFNLEVBQUUsTUFBTTtvQkFDZCxJQUFJLEVBQUUsT0FBZ0I7b0JBQ3RCLFdBQVcsRUFBRSw0Q0FBNEM7b0JBQ3pELE1BQU0sRUFBRSxFQUFFLElBQUksRUFBRTtvQkFDaEIsS0FBSyxFQUFFLEtBQUs7aUJBQ2IsQ0FBQyxDQUFDO1lBQ0wsQ0FBQztZQUVELE9BQU8sT0FBTyxDQUFDO1FBQ2pCLENBQUM7UUFBQyxNQUFNLENBQUM7WUFDUCxPQUFPLEVBQUUsQ0FBQztRQUNaLENBQUM7SUFDSCxDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIENvbGxlY3RzIGFnZ3JlZ2F0ZSBzZWN1cml0eS1ldmVudCBjb3VudHMgZnJvbSBTZWN1cml0eU1vbml0b3IsIGJyb2tlbiBkb3duXG4gKiBieSBzZXZlcml0eSBhbmQgZXZlbnQgdHlwZS4gQWNjZXB0cyBhbiBpbmplY3RhYmxlIHJlcG9ydCBmdW5jdGlvbiBzbyB0aGVcbiAqIGNvbGxlY3RvciBjYW4gYmUgdGVzdGVkIHdpdGhvdXQgYSBsaXZlIFNlY3VyaXR5TW9uaXRvciBzaW5nbGV0b24uXG4gKi9cblxuaW1wb3J0IHR5cGUgeyBJTWV0cmljQ29sbGVjdG9yLCBNZXRyaWNFbnRyeSB9IGZyb20gJy4uL3R5cGVzLmpzJztcbmltcG9ydCB7IFNlY3VyaXR5TW9uaXRvciB9IGZyb20gJy4uLy4uL3NlY3VyaXR5L3NlY3VyaXR5TW9uaXRvci5qcyc7XG5cbmNvbnN0IFNPVVJDRSA9ICdTZWN1cml0eU1vbml0b3InIGFzIGNvbnN0O1xuXG5pbnRlcmZhY2UgU2VjdXJpdHlSZXBvcnQge1xuICB0b3RhbEV2ZW50czogbnVtYmVyO1xuICBldmVudHNCeVNldmVyaXR5OiBSZWNvcmQ8c3RyaW5nLCBudW1iZXI+O1xuICBldmVudHNCeVR5cGU6IFJlY29yZDxzdHJpbmcsIG51bWJlcj47XG4gIHJlY2VudENyaXRpY2FsRXZlbnRzOiB1bmtub3duW107XG59XG5cbmV4cG9ydCBjbGFzcyBTZWN1cml0eU1vbml0b3JDb2xsZWN0b3IgaW1wbGVtZW50cyBJTWV0cmljQ29sbGVjdG9yIHtcbiAgcmVhZG9ubHkgbmFtZSA9ICdzZWN1cml0eS1tb25pdG9yJztcbiAgcmVhZG9ubHkgZGVzY3JpcHRpb24gPVxuICAgICdUb3RhbCBzZWN1cml0eSBldmVudHMgYW5kIHBlci1zZXZlcml0eS9wZXItdHlwZSBicmVha2Rvd25zIGZyb20gU2VjdXJpdHlNb25pdG9yJztcblxuICBwcml2YXRlIHJlYWRvbmx5IHJlcG9ydEZuOiAoKSA9PiBTZWN1cml0eVJlcG9ydDtcblxuICBjb25zdHJ1Y3RvcihyZXBvcnRGbj86ICgpID0+IFNlY3VyaXR5UmVwb3J0KSB7XG4gICAgdGhpcy5yZXBvcnRGbiA9IHJlcG9ydEZuID8/ICgoKSA9PiBTZWN1cml0eU1vbml0b3IuZ2VuZXJhdGVTZWN1cml0eVJlcG9ydCgpKTtcbiAgfVxuXG4gIGNvbGxlY3QoKTogTWV0cmljRW50cnlbXSB7XG4gICAgdHJ5IHtcbiAgICAgIGNvbnN0IHJlcG9ydCA9IHRoaXMucmVwb3J0Rm4oKTtcbiAgICAgIGNvbnN0IGVudHJpZXM6IE1ldHJpY0VudHJ5W10gPSBbXTtcblxuICAgICAgZW50cmllcy5wdXNoKHtcbiAgICAgICAgdHlwZTogJ2NvdW50ZXInIGFzIGNvbnN0LFxuICAgICAgICBuYW1lOiAnc2VjdXJpdHkubW9uaXRvci5ldmVudHNfdG90YWwnLFxuICAgICAgICBzb3VyY2U6IFNPVVJDRSxcbiAgICAgICAgdW5pdDogJ2NvdW50JyBhcyBjb25zdCxcbiAgICAgICAgZGVzY3JpcHRpb246ICdUb3RhbCBudW1iZXIgb2Ygc2VjdXJpdHkgZXZlbnRzIHJlY29yZGVkJyxcbiAgICAgICAgdmFsdWU6IHJlcG9ydC50b3RhbEV2ZW50cyxcbiAgICAgIH0pO1xuXG4gICAgICBmb3IgKGNvbnN0IFtzZXZlcml0eSwgY291bnRdIG9mIE9iamVjdC5lbnRyaWVzKHJlcG9ydC5ldmVudHNCeVNldmVyaXR5KSkge1xuICAgICAgICBlbnRyaWVzLnB1c2goe1xuICAgICAgICAgIHR5cGU6ICdnYXVnZScgYXMgY29uc3QsXG4gICAgICAgICAgbmFtZTogJ3NlY3VyaXR5Lm1vbml0b3IuZXZlbnRzX2J5X3NldmVyaXR5JyxcbiAgICAgICAgICBzb3VyY2U6IFNPVVJDRSxcbiAgICAgICAgICB1bml0OiAnY291bnQnIGFzIGNvbnN0LFxuICAgICAgICAgIGRlc2NyaXB0aW9uOiAnU2VjdXJpdHkgZXZlbnQgY291bnQgZ3JvdXBlZCBieSBzZXZlcml0eSBsZXZlbCcsXG4gICAgICAgICAgbGFiZWxzOiB7IHNldmVyaXR5IH0sXG4gICAgICAgICAgdmFsdWU6IGNvdW50LFxuICAgICAgICB9KTtcbiAgICAgIH1cblxuICAgICAgZm9yIChjb25zdCBbdHlwZSwgY291bnRdIG9mIE9iamVjdC5lbnRyaWVzKHJlcG9ydC5ldmVudHNCeVR5cGUpKSB7XG4gICAgICAgIGVudHJpZXMucHVzaCh7XG4gICAgICAgICAgdHlwZTogJ2dhdWdlJyBhcyBjb25zdCxcbiAgICAgICAgICBuYW1lOiAnc2VjdXJpdHkubW9uaXRvci5ldmVudHNfYnlfdHlwZScsXG4gICAgICAgICAgc291cmNlOiBTT1VSQ0UsXG4gICAgICAgICAgdW5pdDogJ2NvdW50JyBhcyBjb25zdCxcbiAgICAgICAgICBkZXNjcmlwdGlvbjogJ1NlY3VyaXR5IGV2ZW50IGNvdW50IGdyb3VwZWQgYnkgZXZlbnQgdHlwZScsXG4gICAgICAgICAgbGFiZWxzOiB7IHR5cGUgfSxcbiAgICAgICAgICB2YWx1ZTogY291bnQsXG4gICAgICAgIH0pO1xuICAgICAgfVxuXG4gICAgICByZXR1cm4gZW50cmllcztcbiAgICB9IGNhdGNoIHtcbiAgICAgIHJldHVybiBbXTtcbiAgICB9XG4gIH1cbn1cbiJdfQ==

package/dist/metrics/collectors/SecurityTelemetryCollector.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Collects blocked-attack counts and per-severity breakdowns from a
+ * SecurityTelemetry instance. The current hour's attack rate is surfaced as a
+ * gauge so dashboards can display a rolling "attacks this hour" reading.
+ */
+import type { IMetricCollector, MetricEntry } from '../types.js';
+import type { SecurityTelemetry } from '../../security/telemetry/SecurityTelemetry.js';
+export declare class SecurityTelemetryCollector implements IMetricCollector {
+    private readonly telemetry;
+    readonly name = "security-telemetry";
+    readonly description = "Blocked attack counts, unique vectors, and severity breakdown from SecurityTelemetry";
+    constructor(telemetry: SecurityTelemetry);
+    collect(): MetricEntry[];
+}
+//# sourceMappingURL=SecurityTelemetryCollector.d.ts.map

package/dist/metrics/collectors/SecurityTelemetryCollector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SecurityTelemetryCollector.d.ts","sourceRoot":"","sources":["../../../src/metrics/collectors/SecurityTelemetryCollector.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AACjE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,+CAA+C,CAAC;AAIvF,qBAAa,0BAA2B,YAAW,gBAAgB;IAKrD,OAAO,CAAC,QAAQ,CAAC,SAAS;IAJtC,QAAQ,CAAC,IAAI,wBAAwB;IACrC,QAAQ,CAAC,WAAW,0FACqE;gBAE5D,SAAS,EAAE,iBAAiB;IAEzD,OAAO,IAAI,WAAW,EAAE;CAmGzB"}

package/dist/metrics/collectors/SecurityTelemetryCollector.js

@@ -0,0 +1,112 @@
+/**
+ * Collects blocked-attack counts and per-severity breakdowns from a
+ * SecurityTelemetry instance. The current hour's attack rate is surfaced as a
+ * gauge so dashboards can display a rolling "attacks this hour" reading.
+ */
+const SOURCE = 'SecurityTelemetry';
+export class SecurityTelemetryCollector {
+    telemetry;
+    name = 'security-telemetry';
+    description = 'Blocked attack counts, unique vectors, and severity breakdown from SecurityTelemetry';
+    constructor(telemetry) {
+        this.telemetry = telemetry;
+    }
+    collect() {
+        try {
+            const m = this.telemetry.getMetrics();
+            // attacksPerHour is a 24-element array indexed by hours-ago (0 = current hour)
+            const attacksThisHour = Array.isArray(m.attacksPerHour) ? (m.attacksPerHour[0] ?? 0) : 0;
+            const entries = [
+                {
+                    type: 'gauge',
+                    name: 'security.telemetry.blocked_total',
+                    source: SOURCE,
+                    unit: 'count',
+                    description: 'Total blocked attack attempts since process start',
+                    value: m.totalBlockedAttempts,
+                },
+                {
+                    type: 'gauge',
+                    name: 'security.telemetry.unique_vectors',
+                    source: SOURCE,
+                    unit: 'count',
+                    description: 'Number of distinct attack vectors observed',
+                    value: m.uniqueAttackVectors,
+                },
+                {
+                    type: 'gauge',
+                    name: 'security.telemetry.blocked_by_severity',
+                    source: SOURCE,
+                    unit: 'count',
+                    description: 'Blocked attacks broken down by severity',
+                    labels: { severity: 'critical' },
+                    value: m.criticalAttacksBlocked,
+                },
+                {
+                    type: 'gauge',
+                    name: 'security.telemetry.blocked_by_severity',
+                    source: SOURCE,
+                    unit: 'count',
+                    description: 'Blocked attacks broken down by severity',
+                    labels: { severity: 'high' },
+                    value: m.highSeverityBlocked,
+                },
+                {
+                    type: 'gauge',
+                    name: 'security.telemetry.blocked_by_severity',
+                    source: SOURCE,
+                    unit: 'count',
+                    description: 'Blocked attacks broken down by severity',
+                    labels: { severity: 'medium' },
+                    value: m.mediumSeverityBlocked,
+                },
+                {
+                    type: 'gauge',
+                    name: 'security.telemetry.blocked_by_severity',
+                    source: SOURCE,
+                    unit: 'count',
+                    description: 'Blocked attacks broken down by severity',
+                    labels: { severity: 'low' },
+                    value: m.lowSeverityBlocked,
+                },
+                {
+                    type: 'gauge',
+                    name: 'security.telemetry.attacks_per_hour',
+                    source: SOURCE,
+                    unit: 'count',
+                    description: 'Attack attempts recorded in the current clock hour',
+                    value: attacksThisHour,
+                },
+                {
+                    type: 'gauge',
+                    name: 'security.telemetry.dedup_suppressed',
+                    source: SOURCE,
+                    unit: 'count',
+                    description: 'Repeated events suppressed by deduplication',
+                    value: m.deduplication.suppressedEvents,
+                },
+                {
+                    type: 'gauge',
+                    name: 'security.telemetry.dedup_unique',
+                    source: SOURCE,
+                    unit: 'count',
+                    description: 'Unique events that passed through deduplication',
+                    value: m.deduplication.uniqueEvents,
+                },
+                {
+                    type: 'gauge',
+                    name: 'security.telemetry.dedup_cache_size',
+                    source: SOURCE,
+                    unit: 'count',
+                    description: 'Current deduplication cache size',
+                    value: m.deduplication.cacheSize,
+                },
+            ];
+            return entries;
+        }
+        catch {
+            return [];
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SecurityTelemetryCollector.js","sourceRoot":"","sources":["../../../src/metrics/collectors/SecurityTelemetryCollector.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Collects blocked-attack counts and per-severity breakdowns from a\n * SecurityTelemetry instance. The current hour's attack rate is surfaced as a\n * gauge so dashboards can display a rolling \"attacks this hour\" reading.\n */\n\nimport type { IMetricCollector, MetricEntry } from '../types.js';\nimport type { SecurityTelemetry } from '../../security/telemetry/SecurityTelemetry.js';\n\nconst SOURCE = 'SecurityTelemetry' as const;\n\nexport class SecurityTelemetryCollector implements IMetricCollector {\n  readonly name = 'security-telemetry';\n  readonly description =\n    'Blocked attack counts, unique vectors, and severity breakdown from SecurityTelemetry';\n\n  constructor(private readonly telemetry: SecurityTelemetry) {}\n\n  collect(): MetricEntry[] {\n    try {\n      const m = this.telemetry.getMetrics();\n\n      // attacksPerHour is a 24-element array indexed by hours-ago (0 = current hour)\n      const attacksThisHour = Array.isArray(m.attacksPerHour) ? (m.attacksPerHour[0] ?? 0) : 0;\n\n      const entries: MetricEntry[] = [\n        {\n          type: 'gauge' as const,\n          name: 'security.telemetry.blocked_total',\n          source: SOURCE,\n          unit: 'count' as const,\n          description: 'Total blocked attack attempts since process start',\n          value: m.totalBlockedAttempts,\n        },\n        {\n          type: 'gauge' as const,\n          name: 'security.telemetry.unique_vectors',\n          source: SOURCE,\n          unit: 'count' as const,\n          description: 'Number of distinct attack vectors observed',\n          value: m.uniqueAttackVectors,\n        },\n        {\n          type: 'gauge' as const,\n          name: 'security.telemetry.blocked_by_severity',\n          source: SOURCE,\n          unit: 'count' as const,\n          description: 'Blocked attacks broken down by severity',\n          labels: { severity: 'critical' },\n          value: m.criticalAttacksBlocked,\n        },\n        {\n          type: 'gauge' as const,\n          name: 'security.telemetry.blocked_by_severity',\n          source: SOURCE,\n          unit: 'count' as const,\n          description: 'Blocked attacks broken down by severity',\n          labels: { severity: 'high' },\n          value: m.highSeverityBlocked,\n        },\n        {\n          type: 'gauge' as const,\n          name: 'security.telemetry.blocked_by_severity',\n          source: SOURCE,\n          unit: 'count' as const,\n          description: 'Blocked attacks broken down by severity',\n          labels: { severity: 'medium' },\n          value: m.mediumSeverityBlocked,\n        },\n        {\n          type: 'gauge' as const,\n          name: 'security.telemetry.blocked_by_severity',\n          source: SOURCE,\n          unit: 'count' as const,\n          description: 'Blocked attacks broken down by severity',\n          labels: { severity: 'low' },\n          value: m.lowSeverityBlocked,\n        },\n        {\n          type: 'gauge' as const,\n          name: 'security.telemetry.attacks_per_hour',\n          source: SOURCE,\n          unit: 'count' as const,\n          description: 'Attack attempts recorded in the current clock hour',\n          value: attacksThisHour,\n        },\n        {\n          type: 'gauge' as const,\n          name: 'security.telemetry.dedup_suppressed',\n          source: SOURCE,\n          unit: 'count' as const,\n          description: 'Repeated events suppressed by deduplication',\n          value: m.deduplication.suppressedEvents,\n        },\n        {\n          type: 'gauge' as const,\n          name: 'security.telemetry.dedup_unique',\n          source: SOURCE,\n          unit: 'count' as const,\n          description: 'Unique events that passed through deduplication',\n          value: m.deduplication.uniqueEvents,\n        },\n        {\n          type: 'gauge' as const,\n          name: 'security.telemetry.dedup_cache_size',\n          source: SOURCE,\n          unit: 'count' as const,\n          description: 'Current deduplication cache size',\n          value: m.deduplication.cacheSize,\n        },\n      ];\n\n      return entries;\n    } catch {\n      return [];\n    }\n  }\n}\n"]}

package/dist/metrics/collectors/TriggerMetricsTrackerCollector.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Collector for TriggerMetricsTracker metrics.
+ *
+ * Exposes the number of pending trigger metric entries that have not yet
+ * been flushed, sourced from `TriggerMetricsTracker.pendingCount`.
+ */
+import type { IMetricCollector, MetricEntry } from '../types.js';
+import type { TriggerMetricsTracker } from '../../portfolio/enhanced-index/TriggerMetricsTracker.js';
+export declare class TriggerMetricsTrackerCollector implements IMetricCollector {
+    private readonly tracker;
+    readonly name = "trigger-metrics";
+    readonly description = "Pending trigger metric count from TriggerMetricsTracker.";
+    constructor(tracker: TriggerMetricsTracker);
+    collect(): MetricEntry[];
+}
+//# sourceMappingURL=TriggerMetricsTrackerCollector.d.ts.map

package/dist/metrics/collectors/TriggerMetricsTrackerCollector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TriggerMetricsTrackerCollector.d.ts","sourceRoot":"","sources":["../../../src/metrics/collectors/TriggerMetricsTrackerCollector.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AACjE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,yDAAyD,CAAC;AAErG,qBAAa,8BAA+B,YAAW,gBAAgB;IAIzD,OAAO,CAAC,QAAQ,CAAC,OAAO;IAHpC,QAAQ,CAAC,IAAI,qBAAqB;IAClC,QAAQ,CAAC,WAAW,8DAA8D;gBAErD,OAAO,EAAE,qBAAqB;IAE3D,OAAO,IAAI,WAAW,EAAE;CAgBzB"}

package/dist/metrics/collectors/TriggerMetricsTrackerCollector.js

@@ -0,0 +1,26 @@
+export class TriggerMetricsTrackerCollector {
+    tracker;
+    name = 'trigger-metrics';
+    description = 'Pending trigger metric count from TriggerMetricsTracker.';
+    constructor(tracker) {
+        this.tracker = tracker;
+    }
+    collect() {
+        try {
+            return [
+                {
+                    type: 'gauge',
+                    name: 'portfolio.triggers.pending_current',
+                    source: 'TriggerMetricsTracker',
+                    unit: 'count',
+                    description: 'Number of trigger metric entries pending flush.',
+                    value: this.tracker.pendingCount,
+                },
+            ];
+        }
+        catch {
+            return [];
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/metrics/collectors/index.d.ts

@@ -0,0 +1,11 @@
+export { PerformanceMonitorCollector } from './PerformanceMonitorCollector.js';
+export { LRUCacheCollector } from './LRUCacheCollector.js';
+export { SecurityMonitorCollector } from './SecurityMonitorCollector.js';
+export { SecurityTelemetryCollector } from './SecurityTelemetryCollector.js';
+export { FileLockManagerCollector } from './FileLockManagerCollector.js';
+export { DefaultElementProviderCollector } from './DefaultElementProviderCollector.js';
+export { TriggerMetricsTrackerCollector } from './TriggerMetricsTrackerCollector.js';
+export { OperationalTelemetryCollector } from './OperationalTelemetryCollector.js';
+export { OperationMetricsCollector } from './OperationMetricsCollector.js';
+export { GatekeeperMetricsCollector } from './GatekeeperMetricsCollector.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/metrics/collectors/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/metrics/collectors/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAAE,MAAM,kCAAkC,CAAC;AAC/E,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAC;AACzE,OAAO,EAAE,0BAA0B,EAAE,MAAM,iCAAiC,CAAC;AAC7E,OAAO,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAC;AACzE,OAAO,EAAE,+BAA+B,EAAE,MAAM,sCAAsC,CAAC;AACvF,OAAO,EAAE,8BAA8B,EAAE,MAAM,qCAAqC,CAAC;AACrF,OAAO,EAAE,6BAA6B,EAAE,MAAM,oCAAoC,CAAC;AACnF,OAAO,EAAE,yBAAyB,EAAE,MAAM,gCAAgC,CAAC;AAC3E,OAAO,EAAE,0BAA0B,EAAE,MAAM,iCAAiC,CAAC"}

package/dist/metrics/collectors/index.js

@@ -0,0 +1,11 @@
+export { PerformanceMonitorCollector } from './PerformanceMonitorCollector.js';
+export { LRUCacheCollector } from './LRUCacheCollector.js';
+export { SecurityMonitorCollector } from './SecurityMonitorCollector.js';
+export { SecurityTelemetryCollector } from './SecurityTelemetryCollector.js';
+export { FileLockManagerCollector } from './FileLockManagerCollector.js';
+export { DefaultElementProviderCollector } from './DefaultElementProviderCollector.js';
+export { TriggerMetricsTrackerCollector } from './TriggerMetricsTrackerCollector.js';
+export { OperationalTelemetryCollector } from './OperationalTelemetryCollector.js';
+export { OperationMetricsCollector } from './OperationMetricsCollector.js';
+export { GatekeeperMetricsCollector } from './GatekeeperMetricsCollector.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbWV0cmljcy9jb2xsZWN0b3JzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSwyQkFBMkIsRUFBRSxNQUFNLGtDQUFrQyxDQUFDO0FBQy9FLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBQzNELE9BQU8sRUFBRSx3QkFBd0IsRUFBRSxNQUFNLCtCQUErQixDQUFDO0FBQ3pFLE9BQU8sRUFBRSwwQkFBMEIsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBQzdFLE9BQU8sRUFBRSx3QkFBd0IsRUFBRSxNQUFNLCtCQUErQixDQUFDO0FBQ3pFLE9BQU8sRUFBRSwrQkFBK0IsRUFBRSxNQUFNLHNDQUFzQyxDQUFDO0FBQ3ZGLE9BQU8sRUFBRSw4QkFBOEIsRUFBRSxNQUFNLHFDQUFxQyxDQUFDO0FBQ3JGLE9BQU8sRUFBRSw2QkFBNkIsRUFBRSxNQUFNLG9DQUFvQyxDQUFDO0FBQ25GLE9BQU8sRUFBRSx5QkFBeUIsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBQzNFLE9BQU8sRUFBRSwwQkFBMEIsRUFBRSxNQUFNLGlDQUFpQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgUGVyZm9ybWFuY2VNb25pdG9yQ29sbGVjdG9yIH0gZnJvbSAnLi9QZXJmb3JtYW5jZU1vbml0b3JDb2xsZWN0b3IuanMnO1xuZXhwb3J0IHsgTFJVQ2FjaGVDb2xsZWN0b3IgfSBmcm9tICcuL0xSVUNhY2hlQ29sbGVjdG9yLmpzJztcbmV4cG9ydCB7IFNlY3VyaXR5TW9uaXRvckNvbGxlY3RvciB9IGZyb20gJy4vU2VjdXJpdHlNb25pdG9yQ29sbGVjdG9yLmpzJztcbmV4cG9ydCB7IFNlY3VyaXR5VGVsZW1ldHJ5Q29sbGVjdG9yIH0gZnJvbSAnLi9TZWN1cml0eVRlbGVtZXRyeUNvbGxlY3Rvci5qcyc7XG5leHBvcnQgeyBGaWxlTG9ja01hbmFnZXJDb2xsZWN0b3IgfSBmcm9tICcuL0ZpbGVMb2NrTWFuYWdlckNvbGxlY3Rvci5qcyc7XG5leHBvcnQgeyBEZWZhdWx0RWxlbWVudFByb3ZpZGVyQ29sbGVjdG9yIH0gZnJvbSAnLi9EZWZhdWx0RWxlbWVudFByb3ZpZGVyQ29sbGVjdG9yLmpzJztcbmV4cG9ydCB7IFRyaWdnZXJNZXRyaWNzVHJhY2tlckNvbGxlY3RvciB9IGZyb20gJy4vVHJpZ2dlck1ldHJpY3NUcmFja2VyQ29sbGVjdG9yLmpzJztcbmV4cG9ydCB7IE9wZXJhdGlvbmFsVGVsZW1ldHJ5Q29sbGVjdG9yIH0gZnJvbSAnLi9PcGVyYXRpb25hbFRlbGVtZXRyeUNvbGxlY3Rvci5qcyc7XG5leHBvcnQgeyBPcGVyYXRpb25NZXRyaWNzQ29sbGVjdG9yIH0gZnJvbSAnLi9PcGVyYXRpb25NZXRyaWNzQ29sbGVjdG9yLmpzJztcbmV4cG9ydCB7IEdhdGVrZWVwZXJNZXRyaWNzQ29sbGVjdG9yIH0gZnJvbSAnLi9HYXRla2VlcGVyTWV0cmljc0NvbGxlY3Rvci5qcyc7XG4iXX0=

package/dist/metrics/sinks/MemoryMetricsSink.d.ts

@@ -0,0 +1,22 @@
+/**
+ * In-memory ring buffer sink for metric snapshots.
+ *
+ * Stores snapshots in an EvictingQueue and provides a query interface
+ * for the MCP query_metrics tool. Follows the same query pattern as
+ * MemoryLogSink (see src/logging/sinks/MemoryLogSink.ts).
+ */
+import type { IMetricsSink, MetricQueryOptions, MetricQueryResult, MetricSnapshot } from '../types.js';
+export declare class MemoryMetricsSink implements IMetricsSink {
+    readonly name = "MemoryMetricsSink";
+    private readonly queue;
+    constructor(maxSnapshots?: number);
+    onSnapshot(snapshot: MetricSnapshot): void;
+    flush(): Promise<void>;
+    close(): Promise<void>;
+    query(options?: MetricQueryOptions): MetricQueryResult;
+    getStats(): {
+        size: number;
+        capacity: number;
+    };
+}
+//# sourceMappingURL=MemoryMetricsSink.d.ts.map

package/dist/metrics/sinks/MemoryMetricsSink.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MemoryMetricsSink.d.ts","sourceRoot":"","sources":["../../../src/metrics/sinks/MemoryMetricsSink.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,EACV,YAAY,EAEZ,kBAAkB,EAClB,iBAAiB,EACjB,cAAc,EACf,MAAM,aAAa,CAAC;AAErB,qBAAa,iBAAkB,YAAW,YAAY;IACpD,QAAQ,CAAC,IAAI,uBAAuB;IACpC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAgC;gBAE1C,YAAY,GAAE,MAAY;IAItC,UAAU,CAAC,QAAQ,EAAE,cAAc,GAAG,IAAI;IAIpC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAItB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAI5B,KAAK,CAAC,OAAO,CAAC,EAAE,kBAAkB,GAAG,iBAAiB;IA4EtD,QAAQ,IAAI;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE;CAG/C"}

package/dist/metrics/sinks/MemoryMetricsSink.js

@@ -0,0 +1,121 @@
+/**
+ * In-memory ring buffer sink for metric snapshots.
+ *
+ * Stores snapshots in an EvictingQueue and provides a query interface
+ * for the MCP query_metrics tool. Follows the same query pattern as
+ * MemoryLogSink (see src/logging/sinks/MemoryLogSink.ts).
+ */
+import { EvictingQueue } from '../../utils/EvictingQueue.js';
+export class MemoryMetricsSink {
+    name = 'MemoryMetricsSink';
+    queue;
+    constructor(maxSnapshots = 240) {
+        this.queue = new EvictingQueue(maxSnapshots);
+    }
+    onSnapshot(snapshot) {
+        this.queue.push(snapshot);
+    }
+    async flush() {
+        // No-op — in-memory, nothing to flush.
+    }
+    async close() {
+        this.queue.clear();
+    }
+    query(options) {
+        const latest = options?.latest ?? true;
+        const limit = Math.min(Math.max(options?.limit ?? 1, 0), 100);
+        const offset = Math.max(options?.offset ?? 0, 0);
+        const allSnapshots = this.queue.toArray();
+        // Compute availability bounds BEFORE filtering
+        const oldestAvailable = allSnapshots.length > 0 ? allSnapshots[0].timestamp : '';
+        const newestAvailable = allSnapshots.length > 0 ? allSnapshots.at(-1).timestamp : '';
+        // If limit is 0, return empty result with bounds
+        if (limit === 0) {
+            return {
+                snapshots: [],
+                total: 0,
+                hasMore: false,
+                limit,
+                offset,
+                oldestAvailable,
+                newestAvailable,
+            };
+        }
+        // 1. Select snapshots based on latest flag
+        let snapshots;
+        if (latest) {
+            snapshots = allSnapshots.length > 0 ? [allSnapshots.at(-1)] : [];
+        }
+        else {
+            snapshots = [...allSnapshots];
+        }
+        // 2. Filter by time range
+        if (options?.since) {
+            const since = options.since;
+            snapshots = snapshots.filter(s => s.timestamp > since);
+        }
+        if (options?.until) {
+            const until = options.until;
+            snapshots = snapshots.filter(s => s.timestamp < until);
+        }
+        // 3. Filter metrics within each snapshot by name/source/type
+        if (options?.names || options?.source || options?.type) {
+            const filtered = [];
+            for (const snapshot of snapshots) {
+                const matchedMetrics = snapshot.metrics.filter(metric => matchesMetricFilters(metric, options));
+                if (matchedMetrics.length > 0) {
+                    filtered.push({ ...snapshot, metrics: matchedMetrics });
+                }
+            }
+            snapshots = filtered;
+        }
+        // 4. Sort newest-first (descending timestamp)
+        snapshots.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+        // 5. Count total before pagination
+        const total = snapshots.length;
+        // 6. Paginate
+        snapshots = snapshots.slice(offset, offset + limit);
+        return {
+            snapshots,
+            total,
+            hasMore: offset + limit < total,
+            limit,
+            offset,
+            oldestAvailable,
+            newestAvailable,
+        };
+    }
+    getStats() {
+        return { size: this.queue.size, capacity: this.queue.capacity };
+    }
+}
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+function matchesMetricFilters(metric, options) {
+    // Name filter: prefix match if ends with '.' or '.*', else exact match
+    if (options.names && options.names.length > 0) {
+        const matched = options.names.some(name => {
+            if (name.endsWith('.') || name.endsWith('.*')) {
+                const prefix = name.endsWith('.*') ? name.slice(0, -1) : name;
+                return metric.name.startsWith(prefix);
+            }
+            return metric.name === name;
+        });
+        if (!matched)
+            return false;
+    }
+    // Source filter: case-insensitive substring match
+    if (options.source) {
+        const needle = options.source.toLowerCase();
+        if (!metric.source.toLowerCase().includes(needle))
+            return false;
+    }
+    // Type filter: exact match
+    if (options.type) {
+        if (metric.type !== options.type)
+            return false;
+    }
+    return true;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"MemoryMetricsSink.js","sourceRoot":"","sources":["../../../src/metrics/sinks/MemoryMetricsSink.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * In-memory ring buffer sink for metric snapshots.\n *\n * Stores snapshots in an EvictingQueue and provides a query interface\n * for the MCP query_metrics tool. Follows the same query pattern as\n * MemoryLogSink (see src/logging/sinks/MemoryLogSink.ts).\n */\n\nimport { EvictingQueue } from '../../utils/EvictingQueue.js';\nimport type {\n  IMetricsSink,\n  MetricEntry,\n  MetricQueryOptions,\n  MetricQueryResult,\n  MetricSnapshot,\n} from '../types.js';\n\nexport class MemoryMetricsSink implements IMetricsSink {\n  readonly name = 'MemoryMetricsSink';\n  private readonly queue: EvictingQueue<MetricSnapshot>;\n\n  constructor(maxSnapshots: number = 240) {\n    this.queue = new EvictingQueue<MetricSnapshot>(maxSnapshots);\n  }\n\n  onSnapshot(snapshot: MetricSnapshot): void {\n    this.queue.push(snapshot);\n  }\n\n  async flush(): Promise<void> {\n    // No-op — in-memory, nothing to flush.\n  }\n\n  async close(): Promise<void> {\n    this.queue.clear();\n  }\n\n  query(options?: MetricQueryOptions): MetricQueryResult {\n    const latest = options?.latest ?? true;\n    const limit = Math.min(Math.max(options?.limit ?? 1, 0), 100);\n    const offset = Math.max(options?.offset ?? 0, 0);\n\n    const allSnapshots = this.queue.toArray();\n\n    // Compute availability bounds BEFORE filtering\n    const oldestAvailable = allSnapshots.length > 0 ? allSnapshots[0].timestamp : '';\n    const newestAvailable = allSnapshots.length > 0 ? allSnapshots.at(-1)!.timestamp : '';\n\n    // If limit is 0, return empty result with bounds\n    if (limit === 0) {\n      return {\n        snapshots: [],\n        total: 0,\n        hasMore: false,\n        limit,\n        offset,\n        oldestAvailable,\n        newestAvailable,\n      };\n    }\n\n    // 1. Select snapshots based on latest flag\n    let snapshots: MetricSnapshot[];\n    if (latest) {\n      snapshots = allSnapshots.length > 0 ? [allSnapshots.at(-1)!] : [];\n    } else {\n      snapshots = [...allSnapshots];\n    }\n\n    // 2. Filter by time range\n    if (options?.since) {\n      const since = options.since;\n      snapshots = snapshots.filter(s => s.timestamp > since);\n    }\n    if (options?.until) {\n      const until = options.until;\n      snapshots = snapshots.filter(s => s.timestamp < until);\n    }\n\n    // 3. Filter metrics within each snapshot by name/source/type\n    if (options?.names || options?.source || options?.type) {\n      const filtered: MetricSnapshot[] = [];\n      for (const snapshot of snapshots) {\n        const matchedMetrics = snapshot.metrics.filter(metric =>\n          matchesMetricFilters(metric, options),\n        );\n        if (matchedMetrics.length > 0) {\n          filtered.push({ ...snapshot, metrics: matchedMetrics });\n        }\n      }\n      snapshots = filtered;\n    }\n\n    // 4. Sort newest-first (descending timestamp)\n    snapshots.sort((a, b) => b.timestamp.localeCompare(a.timestamp));\n\n    // 5. Count total before pagination\n    const total = snapshots.length;\n\n    // 6. Paginate\n    snapshots = snapshots.slice(offset, offset + limit);\n\n    return {\n      snapshots,\n      total,\n      hasMore: offset + limit < total,\n      limit,\n      offset,\n      oldestAvailable,\n      newestAvailable,\n    };\n  }\n\n  getStats(): { size: number; capacity: number } {\n    return { size: this.queue.size, capacity: this.queue.capacity };\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Internal helpers\n// ---------------------------------------------------------------------------\n\nfunction matchesMetricFilters(\n  metric: MetricEntry,\n  options: MetricQueryOptions,\n): boolean {\n  // Name filter: prefix match if ends with '.' or '.*', else exact match\n  if (options.names && options.names.length > 0) {\n    const matched = options.names.some(name => {\n      if (name.endsWith('.') || name.endsWith('.*')) {\n        const prefix = name.endsWith('.*') ? name.slice(0, -1) : name;\n        return metric.name.startsWith(prefix);\n      }\n      return metric.name === name;\n    });\n    if (!matched) return false;\n  }\n\n  // Source filter: case-insensitive substring match\n  if (options.source) {\n    const needle = options.source.toLowerCase();\n    if (!metric.source.toLowerCase().includes(needle)) return false;\n  }\n\n  // Type filter: exact match\n  if (options.type) {\n    if (metric.type !== options.type) return false;\n  }\n\n  return true;\n}\n"]}

package/dist/metrics/types.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Core types for the Metrics Collection System.
+ *
+ * These types are shared across the MetricsManager, all sinks, and all collectors.
+ */
+export type MetricType = 'counter' | 'gauge' | 'histogram';
+export type MetricUnit = 'count' | 'bytes' | 'milliseconds' | 'seconds' | 'percent' | 'ratio' | 'operations' | 'megabytes' | 'none';
+export interface BaseMetricEntry {
+    readonly name: string;
+    readonly source: string;
+    readonly unit: MetricUnit;
+    readonly description?: string;
+    readonly labels?: Readonly<Record<string, string>>;
+}
+export interface CounterEntry extends BaseMetricEntry {
+    readonly type: 'counter';
+    readonly value: number;
+}
+export interface GaugeEntry extends BaseMetricEntry {
+    readonly type: 'gauge';
+    readonly value: number;
+}
+export interface HistogramValue {
+    readonly count: number;
+    readonly sum: number;
+    readonly min?: number;
+    readonly max?: number;
+    readonly avg?: number;
+    readonly p50?: number;
+    readonly p75?: number;
+    readonly p90?: number;
+    readonly p95?: number;
+    readonly p99?: number;
+}
+export interface HistogramEntry extends BaseMetricEntry {
+    readonly type: 'histogram';
+    readonly value: HistogramValue;
+}
+export type MetricEntry = CounterEntry | GaugeEntry | HistogramEntry;
+export interface MetricSnapshot {
+    readonly id: string;
+    readonly timestamp: string;
+    readonly metrics: readonly MetricEntry[];
+    readonly errors: readonly string[];
+    readonly durationMs: number;
+}
+export interface IMetricCollector {
+    readonly name: string;
+    readonly description: string;
+    collect(): MetricEntry[] | Promise<MetricEntry[]>;
+}
+export interface IMetricsSink {
+    readonly name: string;
+    onSnapshot(snapshot: MetricSnapshot): void;
+    flush(): Promise<void>;
+    close(): Promise<void>;
+}
+export interface MetricQueryOptions {
+    names?: string[];
+    source?: string;
+    type?: MetricType;
+    since?: string;
+    until?: string;
+    latest?: boolean;
+    limit?: number;
+    offset?: number;
+}
+export interface MetricQueryResult {
+    readonly snapshots: readonly MetricSnapshot[];
+    readonly total: number;
+    readonly hasMore: boolean;
+    readonly limit: number;
+    readonly offset: number;
+    readonly oldestAvailable: string;
+    readonly newestAvailable: string;
+}
+export interface MetricsManagerConfig {
+    readonly enabled: boolean;
+    readonly collectionIntervalMs: number;
+    readonly maxSnapshotSize: number;
+    readonly collectorFailureThreshold: number;
+    readonly collectionDurationWarnMs: number;
+    readonly memorySnapshotCapacity: number;
+}
+/**
+ * Map the flat env object (from Zod-parsed `process.env`) to a typed
+ * `MetricsManagerConfig`. Keeps the mapping in one place so the DI container
+ * only needs `buildMetricsManagerConfig(env)`.
+ */
+export declare function buildMetricsManagerConfig(envVars: {
+    DOLLHOUSE_METRICS_ENABLED: boolean;
+    DOLLHOUSE_METRICS_COLLECTION_INTERVAL_MS: number;
+    DOLLHOUSE_METRICS_MAX_SNAPSHOT_SIZE: number;
+    DOLLHOUSE_METRICS_COLLECTOR_FAILURE_THRESHOLD: number;
+    DOLLHOUSE_METRICS_COLLECTION_DURATION_WARN_MS: number;
+    DOLLHOUSE_METRICS_MEMORY_SNAPSHOT_CAPACITY: number;
+}): MetricsManagerConfig;
+//# sourceMappingURL=types.d.ts.map

package/dist/metrics/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/metrics/types.ts"],"names":[],"mappings":"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"}

package/dist/metrics/types.js

@@ -0,0 +1,24 @@
+/**
+ * Core types for the Metrics Collection System.
+ *
+ * These types are shared across the MetricsManager, all sinks, and all collectors.
+ */
+// ---------------------------------------------------------------------------
+// Helper: build config from env vars
+// ---------------------------------------------------------------------------
+/**
+ * Map the flat env object (from Zod-parsed `process.env`) to a typed
+ * `MetricsManagerConfig`. Keeps the mapping in one place so the DI container
+ * only needs `buildMetricsManagerConfig(env)`.
+ */
+export function buildMetricsManagerConfig(envVars) {
+    return {
+        enabled: envVars.DOLLHOUSE_METRICS_ENABLED,
+        collectionIntervalMs: envVars.DOLLHOUSE_METRICS_COLLECTION_INTERVAL_MS,
+        maxSnapshotSize: envVars.DOLLHOUSE_METRICS_MAX_SNAPSHOT_SIZE,
+        collectorFailureThreshold: envVars.DOLLHOUSE_METRICS_COLLECTOR_FAILURE_THRESHOLD,
+        collectionDurationWarnMs: envVars.DOLLHOUSE_METRICS_COLLECTION_DURATION_WARN_MS,
+        memorySnapshotCapacity: envVars.DOLLHOUSE_METRICS_MEMORY_SNAPSHOT_CAPACITY,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/portfolio/DefaultElementProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DefaultElementProvider.d.ts","sourceRoot":"","sources":["../../src/portfolio/DefaultElementProvider.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"DefaultElementProvider.d.ts","sourceRoot":"","sources":["../../src/portfolio/DefaultElementProvider.ts"],"names":[],"mappings":"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"}