@lssm/lib.observability 0.0.0-canary-20251217063201 → 0.0.0-canary-20251217072406

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # @lssm/lib.observability
 
-## 0.0.0-canary-20251217063201
+## 0.0.0-canary-20251217072406
 
 ### Minor Changes
 
@@ -9,7 +9,7 @@
 ### Patch Changes
 
 - Updated dependencies [66a5dfd]
-  - @lssm/lib.lifecycle@0.0.0-canary-20251217063201
+  - @lssm/lib.lifecycle@0.0.0-canary-20251217072406
 
 ## 0.5.0
 

package/dist/anomaly/alert-manager.mjs

@@ -1 +1,22 @@
-var e=class{cooldownMs;lastAlert=new Map;constructor(e){this.options=e,this.cooldownMs=e.cooldownMs??6e4}async notify(e,t){let n=`${e.type}:${t.culprit?.id??`none`}`,r=Date.now();r-(this.lastAlert.get(n)??0)<this.cooldownMs||(await this.options.transport({signal:e,analysis:t}),this.lastAlert.set(n,r))}};export{e as AlertManager};
+//#region src/anomaly/alert-manager.ts
+var AlertManager = class {
+	cooldownMs;
+	lastAlert = /* @__PURE__ */ new Map();
+	constructor(options) {
+		this.options = options;
+		this.cooldownMs = options.cooldownMs ?? 6e4;
+	}
+	async notify(signal, analysis) {
+		const key = `${signal.type}:${analysis.culprit?.id ?? "none"}`;
+		const now = Date.now();
+		if (now - (this.lastAlert.get(key) ?? 0) < this.cooldownMs) return;
+		await this.options.transport({
+			signal,
+			analysis
+		});
+		this.lastAlert.set(key, now);
+	}
+};
+
+//#endregion
+export { AlertManager };

package/dist/anomaly/anomaly-detector.mjs

@@ -1 +1,57 @@
-import{BaselineCalculator as e}from"./baseline-calculator.mjs";var t=class{baseline;thresholds={errorRateDelta:.5,latencyDelta:.35,throughputDrop:.4,minSamples:10};constructor(t={}){this.baseline=new e,this.thresholds={...this.thresholds,...t}}evaluate(e){let t=this.baseline.update(e);if(t.sampleCount<this.thresholds.minSamples)return[];let n=[],r=this.relativeDelta(e.errorRate,t.errorRate);r>this.thresholds.errorRateDelta&&n.push({type:`error_rate_spike`,delta:r,point:e,baseline:t});let i=this.relativeDelta(e.latencyP99,t.latencyP99);i>this.thresholds.latencyDelta&&n.push({type:`latency_regression`,delta:i,point:e,baseline:t});let a=this.relativeDrop(e.throughput,t.throughput);return a>this.thresholds.throughputDrop&&n.push({type:`throughput_drop`,delta:a,point:e,baseline:t}),n}relativeDelta(e,t){return t===0?0:(e-t)/t}relativeDrop(e,t){return t===0?0:(t-e)/t}};export{t as AnomalyDetector};
+import { BaselineCalculator } from "./baseline-calculator.mjs";
+
+//#region src/anomaly/anomaly-detector.ts
+var AnomalyDetector = class {
+	baseline;
+	thresholds = {
+		errorRateDelta: .5,
+		latencyDelta: .35,
+		throughputDrop: .4,
+		minSamples: 10
+	};
+	constructor(options = {}) {
+		this.baseline = new BaselineCalculator();
+		this.thresholds = {
+			...this.thresholds,
+			...options
+		};
+	}
+	evaluate(point) {
+		const baselineSnapshot = this.baseline.update(point);
+		if (baselineSnapshot.sampleCount < this.thresholds.minSamples) return [];
+		const signals = [];
+		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;
+	}
+	relativeDelta(value, baseline) {
+		if (baseline === 0) return 0;
+		return (value - baseline) / baseline;
+	}
+	relativeDrop(value, baseline) {
+		if (baseline === 0) return 0;
+		return (baseline - value) / baseline;
+	}
+};
+
+//#endregion
+export { AnomalyDetector };

package/dist/anomaly/baseline-calculator.mjs

@@ -1 +1,36 @@
-var e=class{snapshot={latencyP99:0,latencyP95:0,errorRate:0,throughput:0,sampleCount:0};constructor(e=.2){this.alpha=e}update(e){let{sampleCount:t}=this.snapshot,n=t+1,r=t===0?1:this.alpha;return this.snapshot={latencyP99:this.mix(this.snapshot.latencyP99,e.latencyP99,r),latencyP95:this.mix(this.snapshot.latencyP95,e.latencyP95,r),errorRate:this.mix(this.snapshot.errorRate,e.errorRate,r),throughput:this.mix(this.snapshot.throughput,e.throughput,r),sampleCount:n},this.snapshot}getSnapshot(){return this.snapshot}mix(e,t,n){return this.snapshot.sampleCount===0?t:e*(1-n)+t*n}};export{e as BaselineCalculator};
+//#region src/anomaly/baseline-calculator.ts
+var BaselineCalculator = class {
+	snapshot = {
+		latencyP99: 0,
+		latencyP95: 0,
+		errorRate: 0,
+		throughput: 0,
+		sampleCount: 0
+	};
+	constructor(alpha = .2) {
+		this.alpha = alpha;
+	}
+	update(point) {
+		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;
+	}
+	mix(current, next, weight) {
+		if (this.snapshot.sampleCount === 0) return next;
+		return current * (1 - weight) + next * weight;
+	}
+};
+
+//#endregion
+export { BaselineCalculator };

package/dist/anomaly/root-cause-analyzer.mjs

@@ -1 +1,26 @@
-var e=class{constructor(e=900*1e3){this.lookbackMs=e}analyze(e,t){let n=new Date(e.point.timestamp.getTime()-this.lookbackMs),r=t.filter(e=>e.deployedAt>=n).sort((e,t)=>t.deployedAt.getTime()-e.deployedAt.getTime()),i=[],a;return r.length>0?(a=r[0],i.push(`Closest deployment ${a.id} (${a.operation}) at ${a.deployedAt.toISOString()}`)):i.push(`No deployments found within lookback window.`),e.type===`latency_regression`&&i.push(`Verify recent schema changes and external dependency latency.`),e.type===`error_rate_spike`&&i.push(`Check SLO monitor for correlated incidents.`),{signal:e,culprit:a,notes:i}}};export{e as RootCauseAnalyzer};
+//#region src/anomaly/root-cause-analyzer.ts
+var RootCauseAnalyzer = class {
+	constructor(lookbackMs = 900 * 1e3) {
+		this.lookbackMs = lookbackMs;
+	}
+	analyze(signal, deployments) {
+		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 = [];
+		let culprit;
+		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
+		};
+	}
+};
+
+//#endregion
+export { RootCauseAnalyzer };

package/dist/index.mjs

@@ -1 +1,14 @@
-import{getTracer as e,traceAsync as t,traceSync as n}from"./tracing/index.mjs";import{createCounter as r,createHistogram as i,createUpDownCounter as a,getMeter as o,standardMetrics as s}from"./metrics/index.mjs";import{Logger as c,logger as l}from"./logging/index.mjs";import{createTracingMiddleware as u}from"./tracing/middleware.mjs";import{IntentAggregator as d}from"./intent/aggregator.mjs";import{IntentDetector as f}from"./intent/detector.mjs";import{EvolutionPipeline as p}from"./pipeline/evolution-pipeline.mjs";import{LifecycleKpiPipeline as m}from"./pipeline/lifecycle-pipeline.mjs";import{BaselineCalculator as h}from"./anomaly/baseline-calculator.mjs";import{AnomalyDetector as g}from"./anomaly/anomaly-detector.mjs";import{RootCauseAnalyzer as _}from"./anomaly/root-cause-analyzer.mjs";import{AlertManager as v}from"./anomaly/alert-manager.mjs";export{v as AlertManager,g as AnomalyDetector,h as BaselineCalculator,p as EvolutionPipeline,d as IntentAggregator,f as IntentDetector,m as LifecycleKpiPipeline,c as Logger,_ as RootCauseAnalyzer,r as createCounter,i as createHistogram,u as createTracingMiddleware,a as createUpDownCounter,o as getMeter,e as getTracer,l as logger,s as standardMetrics,t as traceAsync,n as traceSync};
+import { getTracer, traceAsync, traceSync } from "./tracing/index.mjs";
+import { createCounter, createHistogram, createUpDownCounter, getMeter, standardMetrics } from "./metrics/index.mjs";
+import { Logger, logger } from "./logging/index.mjs";
+import { createTracingMiddleware } from "./tracing/middleware.mjs";
+import { IntentAggregator } from "./intent/aggregator.mjs";
+import { IntentDetector } from "./intent/detector.mjs";
+import { EvolutionPipeline } from "./pipeline/evolution-pipeline.mjs";
+import { LifecycleKpiPipeline } from "./pipeline/lifecycle-pipeline.mjs";
+import { BaselineCalculator } from "./anomaly/baseline-calculator.mjs";
+import { AnomalyDetector } from "./anomaly/anomaly-detector.mjs";
+import { RootCauseAnalyzer } from "./anomaly/root-cause-analyzer.mjs";
+import { AlertManager } from "./anomaly/alert-manager.mjs";
+
+export { AlertManager, AnomalyDetector, BaselineCalculator, EvolutionPipeline, IntentAggregator, IntentDetector, LifecycleKpiPipeline, Logger, RootCauseAnalyzer, createCounter, createHistogram, createTracingMiddleware, createUpDownCounter, getMeter, getTracer, logger, standardMetrics, traceAsync, traceSync };

package/dist/intent/aggregator.mjs

@@ -1 +1,95 @@
-var e=class{windowMs;sequenceSampleSize;samples=[];constructor(e={}){this.windowMs=e.windowMs??9e5,this.sequenceSampleSize=e.sequenceSampleSize??1e3}add(e){this.samples.push(e)}flush(e=new Date){let t=e.getTime()-this.windowMs,n=this.samples.filter(e=>e.timestamp.getTime()>=t);this.samples.length=0;let r=this.aggregateMetrics(n),i=this.buildSequences(n),a=n.map(e=>e.timestamp.getTime());return{metrics:r,sequences:i,sampleCount:n.length,windowStart:a.length?new Date(Math.min(...a)):void 0,windowEnd:a.length?new Date(Math.max(...a)):void 0}}aggregateMetrics(e){if(!e.length)return[];let n=new Map;for(let t of e){let e=`${t.operation.name}.v${t.operation.version}`,r=n.get(e)??[];r.push(t),n.set(e,r)}return[...n.values()].map(e=>{let n=e.map(e=>e.durationMs).sort((e,t)=>e-t),r=e.filter(e=>!e.success),i=e.length,a=r.reduce((e,t)=>(t.errorCode&&(e[t.errorCode]=(e[t.errorCode]??0)+1),e),{}),o=e.map(e=>e.timestamp.getTime());return{operation:e[0].operation,totalCalls:i,successRate:(i-r.length)/i,errorRate:r.length/i,averageLatencyMs:n.reduce((e,t)=>e+t,0)/i,p95LatencyMs:t(n,.95),p99LatencyMs:t(n,.99),maxLatencyMs:Math.max(...n),windowStart:new Date(Math.min(...o)),windowEnd:new Date(Math.max(...o)),topErrors:a}})}buildSequences(e){let t=new Map;for(let n of e.slice(-this.sequenceSampleSize)){if(!n.traceId)continue;let e=t.get(n.traceId)??[];e.push(n),t.set(n.traceId,e)}let n={};for(let[e,r]of t.entries()){let e=r.sort((e,t)=>e.timestamp.getTime()-t.timestamp.getTime()),t=e.map(e=>e.operation.name);if(t.length<2)continue;let i=`${t.join(`>`)}@${e[0]?.tenantId??`global`}`,a=n[i];a?a.count+=1:n[i]={steps:t,tenantId:e[0]?.tenantId,count:1}}return Object.values(n).sort((e,t)=>t.count-e.count)}};function t(e,t){return e.length?e.length===1?e[0]:e[Math.min(e.length-1,Math.floor(t*e.length))]:0}export{e as IntentAggregator};
+//#region src/intent/aggregator.ts
+const DEFAULT_WINDOW_MS = 900 * 1e3;
+var IntentAggregator = class {
+	windowMs;
+	sequenceSampleSize;
+	samples = [];
+	constructor(options = {}) {
+		this.windowMs = options.windowMs ?? DEFAULT_WINDOW_MS;
+		this.sequenceSampleSize = options.sequenceSampleSize ?? 1e3;
+	}
+	add(sample) {
+		this.samples.push(sample);
+	}
+	flush(now = /* @__PURE__ */ new Date()) {
+		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)) : void 0,
+			windowEnd: timestamps.length ? new Date(Math.max(...timestamps)) : void 0
+		};
+	}
+	aggregateMetrics(samples) {
+		if (!samples.length) return [];
+		const groups = /* @__PURE__ */ new Map();
+		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((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, .95),
+				p99LatencyMs: percentile(durations, .99),
+				maxLatencyMs: Math.max(...durations),
+				windowStart: new Date(Math.min(...timestamps)),
+				windowEnd: new Date(Math.max(...timestamps)),
+				topErrors
+			};
+		});
+	}
+	buildSequences(samples) {
+		const byTrace = /* @__PURE__ */ new Map();
+		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 = {};
+		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, ratio) {
+	if (!values.length) return 0;
+	if (values.length === 1) return values[0];
+	return values[Math.min(values.length - 1, Math.floor(ratio * values.length))];
+}
+
+//#endregion
+export { IntentAggregator };

package/dist/intent/detector.mjs

@@ -1 +1,121 @@
-import{randomUUID as e}from"node:crypto";const t={errorRateThreshold:.05,latencyP99ThresholdMs:750,throughputDropThreshold:.3,minSequenceLength:3};var n=class{options;constructor(e={}){this.options={errorRateThreshold:e.errorRateThreshold??t.errorRateThreshold,latencyP99ThresholdMs:e.latencyP99ThresholdMs??t.latencyP99ThresholdMs,throughputDropThreshold:e.throughputDropThreshold??t.throughputDropThreshold,minSequenceLength:e.minSequenceLength??t.minSequenceLength}}detectFromMetrics(t,n){let r=[],i=new Map((n??[]).map(e=>[`${e.operation.name}.v${e.operation.version}`,e]));for(let n of t){if(n.errorRate>=this.options.errorRateThreshold){r.push({id:e(),type:`error-spike`,operation:n.operation,confidence:Math.min(1,n.errorRate/this.options.errorRateThreshold),description:`Error rate ${n.errorRate.toFixed(2)} exceeded threshold`,metadata:{errorRate:n.errorRate,topErrors:n.topErrors},evidence:[{type:`metric`,description:`error-rate`,data:{errorRate:n.errorRate,threshold:this.options.errorRateThreshold}}]});continue}if(n.p99LatencyMs>=this.options.latencyP99ThresholdMs){r.push({id:e(),type:`latency-regression`,operation:n.operation,confidence:Math.min(1,n.p99LatencyMs/this.options.latencyP99ThresholdMs),description:`P99 latency ${n.p99LatencyMs}ms exceeded threshold`,metadata:{p99LatencyMs:n.p99LatencyMs},evidence:[{type:`metric`,description:`p99-latency`,data:{p99LatencyMs:n.p99LatencyMs,threshold:this.options.latencyP99ThresholdMs}}]});continue}let t=i.get(`${n.operation.name}.v${n.operation.version}`);if(t){let i=(t.totalCalls-n.totalCalls)/Math.max(t.totalCalls,1);i>=this.options.throughputDropThreshold&&r.push({id:e(),type:`throughput-drop`,operation:n.operation,confidence:Math.min(1,i/this.options.throughputDropThreshold),description:`Throughput dropped ${(i*100).toFixed(1)}% vs baseline`,metadata:{baselineCalls:t.totalCalls,currentCalls:n.totalCalls},evidence:[{type:`metric`,description:`throughput-drop`,data:{baselineCalls:t.totalCalls,currentCalls:n.totalCalls}}]})}}return r}detectSequentialIntents(t){let n=[];for(let r of t){if(r.steps.length<this.options.minSequenceLength)continue;let t=r.steps.join(` → `);n.push({id:e(),type:`missing-workflow-step`,confidence:.6,description:`Repeated workflow detected: ${t}`,metadata:{steps:r.steps,tenantId:r.tenantId,occurrences:r.count},evidence:[{type:`sequence`,description:`sequential-calls`,data:{steps:r.steps,count:r.count}}]})}return n}};export{n as IntentDetector};
+import { randomUUID } from "node:crypto";
+
+//#region src/intent/detector.ts
+const DEFAULTS = {
+	errorRateThreshold: .05,
+	latencyP99ThresholdMs: 750,
+	throughputDropThreshold: .3,
+	minSequenceLength: 3
+};
+var IntentDetector = class {
+	options;
+	constructor(options = {}) {
+		this.options = {
+			errorRateThreshold: options.errorRateThreshold ?? DEFAULTS.errorRateThreshold,
+			latencyP99ThresholdMs: options.latencyP99ThresholdMs ?? DEFAULTS.latencyP99ThresholdMs,
+			throughputDropThreshold: options.throughputDropThreshold ?? DEFAULTS.throughputDropThreshold,
+			minSequenceLength: options.minSequenceLength ?? DEFAULTS.minSequenceLength
+		};
+	}
+	detectFromMetrics(current, previous) {
+		const signals = [];
+		const baseline = new Map((previous ?? []).map((metric) => [`${metric.operation.name}.v${metric.operation.version}`, metric]));
+		for (const metric of current) {
+			if (metric.errorRate >= this.options.errorRateThreshold) {
+				signals.push({
+					id: randomUUID(),
+					type: "error-spike",
+					operation: metric.operation,
+					confidence: Math.min(1, metric.errorRate / this.options.errorRateThreshold),
+					description: `Error rate ${metric.errorRate.toFixed(2)} exceeded threshold`,
+					metadata: {
+						errorRate: metric.errorRate,
+						topErrors: metric.topErrors
+					},
+					evidence: [{
+						type: "metric",
+						description: "error-rate",
+						data: {
+							errorRate: metric.errorRate,
+							threshold: this.options.errorRateThreshold
+						}
+					}]
+				});
+				continue;
+			}
+			if (metric.p99LatencyMs >= this.options.latencyP99ThresholdMs) {
+				signals.push({
+					id: randomUUID(),
+					type: "latency-regression",
+					operation: metric.operation,
+					confidence: Math.min(1, metric.p99LatencyMs / this.options.latencyP99ThresholdMs),
+					description: `P99 latency ${metric.p99LatencyMs}ms exceeded threshold`,
+					metadata: { p99LatencyMs: metric.p99LatencyMs },
+					evidence: [{
+						type: "metric",
+						description: "p99-latency",
+						data: {
+							p99LatencyMs: metric.p99LatencyMs,
+							threshold: this.options.latencyP99ThresholdMs
+						}
+					}]
+				});
+				continue;
+			}
+			const base = baseline.get(`${metric.operation.name}.v${metric.operation.version}`);
+			if (base) {
+				const drop = (base.totalCalls - metric.totalCalls) / Math.max(base.totalCalls, 1);
+				if (drop >= this.options.throughputDropThreshold) signals.push({
+					id: randomUUID(),
+					type: "throughput-drop",
+					operation: metric.operation,
+					confidence: Math.min(1, drop / this.options.throughputDropThreshold),
+					description: `Throughput dropped ${(drop * 100).toFixed(1)}% vs baseline`,
+					metadata: {
+						baselineCalls: base.totalCalls,
+						currentCalls: metric.totalCalls
+					},
+					evidence: [{
+						type: "metric",
+						description: "throughput-drop",
+						data: {
+							baselineCalls: base.totalCalls,
+							currentCalls: metric.totalCalls
+						}
+					}]
+				});
+			}
+		}
+		return signals;
+	}
+	detectSequentialIntents(sequences) {
+		const signals = [];
+		for (const sequence of sequences) {
+			if (sequence.steps.length < this.options.minSequenceLength) continue;
+			const description = sequence.steps.join(" → ");
+			signals.push({
+				id: randomUUID(),
+				type: "missing-workflow-step",
+				confidence: .6,
+				description: `Repeated workflow detected: ${description}`,
+				metadata: {
+					steps: sequence.steps,
+					tenantId: sequence.tenantId,
+					occurrences: sequence.count
+				},
+				evidence: [{
+					type: "sequence",
+					description: "sequential-calls",
+					data: {
+						steps: sequence.steps,
+						count: sequence.count
+					}
+				}]
+			});
+		}
+		return signals;
+	}
+};
+
+//#endregion
+export { IntentDetector };

package/dist/lifecycle/dist/index.mjs

@@ -1 +1,4 @@
-import{e,n as t,t as n}from"./types/stages.mjs";import"./types/axes.mjs";import"./types/signals.mjs";import"./types/milestones.mjs";import{o as r,r as i}from"./utils/formatters.mjs";
+import { LIFECYCLE_STAGE_META, LifecycleStage } from "./types/stages.mjs";
+import "./types/signals.mjs";
+import "./types/milestones.mjs";
+import { getStageLabel } from "./utils/formatters.mjs";

package/dist/lifecycle/dist/types/milestones.mjs

@@ -1 +1 @@
-import"./stages.mjs";
+import "./stages.mjs";

package/dist/lifecycle/dist/types/signals.mjs

@@ -1 +1 @@
-import"./stages.mjs";
+import "./stages.mjs";

package/dist/lifecycle/dist/types/stages.mjs

@@ -1 +1,151 @@
-let e=function(e){return e[e.Exploration=0]=`Exploration`,e[e.ProblemSolutionFit=1]=`ProblemSolutionFit`,e[e.MvpEarlyTraction=2]=`MvpEarlyTraction`,e[e.ProductMarketFit=3]=`ProductMarketFit`,e[e.GrowthScaleUp=4]=`GrowthScaleUp`,e[e.ExpansionPlatform=5]=`ExpansionPlatform`,e[e.MaturityRenewal=6]=`MaturityRenewal`,e}({});const t=[e.Exploration,e.ProblemSolutionFit,e.MvpEarlyTraction,e.ProductMarketFit,e.GrowthScaleUp,e.ExpansionPlatform,e.MaturityRenewal],n={[e.Exploration]:{id:e.Exploration,order:0,slug:`exploration`,name:`Exploration / Ideation`,question:`Is there a problem worth my time?`,signals:[`20+ discovery interviews`,`Clear problem statement`,`Named ICP`],traps:[`Branding before discovery`,`Premature tooling decisions`],focusAreas:[`Customer discovery`,`Problem definition`,`Segment clarity`]},[e.ProblemSolutionFit]:{id:e.ProblemSolutionFit,order:1,slug:`problem-solution-fit`,name:`Problem–Solution Fit`,question:`Do people care enough about this solution?`,signals:[`Prototype reuse`,`Referral energy`,`Pre-pay interest`],traps:[`“Market is huge” without users`,`Skipping qualitative loops`],focusAreas:[`Solution hypothesis`,`Value messaging`,`Feedback capture`]},[e.MvpEarlyTraction]:{id:e.MvpEarlyTraction,order:2,slug:`mvp-early-traction`,name:`MVP & Early Traction`,question:`Can we get real usage and learn fast?`,signals:[`20–50 named active users`,`Weekly releases`,`Noisy feedback`],traps:[`Overbuilt infra for 10 users`,`Undefined retention metric`],focusAreas:[`Activation`,`Cohort tracking`,`Feedback rituals`]},[e.ProductMarketFit]:{id:e.ProductMarketFit,order:3,slug:`product-market-fit`,name:`Product–Market Fit`,question:`Is this pulling us forward?`,signals:[`Retention without heroics`,`Organic word-of-mouth`,`Value stories`],traps:[`Hero growth that does not scale`,`Ignoring churn signals`],focusAreas:[`Retention`,`Reliability`,`ICP clarity`]},[e.GrowthScaleUp]:{id:e.GrowthScaleUp,order:4,slug:`growth-scale-up`,name:`Growth / Scale-up`,question:`Can we grow this repeatably?`,signals:[`Predictable channels`,`Specialized hires`,`Unit economics on track`],traps:[`Paid spend masking retention gaps`,`Infra debt blocking launches`],focusAreas:[`Ops systems`,`Growth loops`,`Reliability engineering`]},[e.ExpansionPlatform]:{id:e.ExpansionPlatform,order:5,slug:`expansion-platform`,name:`Expansion / Platform`,question:`What is the next growth curve?`,signals:[`Stable core metrics`,`Partner/API demand`,`Ecosystem pull`],traps:[`Platform theater before wedge is solid`],focusAreas:[`Partnerships`,`APIs`,`New market validation`]},[e.MaturityRenewal]:{id:e.MaturityRenewal,order:6,slug:`maturity-renewal`,name:`Maturity / Renewal`,question:`Optimize, reinvent, or sunset?`,signals:[`Margin focus`,`Portfolio bets`,`Narrative refresh`],traps:[`Assuming past success is enough`],focusAreas:[`Cost optimization`,`Reinvention bets`,`Sunset planning`]}};export{e,n,t};
+//#region ../lifecycle/dist/types/stages.js
+let LifecycleStage = /* @__PURE__ */ function(LifecycleStage$1) {
+	LifecycleStage$1[LifecycleStage$1["Exploration"] = 0] = "Exploration";
+	LifecycleStage$1[LifecycleStage$1["ProblemSolutionFit"] = 1] = "ProblemSolutionFit";
+	LifecycleStage$1[LifecycleStage$1["MvpEarlyTraction"] = 2] = "MvpEarlyTraction";
+	LifecycleStage$1[LifecycleStage$1["ProductMarketFit"] = 3] = "ProductMarketFit";
+	LifecycleStage$1[LifecycleStage$1["GrowthScaleUp"] = 4] = "GrowthScaleUp";
+	LifecycleStage$1[LifecycleStage$1["ExpansionPlatform"] = 5] = "ExpansionPlatform";
+	LifecycleStage$1[LifecycleStage$1["MaturityRenewal"] = 6] = "MaturityRenewal";
+	return LifecycleStage$1;
+}({});
+const LIFECYCLE_STAGE_ORDER = [
+	LifecycleStage.Exploration,
+	LifecycleStage.ProblemSolutionFit,
+	LifecycleStage.MvpEarlyTraction,
+	LifecycleStage.ProductMarketFit,
+	LifecycleStage.GrowthScaleUp,
+	LifecycleStage.ExpansionPlatform,
+	LifecycleStage.MaturityRenewal
+];
+const LIFECYCLE_STAGE_META = {
+	[LifecycleStage.Exploration]: {
+		id: LifecycleStage.Exploration,
+		order: 0,
+		slug: "exploration",
+		name: "Exploration / Ideation",
+		question: "Is there a problem worth my time?",
+		signals: [
+			"20+ discovery interviews",
+			"Clear problem statement",
+			"Named ICP"
+		],
+		traps: ["Branding before discovery", "Premature tooling decisions"],
+		focusAreas: [
+			"Customer discovery",
+			"Problem definition",
+			"Segment clarity"
+		]
+	},
+	[LifecycleStage.ProblemSolutionFit]: {
+		id: LifecycleStage.ProblemSolutionFit,
+		order: 1,
+		slug: "problem-solution-fit",
+		name: "Problem–Solution Fit",
+		question: "Do people care enough about this solution?",
+		signals: [
+			"Prototype reuse",
+			"Referral energy",
+			"Pre-pay interest"
+		],
+		traps: ["“Market is huge” without users", "Skipping qualitative loops"],
+		focusAreas: [
+			"Solution hypothesis",
+			"Value messaging",
+			"Feedback capture"
+		]
+	},
+	[LifecycleStage.MvpEarlyTraction]: {
+		id: LifecycleStage.MvpEarlyTraction,
+		order: 2,
+		slug: "mvp-early-traction",
+		name: "MVP & Early Traction",
+		question: "Can we get real usage and learn fast?",
+		signals: [
+			"20–50 named active users",
+			"Weekly releases",
+			"Noisy feedback"
+		],
+		traps: ["Overbuilt infra for 10 users", "Undefined retention metric"],
+		focusAreas: [
+			"Activation",
+			"Cohort tracking",
+			"Feedback rituals"
+		]
+	},
+	[LifecycleStage.ProductMarketFit]: {
+		id: LifecycleStage.ProductMarketFit,
+		order: 3,
+		slug: "product-market-fit",
+		name: "Product–Market Fit",
+		question: "Is this pulling us forward?",
+		signals: [
+			"Retention without heroics",
+			"Organic word-of-mouth",
+			"Value stories"
+		],
+		traps: ["Hero growth that does not scale", "Ignoring churn signals"],
+		focusAreas: [
+			"Retention",
+			"Reliability",
+			"ICP clarity"
+		]
+	},
+	[LifecycleStage.GrowthScaleUp]: {
+		id: LifecycleStage.GrowthScaleUp,
+		order: 4,
+		slug: "growth-scale-up",
+		name: "Growth / Scale-up",
+		question: "Can we grow this repeatably?",
+		signals: [
+			"Predictable channels",
+			"Specialized hires",
+			"Unit economics on track"
+		],
+		traps: ["Paid spend masking retention gaps", "Infra debt blocking launches"],
+		focusAreas: [
+			"Ops systems",
+			"Growth loops",
+			"Reliability engineering"
+		]
+	},
+	[LifecycleStage.ExpansionPlatform]: {
+		id: LifecycleStage.ExpansionPlatform,
+		order: 5,
+		slug: "expansion-platform",
+		name: "Expansion / Platform",
+		question: "What is the next growth curve?",
+		signals: [
+			"Stable core metrics",
+			"Partner/API demand",
+			"Ecosystem pull"
+		],
+		traps: ["Platform theater before wedge is solid"],
+		focusAreas: [
+			"Partnerships",
+			"APIs",
+			"New market validation"
+		]
+	},
+	[LifecycleStage.MaturityRenewal]: {
+		id: LifecycleStage.MaturityRenewal,
+		order: 6,
+		slug: "maturity-renewal",
+		name: "Maturity / Renewal",
+		question: "Optimize, reinvent, or sunset?",
+		signals: [
+			"Margin focus",
+			"Portfolio bets",
+			"Narrative refresh"
+		],
+		traps: ["Assuming past success is enough"],
+		focusAreas: [
+			"Cost optimization",
+			"Reinvention bets",
+			"Sunset planning"
+		]
+	}
+};
+
+//#endregion
+export { LIFECYCLE_STAGE_META, LifecycleStage };

package/dist/lifecycle/dist/utils/formatters.mjs

@@ -1 +1,7 @@
-import{n as e,t}from"../types/stages.mjs";const n=e=>[`Product: ${e.product}`,`Company: ${e.company}`,`Capital: ${e.capital}`],r=t=>e[t].name;export{r as o,n as r};
+import { LIFECYCLE_STAGE_META } from "../types/stages.mjs";
+
+//#region ../lifecycle/dist/utils/formatters.js
+const getStageLabel = (stage) => LIFECYCLE_STAGE_META[stage].name;
+
+//#endregion
+export { getStageLabel };

package/dist/logging/index.mjs

@@ -1 +1,39 @@
-import{context as e,trace as t}from"@opentelemetry/api";var n=class{constructor(e){this.serviceName=e}log(n,r,i={}){let a=t.getSpan(e.active()),o=a?.spanContext().traceId,s=a?.spanContext().spanId,c={timestamp:new Date().toISOString(),service:this.serviceName,level:n,message:r,traceId:o,spanId:s,...i};console.log(JSON.stringify(c))}debug(e,t){this.log(`debug`,e,t)}info(e,t){this.log(`info`,e,t)}warn(e,t){this.log(`warn`,e,t)}error(e,t){this.log(`error`,e,t)}};const r=new n(process.env.OTEL_SERVICE_NAME||`unknown-service`);export{n as Logger,r as logger};
+import { context, trace } from "@opentelemetry/api";
+
+//#region src/logging/index.ts
+var Logger = class {
+	constructor(serviceName) {
+		this.serviceName = serviceName;
+	}
+	log(level, message, meta = {}) {
+		const span = trace.getSpan(context.active());
+		const traceId = span?.spanContext().traceId;
+		const spanId = span?.spanContext().spanId;
+		const entry = {
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			service: this.serviceName,
+			level,
+			message,
+			traceId,
+			spanId,
+			...meta
+		};
+		console.log(JSON.stringify(entry));
+	}
+	debug(message, meta) {
+		this.log("debug", message, meta);
+	}
+	info(message, meta) {
+		this.log("info", message, meta);
+	}
+	warn(message, meta) {
+		this.log("warn", message, meta);
+	}
+	error(message, meta) {
+		this.log("error", message, meta);
+	}
+};
+const logger = new Logger(process.env.OTEL_SERVICE_NAME || "unknown-service");
+
+//#endregion
+export { Logger, logger };

package/dist/metrics/index.mjs

@@ -1 +1,25 @@
-import{metrics as e}from"@opentelemetry/api";function t(t=`@lssm/lib.observability`){return e.getMeter(t)}function n(e,n,r){return t(r).createCounter(e,{description:n})}function r(e,n,r){return t(r).createUpDownCounter(e,{description:n})}function i(e,n,r){return t(r).createHistogram(e,{description:n})}const a={httpRequests:n(`http_requests_total`,`Total HTTP requests`),httpDuration:i(`http_request_duration_seconds`,`HTTP request duration`),operationErrors:n(`operation_errors_total`,`Total operation errors`),workflowDuration:i(`workflow_duration_seconds`,`Workflow execution duration`)};export{n as createCounter,i as createHistogram,r as createUpDownCounter,t as getMeter,a as standardMetrics};
+import { metrics } from "@opentelemetry/api";
+
+//#region src/metrics/index.ts
+const DEFAULT_METER_NAME = "@lssm/lib.observability";
+function getMeter(name = DEFAULT_METER_NAME) {
+	return metrics.getMeter(name);
+}
+function createCounter(name, description, meterName) {
+	return getMeter(meterName).createCounter(name, { description });
+}
+function createUpDownCounter(name, description, meterName) {
+	return getMeter(meterName).createUpDownCounter(name, { description });
+}
+function createHistogram(name, description, meterName) {
+	return getMeter(meterName).createHistogram(name, { description });
+}
+const standardMetrics = {
+	httpRequests: createCounter("http_requests_total", "Total HTTP requests"),
+	httpDuration: createHistogram("http_request_duration_seconds", "HTTP request duration"),
+	operationErrors: createCounter("operation_errors_total", "Total operation errors"),
+	workflowDuration: createHistogram("workflow_duration_seconds", "Workflow execution duration")
+};
+
+//#endregion
+export { createCounter, createHistogram, createUpDownCounter, getMeter, standardMetrics };

package/dist/pipeline/evolution-pipeline.mjs

@@ -1 +1,65 @@
-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};
+import { IntentAggregator } from "../intent/aggregator.mjs";
+import { IntentDetector } from "../intent/detector.mjs";
+import { EventEmitter } from "node:events";
+
+//#region src/pipeline/evolution-pipeline.ts
+var EvolutionPipeline = class {
+	detector;
+	aggregator;
+	emitter;
+	onIntent;
+	onSnapshot;
+	timer;
+	previousMetrics;
+	constructor(options = {}) {
+		this.detector = options.detector ?? new IntentDetector();
+		this.aggregator = options.aggregator ?? new IntentAggregator();
+		this.emitter = options.emitter ?? new EventEmitter();
+		this.onIntent = options.onIntent;
+		this.onSnapshot = options.onSnapshot;
+	}
+	ingest(sample) {
+		this.aggregator.add(sample);
+	}
+	on(listener) {
+		this.emitter.on("event", listener);
+	}
+	start(intervalMs = 300 * 1e3) {
+		this.stop();
+		this.timer = setInterval(() => {
+			this.run();
+		}, intervalMs);
+	}
+	stop() {
+		if (this.timer) {
+			clearInterval(this.timer);
+			this.timer = void 0;
+		}
+	}
+	async run() {
+		const snapshot = this.aggregator.flush();
+		this.emit({
+			type: "telemetry.window",
+			payload: { sampleCount: snapshot.sampleCount }
+		});
+		if (this.onSnapshot) await this.onSnapshot(snapshot);
+		if (!snapshot.sampleCount) return;
+		const metricSignals = this.detector.detectFromMetrics(snapshot.metrics, this.previousMetrics);
+		const sequenceSignals = this.detector.detectSequentialIntents(snapshot.sequences);
+		this.previousMetrics = snapshot.metrics;
+		const signals = [...metricSignals, ...sequenceSignals];
+		for (const signal of signals) {
+			if (this.onIntent) await this.onIntent(signal);
+			this.emit({
+				type: "intent.detected",
+				payload: signal
+			});
+		}
+	}
+	emit(event) {
+		this.emitter.emit("event", event);
+	}
+};
+
+//#endregion
+export { EvolutionPipeline };

package/dist/pipeline/lifecycle-pipeline.mjs

@@ -1 +1,73 @@
-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};
+import { createCounter, createHistogram, createUpDownCounter } from "../metrics/index.mjs";
+import { getStageLabel } from "../lifecycle/dist/utils/formatters.mjs";
+import "../lifecycle/dist/index.mjs";
+import { EventEmitter } from "node:events";
+
+//#region src/pipeline/lifecycle-pipeline.ts
+var LifecycleKpiPipeline = class {
+	assessmentCounter;
+	confidenceHistogram;
+	stageUpDownCounter;
+	emitter;
+	lowConfidenceThreshold;
+	currentStageByTenant = /* @__PURE__ */ new Map();
+	constructor(options = {}) {
+		const meterName = options.meterName ?? "@lssm/lib.lifecycle-kpi";
+		this.assessmentCounter = createCounter("lifecycle_assessments_total", "Total lifecycle assessments", meterName);
+		this.confidenceHistogram = createHistogram("lifecycle_assessment_confidence", "Lifecycle assessment confidence distribution", meterName);
+		this.stageUpDownCounter = createUpDownCounter("lifecycle_stage_tenants", "Current tenants per lifecycle stage", meterName);
+		this.emitter = options.emitter ?? new EventEmitter();
+		this.lowConfidenceThreshold = options.lowConfidenceThreshold ?? .4;
+	}
+	recordAssessment(assessment, tenantId) {
+		const attributes = {
+			stage: getStageLabel(assessment.stage),
+			tenantId
+		};
+		this.assessmentCounter.add(1, attributes);
+		this.confidenceHistogram.record(assessment.confidence, attributes);
+		this.ensureStageCounters(assessment.stage, tenantId);
+		this.emitter.emit("event", {
+			type: "assessment.recorded",
+			payload: {
+				tenantId,
+				stage: assessment.stage
+			}
+		});
+		if (assessment.confidence < this.lowConfidenceThreshold) this.emitter.emit("event", {
+			type: "confidence.low",
+			payload: {
+				tenantId,
+				confidence: assessment.confidence
+			}
+		});
+	}
+	on(listener) {
+		this.emitter.on("event", listener);
+	}
+	ensureStageCounters(stage, tenantId) {
+		if (!tenantId) return;
+		const previous = this.currentStageByTenant.get(tenantId);
+		if (previous === stage) return;
+		if (previous !== void 0) this.stageUpDownCounter.add(-1, {
+			stage: getStageLabel(previous),
+			tenantId
+		});
+		this.stageUpDownCounter.add(1, {
+			stage: getStageLabel(stage),
+			tenantId
+		});
+		this.currentStageByTenant.set(tenantId, stage);
+		this.emitter.emit("event", {
+			type: "stage.changed",
+			payload: {
+				tenantId,
+				previousStage: previous,
+				nextStage: stage
+			}
+		});
+	}
+};
+
+//#endregion
+export { LifecycleKpiPipeline };

package/dist/tracing/index.mjs

@@ -1 +1,46 @@
-import{SpanStatusCode as e,trace as t}from"@opentelemetry/api";function n(e=`@lssm/lib.observability`){return t.getTracer(e)}async function r(t,r,i){return n(i).startActiveSpan(t,async t=>{try{let n=await r(t);return t.setStatus({code:e.OK}),n}catch(n){throw t.recordException(n),t.setStatus({code:e.ERROR,message:n instanceof Error?n.message:String(n)}),n}finally{t.end()}})}function i(t,r,i){return n(i).startActiveSpan(t,t=>{try{let n=r(t);return t.setStatus({code:e.OK}),n}catch(n){throw t.recordException(n),t.setStatus({code:e.ERROR,message:n instanceof Error?n.message:String(n)}),n}finally{t.end()}})}export{n as getTracer,r as traceAsync,i as traceSync};
+import { SpanStatusCode, trace } from "@opentelemetry/api";
+
+//#region src/tracing/index.ts
+const DEFAULT_TRACER_NAME = "@lssm/lib.observability";
+function getTracer(name = DEFAULT_TRACER_NAME) {
+	return trace.getTracer(name);
+}
+async function traceAsync(name, fn, tracerName) {
+	return getTracer(tracerName).startActiveSpan(name, async (span) => {
+		try {
+			const result = await fn(span);
+			span.setStatus({ code: SpanStatusCode.OK });
+			return result;
+		} catch (error) {
+			span.recordException(error);
+			span.setStatus({
+				code: SpanStatusCode.ERROR,
+				message: error instanceof Error ? error.message : String(error)
+			});
+			throw error;
+		} finally {
+			span.end();
+		}
+	});
+}
+function traceSync(name, fn, tracerName) {
+	return getTracer(tracerName).startActiveSpan(name, (span) => {
+		try {
+			const result = fn(span);
+			span.setStatus({ code: SpanStatusCode.OK });
+			return result;
+		} catch (error) {
+			span.recordException(error);
+			span.setStatus({
+				code: SpanStatusCode.ERROR,
+				message: error instanceof Error ? error.message : String(error)
+			});
+			throw error;
+		} finally {
+			span.end();
+		}
+	});
+}
+
+//#endregion
+export { getTracer, traceAsync, traceSync };

package/dist/tracing/middleware.mjs

@@ -1 +1,79 @@
-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};
+import { traceAsync } from "./index.mjs";
+import { standardMetrics } from "../metrics/index.mjs";
+
+//#region src/tracing/middleware.ts
+function createTracingMiddleware(options = {}) {
+	return async (req, next) => {
+		const method = req.method;
+		const path = new URL(req.url).pathname;
+		standardMetrics.httpRequests.add(1, {
+			method,
+			path
+		});
+		const startTime = performance.now();
+		return traceAsync(`HTTP ${method} ${path}`, async (span) => {
+			span.setAttribute("http.method", method);
+			span.setAttribute("http.url", req.url);
+			try {
+				const response = await next();
+				span.setAttribute("http.status_code", response.status);
+				const duration = (performance.now() - startTime) / 1e3;
+				standardMetrics.httpDuration.record(duration, {
+					method,
+					path,
+					status: response.status.toString()
+				});
+				emitTelemetrySample({
+					req,
+					res: response,
+					span,
+					success: true,
+					durationMs: duration * 1e3,
+					options
+				});
+				return response;
+			} catch (error) {
+				standardMetrics.operationErrors.add(1, {
+					method,
+					path
+				});
+				emitTelemetrySample({
+					req,
+					span,
+					success: false,
+					durationMs: performance.now() - startTime,
+					error,
+					options
+				});
+				throw error;
+			}
+		});
+	};
+}
+function emitTelemetrySample({ req, res, span, success, durationMs, error, options }) {
+	if (!options.onSample || !options.resolveOperation) return;
+	const operation = options.resolveOperation({
+		req,
+		res
+	});
+	if (!operation) return;
+	const sample = {
+		operation,
+		durationMs,
+		success,
+		timestamp: /* @__PURE__ */ new Date(),
+		errorCode: !success && error instanceof Error ? error.name : success ? void 0 : "unknown",
+		tenantId: options.tenantResolver?.(req),
+		actorId: options.actorResolver?.(req),
+		traceId: span.spanContext().traceId,
+		metadata: {
+			method: req.method,
+			path: new URL(req.url).pathname,
+			status: res?.status
+		}
+	};
+	options.onSample(sample);
+}
+
+//#endregion
+export { createTracingMiddleware };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lssm/lib.observability",
-  "version": "0.0.0-canary-20251217063201",
+  "version": "0.0.0-canary-20251217072406",
   "main": "./dist/index.mjs",
   "types": "./dist/index.d.mts",
   "scripts": {
@@ -17,12 +17,14 @@
     "test": "bun run"
   },
   "dependencies": {
-    "@lssm/lib.lifecycle": "0.0.0-canary-20251217063201"
+    "@lssm/lib.lifecycle": "0.0.0-canary-20251217072406"
   },
   "peerDependencies": {
     "@opentelemetry/api": "*"
   },
   "devDependencies": {
+    "@lssm/tool.tsdown": "0.0.0-canary-20251217072406",
+    "@lssm/tool.typescript": "0.0.0-canary-20251217072406",
     "typescript": "^5.0.0"
   },
   "exports": {

package/dist/lifecycle/dist/types/axes.mjs

@@ -1 +0,0 @@
-(function(e){return e.Sketch=`Sketch`,e.Prototype=`Prototype`,e.Mvp=`MVP`,e.V1=`V1`,e.Ecosystem=`Ecosystem`,e})({}),function(e){return e.Solo=`Solo`,e.TinyTeam=`TinyTeam`,e.FunctionalOrg=`FunctionalOrg`,e.MultiTeam=`MultiTeam`,e.Bureaucratic=`Bureaucratic`,e}({}),function(e){return e.Bootstrapped=`Bootstrapped`,e.PreSeed=`PreSeed`,e.Seed=`Seed`,e.SeriesAorB=`SeriesAorB`,e.LateStage=`LateStage`,e}({});