@lssm/lib.observability 0.0.0-canary-20251120170226 → 0.2.0

package/dist/pipeline/evolution-pipeline.d.mts

@@ -0,0 +1,40 @@
+import { IntentAggregator, IntentAggregatorSnapshot, TelemetrySample } from "../intent/aggregator.mjs";
+import { IntentDetector, IntentSignal } from "../intent/detector.mjs";
+import { EventEmitter } from "node:events";
+
+//#region src/pipeline/evolution-pipeline.d.ts
+type EvolutionPipelineEvent = {
+  type: 'intent.detected';
+  payload: IntentSignal;
+} | {
+  type: 'telemetry.window';
+  payload: {
+    sampleCount: number;
+  };
+};
+interface EvolutionPipelineOptions {
+  detector?: IntentDetector;
+  aggregator?: IntentAggregator;
+  emitter?: EventEmitter;
+  onIntent?: (intent: IntentSignal) => Promise<void> | void;
+  onSnapshot?: (snapshot: IntentAggregatorSnapshot) => Promise<void> | void;
+}
+declare class EvolutionPipeline {
+  private readonly detector;
+  private readonly aggregator;
+  private readonly emitter;
+  private readonly onIntent?;
+  private readonly onSnapshot?;
+  private timer?;
+  private previousMetrics?;
+  constructor(options?: EvolutionPipelineOptions);
+  ingest(sample: TelemetrySample): void;
+  on(listener: (event: EvolutionPipelineEvent) => void): void;
+  start(intervalMs?: number): void;
+  stop(): void;
+  run(): Promise<void>;
+  private emit;
+}
+//#endregion
+export { EvolutionPipeline, EvolutionPipelineEvent, EvolutionPipelineOptions };
+//# sourceMappingURL=evolution-pipeline.d.mts.map

package/dist/pipeline/evolution-pipeline.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evolution-pipeline.d.mts","names":[],"sources":["../../src/pipeline/evolution-pipeline.ts"],"sourcesContent":[],"mappings":";;;;;KAQY,sBAAA;;EAAA,OAAA,EAC4B,YAD5B;AAIZ,CAAA,GAAiB;EACJ,IAAA,EAAA,kBAAA;EACE,OAAA,EAAA;IACH,WAAA,EAAA,MAAA;EACU,CAAA;CAAiB;AACb,UALT,wBAAA,CAKS;EAA6B,QAAA,CAAA,EAJ1C,cAI0C;EAAO,UAAA,CAAA,EAH/C,gBAG+C;EAGjD,OAAA,CAAA,EALD,YAKkB;EAWP,QAAA,CAAA,EAAA,CAAA,MAAA,EAfD,YAeC,EAAA,GAfgB,OAehB,CAAA,IAAA,CAAA,GAAA,IAAA;EAQN,UAAA,CAAA,EAAA,CAAA,QAAA,EAtBS,wBAsBT,EAAA,GAtBsC,OAsBtC,CAAA,IAAA,CAAA,GAAA,IAAA;;AAsBN,cAzCE,iBAAA,CAyCF;EAAA,iBAAA,QAAA;;;;;;;wBA9BY;iBAQN;uBAIM;;;SAkBZ"}

package/dist/pipeline/evolution-pipeline.mjs

@@ -0,0 +1,2 @@
+import{IntentAggregator as e}from"../intent/aggregator.mjs";import{IntentDetector as t}from"../intent/detector.mjs";import{EventEmitter as n}from"node:events";var r=class{detector;aggregator;emitter;onIntent;onSnapshot;timer;previousMetrics;constructor(r={}){this.detector=r.detector??new t,this.aggregator=r.aggregator??new e,this.emitter=r.emitter??new n,this.onIntent=r.onIntent,this.onSnapshot=r.onSnapshot}ingest(e){this.aggregator.add(e)}on(e){this.emitter.on(`event`,e)}start(e=300*1e3){this.stop(),this.timer=setInterval(()=>{this.run()},e)}stop(){this.timer&&=(clearInterval(this.timer),void 0)}async run(){let e=this.aggregator.flush();if(this.emit({type:`telemetry.window`,payload:{sampleCount:e.sampleCount}}),this.onSnapshot&&await this.onSnapshot(e),!e.sampleCount)return;let t=this.detector.detectFromMetrics(e.metrics,this.previousMetrics),n=this.detector.detectSequentialIntents(e.sequences);this.previousMetrics=e.metrics;let r=[...t,...n];for(let e of r)this.onIntent&&await this.onIntent(e),this.emit({type:`intent.detected`,payload:e})}emit(e){this.emitter.emit(`event`,e)}};export{r as EvolutionPipeline};
+//# sourceMappingURL=evolution-pipeline.mjs.map

package/dist/pipeline/evolution-pipeline.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"evolution-pipeline.mjs","names":[],"sources":["../../src/pipeline/evolution-pipeline.ts"],"sourcesContent":["import { EventEmitter } from 'node:events';\nimport {\n  IntentAggregator,\n  type IntentAggregatorSnapshot,\n  type TelemetrySample,\n} from '../intent/aggregator';\nimport { IntentDetector, type IntentSignal } from '../intent/detector';\n\nexport type EvolutionPipelineEvent =\n  | { type: 'intent.detected'; payload: IntentSignal }\n  | { type: 'telemetry.window'; payload: { sampleCount: number } };\n\nexport interface EvolutionPipelineOptions {\n  detector?: IntentDetector;\n  aggregator?: IntentAggregator;\n  emitter?: EventEmitter;\n  onIntent?: (intent: IntentSignal) => Promise<void> | void;\n  onSnapshot?: (snapshot: IntentAggregatorSnapshot) => Promise<void> | void;\n}\n\nexport class EvolutionPipeline {\n  private readonly detector: IntentDetector;\n  private readonly aggregator: IntentAggregator;\n  private readonly emitter: EventEmitter;\n  private readonly onIntent?: (intent: IntentSignal) => Promise<void> | void;\n  private readonly onSnapshot?: (\n    snapshot: IntentAggregatorSnapshot\n  ) => Promise<void> | void;\n  private timer?: NodeJS.Timeout;\n  private previousMetrics?: ReturnType<IntentAggregator['flush']>['metrics'];\n\n  constructor(options: EvolutionPipelineOptions = {}) {\n    this.detector = options.detector ?? new IntentDetector();\n    this.aggregator = options.aggregator ?? new IntentAggregator();\n    this.emitter = options.emitter ?? new EventEmitter();\n    this.onIntent = options.onIntent;\n    this.onSnapshot = options.onSnapshot;\n  }\n\n  ingest(sample: TelemetrySample) {\n    this.aggregator.add(sample);\n  }\n\n  on(listener: (event: EvolutionPipelineEvent) => void) {\n    this.emitter.on('event', listener);\n  }\n\n  start(intervalMs = 5 * 60 * 1000) {\n    this.stop();\n    this.timer = setInterval(() => {\n      void this.run();\n    }, intervalMs);\n  }\n\n  stop() {\n    if (this.timer) {\n      clearInterval(this.timer);\n      this.timer = undefined;\n    }\n  }\n\n  async run() {\n    const snapshot = this.aggregator.flush();\n    this.emit({\n      type: 'telemetry.window',\n      payload: { sampleCount: snapshot.sampleCount },\n    });\n    if (this.onSnapshot) await this.onSnapshot(snapshot);\n    if (!snapshot.sampleCount) return;\n\n    const metricSignals = this.detector.detectFromMetrics(\n      snapshot.metrics,\n      this.previousMetrics\n    );\n    const sequenceSignals = this.detector.detectSequentialIntents(\n      snapshot.sequences\n    );\n    this.previousMetrics = snapshot.metrics;\n\n    const signals = [...metricSignals, ...sequenceSignals];\n    for (const signal of signals) {\n      if (this.onIntent) await this.onIntent(signal);\n      this.emit({ type: 'intent.detected', payload: signal });\n    }\n  }\n\n  private emit(event: EvolutionPipelineEvent) {\n    this.emitter.emit('event', event);\n  }\n}\n"],"mappings":"+JAoBA,IAAa,EAAb,KAA+B,CAC7B,SACA,WACA,QACA,SACA,WAGA,MACA,gBAEA,YAAY,EAAoC,EAAE,CAAE,CAClD,KAAK,SAAW,EAAQ,UAAY,IAAI,EACxC,KAAK,WAAa,EAAQ,YAAc,IAAI,EAC5C,KAAK,QAAU,EAAQ,SAAW,IAAI,EACtC,KAAK,SAAW,EAAQ,SACxB,KAAK,WAAa,EAAQ,WAG5B,OAAO,EAAyB,CAC9B,KAAK,WAAW,IAAI,EAAO,CAG7B,GAAG,EAAmD,CACpD,KAAK,QAAQ,GAAG,QAAS,EAAS,CAGpC,MAAM,EAAa,IAAS,IAAM,CAChC,KAAK,MAAM,CACX,KAAK,MAAQ,gBAAkB,CACxB,KAAK,KAAK,EACd,EAAW,CAGhB,MAAO,CACL,AAEE,KAAK,SADL,cAAc,KAAK,MAAM,CACZ,IAAA,IAIjB,MAAM,KAAM,CACV,IAAM,EAAW,KAAK,WAAW,OAAO,CAMxC,GALA,KAAK,KAAK,CACR,KAAM,mBACN,QAAS,CAAE,YAAa,EAAS,YAAa,CAC/C,CAAC,CACE,KAAK,YAAY,MAAM,KAAK,WAAW,EAAS,CAChD,CAAC,EAAS,YAAa,OAE3B,IAAM,EAAgB,KAAK,SAAS,kBAClC,EAAS,QACT,KAAK,gBACN,CACK,EAAkB,KAAK,SAAS,wBACpC,EAAS,UACV,CACD,KAAK,gBAAkB,EAAS,QAEhC,IAAM,EAAU,CAAC,GAAG,EAAe,GAAG,EAAgB,CACtD,IAAK,IAAM,KAAU,EACf,KAAK,UAAU,MAAM,KAAK,SAAS,EAAO,CAC9C,KAAK,KAAK,CAAE,KAAM,kBAAmB,QAAS,EAAQ,CAAC,CAI3D,KAAa,EAA+B,CAC1C,KAAK,QAAQ,KAAK,QAAS,EAAM"}

package/dist/pipeline/lifecycle-pipeline.d.mts

@@ -0,0 +1,44 @@
+import { EventEmitter } from "node:events";
+import { LifecycleAssessment, LifecycleStage } from "@lssm/lib.lifecycle";
+
+//#region src/pipeline/lifecycle-pipeline.d.ts
+type LifecyclePipelineEvent = {
+  type: 'assessment.recorded';
+  payload: {
+    tenantId?: string;
+    stage: LifecycleStage;
+  };
+} | {
+  type: 'stage.changed';
+  payload: {
+    tenantId?: string;
+    previousStage?: LifecycleStage;
+    nextStage: LifecycleStage;
+  };
+} | {
+  type: 'confidence.low';
+  payload: {
+    tenantId?: string;
+    confidence: number;
+  };
+};
+interface LifecycleKpiPipelineOptions {
+  meterName?: string;
+  emitter?: EventEmitter;
+  lowConfidenceThreshold?: number;
+}
+declare class LifecycleKpiPipeline {
+  private readonly assessmentCounter;
+  private readonly confidenceHistogram;
+  private readonly stageUpDownCounter;
+  private readonly emitter;
+  private readonly lowConfidenceThreshold;
+  private readonly currentStageByTenant;
+  constructor(options?: LifecycleKpiPipelineOptions);
+  recordAssessment(assessment: LifecycleAssessment, tenantId?: string): void;
+  on(listener: (event: LifecyclePipelineEvent) => void): void;
+  private ensureStageCounters;
+}
+//#endregion
+export { LifecycleKpiPipeline, LifecycleKpiPipelineOptions, LifecyclePipelineEvent };
+//# sourceMappingURL=lifecycle-pipeline.d.mts.map

package/dist/pipeline/lifecycle-pipeline.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lifecycle-pipeline.d.mts","names":[],"sources":["../../src/pipeline/lifecycle-pipeline.ts"],"sourcesContent":[],"mappings":";;;;KASY,sBAAA;;EAAA,OAAA,EAAA;IAG+B,QAAA,CAAA,EAAA,MAAA;IAMnB,KAAA,EANmB,cAMnB;EACL,CAAA;CAAc,GAAA;EAQhB,IAAA,EAAA,eAAA;EAMJ,OAAA,EAAA;IAQU,QAAA,CAAA,EAAA,MAAA;IAqBQ,aAAA,CAAA,EA5CP,cA4CO;IAoBR,SAAA,EA/DJ,cA+DI;EAAsB,CAAA;;;;;;;;UAvD5B,2BAAA;;YAEL;;;cAIC,oBAAA;;;;;;;wBAQU;+BAqBQ;uBAoBR"}

package/dist/pipeline/lifecycle-pipeline.mjs

@@ -0,0 +1,2 @@
+import{createCounter as e,createHistogram as t,createUpDownCounter as n}from"../metrics/index.mjs";import{o as r}from"../lifecycle/dist/utils/formatters.mjs";import"../lifecycle/dist/index.mjs";import{EventEmitter as i}from"node:events";var a=class{assessmentCounter;confidenceHistogram;stageUpDownCounter;emitter;lowConfidenceThreshold;currentStageByTenant=new Map;constructor(r={}){let a=r.meterName??`@lssm/lib.lifecycle-kpi`;this.assessmentCounter=e(`lifecycle_assessments_total`,`Total lifecycle assessments`,a),this.confidenceHistogram=t(`lifecycle_assessment_confidence`,`Lifecycle assessment confidence distribution`,a),this.stageUpDownCounter=n(`lifecycle_stage_tenants`,`Current tenants per lifecycle stage`,a),this.emitter=r.emitter??new i,this.lowConfidenceThreshold=r.lowConfidenceThreshold??.4}recordAssessment(e,t){let n={stage:r(e.stage),tenantId:t};this.assessmentCounter.add(1,n),this.confidenceHistogram.record(e.confidence,n),this.ensureStageCounters(e.stage,t),this.emitter.emit(`event`,{type:`assessment.recorded`,payload:{tenantId:t,stage:e.stage}}),e.confidence<this.lowConfidenceThreshold&&this.emitter.emit(`event`,{type:`confidence.low`,payload:{tenantId:t,confidence:e.confidence}})}on(e){this.emitter.on(`event`,e)}ensureStageCounters(e,t){if(!t)return;let n=this.currentStageByTenant.get(t);n!==e&&(n!==void 0&&this.stageUpDownCounter.add(-1,{stage:r(n),tenantId:t}),this.stageUpDownCounter.add(1,{stage:r(e),tenantId:t}),this.currentStageByTenant.set(t,e),this.emitter.emit(`event`,{type:`stage.changed`,payload:{tenantId:t,previousStage:n,nextStage:e}}))}};export{a as LifecycleKpiPipeline};
+//# sourceMappingURL=lifecycle-pipeline.mjs.map

package/dist/pipeline/lifecycle-pipeline.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"lifecycle-pipeline.mjs","names":["getStageLabel"],"sources":["../../src/pipeline/lifecycle-pipeline.ts"],"sourcesContent":["import { EventEmitter } from 'node:events';\nimport type { LifecycleAssessment, LifecycleStage } from '@lssm/lib.lifecycle';\nimport { getStageLabel } from '@lssm/lib.lifecycle';\nimport {\n  createCounter,\n  createHistogram,\n  createUpDownCounter,\n} from '../metrics';\n\nexport type LifecyclePipelineEvent =\n  | {\n      type: 'assessment.recorded';\n      payload: { tenantId?: string; stage: LifecycleStage };\n    }\n  | {\n      type: 'stage.changed';\n      payload: {\n        tenantId?: string;\n        previousStage?: LifecycleStage;\n        nextStage: LifecycleStage;\n      };\n    }\n  | {\n      type: 'confidence.low';\n      payload: { tenantId?: string; confidence: number };\n    };\n\nexport interface LifecycleKpiPipelineOptions {\n  meterName?: string;\n  emitter?: EventEmitter;\n  lowConfidenceThreshold?: number;\n}\n\nexport class LifecycleKpiPipeline {\n  private readonly assessmentCounter;\n  private readonly confidenceHistogram;\n  private readonly stageUpDownCounter;\n  private readonly emitter: EventEmitter;\n  private readonly lowConfidenceThreshold: number;\n  private readonly currentStageByTenant = new Map<string, LifecycleStage>();\n\n  constructor(options: LifecycleKpiPipelineOptions = {}) {\n    const meterName = options.meterName ?? '@lssm/lib.lifecycle-kpi';\n    this.assessmentCounter = createCounter(\n      'lifecycle_assessments_total',\n      'Total lifecycle assessments',\n      meterName\n    );\n    this.confidenceHistogram = createHistogram(\n      'lifecycle_assessment_confidence',\n      'Lifecycle assessment confidence distribution',\n      meterName\n    );\n    this.stageUpDownCounter = createUpDownCounter(\n      'lifecycle_stage_tenants',\n      'Current tenants per lifecycle stage',\n      meterName\n    );\n    this.emitter = options.emitter ?? new EventEmitter();\n    this.lowConfidenceThreshold = options.lowConfidenceThreshold ?? 0.4;\n  }\n\n  recordAssessment(assessment: LifecycleAssessment, tenantId?: string) {\n    const stageLabel = getStageLabel(assessment.stage);\n    const attributes = { stage: stageLabel, tenantId };\n    this.assessmentCounter.add(1, attributes);\n    this.confidenceHistogram.record(assessment.confidence, attributes);\n\n    this.ensureStageCounters(assessment.stage, tenantId);\n    this.emitter.emit('event', {\n      type: 'assessment.recorded',\n      payload: { tenantId, stage: assessment.stage },\n    } satisfies LifecyclePipelineEvent);\n\n    if (assessment.confidence < this.lowConfidenceThreshold) {\n      this.emitter.emit('event', {\n        type: 'confidence.low',\n        payload: { tenantId, confidence: assessment.confidence },\n      } satisfies LifecyclePipelineEvent);\n    }\n  }\n\n  on(listener: (event: LifecyclePipelineEvent) => void) {\n    this.emitter.on('event', listener);\n  }\n\n  private ensureStageCounters(stage: LifecycleStage, tenantId?: string) {\n    if (!tenantId) return;\n    const previous = this.currentStageByTenant.get(tenantId);\n    if (previous === stage) return;\n\n    if (previous !== undefined) {\n      this.stageUpDownCounter.add(-1, {\n        stage: getStageLabel(previous),\n        tenantId,\n      });\n    }\n    this.stageUpDownCounter.add(1, { stage: getStageLabel(stage), tenantId });\n    this.currentStageByTenant.set(tenantId, stage);\n    this.emitter.emit('event', {\n      type: 'stage.changed',\n      payload: { tenantId, previousStage: previous, nextStage: stage },\n    } satisfies LifecyclePipelineEvent);\n  }\n}\n"],"mappings":"6OAiCA,IAAa,EAAb,KAAkC,CAChC,kBACA,oBACA,mBACA,QACA,uBACA,qBAAwC,IAAI,IAE5C,YAAY,EAAuC,EAAE,CAAE,CACrD,IAAM,EAAY,EAAQ,WAAa,0BACvC,KAAK,kBAAoB,EACvB,8BACA,8BACA,EACD,CACD,KAAK,oBAAsB,EACzB,kCACA,+CACA,EACD,CACD,KAAK,mBAAqB,EACxB,0BACA,sCACA,EACD,CACD,KAAK,QAAU,EAAQ,SAAW,IAAI,EACtC,KAAK,uBAAyB,EAAQ,wBAA0B,GAGlE,iBAAiB,EAAiC,EAAmB,CAEnE,IAAM,EAAa,CAAE,MADFA,EAAc,EAAW,MAAM,CACV,WAAU,CAClD,KAAK,kBAAkB,IAAI,EAAG,EAAW,CACzC,KAAK,oBAAoB,OAAO,EAAW,WAAY,EAAW,CAElE,KAAK,oBAAoB,EAAW,MAAO,EAAS,CACpD,KAAK,QAAQ,KAAK,QAAS,CACzB,KAAM,sBACN,QAAS,CAAE,WAAU,MAAO,EAAW,MAAO,CAC/C,CAAkC,CAE/B,EAAW,WAAa,KAAK,wBAC/B,KAAK,QAAQ,KAAK,QAAS,CACzB,KAAM,iBACN,QAAS,CAAE,WAAU,WAAY,EAAW,WAAY,CACzD,CAAkC,CAIvC,GAAG,EAAmD,CACpD,KAAK,QAAQ,GAAG,QAAS,EAAS,CAGpC,oBAA4B,EAAuB,EAAmB,CACpE,GAAI,CAAC,EAAU,OACf,IAAM,EAAW,KAAK,qBAAqB,IAAI,EAAS,CACpD,IAAa,IAEb,IAAa,IAAA,IACf,KAAK,mBAAmB,IAAI,GAAI,CAC9B,MAAOA,EAAc,EAAS,CAC9B,WACD,CAAC,CAEJ,KAAK,mBAAmB,IAAI,EAAG,CAAE,MAAOA,EAAc,EAAM,CAAE,WAAU,CAAC,CACzE,KAAK,qBAAqB,IAAI,EAAU,EAAM,CAC9C,KAAK,QAAQ,KAAK,QAAS,CACzB,KAAM,gBACN,QAAS,CAAE,WAAU,cAAe,EAAU,UAAW,EAAO,CACjE,CAAkC"}

package/dist/tracing/middleware.d.mts

@@ -1,5 +1,19 @@
+import { TelemetrySample } from "../intent/aggregator.mjs";
+
 //#region src/tracing/middleware.d.ts
-declare function createTracingMiddleware(): (req: Request, next: () => Promise<Response>) => Promise<Response>;
+interface TracingMiddlewareOptions {
+  resolveOperation?: (input: {
+    req: Request;
+    res?: Response;
+  }) => {
+    name: string;
+    version: number;
+  } | undefined;
+  onSample?: (sample: TelemetrySample) => void;
+  tenantResolver?: (req: Request) => string | undefined;
+  actorResolver?: (req: Request) => string | undefined;
+}
+declare function createTracingMiddleware(options?: TracingMiddlewareOptions): (req: Request, next: () => Promise<Response>) => Promise<Response>;
 //#endregion
-export { createTracingMiddleware };
+export { TracingMiddlewareOptions, createTracingMiddleware };
 //# sourceMappingURL=middleware.d.mts.map

package/dist/tracing/middleware.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"middleware.d.mts","names":[],"sources":["../../src/tracing/middleware.ts"],"sourcesContent":[],"mappings":";iBAGgB,uBAAA,CAAA,SACK,qBAAqB,QAAQ,cAAS,QAAA"}
+{"version":3,"file":"middleware.d.mts","names":[],"sources":["../../src/tracing/middleware.ts"],"sourcesContent":[],"mappings":";;;UAKiB,wBAAA;;IAAA,GAAA,EAER,OAFQ;IAER,GAAA,CAAA,EACC,QADD;EACC,CAAA,EAAA,GAAA;IAEY,IAAA,EAAA,MAAA;IACG,OAAA,EAAA,MAAA;EACD,CAAA,GAAA,SAAA;EAAO,QAAA,CAAA,EAAA,CAAA,MAAA,EAFT,eAES,EAAA,GAAA,IAAA;EAGf,cAAA,CAAA,EAAA,CAAA,GAAA,EAJS,OAIc,EAAA,GAAA,MAAA,GAAA,SAAA;EAC5B,aAAA,CAAA,EAAA,CAAA,GAAA,EAJa,OAIb,EAAA,GAAA,MAAA,GAAA,SAAA;;AAEuC,iBAHlC,uBAAA,CAGkC,OAAA,CAAA,EAFvC,wBAEuC,CAAA,EAAA,CAAA,GAAA,EAA7B,OAA6B,EAAA,IAAA,EAAA,GAAA,GAAR,OAAQ,CAAA,QAAA,CAAA,EAAA,GAAS,OAAT,CAAS,QAAT,CAAA"}

package/dist/tracing/middleware.mjs

@@ -1,2 +1,2 @@
-import{traceAsync as e}from"./index.mjs";import{standardMetrics as t}from"../metrics/index.mjs";function n(){return async(n,r)=>{let i=n.method,a=new URL(n.url).pathname;t.httpRequests.add(1,{method:i,path:a});let o=performance.now();return e(`HTTP ${i} ${a}`,async e=>{e.setAttribute(`http.method`,i),e.setAttribute(`http.url`,n.url);try{let n=await r();e.setAttribute(`http.status_code`,n.status);let s=(performance.now()-o)/1e3;return t.httpDuration.record(s,{method:i,path:a,status:n.status.toString()}),n}catch(e){throw t.operationErrors.add(1,{method:i,path:a}),e}})}}export{n as createTracingMiddleware};
+import{traceAsync as e}from"./index.mjs";import{standardMetrics as t}from"../metrics/index.mjs";function n(n={}){return async(i,a)=>{let o=i.method,s=new URL(i.url).pathname;t.httpRequests.add(1,{method:o,path:s});let c=performance.now();return e(`HTTP ${o} ${s}`,async e=>{e.setAttribute(`http.method`,o),e.setAttribute(`http.url`,i.url);try{let l=await a();e.setAttribute(`http.status_code`,l.status);let u=(performance.now()-c)/1e3;return t.httpDuration.record(u,{method:o,path:s,status:l.status.toString()}),r({req:i,res:l,span:e,success:!0,durationMs:u*1e3,options:n}),l}catch(a){throw t.operationErrors.add(1,{method:o,path:s}),r({req:i,span:e,success:!1,durationMs:performance.now()-c,error:a,options:n}),a}})}}function r({req:e,res:t,span:n,success:r,durationMs:i,error:a,options:o}){if(!o.onSample||!o.resolveOperation)return;let s=o.resolveOperation({req:e,res:t});if(!s)return;let c={operation:s,durationMs:i,success:r,timestamp:new Date,errorCode:!r&&a instanceof Error?a.name:r?void 0:`unknown`,tenantId:o.tenantResolver?.(e),actorId:o.actorResolver?.(e),traceId:n.spanContext().traceId,metadata:{method:e.method,path:new URL(e.url).pathname,status:t?.status}};o.onSample(c)}export{n as createTracingMiddleware};
 //# sourceMappingURL=middleware.mjs.map

package/dist/tracing/middleware.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"middleware.mjs","names":[],"sources":["../../src/tracing/middleware.ts"],"sourcesContent":["import { traceAsync } from './index';\nimport { standardMetrics } from '../metrics';\n\nexport function createTracingMiddleware() {\n  return async (req: Request, next: () => Promise<Response>) => {\n    const method = req.method;\n    const url = new URL(req.url);\n    const path = url.pathname;\n\n    standardMetrics.httpRequests.add(1, { method, path });\n    const startTime = performance.now();\n\n    return traceAsync(`HTTP ${method} ${path}`, async (span) => {\n      span.setAttribute('http.method', method);\n      span.setAttribute('http.url', req.url);\n\n      try {\n        const response = await next();\n        span.setAttribute('http.status_code', response.status);\n\n        const duration = (performance.now() - startTime) / 1000;\n        standardMetrics.httpDuration.record(duration, {\n          method,\n          path,\n          status: response.status.toString(),\n        });\n\n        return response;\n      } catch (error) {\n        standardMetrics.operationErrors.add(1, { method, path });\n        throw error;\n      }\n    });\n  };\n}\n"],"mappings":"gGAGA,SAAgB,GAA0B,CACxC,OAAO,MAAO,EAAc,IAAkC,CAC5D,IAAM,EAAS,EAAI,OAEb,EADM,IAAI,IAAI,EAAI,IAAI,CACX,SAEjB,EAAgB,aAAa,IAAI,EAAG,CAAE,SAAQ,OAAM,CAAC,CACrD,IAAM,EAAY,YAAY,KAAK,CAEnC,OAAO,EAAW,QAAQ,EAAO,GAAG,IAAQ,KAAO,IAAS,CAC1D,EAAK,aAAa,cAAe,EAAO,CACxC,EAAK,aAAa,WAAY,EAAI,IAAI,CAEtC,GAAI,CACF,IAAM,EAAW,MAAM,GAAM,CAC7B,EAAK,aAAa,mBAAoB,EAAS,OAAO,CAEtD,IAAM,GAAY,YAAY,KAAK,CAAG,GAAa,IAOnD,OANA,EAAgB,aAAa,OAAO,EAAU,CAC5C,SACA,OACA,OAAQ,EAAS,OAAO,UAAU,CACnC,CAAC,CAEK,QACA,EAAO,CAEd,MADA,EAAgB,gBAAgB,IAAI,EAAG,CAAE,SAAQ,OAAM,CAAC,CAClD,IAER"}
+{"version":3,"file":"middleware.mjs","names":["sample: TelemetrySample"],"sources":["../../src/tracing/middleware.ts"],"sourcesContent":["import type { Span } from '@opentelemetry/api';\nimport { traceAsync } from './index';\nimport { standardMetrics } from '../metrics';\nimport type { TelemetrySample } from '../intent/aggregator';\n\nexport interface TracingMiddlewareOptions {\n  resolveOperation?: (input: {\n    req: Request;\n    res?: Response;\n  }) => { name: string; version: number } | undefined;\n  onSample?: (sample: TelemetrySample) => void;\n  tenantResolver?: (req: Request) => string | undefined;\n  actorResolver?: (req: Request) => string | undefined;\n}\n\nexport function createTracingMiddleware(\n  options: TracingMiddlewareOptions = {}\n) {\n  return async (req: Request, next: () => Promise<Response>) => {\n    const method = req.method;\n    const url = new URL(req.url);\n    const path = url.pathname;\n\n    standardMetrics.httpRequests.add(1, { method, path });\n    const startTime = performance.now();\n\n    return traceAsync(`HTTP ${method} ${path}`, async (span) => {\n      span.setAttribute('http.method', method);\n      span.setAttribute('http.url', req.url);\n\n      try {\n        const response = await next();\n        span.setAttribute('http.status_code', response.status);\n\n        const duration = (performance.now() - startTime) / 1000;\n        standardMetrics.httpDuration.record(duration, {\n          method,\n          path,\n          status: response.status.toString(),\n        });\n\n        emitTelemetrySample({\n          req,\n          res: response,\n          span,\n          success: true,\n          durationMs: duration * 1000,\n          options,\n        });\n\n        return response;\n      } catch (error) {\n        standardMetrics.operationErrors.add(1, { method, path });\n        emitTelemetrySample({\n          req,\n          span,\n          success: false,\n          durationMs: performance.now() - startTime,\n          error,\n          options,\n        });\n        throw error;\n      }\n    });\n  };\n}\n\ninterface EmitTelemetryArgs {\n  req: Request;\n  res?: Response;\n  span: Span;\n  success: boolean;\n  durationMs: number;\n  error?: unknown;\n  options: TracingMiddlewareOptions;\n}\n\nfunction emitTelemetrySample({\n  req,\n  res,\n  span,\n  success,\n  durationMs,\n  error,\n  options,\n}: EmitTelemetryArgs) {\n  if (!options.onSample || !options.resolveOperation) return;\n  const operation = options.resolveOperation({ req, res });\n  if (!operation) return;\n  const sample: TelemetrySample = {\n    operation,\n    durationMs,\n    success,\n    timestamp: new Date(),\n    errorCode:\n      !success && error instanceof Error\n        ? error.name\n        : success\n          ? undefined\n          : 'unknown',\n    tenantId: options.tenantResolver?.(req),\n    actorId: options.actorResolver?.(req),\n    traceId: span.spanContext().traceId,\n    metadata: {\n      method: req.method,\n      path: new URL(req.url).pathname,\n      status: res?.status,\n    },\n  };\n  options.onSample(sample);\n}\n"],"mappings":"gGAeA,SAAgB,EACd,EAAoC,EAAE,CACtC,CACA,OAAO,MAAO,EAAc,IAAkC,CAC5D,IAAM,EAAS,EAAI,OAEb,EADM,IAAI,IAAI,EAAI,IAAI,CACX,SAEjB,EAAgB,aAAa,IAAI,EAAG,CAAE,SAAQ,OAAM,CAAC,CACrD,IAAM,EAAY,YAAY,KAAK,CAEnC,OAAO,EAAW,QAAQ,EAAO,GAAG,IAAQ,KAAO,IAAS,CAC1D,EAAK,aAAa,cAAe,EAAO,CACxC,EAAK,aAAa,WAAY,EAAI,IAAI,CAEtC,GAAI,CACF,IAAM,EAAW,MAAM,GAAM,CAC7B,EAAK,aAAa,mBAAoB,EAAS,OAAO,CAEtD,IAAM,GAAY,YAAY,KAAK,CAAG,GAAa,IAgBnD,OAfA,EAAgB,aAAa,OAAO,EAAU,CAC5C,SACA,OACA,OAAQ,EAAS,OAAO,UAAU,CACnC,CAAC,CAEF,EAAoB,CAClB,MACA,IAAK,EACL,OACA,QAAS,GACT,WAAY,EAAW,IACvB,UACD,CAAC,CAEK,QACA,EAAO,CAUd,MATA,EAAgB,gBAAgB,IAAI,EAAG,CAAE,SAAQ,OAAM,CAAC,CACxD,EAAoB,CAClB,MACA,OACA,QAAS,GACT,WAAY,YAAY,KAAK,CAAG,EAChC,QACA,UACD,CAAC,CACI,IAER,EAcN,SAAS,EAAoB,CAC3B,MACA,MACA,OACA,UACA,aACA,QACA,WACoB,CACpB,GAAI,CAAC,EAAQ,UAAY,CAAC,EAAQ,iBAAkB,OACpD,IAAM,EAAY,EAAQ,iBAAiB,CAAE,MAAK,MAAK,CAAC,CACxD,GAAI,CAAC,EAAW,OAChB,IAAMA,EAA0B,CAC9B,YACA,aACA,UACA,UAAW,IAAI,KACf,UACE,CAAC,GAAW,aAAiB,MACzB,EAAM,KACN,EACE,IAAA,GACA,UACR,SAAU,EAAQ,iBAAiB,EAAI,CACvC,QAAS,EAAQ,gBAAgB,EAAI,CACrC,QAAS,EAAK,aAAa,CAAC,QAC5B,SAAU,CACR,OAAQ,EAAI,OACZ,KAAM,IAAI,IAAI,EAAI,IAAI,CAAC,SACvB,OAAQ,GAAK,OACd,CACF,CACD,EAAQ,SAAS,EAAO"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lssm/lib.observability",
-  "version": "0.0.0-canary-20251120170226",
+  "version": "0.2.0",
   "main": "./dist/index.mjs",
   "types": "./dist/index.d.mts",
   "scripts": {
@@ -14,6 +14,9 @@
     "lint:check": "eslint src",
     "test": "vitest run"
   },
+  "dependencies": {
+    "@lssm/lib.lifecycle": "workspace:*"
+  },
   "peerDependencies": {
     "@opentelemetry/api": "*"
   },
@@ -23,8 +26,16 @@
   },
   "exports": {
     ".": "./dist/index.mjs",
+    "./anomaly/alert-manager": "./dist/anomaly/alert-manager.mjs",
+    "./anomaly/anomaly-detector": "./dist/anomaly/anomaly-detector.mjs",
+    "./anomaly/baseline-calculator": "./dist/anomaly/baseline-calculator.mjs",
+    "./anomaly/root-cause-analyzer": "./dist/anomaly/root-cause-analyzer.mjs",
+    "./intent/aggregator": "./dist/intent/aggregator.mjs",
+    "./intent/detector": "./dist/intent/detector.mjs",
     "./logging": "./dist/logging/index.mjs",
     "./metrics": "./dist/metrics/index.mjs",
+    "./pipeline/evolution-pipeline": "./dist/pipeline/evolution-pipeline.mjs",
+    "./pipeline/lifecycle-pipeline": "./dist/pipeline/lifecycle-pipeline.mjs",
     "./tracing": "./dist/tracing/index.mjs",
     "./tracing/middleware": "./dist/tracing/middleware.mjs",
     "./*": "./*"

package/src/anomaly/alert-manager.ts

@@ -0,0 +1,31 @@
+import type { AnomalySignal } from './anomaly-detector';
+import type { RootCauseAnalysis } from './root-cause-analyzer';
+
+export interface AlertManagerOptions {
+  cooldownMs?: number;
+  transport: (payload: {
+    signal: AnomalySignal;
+    analysis: RootCauseAnalysis;
+  }) => Promise<void> | void;
+}
+
+export class AlertManager {
+  private readonly cooldownMs: number;
+  private readonly lastAlert = new Map<string, number>();
+
+  constructor(private readonly options: AlertManagerOptions) {
+    this.cooldownMs = options.cooldownMs ?? 60_000;
+  }
+
+  async notify(signal: AnomalySignal, analysis: RootCauseAnalysis) {
+    const key = `${signal.type}:${analysis.culprit?.id ?? 'none'}`;
+    const now = Date.now();
+    const last = this.lastAlert.get(key) ?? 0;
+    if (now - last < this.cooldownMs) {
+      return;
+    }
+
+    await this.options.transport({ signal, analysis });
+    this.lastAlert.set(key, now);
+  }
+}

package/src/anomaly/anomaly-detector.ts

@@ -0,0 +1,94 @@
+import { BaselineCalculator, type MetricPoint } from './baseline-calculator';
+
+export interface AnomalyThresholds {
+  errorRateDelta?: number;
+  latencyDelta?: number;
+  throughputDrop?: number;
+  minSamples?: number;
+}
+
+export interface AnomalySignal {
+  type: 'error_rate_spike' | 'latency_regression' | 'throughput_drop';
+  delta: number;
+  point: MetricPoint;
+  baseline: ReturnType<BaselineCalculator['getSnapshot']>;
+}
+
+export class AnomalyDetector {
+  private readonly baseline: BaselineCalculator;
+  private readonly thresholds: Required<AnomalyThresholds> = {
+    errorRateDelta: 0.5,
+    latencyDelta: 0.35,
+    throughputDrop: 0.4,
+    minSamples: 10,
+  } as Required<AnomalyThresholds>;
+
+  constructor(options: AnomalyThresholds = {}) {
+    this.baseline = new BaselineCalculator();
+    this.thresholds = { ...this.thresholds, ...options };
+  }
+
+  evaluate(point: MetricPoint): AnomalySignal[] {
+    const baselineSnapshot = this.baseline.update(point);
+    if (baselineSnapshot.sampleCount < this.thresholds.minSamples) {
+      return [];
+    }
+
+    const signals: AnomalySignal[] = [];
+
+    const errorDelta = this.relativeDelta(
+      point.errorRate,
+      baselineSnapshot.errorRate
+    );
+    if (errorDelta > this.thresholds.errorRateDelta) {
+      signals.push({
+        type: 'error_rate_spike',
+        delta: errorDelta,
+        point,
+        baseline: baselineSnapshot,
+      });
+    }
+
+    const latencyDelta = this.relativeDelta(
+      point.latencyP99,
+      baselineSnapshot.latencyP99
+    );
+    if (latencyDelta > this.thresholds.latencyDelta) {
+      signals.push({
+        type: 'latency_regression',
+        delta: latencyDelta,
+        point,
+        baseline: baselineSnapshot,
+      });
+    }
+
+    const throughputDelta = this.relativeDrop(
+      point.throughput,
+      baselineSnapshot.throughput
+    );
+    if (throughputDelta > this.thresholds.throughputDrop) {
+      signals.push({
+        type: 'throughput_drop',
+        delta: throughputDelta,
+        point,
+        baseline: baselineSnapshot,
+      });
+    }
+
+    return signals;
+  }
+
+  private relativeDelta(value: number, baseline: number) {
+    if (baseline === 0) {
+      return 0;
+    }
+    return (value - baseline) / baseline;
+  }
+
+  private relativeDrop(value: number, baseline: number) {
+    if (baseline === 0) {
+      return 0;
+    }
+    return (baseline - value) / baseline;
+  }
+}

package/src/anomaly/baseline-calculator.ts

@@ -0,0 +1,54 @@
+export interface MetricPoint {
+  latencyP99: number;
+  latencyP95: number;
+  errorRate: number;
+  throughput: number;
+  timestamp: Date;
+}
+
+export interface BaselineSnapshot {
+  latencyP99: number;
+  latencyP95: number;
+  errorRate: number;
+  throughput: number;
+  sampleCount: number;
+}
+
+export class BaselineCalculator {
+  private snapshot: BaselineSnapshot = {
+    latencyP99: 0,
+    latencyP95: 0,
+    errorRate: 0,
+    throughput: 0,
+    sampleCount: 0,
+  };
+
+  constructor(private readonly alpha = 0.2) {}
+
+  update(point: MetricPoint): BaselineSnapshot {
+    const { sampleCount } = this.snapshot;
+    const nextCount = sampleCount + 1;
+    const weight = sampleCount === 0 ? 1 : this.alpha;
+
+    this.snapshot = {
+      latencyP99: this.mix(this.snapshot.latencyP99, point.latencyP99, weight),
+      latencyP95: this.mix(this.snapshot.latencyP95, point.latencyP95, weight),
+      errorRate: this.mix(this.snapshot.errorRate, point.errorRate, weight),
+      throughput: this.mix(this.snapshot.throughput, point.throughput, weight),
+      sampleCount: nextCount,
+    };
+
+    return this.snapshot;
+  }
+
+  getSnapshot() {
+    return this.snapshot;
+  }
+
+  private mix(current: number, next: number, weight: number) {
+    if (this.snapshot.sampleCount === 0) {
+      return next;
+    }
+    return current * (1 - weight) + next * weight;
+  }
+}

package/src/anomaly/root-cause-analyzer.ts

@@ -0,0 +1,55 @@
+import type { AnomalySignal } from './anomaly-detector';
+
+export interface DeploymentEvent {
+  id: string;
+  operation: string;
+  deployedAt: Date;
+  stage?: string;
+  status: 'in_progress' | 'completed' | 'rolled_back';
+}
+
+export interface RootCauseAnalysis {
+  signal: AnomalySignal;
+  culprit?: DeploymentEvent;
+  notes: string[];
+}
+
+export class RootCauseAnalyzer {
+  constructor(private readonly lookbackMs: number = 15 * 60 * 1000) {}
+
+  analyze(
+    signal: AnomalySignal,
+    deployments: DeploymentEvent[]
+  ): RootCauseAnalysis {
+    const windowStart = new Date(
+      signal.point.timestamp.getTime() - this.lookbackMs
+    );
+    const candidates = deployments
+      .filter((deployment) => deployment.deployedAt >= windowStart)
+      .sort((a, b) => b.deployedAt.getTime() - a.deployedAt.getTime());
+
+    const notes: string[] = [];
+    let culprit: DeploymentEvent | undefined;
+
+    if (candidates.length > 0) {
+      culprit = candidates[0]!;
+      notes.push(
+        `Closest deployment ${culprit.id} (${culprit.operation}) at ${culprit.deployedAt.toISOString()}`
+      );
+    } else {
+      notes.push('No deployments found within lookback window.');
+    }
+
+    if (signal.type === 'latency_regression') {
+      notes.push(
+        'Verify recent schema changes and external dependency latency.'
+      );
+    }
+
+    if (signal.type === 'error_rate_spike') {
+      notes.push('Check SLO monitor for correlated incidents.');
+    }
+
+    return { signal, culprit, notes };
+  }
+}

package/src/index.ts

@@ -7,6 +7,41 @@ export {
   standardMetrics,
 } from './metrics';
 export { Logger, logger } from './logging';
-export { createTracingMiddleware } from './tracing/middleware';
+export {
+  createTracingMiddleware,
+  type TracingMiddlewareOptions,
+} from './tracing/middleware';
+export {
+  IntentAggregator,
+  type IntentAggregatorSnapshot,
+  type TelemetrySample,
+} from './intent/aggregator';
+export {
+  IntentDetector,
+  type IntentSignal,
+  type IntentSignalType,
+} from './intent/detector';
+export {
+  EvolutionPipeline,
+  type EvolutionPipelineEvent,
+  type EvolutionPipelineOptions,
+} from './pipeline/evolution-pipeline';
+export {
+  LifecycleKpiPipeline,
+  type LifecycleKpiPipelineOptions,
+  type LifecyclePipelineEvent,
+} from './pipeline/lifecycle-pipeline';
 
 export type { LogLevel, LogEntry } from './logging';
+
+export { BaselineCalculator } from './anomaly/baseline-calculator';
+export {
+  AnomalyDetector,
+  type AnomalySignal,
+  type AnomalyThresholds,
+} from './anomaly/anomaly-detector';
+export {
+  RootCauseAnalyzer,
+  type RootCauseAnalysis,
+} from './anomaly/root-cause-analyzer';
+export { AlertManager } from './anomaly/alert-manager';

package/src/intent/aggregator.ts

@@ -0,0 +1,161 @@
+export interface TelemetrySample {
+  operation: { name: string; version: number };
+  durationMs: number;
+  success: boolean;
+  timestamp: Date;
+  errorCode?: string;
+  tenantId?: string;
+  traceId?: string;
+  actorId?: string;
+  metadata?: Record<string, unknown>;
+}
+
+export interface AggregatedOperationMetrics {
+  operation: { name: string; version: number };
+  totalCalls: number;
+  successRate: number;
+  errorRate: number;
+  averageLatencyMs: number;
+  p95LatencyMs: number;
+  p99LatencyMs: number;
+  maxLatencyMs: number;
+  windowStart: Date;
+  windowEnd: Date;
+  topErrors: Record<string, number>;
+}
+
+export interface OperationSequence {
+  steps: string[];
+  tenantId?: string;
+  count: number;
+}
+
+export interface IntentAggregatorSnapshot {
+  metrics: AggregatedOperationMetrics[];
+  sequences: OperationSequence[];
+  sampleCount: number;
+  windowStart?: Date;
+  windowEnd?: Date;
+}
+
+export interface IntentAggregatorOptions {
+  windowMs?: number;
+  sequenceSampleSize?: number;
+}
+
+const DEFAULT_WINDOW_MS = 15 * 60 * 1000; // 15 minutes
+
+export class IntentAggregator {
+  private readonly windowMs: number;
+  private readonly sequenceSampleSize: number;
+  private readonly samples: TelemetrySample[] = [];
+
+  constructor(options: IntentAggregatorOptions = {}) {
+    this.windowMs = options.windowMs ?? DEFAULT_WINDOW_MS;
+    this.sequenceSampleSize = options.sequenceSampleSize ?? 1000;
+  }
+
+  add(sample: TelemetrySample) {
+    this.samples.push(sample);
+  }
+
+  flush(now = new Date()): IntentAggregatorSnapshot {
+    const minTimestamp = now.getTime() - this.windowMs;
+    const windowSamples = this.samples.filter(
+      (sample) => sample.timestamp.getTime() >= minTimestamp
+    );
+    this.samples.length = 0;
+    const metrics = this.aggregateMetrics(windowSamples);
+    const sequences = this.buildSequences(windowSamples);
+    const timestamps = windowSamples.map((sample) =>
+      sample.timestamp.getTime()
+    );
+    return {
+      metrics,
+      sequences,
+      sampleCount: windowSamples.length,
+      windowStart: timestamps.length
+        ? new Date(Math.min(...timestamps))
+        : undefined,
+      windowEnd: timestamps.length
+        ? new Date(Math.max(...timestamps))
+        : undefined,
+    };
+  }
+
+  private aggregateMetrics(samples: TelemetrySample[]) {
+    if (!samples.length) return [] as AggregatedOperationMetrics[];
+    const groups = new Map<string, TelemetrySample[]>();
+    for (const sample of samples) {
+      const key = `${sample.operation.name}.v${sample.operation.version}`;
+      const arr = groups.get(key) ?? [];
+      arr.push(sample);
+      groups.set(key, arr);
+    }
+
+    return [...groups.values()].map((group) => {
+      const durations = group.map((s) => s.durationMs).sort((a, b) => a - b);
+      const errors = group.filter((s) => !s.success);
+      const totalCalls = group.length;
+      const topErrors = errors.reduce<Record<string, number>>((acc, sample) => {
+        if (!sample.errorCode) return acc;
+        acc[sample.errorCode] = (acc[sample.errorCode] ?? 0) + 1;
+        return acc;
+      }, {});
+      const timestamps = group.map((s) => s.timestamp.getTime());
+      return {
+        operation: group[0]!.operation,
+        totalCalls,
+        successRate: (totalCalls - errors.length) / totalCalls,
+        errorRate: errors.length / totalCalls,
+        averageLatencyMs:
+          durations.reduce((sum, value) => sum + value, 0) / totalCalls,
+        p95LatencyMs: percentile(durations, 0.95),
+        p99LatencyMs: percentile(durations, 0.99),
+        maxLatencyMs: Math.max(...durations),
+        windowStart: new Date(Math.min(...timestamps)),
+        windowEnd: new Date(Math.max(...timestamps)),
+        topErrors,
+      } satisfies AggregatedOperationMetrics;
+    });
+  }
+
+  private buildSequences(samples: TelemetrySample[]): OperationSequence[] {
+    const byTrace = new Map<string, TelemetrySample[]>();
+    for (const sample of samples.slice(-this.sequenceSampleSize)) {
+      if (!sample.traceId) continue;
+      const arr = byTrace.get(sample.traceId) ?? [];
+      arr.push(sample);
+      byTrace.set(sample.traceId, arr);
+    }
+
+    const sequences: Record<string, OperationSequence> = {};
+    for (const [traceId, events] of byTrace.entries()) {
+      const ordered = events.sort(
+        (a, b) => a.timestamp.getTime() - b.timestamp.getTime()
+      );
+      const steps = ordered.map((event) => event.operation.name);
+      if (steps.length < 2) continue;
+      const key = `${steps.join('>')}@${ordered[0]?.tenantId ?? 'global'}`;
+      const existing = sequences[key];
+      if (existing) {
+        existing.count += 1;
+      } else {
+        sequences[key] = {
+          steps,
+          tenantId: ordered[0]?.tenantId,
+          count: 1,
+        };
+      }
+    }
+
+    return Object.values(sequences).sort((a, b) => b.count - a.count);
+  }
+}
+
+function percentile(values: number[], ratio: number) {
+  if (!values.length) return 0;
+  if (values.length === 1) return values[0]!;
+  const index = Math.min(values.length - 1, Math.floor(ratio * values.length));
+  return values[index]!;
+}