effect 4.0.0-beta.102 → 4.0.0-beta.103

package/dist/Metric.d.ts

@@ -38,12 +38,8 @@ import type { Contravariant, Covariant } from "./Types.ts";
  *
  * **Example** (Using multiple metric types)
  *
- * ```ts
- * import { Data, Effect, Metric } from "effect"
- *
- * class MetricExample extends Data.TaggedError("MetricExample")<{
- *   readonly operation: string
- * }> {}
+ * ```ts import.meta.vitest
+ * import { Effect, Metric } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   // Create different types of metrics
@@ -89,6 +85,13 @@ import type { Contravariant, Covariant } from "./Types.ts";
  *     }
  *   }
  * })
+ *
+ * const result = await Effect.runPromise(Effect.provideService(program, Metric.MetricRegistry, new Map()))
+ * const values = [
+ *   result.counter.state.count,
+ *   result.gauge.state.value,
+ *   result.frequency.state.occurrences.get("200")
+ * ] // => [1, 128, 1]
  * ```
  *
  * @category models
@@ -116,12 +119,8 @@ export interface Metric<in Input, out State> extends Pipeable {
  *
  * **Example** (Using counter metrics)
  *
- * ```ts
- * import { Data, Effect, Metric } from "effect"
- *
- * class CounterInterfaceError extends Data.TaggedError("CounterInterfaceError")<{
- *   readonly operation: string
- * }> {}
+ * ```ts import.meta.vitest
+ * import { Effect, Metric } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   // Create different types of counters
@@ -167,9 +166,12 @@ export interface Metric<in Input, out State> extends Pipeable {
  *     bytes: { count: bytesState.count, incremental: bytesState.incremental }
  *   }
  * })
+ *
+ * const result = await Effect.runPromise(Effect.provideService(program, Metric.MetricRegistry, new Map()))
+ * const counts = [result.requests.count, result.bytes.count] // => [6, 1024n]
  * ```
  *
- * @category metrics
+ * @category models
  * @since 2.0.0
  */
 export interface Counter<in Input extends number | bigint> extends Metric<Input, CounterState<Input>> {
@@ -179,12 +181,8 @@ export interface Counter<in Input extends number | bigint> extends Metric<Input,
  *
  * **Example** (Reading counter state)
  *
- * ```ts
- * import { Data, Effect, Metric } from "effect"
- *
- * class CounterStateError extends Data.TaggedError("CounterStateError")<{
- *   readonly operation: string
- * }> {}
+ * ```ts import.meta.vitest
+ * import { Effect, Metric } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   // Create different types of counters
@@ -209,7 +207,6 @@ export interface Counter<in Input extends number | bigint> extends Metric<Input,
  *   const byteState: Metric.CounterState<bigint> = yield* Metric.value(
  *     byteCounter
  *   )
- *
  *   // CounterState contains:
  *   // - count: current count value (number or bigint based on counter type)
  *   // - incremental: whether counter only allows increases
@@ -229,9 +226,12 @@ export interface Counter<in Input extends number | bigint> extends Metric<Input,
  *     }
  *   }
  * })
+ *
+ * const result = await Effect.runPromise(Effect.provideService(program, Metric.MetricRegistry, new Map()))
+ * const counts = [result.requests.total, result.errors.total, result.bytes.total] // => [3, 3, 1024000n]
  * ```
  *
- * @category Counter
+ * @category models
  * @since 4.0.0
  */
 export interface CounterState<in Input extends number | bigint> {
@@ -249,32 +249,16 @@ export interface CounterState<in Input extends number | bigint> {
  *
  * **Example** (Using frequency metrics)
  *
- * ```ts
- * import { Data, Effect, Metric } from "effect"
- *
- * class FrequencyInterfaceError
- *   extends Data.TaggedError("FrequencyInterfaceError")<{
- *     readonly operation: string
- *   }>
- * {}
+ * ```ts import.meta.vitest
+ * import { Effect, Metric } from "effect"
  *
  * // Function that accepts any Frequency metric
- * const logFrequencyMetric = (freq: Metric.Frequency) =>
+ * const analyzeFrequencyMetric = (freq: Metric.Frequency) =>
  *   Effect.gen(function*() {
  *     const state = yield* Metric.value(freq)
  *
- *     yield* Effect.log(`Frequency Metric: ${freq.id}`)
- *     yield* Effect.log(`Description: ${freq.description ?? "No description"}`)
- *     yield* Effect.log(`Type: ${freq.type}`) // "Frequency"
- *
  *     // Access the frequency state
  *     const occurrences: ReadonlyMap<string, number> = state.occurrences
- *     yield* Effect.log(`Total unique values: ${occurrences.size}`)
- *
- *     // Iterate through all occurrences
- *     for (const [value, count] of occurrences) {
- *       yield* Effect.log(`  "${value}": ${count} occurrences`)
- *     }
  *
  *     // Find most frequent value
  *     let maxCount = 0
@@ -311,14 +295,16 @@ export interface CounterState<in Input extends number | bigint> {
  *   yield* Metric.update(userActions, "login")
  *
  *   // Use the function with different frequency metrics
- *   const statusAnalysis = yield* logFrequencyMetric(statusCodes)
- *   const actionAnalysis = yield* logFrequencyMetric(userActions)
- *
+ *   const statusAnalysis = yield* analyzeFrequencyMetric(statusCodes)
+ *   const actionAnalysis = yield* analyzeFrequencyMetric(userActions)
  *   return { statusAnalysis, actionAnalysis }
  * })
+ *
+ * const result = await Effect.runPromise(Effect.provideService(program, Metric.MetricRegistry, new Map()))
+ * const values = [result.statusAnalysis.mostFrequent, result.actionAnalysis.mostFrequent] // => ["200", "login"]
  * ```
  *
- * @category metrics
+ * @category models
  * @since 2.0.0
  */
 export interface Frequency extends Metric<string, FrequencyState> {
@@ -328,12 +314,8 @@ export interface Frequency extends Metric<string, FrequencyState> {
  *
  * **Example** (Reading frequency state)
  *
- * ```ts
- * import { Data, Effect, Metric } from "effect"
- *
- * class FrequencyStateError extends Data.TaggedError("FrequencyStateError")<{
- *   readonly operation: string
- * }> {}
+ * ```ts import.meta.vitest
+ * import { Effect, Metric } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   // Create frequency metrics for different categories
@@ -381,7 +363,6 @@ export interface Frequency extends Metric<string, FrequencyState> {
  *
  *   const topStatus = getMostFrequent(statusState.occurrences)
  *   const topAction = getMostFrequent(actionState.occurrences)
- *
  *   return {
  *     statusCodes: {
  *       totalResponses: Array.from(statusState.occurrences.values()).reduce(
@@ -401,9 +382,13 @@ export interface Frequency extends Metric<string, FrequencyState> {
  *     }
  *   }
  * })
+ *
+ * const result = await Effect.runPromise(Effect.provideService(program, Metric.MetricRegistry, new Map()))
+ * const mostCommon = [result.statusCodes.mostCommon, result.userActions.mostCommon]
+ * mostCommon.map(({ key, count }) => [key, count]) // => [["200", 3], ["click", 3]]
  * ```
  *
- * @category metrics
+ * @category models
  * @since 4.0.0
  */
 export interface FrequencyState {
@@ -419,12 +404,8 @@ export interface FrequencyState {
  *
  * **Example** (Using gauge metrics)
  *
- * ```ts
- * import { Data, Effect, Metric } from "effect"
- *
- * class GaugeInterfaceError extends Data.TaggedError("GaugeInterfaceError")<{
- *   readonly operation: string
- * }> {}
+ * ```ts import.meta.vitest
+ * import { Effect, Metric } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   // Create different types of gauges
@@ -454,7 +435,6 @@ export interface FrequencyState {
  *   const diskState: Metric.GaugeState<bigint> = yield* Metric.value(
  *     diskSpaceGauge
  *   )
- *
  *   // Gauge state contains:
  *   // - value: current instantaneous value
  *
@@ -463,9 +443,12 @@ export interface FrequencyState {
  *     disk: { currentValue: diskState.value } // 5000000000n
  *   }
  * })
+ *
+ * const result = await Effect.runPromise(Effect.provideService(program, Metric.MetricRegistry, new Map()))
+ * const values = [result.memory.currentValue, result.disk.currentValue] // => [704, 5000000000n]
  * ```
  *
- * @category metrics
+ * @category models
  * @since 2.0.0
  */
 export interface Gauge<in Input extends number | bigint> extends Metric<Input, GaugeState<Input>> {
@@ -475,12 +458,8 @@ export interface Gauge<in Input extends number | bigint> extends Metric<Input, G
  *
  * **Example** (Reading gauge state)
  *
- * ```ts
- * import { Data, Effect, Metric } from "effect"
- *
- * class GaugeStateError extends Data.TaggedError("GaugeStateError")<{
- *   readonly operation: string
- * }> {}
+ * ```ts import.meta.vitest
+ * import { Effect, Metric } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   // Create different types of gauges
@@ -516,7 +495,6 @@ export interface Gauge<in Input extends number | bigint> extends Metric<Input, G
  *   const queueState: Metric.GaugeState<number> = yield* Metric.value(
  *     queueSizeGauge
  *   )
- *
  *   // GaugeState contains:
  *   // - value: current instantaneous value (number or bigint based on gauge type)
  *
@@ -532,9 +510,13 @@ export interface Gauge<in Input extends number | bigint> extends Metric<Input, G
  *     }
  *   }
  * })
+ *
+ * const result = await Effect.runPromise(Effect.provideService(program, Metric.MetricRegistry, new Map()))
+ * const values = [result.environment.temperature, result.system.diskUsage, result.system.queueSize]
+ * values // => [23.1, 5000000000n, 15]
  * ```
  *
- * @category metrics
+ * @category models
  * @since 4.0.0
  */
 export interface GaugeState<in Input extends number | bigint> {
@@ -550,14 +532,8 @@ export interface GaugeState<in Input extends number | bigint> {
  *
  * **Example** (Using histogram metrics)
  *
- * ```ts
- * import { Data, Effect, Metric } from "effect"
- *
- * class HistogramInterfaceError
- *   extends Data.TaggedError("HistogramInterfaceError")<{
- *     readonly operation: string
- *   }>
- * {}
+ * ```ts import.meta.vitest
+ * import { Effect, Metric } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   // Create histograms with different boundary strategies
@@ -565,7 +541,7 @@ export interface GaugeState<in Input extends number | bigint> {
  *     "http_response_time_ms",
  *     {
  *       description: "HTTP response time distribution in milliseconds",
- *       boundaries: Metric.linearBoundaries({ start: 0, width: 50, count: 20 }) // 0, 50, 100, ..., 950
+ *       boundaries: Metric.linearBoundaries({ start: 0, width: 50, count: 20 }) // 50, 100, ..., 900, Infinity
  *     }
  *   )
  *
@@ -598,7 +574,6 @@ export interface GaugeState<in Input extends number | bigint> {
  *   const fileSizeState: Metric.HistogramState = yield* Metric.value(
  *     fileSizeHistogram
  *   )
- *
  *   // Histogram state contains:
  *   // - buckets: Array of [boundary, cumulativeCount] pairs
  *   // - count: total number of observations
@@ -622,9 +597,13 @@ export interface GaugeState<in Input extends number | bigint> {
  *     }
  *   }
  * })
+ *
+ * const result = await Effect.runPromise(Effect.provideService(program, Metric.MetricRegistry, new Map()))
+ * const values = [result.responseTime.totalRequests, result.responseTime.totalTime, result.fileSize.totalBytes]
+ * values // => [4, 445, 118]
  * ```
  *
- * @category metrics
+ * @category models
  * @since 2.0.0
  */
 export interface Histogram<Input> extends Metric<Input, HistogramState> {
@@ -634,18 +613,14 @@ export interface Histogram<Input> extends Metric<Input, HistogramState> {
  *
  * **Example** (Reading histogram state)
  *
- * ```ts
- * import { Data, Effect, Metric } from "effect"
- *
- * class HistogramStateError extends Data.TaggedError("HistogramStateError")<{
- *   readonly operation: string
- * }> {}
+ * ```ts import.meta.vitest
+ * import { Effect, Metric } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   // Create histogram with linear boundaries
  *   const responseTimeHistogram = Metric.histogram("api_response_time_ms", {
  *     description: "API response time distribution",
- *     boundaries: Metric.linearBoundaries({ start: 0, width: 100, count: 10 }) // 0, 100, 200, ..., 900
+ *     boundaries: Metric.linearBoundaries({ start: 0, width: 100, count: 10 }) // 100, 200, ..., 800, Infinity
  *   })
  *
  *   // Record observations
@@ -692,7 +667,6 @@ export interface Histogram<Input> extends Metric<Input, HistogramState> {
  *   }
  *
  *   const bucketAnalysis = analyzeBuckets(state.buckets)
- *
  *   return {
  *     responseTime: {
  *       totalRequests: state.count, // 5
@@ -709,9 +683,14 @@ export interface Histogram<Input> extends Metric<Input, HistogramState> {
  *     }
  *   }
  * })
+ *
+ * const result = await Effect.runPromise(Effect.provideService(program, Metric.MetricRegistry, new Map()))
+ * const stats = result.responseTime
+ * const values = [stats.totalRequests, stats.fastestResponse, stats.slowestResponse, stats.totalTime]
+ * values // => [5, 50, 750, 1295]
  * ```
  *
- * @category metrics
+ * @category models
  * @since 4.0.0
  */
 export interface HistogramState {
@@ -732,12 +711,8 @@ export interface HistogramState {
  *
  * **Example** (Using summary metrics)
  *
- * ```ts
- * import { Data, Effect, Metric } from "effect"
- *
- * class SummaryInterfaceError extends Data.TaggedError("SummaryInterfaceError")<{
- *   readonly operation: string
- * }> {}
+ * ```ts import.meta.vitest
+ * import { Effect, Metric } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   // Create summaries with different quantile configurations
@@ -796,7 +771,6 @@ export interface HistogramState {
  *   const median = getQuantileValue(responseTimeState.quantiles, 0.5)
  *   const p95 = getQuantileValue(responseTimeState.quantiles, 0.95)
  *   const p99 = getQuantileValue(responseTimeState.quantiles, 0.99)
- *
  *   return {
  *     responseTime: {
  *       totalRequests: responseTimeState.count, // 5
@@ -814,9 +788,13 @@ export interface HistogramState {
  *     }
  *   }
  * })
+ *
+ * const result = await Effect.runPromise(Effect.provideService(program, Metric.MetricRegistry, new Map()))
+ * const counts = [result.responseTime.totalRequests, result.responseTime.totalTime, result.requestSize.totalRequests]
+ * counts // => [5, 1461, 3]
  * ```
  *
- * @category metrics
+ * @category models
  * @since 2.0.0
  */
 export interface Summary<Input> extends Metric<Input, SummaryState> {
@@ -826,12 +804,8 @@ export interface Summary<Input> extends Metric<Input, SummaryState> {
  *
  * **Example** (Reading summary state)
  *
- * ```ts
- * import { Data, Effect, Metric } from "effect"
- *
- * class SummaryStateError extends Data.TaggedError("SummaryStateError")<{
- *   readonly operation: string
- * }> {}
+ * ```ts import.meta.vitest
+ * import { Effect, Metric } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   // Create summary with specific quantiles
@@ -874,7 +848,6 @@ export interface Summary<Input> extends Metric<Input, SummaryState> {
  *   }
  *
  *   const quantileValues = extractQuantiles(state.quantiles)
- *
  *   return {
  *     latencyAnalysis: {
  *       totalRequests: state.count, // 7
@@ -896,9 +869,14 @@ export interface Summary<Input> extends Metric<Input, SummaryState> {
  *     }
  *   }
  * })
+ *
+ * const result = await Effect.runPromise(Effect.provideService(program, Metric.MetricRegistry, new Map()))
+ * const analysis = result.latencyAnalysis
+ * const values = [analysis.totalRequests, analysis.fastestResponse, analysis.slowestResponse, analysis.totalLatency]
+ * values // => [7, 45, 890, 1879]
  * ```
  *
- * @category metrics
+ * @category models
  * @since 4.0.0
  */
 export interface SummaryState {
@@ -914,12 +892,8 @@ export interface SummaryState {
  *
  * **Example** (Collecting application metrics)
  *
- * ```ts
- * import { Data, Effect, Metric } from "effect"
- *
- * class MetricsError extends Data.TaggedError("MetricsError")<{
- *   readonly operation: string
- * }> {}
+ * ```ts import.meta.vitest
+ * import { Effect, Metric } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   // Create different types of metrics
@@ -949,6 +923,9 @@ export interface SummaryState {
  *     frequency: frequencyValue
  *   }
  * })
+ *
+ * const result = await Effect.runPromise(Effect.provideService(program, Metric.MetricRegistry, new Map()))
+ * const values = [result.counter.count, result.gauge.value] // => [1, 12]
  * ```
  *
  * @since 2.0.0
@@ -959,78 +936,28 @@ export declare namespace Metric {
      *
      * **Example** (Inspecting metric types)
      *
-     * ```ts
-     * import { Data, Effect, Metric } from "effect"
-     *
-     * class MetricTypeError extends Data.TaggedError("MetricTypeError")<{
-     *   readonly operation: string
-     * }> {}
+     * ```ts import.meta.vitest
+     * import { Metric } from "effect"
      *
-     * const program = Effect.gen(function*() {
-     *   // Create different metric types
-     *   const counter = Metric.counter("requests_total")
-     *   const gauge = Metric.gauge("cpu_usage")
-     *   const frequency = Metric.frequency("status_codes")
-     *   const histogram = Metric.histogram("response_time", {
+     * const metrics: ReadonlyArray<Metric.Metric<any, any>> = [
+     *   Metric.counter("requests_total"),
+     *   Metric.gauge("cpu_usage"),
+     *   Metric.frequency("status_codes"),
+     *   Metric.histogram("response_time", {
      *     boundaries: Metric.linearBoundaries({ start: 0, width: 50, count: 10 })
-     *   })
-     *   const summary = Metric.summary("latency", {
+     *   }),
+     *   Metric.summary("latency", {
      *     maxAge: "5 minutes",
      *     maxSize: 1000,
      *     quantiles: [0.5, 0.95, 0.99]
      *   })
+     * ]
      *
-     *   // Function that checks metric type
-     *   const getMetricInfo = (metric: Metric.Metric<any, any>) => ({
-     *     name: metric.id,
-     *     type: metric.type
-     *   })
-     *
-     *   // Get type information for each metric
-     *   const counterInfo = getMetricInfo(counter) // { name: "requests_total", type: "Counter" }
-     *   const gaugeInfo = getMetricInfo(gauge) // { name: "cpu_usage", type: "Gauge" }
-     *   const frequencyInfo = getMetricInfo(frequency) // { name: "status_codes", type: "Frequency" }
-     *   const histogramInfo = getMetricInfo(histogram) // { name: "response_time", type: "Histogram" }
-     *   const summaryInfo = getMetricInfo(summary) // { name: "latency", type: "Summary" }
-     *
-     *   // Pattern match on metric type
-     *   const describeMetric = (type: string): string => {
-     *     switch (type) {
-     *       case "Counter":
-     *         return "Cumulative values that increase over time"
-     *       case "Gauge":
-     *         return "Instantaneous values that can go up or down"
-     *       case "Frequency":
-     *         return "Counts of discrete string occurrences"
-     *       case "Histogram":
-     *         return "Distribution of values across buckets"
-     *       case "Summary":
-     *         return "Quantile calculations over time windows"
-     *       default:
-     *         return "Unknown metric type"
-     *     }
-     *   }
-     *
-     *   return {
-     *     metrics: [
-     *       counterInfo,
-     *       gaugeInfo,
-     *       frequencyInfo,
-     *       histogramInfo,
-     *       summaryInfo
-     *     ],
-     *     descriptions: {
-     *       Counter: describeMetric("Counter"),
-     *       Gauge: describeMetric("Gauge"),
-     *       Frequency: describeMetric("Frequency"),
-     *       Histogram: describeMetric("Histogram"),
-     *       Summary: describeMetric("Summary")
-     *     }
-     *   }
-     * })
+     * const types: ReadonlyArray<Metric.Metric.Type> = metrics.map((metric) => metric.type)
+     * const actual = types // => ["Counter", "Gauge", "Frequency", "Histogram", "Summary"]
      * ```
      *
-     * @category types
+     * @category models
      * @since 4.0.0
      */
     type Type = "Counter" | "Frequency" | "Gauge" | "Histogram" | "Summary";
@@ -1039,12 +966,8 @@ export declare namespace Metric {
      *
      * **Example** (Providing attributes in different formats)
      *
-     * ```ts
-     * import { Data, Effect, Metric } from "effect"
-     *
-     * class AttributesError extends Data.TaggedError("AttributesError")<{
-     *   readonly operation: string
-     * }> {}
+     * ```ts import.meta.vitest
+     * import { Effect, Metric } from "effect"
      *
      * const program = Effect.gen(function*() {
      *   // Different ways to specify attributes
@@ -1093,19 +1016,22 @@ export declare namespace Metric {
      *   // Both formats result in the same internal representation
      *   const normalizedObject = normalizeAttributes(attributesAsObject)
      *   const normalizedArray = normalizeAttributes(attributesAsArray)
-     *
      *   return {
      *     attributeFormats: {
      *       object: normalizedObject, // { service: "api", environment: "production", version: "1.2.3" }
-     *       array: normalizedArray, // { service: "api", environment: "production", version: "1.2.3" }
-     *       areEqual:
-     *         JSON.stringify(normalizedObject) === JSON.stringify(normalizedArray) // true
+     *       array: normalizedArray // { service: "api", environment: "production", version: "1.2.3" }
      *     }
      *   }
      * })
+     *
+     * const result = await Effect.runPromise(Effect.provideService(program, Metric.MetricRegistry, new Map()))
+     * const objectAttributes = result.attributeFormats.object
+     * const arrayAttributes = result.attributeFormats.array
+     * const sameAttributes = [objectAttributes, arrayAttributes]
+     * sameAttributes // => [{ service: "api", environment: "production", version: "1.2.3" }, { service: "api", environment: "production", version: "1.2.3" }]
      * ```
      *
-     * @category types
+     * @category models
      * @since 4.0.0
      */
     type Attributes = AttributeSet | ReadonlyArray<[string, string]>;
@@ -1114,12 +1040,8 @@ export declare namespace Metric {
      *
      * **Example** (Combining metric attribute sets)
      *
-     * ```ts
-     * import { Data, Effect, Metric } from "effect"
-     *
-     * class AttributeSetError extends Data.TaggedError("AttributeSetError")<{
-     *   readonly operation: string
-     * }> {}
+     * ```ts import.meta.vitest
+     * import { Effect, Metric } from "effect"
      *
      * const program = Effect.gen(function*() {
      *   // Define attribute sets for different contexts
@@ -1180,9 +1102,12 @@ export declare namespace Metric {
      *     }
      *   }
      * })
+     *
+     * const result = await Effect.runPromise(Effect.provideService(program, Metric.MetricRegistry, new Map()))
+     * const validation = [result.attributes.isValid, result.attributes.totalKeys] // => [true, 9]
      * ```
      *
-     * @category types
+     * @category models
      * @since 4.0.0
      */
     type AttributeSet = Readonly<Record<string, string>>;
@@ -1191,7 +1116,7 @@ export declare namespace Metric {
      *
      * **Example** (Extracting metric input types)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Metric } from "effect"
      *
      * // Create various metric types
@@ -1229,9 +1154,11 @@ export declare namespace Metric {
      * // Metric.update(numberCounter, "abc")   // ✗ Type error
      * // Metric.update(stringFrequency, "ok")  // ✓ Valid (string)
      * // Metric.update(stringFrequency, 404)   // ✗ Type error
+     * const metricIds = metrics.map(({ id, type }) => `${id}:${type}`)
+     * metricIds // => ["requests:Counter", "bytes:Counter", "status_codes:Frequency", "cpu_usage:Gauge", "response_time:Histogram"]
      * ```
      *
-     * @category types
+     * @category utility types
      * @since 4.0.0
      */
     type Input<A> = A extends Metric<infer _Input, infer _State> ? _Input : never;
@@ -1240,7 +1167,7 @@ export declare namespace Metric {
      *
      * **Example** (Extracting metric state types)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Effect, Metric } from "effect"
      *
      * // Create various metric types
@@ -1278,7 +1205,6 @@ export declare namespace Metric {
      *   const frequencyState = yield* Metric.value(statusFrequency)
      *   const histogramState = yield* Metric.value(responseHistogram)
      *   const summaryState = yield* Metric.value(latencySummary)
-     *
      *   return {
      *     counter: { count: counterState.count }, // { count: 10 }
      *     gauge: { value: gaugeState.value }, // { value: 85.5 }
@@ -1287,9 +1213,13 @@ export declare namespace Metric {
      *     summary: { observations: summaryState.count } // { observations: 1 }
      *   }
      * })
+     *
+     * const result = await Effect.runPromise(Effect.provideService(program, Metric.MetricRegistry, new Map()))
+     * const values = [result.counter.count, result.gauge.value, result.frequency.uniqueValues]
+     * values // => [10, 85.5, 1]
      * ```
      *
-     * @category types
+     * @category utility types
      * @since 4.0.0
      */
     type State<A> = A extends Metric<infer _Input, infer _State> ? _State : never;
@@ -1298,12 +1228,8 @@ export declare namespace Metric {
      *
      * **Example** (Using metric hooks)
      *
-     * ```ts
-     * import { Data, Effect, Metric } from "effect"
-     *
-     * class HooksError extends Data.TaggedError("HooksError")<{
-     *   readonly operation: string
-     * }> {}
+     * ```ts import.meta.vitest
+     * import { Effect, Metric } from "effect"
      *
      * const program = Effect.gen(function*() {
      *   // Create a counter metric
@@ -1331,9 +1257,12 @@ export declare namespace Metric {
      *     isIncremental: state.incremental // false
      *   }
      * })
+     *
+     * const result = await Effect.runPromise(Effect.provideService(program, Metric.MetricRegistry, new Map()))
+     * const state = result // => { currentCount: 6, isIncremental: false }
      * ```
      *
-     * @category interfaces
+     * @category models
      * @since 4.0.0
      */
     interface Hooks<in Input, out State> {
@@ -1346,12 +1275,8 @@ export declare namespace Metric {
      *
      * **Example** (Inspecting metric metadata)
      *
-     * ```ts
-     * import { Data, Effect, Metric } from "effect"
-     *
-     * class MetadataError extends Data.TaggedError("MetadataError")<{
-     *   readonly operation: string
-     * }> {}
+     * ```ts import.meta.vitest
+     * import { Effect, Metric } from "effect"
      *
      * const program = Effect.gen(function*() {
      *   // Create metrics with different configurations
@@ -1396,9 +1321,12 @@ export declare namespace Metric {
      *     }
      *   }
      * })
+     *
+     * const result = await Effect.runPromise(Effect.provideService(program, Metric.MetricRegistry, new Map()))
+     * const types = [result.counter.type, result.gauge.type, result.frequency.type] // => ["Counter", "Gauge", "Frequency"]
      * ```
      *
-     * @category interfaces
+     * @category models
      * @since 4.0.0
      */
     interface Metadata<in Input, out State> {
@@ -1413,12 +1341,8 @@ export declare namespace Metric {
      *
      * **Example** (Inspecting metric snapshot protocols)
      *
-     * ```ts
-     * import { Data, Effect, Metric } from "effect"
-     *
-     * class SnapshotProtoError extends Data.TaggedError("SnapshotProtoError")<{
-     *   readonly operation: string
-     * }> {}
+     * ```ts import.meta.vitest
+     * import { Effect, Metric } from "effect"
      *
      * const program = Effect.gen(function*() {
      *   // Create and update metrics
@@ -1468,9 +1392,12 @@ export declare namespace Metric {
      *       null
      *   }
      * })
+     *
+     * const result = await Effect.runPromise(Effect.provideService(program, Metric.MetricRegistry, new Map()))
+     * const counts = [result.counter?.count, result.histogram?.observations] // => [25, 2]
      * ```
      *
-     * @category interfaces
+     * @category models
      * @since 4.0.0
      */
     interface SnapshotProto<T extends Type, State> {
@@ -1485,12 +1412,8 @@ export declare namespace Metric {
      *
      * **Example** (Analyzing metric snapshots)
      *
-     * ```ts
-     * import { Data, Effect, Metric } from "effect"
-     *
-     * class SnapshotError extends Data.TaggedError("SnapshotError")<{
-     *   readonly operation: string
-     * }> {}
+     * ```ts import.meta.vitest
+     * import { Effect, Metric } from "effect"
      *
      * const program = Effect.gen(function*() {
      *   // Create different types of metrics
@@ -1544,9 +1467,12 @@ export declare namespace Metric {
      *     analysis
      *   }
      * })
+     *
+     * const result = await Effect.runPromise(Effect.provideService(program, Metric.MetricRegistry, new Map()))
+     * const types = result.metricTypes // => ["Counter", "Gauge", "Frequency", "Histogram", "Summary"]
      * ```
      *
-     * @category types
+     * @category models
      * @since 4.0.0
      */
     type Snapshot = SnapshotProto<"Counter", CounterState<number | bigint>> | SnapshotProto<"Gauge", GaugeState<number | bigint>> | SnapshotProto<"Frequency", FrequencyState> | SnapshotProto<"Histogram", HistogramState> | SnapshotProto<"Summary", SummaryState>;
@@ -1556,12 +1482,8 @@ export declare namespace Metric {
  *
  * **Example** (Accessing the current metric attributes key)
  *
- * ```ts
- * import { Data, Effect, Metric } from "effect"
- *
- * class AttributesKeyError extends Data.TaggedError("AttributesKeyError")<{
- *   readonly operation: string
- * }> {}
+ * ```ts import.meta.vitest
+ * import { Effect, Metric } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   // The key is used internally by the Effect runtime to manage metric attributes
@@ -1595,9 +1517,12 @@ export declare namespace Metric {
  *     isConstant: key === "effect/Metric/CurrentMetricAttributes" // true
  *   }
  * })
+ *
+ * const result = await Effect.runPromise(Effect.provideService(program, Metric.MetricRegistry, new Map()))
+ * const key = result // => { keyValue: "effect/Metric/CurrentMetricAttributes", keyType: "string", isConstant: true }
  * ```
  *
- * @category references
+ * @category constants
  * @since 4.0.0
  */
 export declare const CurrentMetricAttributesKey: "effect/Metric/CurrentMetricAttributes";
@@ -1618,17 +1543,12 @@ export declare const CurrentMetricAttributesKey: "effect/Metric/CurrentMetricAtt
  *
  * **Example** (Providing current metric attributes)
  *
- * ```ts
- * import { Data, Effect, Metric } from "effect"
- *
- * class AttributesError extends Data.TaggedError("AttributesError")<{
- *   readonly operation: string
- * }> {}
+ * ```ts import.meta.vitest
+ * import { Effect, Metric } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   // Access current metric attributes
- *   const attributes = yield* Metric.CurrentMetricAttributes
- *   console.log("Current attributes:", attributes)
+ *   yield* Metric.CurrentMetricAttributes
  *
  *   // Set new attributes context
  *   const newAttributes = { service: "api", version: "1.0" }
@@ -1643,9 +1563,12 @@ export declare const CurrentMetricAttributesKey: "effect/Metric/CurrentMetricAtt
  *
  *   return result
  * })
+ *
+ * const attributes = await Effect.runPromise(program)
+ * const actual = attributes // => { service: "api", version: "1.0" }
  * ```
  *
- * @category references
+ * @category services
  * @since 4.0.0
  */
 export declare const CurrentMetricAttributes: Context.Reference<Readonly<Record<string, string>>>;
@@ -1672,7 +1595,7 @@ export declare const CurrentMetricAttributes: Context.Reference<Readonly<Record<
  * @see {@link snapshot} for reading all registered metrics from the current `Effect` context
  * @see {@link snapshotUnsafe} for reading all registered metrics from an explicit `Context`
  *
- * @category references
+ * @category services
  * @since 4.0.0
  */
 export declare const MetricRegistry: Context.Reference<Map<string, Metric.Metadata<any, any>>>;
@@ -1687,23 +1610,17 @@ declare const TypeId = "~effect/observability/Metric";
  *
  * **Example** (Checking metric values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Metric } from "effect"
  *
- * const counter = Metric.counter("requests")
- * const gauge = Metric.gauge("temperature")
- * const notAMetric = { name: "fake-metric" }
- *
- * console.log(Metric.isMetric(counter)) // true
- * console.log(Metric.isMetric(gauge)) // true
- * console.log(Metric.isMetric(notAMetric)) // false
- * console.log(Metric.isMetric(null)) // false
+ * Metric.isMetric(Metric.counter("requests")) // => true
+ * Metric.isMetric({ name: "requests" }) // => false
  * ```
  *
  * @category guards
  * @since 4.0.0
  */
-export declare const isMetric: (u: unknown) => u is Metric<unknown, never>;
+export declare const isMetric: (u: unknown) => u is Metric<never, unknown>;
 /**
  * Represents a Counter metric that tracks cumulative numerical values over
  * time. Counters can be incremented and decremented and provide a running total
@@ -1718,12 +1635,8 @@ export declare const isMetric: (u: unknown) => u is Metric<unknown, never>;
  *
  * **Example** (Creating counter metrics)
  *
- * ```ts
- * import { Data, Effect, Metric } from "effect"
- *
- * class CounterError extends Data.TaggedError("CounterError")<{
- *   readonly operation: string
- * }> {}
+ * ```ts import.meta.vitest
+ * import { Effect, Metric } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   // Create a basic counter for tracking requests
@@ -1757,6 +1670,9 @@ export declare const isMetric: (u: unknown) => u is Metric<unknown, never>;
  *
  *   return { requestValue, eventValue, bytesValue }
  * })
+ *
+ * const result = await Effect.runPromise(Effect.provideService(program, Metric.MetricRegistry, new Map()))
+ * const counts = [result.requestValue.count, result.eventValue.count, result.bytesValue.count] // => [6, 1, 1024n]
  * ```
  *
  * @category constructors
@@ -1777,12 +1693,8 @@ export declare const counter: {
      *
      * **Example** (Creating counter metrics)
      *
-     * ```ts
-     * import { Data, Effect, Metric } from "effect"
-     *
-     * class CounterError extends Data.TaggedError("CounterError")<{
-     *   readonly operation: string
-     * }> {}
+     * ```ts import.meta.vitest
+     * import { Effect, Metric } from "effect"
      *
      * const program = Effect.gen(function*() {
      *   // Create a basic counter for tracking requests
@@ -1816,6 +1728,9 @@ export declare const counter: {
      *
      *   return { requestValue, eventValue, bytesValue }
      * })
+     *
+     * const result = await Effect.runPromise(Effect.provideService(program, Metric.MetricRegistry, new Map()))
+     * const counts = [result.requestValue.count, result.eventValue.count, result.bytesValue.count] // => [6, 1, 1024n]
      * ```
      *
      * @category constructors
@@ -1841,12 +1756,8 @@ export declare const counter: {
      *
      * **Example** (Creating counter metrics)
      *
-     * ```ts
-     * import { Data, Effect, Metric } from "effect"
-     *
-     * class CounterError extends Data.TaggedError("CounterError")<{
-     *   readonly operation: string
-     * }> {}
+     * ```ts import.meta.vitest
+     * import { Effect, Metric } from "effect"
      *
      * const program = Effect.gen(function*() {
      *   // Create a basic counter for tracking requests
@@ -1880,6 +1791,9 @@ export declare const counter: {
      *
      *   return { requestValue, eventValue, bytesValue }
      * })
+     *
+     * const result = await Effect.runPromise(Effect.provideService(program, Metric.MetricRegistry, new Map()))
+     * const counts = [result.requestValue.count, result.eventValue.count, result.bytesValue.count] // => [6, 1, 1024n]
      * ```
      *
      * @category constructors
@@ -1909,12 +1823,8 @@ export declare const counter: {
  *
  * **Example** (Creating gauge metrics)
  *
- * ```ts
- * import { Data, Effect, Metric } from "effect"
- *
- * class GaugeError extends Data.TaggedError("GaugeError")<{
- *   readonly operation: string
- * }> {}
+ * ```ts import.meta.vitest
+ * import { Effect, Metric } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   // Create a gauge for tracking memory usage
@@ -1953,6 +1863,9 @@ export declare const counter: {
  *
  *   return { memoryValue, cpuValue, diskValue }
  * })
+ *
+ * const result = await Effect.runPromise(Effect.provideService(program, Metric.MetricRegistry, new Map()))
+ * const values = [result.memoryValue.value, result.cpuValue.value, result.diskValue.value] // => [800, 75, 1024000000n]
  * ```
  *
  * @category constructors
@@ -1976,12 +1889,8 @@ export declare const gauge: {
      *
      * **Example** (Creating gauge metrics)
      *
-     * ```ts
-     * import { Data, Effect, Metric } from "effect"
-     *
-     * class GaugeError extends Data.TaggedError("GaugeError")<{
-     *   readonly operation: string
-     * }> {}
+     * ```ts import.meta.vitest
+     * import { Effect, Metric } from "effect"
      *
      * const program = Effect.gen(function*() {
      *   // Create a gauge for tracking memory usage
@@ -2020,6 +1929,9 @@ export declare const gauge: {
      *
      *   return { memoryValue, cpuValue, diskValue }
      * })
+     *
+     * const result = await Effect.runPromise(Effect.provideService(program, Metric.MetricRegistry, new Map()))
+     * const values = [result.memoryValue.value, result.cpuValue.value, result.diskValue.value] // => [800, 75, 1024000000n]
      * ```
      *
      * @category constructors
@@ -2047,12 +1959,8 @@ export declare const gauge: {
      *
      * **Example** (Creating gauge metrics)
      *
-     * ```ts
-     * import { Data, Effect, Metric } from "effect"
-     *
-     * class GaugeError extends Data.TaggedError("GaugeError")<{
-     *   readonly operation: string
-     * }> {}
+     * ```ts import.meta.vitest
+     * import { Effect, Metric } from "effect"
      *
      * const program = Effect.gen(function*() {
      *   // Create a gauge for tracking memory usage
@@ -2091,6 +1999,9 @@ export declare const gauge: {
      *
      *   return { memoryValue, cpuValue, diskValue }
      * })
+     *
+     * const result = await Effect.runPromise(Effect.provideService(program, Metric.MetricRegistry, new Map()))
+     * const values = [result.memoryValue.value, result.cpuValue.value, result.diskValue.value] // => [800, 75, 1024000000n]
      * ```
      *
      * @category constructors
@@ -2119,12 +2030,8 @@ export declare const gauge: {
  *
  * **Example** (Creating frequency metrics)
  *
- * ```ts
- * import { Data, Effect, Metric } from "effect"
- *
- * class FrequencyError extends Data.TaggedError("FrequencyError")<{
- *   readonly operation: string
- * }> {}
+ * ```ts import.meta.vitest
+ * import { Effect, Metric } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   // Create a frequency metric for HTTP status codes
@@ -2174,6 +2081,14 @@ export declare const gauge: {
  *
  *   return { statusCounts, actionCounts, errorCounts }
  * })
+ *
+ * const result = await Effect.runPromise(Effect.provideService(program, Metric.MetricRegistry, new Map()))
+ * const counts = [
+ *   result.statusCounts.occurrences.get("200"),
+ *   result.actionCounts.occurrences.get("login"),
+ *   result.errorCounts.occurrences.get("ValidationError")
+ * ]
+ * counts // => [3, 2, 2]
  * ```
  *
  * @category constructors
@@ -2200,19 +2115,15 @@ export declare const frequency: (name: string, options?: {
  *
  * **Example** (Creating histogram metrics)
  *
- * ```ts
- * import { Data, Effect, Metric } from "effect"
- *
- * class HistogramError extends Data.TaggedError("HistogramError")<{
- *   readonly operation: string
- * }> {}
+ * ```ts import.meta.vitest
+ * import { Effect, Metric } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   // Create a histogram for API response times
  *   const responseTimeHistogram = Metric.histogram("api_response_time", {
  *     description: "Distribution of API response times in milliseconds",
  *     boundaries: Metric.linearBoundaries({ start: 0, width: 50, count: 10 })
- *     // Creates buckets: 0-50ms, 50-100ms, 100-150ms, ..., 400-450ms, 450ms+
+ *     // Creates buckets: 0-50ms, 50-100ms, 100-150ms, ..., 350-400ms, 400ms+
  *   })
  *
  *   // Create a histogram for request payload sizes
@@ -2252,6 +2163,10 @@ export declare const frequency: (name: string, options?: {
  *
  *   return { responseTimeState, payloadSizeState }
  * })
+ *
+ * const result = await Effect.runPromise(Effect.provideService(program, Metric.MetricRegistry, new Map()))
+ * const values = [result.responseTimeState.count, result.responseTimeState.sum, result.payloadSizeState.count]
+ * values // => [5, 500, 3]
  * ```
  *
  * @category constructors
@@ -2280,12 +2195,8 @@ export declare const histogram: (name: string, options: {
  *
  * **Example** (Creating summary metrics)
  *
- * ```ts
- * import { Data, Duration, Effect, Metric } from "effect"
- *
- * class SummaryError extends Data.TaggedError("SummaryError")<{
- *   readonly operation: string
- * }> {}
+ * ```ts import.meta.vitest
+ * import { Duration, Effect, Metric } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   // Create a summary for API response times
@@ -2321,24 +2232,16 @@ export declare const histogram: (name: string, options: {
  *   const responseStats = yield* Metric.value(responseTimeSummary)
  *   const payloadStats = yield* Metric.value(payloadSizeSummary)
  *
- *   console.log({
- *     count: responseStats.count,
- *     min: responseStats.min,
- *     max: responseStats.max,
- *     sum: responseStats.sum
- *   }) // { count: 8, min: 82, max: 240, sum: 1155 }
- *
- *   console.log({
- *     count: payloadStats.count,
- *     min: payloadStats.min,
- *     max: payloadStats.max,
- *     sum: payloadStats.sum
- *   }) // { count: 4, min: 1.2, max: 15.6, sum: 26 }
- *
  *   // Both summaries include quantile information for their configured windows.
  *
  *   return { responseStats, payloadStats }
  * })
+ *
+ * const result = await Effect.runPromise(Effect.provideService(program, Metric.MetricRegistry, new Map()))
+ * const response = result.responseStats
+ * const payload = result.payloadStats
+ * const responseValues = [response.count, response.min, response.max, response.sum] // => [8, 82, 240, 1155]
+ * const payloadValues = [payload.count, payload.min, payload.max, payload.sum] // => [4, 1.2, 15.6, 26]
  * ```
  *
  * @category constructors
@@ -2372,7 +2275,7 @@ export declare const summary: (name: string, options: {
  *
  * **Example** (Creating summaries with explicit timestamps)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Metric } from "effect"
  *
  * const responseTimesSummary = Metric.summaryWithTimestamp(
@@ -2384,6 +2287,7 @@ export declare const summary: (name: string, options: {
  *     quantiles: [0.5, 0.9, 0.99] // Calculate 50th, 90th, and 99th quantiles.
  *   }
  * )
+ * const metadata = [responseTimesSummary.id, responseTimesSummary.type] // => ["response_times_summary", "Summary"]
  * ```
  *
  * @category constructors
@@ -2410,12 +2314,8 @@ export declare const summaryWithTimestamp: (name: string, options: {
  *
  * **Example** (Recording durations with a timer)
  *
- * ```ts
- * import { Data, Duration, Effect, Metric } from "effect"
- *
- * class TimerError extends Data.TaggedError("TimerError")<{
- *   readonly operation: string
- * }> {}
+ * ```ts import.meta.vitest
+ * import { Duration, Effect, Metric } from "effect"
  *
  * // Create a timer metric to track API request durations
  * const apiRequestTimer = Metric.timer("api_request_duration", {
@@ -2429,13 +2329,17 @@ export declare const summaryWithTimestamp: (name: string, options: {
  *   yield* Metric.update(apiRequestTimer, duration)
  *
  *   const state = yield* Metric.value(apiRequestTimer)
- *   console.log({
+ *   return {
  *     count: state.count,
  *     min: state.min,
  *     max: state.max,
  *     sum: state.sum
- *   }) // { count: 1, min: 120, max: 120, sum: 120 }
+ *   }
  * })
+ *
+ * await Effect.runPromise(
+ *   Effect.provideService(apiOperation, Metric.MetricRegistry, new Map())
+ * ) // => { count: 1, min: 120, max: 120, sum: 120 }
  * ```
  *
  * @category constructors
@@ -2460,10 +2364,10 @@ export declare const timer: (name: string, options?: {
  *
  * **Example** (Reading metric state)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Metric } from "effect"
  *
- * const requestCounter = Metric.counter("requests")
+ * const requestCounter = Metric.counter("modify_requests")
  * const responseTime = Metric.histogram("response_time", {
  *   boundaries: [100, 500, 1000, 2000]
  * })
@@ -2475,16 +2379,19 @@ export declare const timer: (name: string, options?: {
  *
  *   // Get current values
  *   const counterState = yield* Metric.value(requestCounter)
- *   console.log(`Request count: ${counterState.count}`)
- *
  *   const histogramState = yield* Metric.value(responseTime)
- *   console.log(`Response time stats:`, {
+ *   return {
+ *     requestCount: counterState.count,
  *     count: histogramState.count,
  *     min: histogramState.min,
  *     max: histogramState.max,
  *     average: histogramState.sum / histogramState.count
- *   })
+ *   }
  * })
+ *
+ * await Effect.runPromise(
+ *   Effect.provideService(program, Metric.MetricRegistry, new Map())
+ * ) // => { requestCount: 1, count: 1, min: 750, max: 750, average: 750 }
  * ```
  *
  * @category getters
@@ -2504,7 +2411,7 @@ export declare const value: <Input, State>(self: Metric<Input, State>) => Effect
  *
  * **Example** (Modifying metric values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Metric } from "effect"
  *
  * const temperatureGauge = Metric.gauge("temperature")
@@ -2524,10 +2431,10 @@ export declare const value: <Input, State>(self: Metric<Input, State>) => Effect
  *
  *   const temp = yield* Metric.value(temperatureGauge)
  *   const requests = yield* Metric.value(requestCounter)
- *
- *   console.log(`Temperature: ${temp.value}°C`) // 22°C
- *   console.log(`Requests: ${requests.count}`) // 15
+ *   return [temp.value, requests.count] as const
  * })
+ *
+ * await Effect.runPromise(Effect.provideService(program, Metric.MetricRegistry, new Map())) // => [22, 15]
  * ```
  *
  * @category mutations
@@ -2547,7 +2454,7 @@ export declare const modify: {
      *
      * **Example** (Modifying metric values)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Effect, Metric } from "effect"
      *
      * const temperatureGauge = Metric.gauge("temperature")
@@ -2567,10 +2474,10 @@ export declare const modify: {
      *
      *   const temp = yield* Metric.value(temperatureGauge)
      *   const requests = yield* Metric.value(requestCounter)
-     *
-     *   console.log(`Temperature: ${temp.value}°C`) // 22°C
-     *   console.log(`Requests: ${requests.count}`) // 15
+     *   return [temp.value, requests.count] as const
      * })
+     *
+     * await Effect.runPromise(Effect.provideService(program, Metric.MetricRegistry, new Map())) // => [22, 15]
      * ```
      *
      * @category mutations
@@ -2590,7 +2497,7 @@ export declare const modify: {
      *
      * **Example** (Modifying metric values)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Effect, Metric } from "effect"
      *
      * const temperatureGauge = Metric.gauge("temperature")
@@ -2610,10 +2517,10 @@ export declare const modify: {
      *
      *   const temp = yield* Metric.value(temperatureGauge)
      *   const requests = yield* Metric.value(requestCounter)
-     *
-     *   console.log(`Temperature: ${temp.value}°C`) // 22°C
-     *   console.log(`Requests: ${requests.count}`) // 15
+     *   return [temp.value, requests.count] as const
      * })
+     *
+     * await Effect.runPromise(Effect.provideService(program, Metric.MetricRegistry, new Map())) // => [22, 15]
      * ```
      *
      * @category mutations
@@ -2634,7 +2541,7 @@ export declare const modify: {
  *
  * **Example** (Updating metric values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Metric } from "effect"
  *
  * const cpuUsage = Metric.gauge("cpu_usage_percent")
@@ -2662,11 +2569,10 @@ export declare const modify: {
  *   const cpu = yield* Metric.value(cpuUsage)
  *   const statuses = yield* Metric.value(httpStatus)
  *   const times = yield* Metric.value(responseTime)
- *
- *   console.log(`CPU Usage: ${cpu.value}%`)
- *   console.log(`Status 200 count: ${statuses.occurrences.get("200")}`) // 2
- *   console.log(`Response time samples: ${times.count}`) // 3
+ *   return [cpu.value, statuses.occurrences.get("200"), times.count] as const
  * })
+ *
+ * await Effect.runPromise(Effect.provideService(program, Metric.MetricRegistry, new Map())) // => [67.8, 2, 3]
  * ```
  *
  * @category mutations
@@ -2686,7 +2592,7 @@ export declare const update: {
      *
      * **Example** (Updating metric values)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Effect, Metric } from "effect"
      *
      * const cpuUsage = Metric.gauge("cpu_usage_percent")
@@ -2714,11 +2620,10 @@ export declare const update: {
      *   const cpu = yield* Metric.value(cpuUsage)
      *   const statuses = yield* Metric.value(httpStatus)
      *   const times = yield* Metric.value(responseTime)
-     *
-     *   console.log(`CPU Usage: ${cpu.value}%`)
-     *   console.log(`Status 200 count: ${statuses.occurrences.get("200")}`) // 2
-     *   console.log(`Response time samples: ${times.count}`) // 3
+     *   return [cpu.value, statuses.occurrences.get("200"), times.count] as const
      * })
+     *
+     * await Effect.runPromise(Effect.provideService(program, Metric.MetricRegistry, new Map())) // => [67.8, 2, 3]
      * ```
      *
      * @category mutations
@@ -2738,7 +2643,7 @@ export declare const update: {
      *
      * **Example** (Updating metric values)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Effect, Metric } from "effect"
      *
      * const cpuUsage = Metric.gauge("cpu_usage_percent")
@@ -2766,11 +2671,10 @@ export declare const update: {
      *   const cpu = yield* Metric.value(cpuUsage)
      *   const statuses = yield* Metric.value(httpStatus)
      *   const times = yield* Metric.value(responseTime)
-     *
-     *   console.log(`CPU Usage: ${cpu.value}%`)
-     *   console.log(`Status 200 count: ${statuses.occurrences.get("200")}`) // 2
-     *   console.log(`Response time samples: ${times.count}`) // 3
+     *   return [cpu.value, statuses.occurrences.get("200"), times.count] as const
      * })
+     *
+     * await Effect.runPromise(Effect.provideService(program, Metric.MetricRegistry, new Map())) // => [67.8, 2, 3]
      * ```
      *
      * @category mutations
@@ -2785,36 +2689,30 @@ export declare const update: {
  *
  * **Example** (Mapping metric inputs)
  *
- * ```ts
- * import { Data, Effect, Metric } from "effect"
- *
- * class MetricError extends Data.TaggedError("MetricError")<{
- *   readonly operation: string
- * }> {}
+ * ```ts import.meta.vitest
+ * import { Effect, Metric } from "effect"
  *
- * // Create a histogram that expects Duration values
  * const durationHistogram = Metric.histogram("request_duration_ms", {
  *   description: "Request duration in milliseconds",
  *   boundaries: Metric.linearBoundaries({ start: 0, width: 100, count: 10 })
  * })
  *
- * // Transform to accept number values representing milliseconds
- * const numberHistogram = Metric.mapInput(
+ * // Accept duration strings while recording numeric milliseconds
+ * const durationStringHistogram = Metric.mapInput(
  *   durationHistogram,
- *   (ms: number) => ms // Direct mapping from number to expected input
+ *   (input: string) => Number(input)
  * )
  *
  * const program = Effect.gen(function*() {
- *   // Now we can update with a plain number
- *   yield* Metric.update(numberHistogram, 250)
- *
- *   // Get metric value to see the recorded state
- *   const value = yield* Metric.value(numberHistogram)
- *   return value
+ *   yield* Metric.update(durationStringHistogram, "250")
+ *   return yield* Metric.value(durationStringHistogram)
  * })
+ *
+ * const value = await Effect.runPromise(Effect.provideService(program, Metric.MetricRegistry, new Map()))
+ * const values = [value.count, value.sum] // => [1, 250]
  * ```
  *
- * @category mapping
+ * @category annotations
  * @since 2.0.0
  */
 export declare const mapInput: {
@@ -2825,36 +2723,30 @@ export declare const mapInput: {
      *
      * **Example** (Mapping metric inputs)
      *
-     * ```ts
-     * import { Data, Effect, Metric } from "effect"
-     *
-     * class MetricError extends Data.TaggedError("MetricError")<{
-     *   readonly operation: string
-     * }> {}
+     * ```ts import.meta.vitest
+     * import { Effect, Metric } from "effect"
      *
-     * // Create a histogram that expects Duration values
      * const durationHistogram = Metric.histogram("request_duration_ms", {
      *   description: "Request duration in milliseconds",
      *   boundaries: Metric.linearBoundaries({ start: 0, width: 100, count: 10 })
      * })
      *
-     * // Transform to accept number values representing milliseconds
-     * const numberHistogram = Metric.mapInput(
+     * // Accept duration strings while recording numeric milliseconds
+     * const durationStringHistogram = Metric.mapInput(
      *   durationHistogram,
-     *   (ms: number) => ms // Direct mapping from number to expected input
+     *   (input: string) => Number(input)
      * )
      *
      * const program = Effect.gen(function*() {
-     *   // Now we can update with a plain number
-     *   yield* Metric.update(numberHistogram, 250)
-     *
-     *   // Get metric value to see the recorded state
-     *   const value = yield* Metric.value(numberHistogram)
-     *   return value
+     *   yield* Metric.update(durationStringHistogram, "250")
+     *   return yield* Metric.value(durationStringHistogram)
      * })
+     *
+     * const value = await Effect.runPromise(Effect.provideService(program, Metric.MetricRegistry, new Map()))
+     * const values = [value.count, value.sum] // => [1, 250]
      * ```
      *
-     * @category mapping
+     * @category annotations
      * @since 2.0.0
      */
     <Input, Input2 extends Input>(f: (input: Input2, context: Context.Context<never>) => Input): <State>(self: Metric<Input, State>) => Metric<Input2, State>;
@@ -2865,36 +2757,30 @@ export declare const mapInput: {
      *
      * **Example** (Mapping metric inputs)
      *
-     * ```ts
-     * import { Data, Effect, Metric } from "effect"
-     *
-     * class MetricError extends Data.TaggedError("MetricError")<{
-     *   readonly operation: string
-     * }> {}
+     * ```ts import.meta.vitest
+     * import { Effect, Metric } from "effect"
      *
-     * // Create a histogram that expects Duration values
      * const durationHistogram = Metric.histogram("request_duration_ms", {
      *   description: "Request duration in milliseconds",
      *   boundaries: Metric.linearBoundaries({ start: 0, width: 100, count: 10 })
      * })
      *
-     * // Transform to accept number values representing milliseconds
-     * const numberHistogram = Metric.mapInput(
+     * // Accept duration strings while recording numeric milliseconds
+     * const durationStringHistogram = Metric.mapInput(
      *   durationHistogram,
-     *   (ms: number) => ms // Direct mapping from number to expected input
+     *   (input: string) => Number(input)
      * )
      *
      * const program = Effect.gen(function*() {
-     *   // Now we can update with a plain number
-     *   yield* Metric.update(numberHistogram, 250)
-     *
-     *   // Get metric value to see the recorded state
-     *   const value = yield* Metric.value(numberHistogram)
-     *   return value
+     *   yield* Metric.update(durationStringHistogram, "250")
+     *   return yield* Metric.value(durationStringHistogram)
      * })
+     *
+     * const value = await Effect.runPromise(Effect.provideService(program, Metric.MetricRegistry, new Map()))
+     * const values = [value.count, value.sum] // => [1, 250]
      * ```
      *
-     * @category mapping
+     * @category annotations
      * @since 2.0.0
      */
     <Input, State, Input2>(self: Metric<Input, State>, f: (input: Input2, context: Context.Context<never>) => Input): Metric<Input2, State>;
@@ -2906,12 +2792,8 @@ export declare const mapInput: {
  *
  * **Example** (Ignoring inputs with a constant value)
  *
- * ```ts
- * import { Data, Effect, Metric } from "effect"
- *
- * class MetricError extends Data.TaggedError("MetricError")<{
- *   readonly operation: string
- * }> {}
+ * ```ts import.meta.vitest
+ * import { Effect, Metric } from "effect"
  *
  * // Create a counter that normally expects a number increment
  * const requestCounter = Metric.counter("total_requests", {
@@ -2930,9 +2812,12 @@ export declare const mapInput: {
  *   const value = yield* Metric.value(simpleRequestCounter)
  *   return value // Counter state will show count: 3
  * })
+ *
+ * const value = await Effect.runPromise(Effect.provideService(program, Metric.MetricRegistry, new Map()))
+ * const count = value.count // => 3
  * ```
  *
- * @category Input
+ * @category mapping
  * @since 2.0.0
  */
 export declare const withConstantInput: {
@@ -2943,12 +2828,8 @@ export declare const withConstantInput: {
      *
      * **Example** (Ignoring inputs with a constant value)
      *
-     * ```ts
-     * import { Data, Effect, Metric } from "effect"
-     *
-     * class MetricError extends Data.TaggedError("MetricError")<{
-     *   readonly operation: string
-     * }> {}
+     * ```ts import.meta.vitest
+     * import { Effect, Metric } from "effect"
      *
      * // Create a counter that normally expects a number increment
      * const requestCounter = Metric.counter("total_requests", {
@@ -2967,9 +2848,12 @@ export declare const withConstantInput: {
      *   const value = yield* Metric.value(simpleRequestCounter)
      *   return value // Counter state will show count: 3
      * })
+     *
+     * const value = await Effect.runPromise(Effect.provideService(program, Metric.MetricRegistry, new Map()))
+     * const count = value.count // => 3
      * ```
      *
-     * @category Input
+     * @category mapping
      * @since 2.0.0
      */
     <Input>(input: Input): <State>(self: Metric<Input, State>) => Metric<unknown, State>;
@@ -2980,12 +2864,8 @@ export declare const withConstantInput: {
      *
      * **Example** (Ignoring inputs with a constant value)
      *
-     * ```ts
-     * import { Data, Effect, Metric } from "effect"
-     *
-     * class MetricError extends Data.TaggedError("MetricError")<{
-     *   readonly operation: string
-     * }> {}
+     * ```ts import.meta.vitest
+     * import { Effect, Metric } from "effect"
      *
      * // Create a counter that normally expects a number increment
      * const requestCounter = Metric.counter("total_requests", {
@@ -3004,9 +2884,12 @@ export declare const withConstantInput: {
      *   const value = yield* Metric.value(simpleRequestCounter)
      *   return value // Counter state will show count: 3
      * })
+     *
+     * const value = await Effect.runPromise(Effect.provideService(program, Metric.MetricRegistry, new Map()))
+     * const count = value.count // => 3
      * ```
      *
-     * @category Input
+     * @category mapping
      * @since 2.0.0
      */
     <Input, State>(self: Metric<Input, State>, input: Input): Metric<unknown, State>;
@@ -3022,7 +2905,7 @@ export declare const withConstantInput: {
  *
  * **Example** (Applying metric attributes)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Metric } from "effect"
  *
  * const requestCounter = Metric.counter("http_requests_total", {
@@ -3055,18 +2938,17 @@ export declare const withConstantInput: {
  *   yield* Metric.update(taggedMetric, 1) // http_requests_total{service="user-api", version="v1"}
  * })
  *
- * // When taking snapshots, each attribute combination appears as a separate metric
- * const viewMetrics = Effect.gen(function*() {
- *   const snapshots = yield* Metric.snapshot
- *   for (const metric of snapshots) {
- *     if (metric.id === "http_requests_total") {
- *       console.log(`${metric.id}`, metric.attributes, metric.state)
- *     }
- *   }
+ * const result = Effect.gen(function*() {
+ *   yield* program
+ *   const get = yield* Metric.value(getRequests)
+ *   const post = yield* Metric.value(postRequests)
+ *   return [get.count, post.count] as const
  * })
+ *
+ * await Effect.runPromise(Effect.provideService(result, Metric.MetricRegistry, new Map())) // => [2, 1]
  * ```
  *
- * @category Attributes
+ * @category mapping
  * @since 4.0.0
  */
 export declare const withAttributes: {
@@ -3081,7 +2963,7 @@ export declare const withAttributes: {
      *
      * **Example** (Applying metric attributes)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Effect, Metric } from "effect"
      *
      * const requestCounter = Metric.counter("http_requests_total", {
@@ -3114,18 +2996,17 @@ export declare const withAttributes: {
      *   yield* Metric.update(taggedMetric, 1) // http_requests_total{service="user-api", version="v1"}
      * })
      *
-     * // When taking snapshots, each attribute combination appears as a separate metric
-     * const viewMetrics = Effect.gen(function*() {
-     *   const snapshots = yield* Metric.snapshot
-     *   for (const metric of snapshots) {
-     *     if (metric.id === "http_requests_total") {
-     *       console.log(`${metric.id}`, metric.attributes, metric.state)
-     *     }
-     *   }
+     * const result = Effect.gen(function*() {
+     *   yield* program
+     *   const get = yield* Metric.value(getRequests)
+     *   const post = yield* Metric.value(postRequests)
+     *   return [get.count, post.count] as const
      * })
+     *
+     * await Effect.runPromise(Effect.provideService(result, Metric.MetricRegistry, new Map())) // => [2, 1]
      * ```
      *
-     * @category Attributes
+     * @category mapping
      * @since 4.0.0
      */
     (attributes: Metric.Attributes): <Input, State>(self: Metric<Input, State>) => Metric<Input, State>;
@@ -3140,7 +3021,7 @@ export declare const withAttributes: {
      *
      * **Example** (Applying metric attributes)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Effect, Metric } from "effect"
      *
      * const requestCounter = Metric.counter("http_requests_total", {
@@ -3173,18 +3054,17 @@ export declare const withAttributes: {
      *   yield* Metric.update(taggedMetric, 1) // http_requests_total{service="user-api", version="v1"}
      * })
      *
-     * // When taking snapshots, each attribute combination appears as a separate metric
-     * const viewMetrics = Effect.gen(function*() {
-     *   const snapshots = yield* Metric.snapshot
-     *   for (const metric of snapshots) {
-     *     if (metric.id === "http_requests_total") {
-     *       console.log(`${metric.id}`, metric.attributes, metric.state)
-     *     }
-     *   }
+     * const result = Effect.gen(function*() {
+     *   yield* program
+     *   const get = yield* Metric.value(getRequests)
+     *   const post = yield* Metric.value(postRequests)
+     *   return [get.count, post.count] as const
      * })
+     *
+     * await Effect.runPromise(Effect.provideService(result, Metric.MetricRegistry, new Map())) // => [2, 1]
      * ```
      *
-     * @category Attributes
+     * @category mapping
      * @since 4.0.0
      */
     <Input, State>(self: Metric<Input, State>, attributes: Metric.Attributes): Metric<Input, State>;
@@ -3199,12 +3079,8 @@ export declare const withAttributes: {
  *
  * **Example** (Capturing metric snapshots)
  *
- * ```ts
- * import { Console, Data, Effect, Metric } from "effect"
- *
- * class SnapshotError extends Data.TaggedError("SnapshotError")<{
- *   readonly operation: string
- * }> {}
+ * ```ts import.meta.vitest
+ * import { Effect, Metric } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   // Create and update some metrics
@@ -3225,19 +3101,16 @@ export declare const withAttributes: {
  *   // Take a snapshot of all metrics
  *   const snapshots = yield* Metric.snapshot
  *
- *   // Examine the snapshots
- *   for (const snapshot of snapshots) {
- *     yield* Console.log(`Metric: ${snapshot.id}`)
- *     yield* Console.log(`Description: ${snapshot.description}`)
- *     yield* Console.log(`Type: ${snapshot.type}`)
- *     yield* Console.log(`State:`, snapshot.state)
- *   }
- *
  *   return snapshots
  * })
+ *
+ * const snapshots = await Effect.runPromise(
+ *   Effect.provideService(program, Metric.MetricRegistry, new Map())
+ * )
+ * const ids = snapshots.map((snapshot) => snapshot.id).sort() // => ["http_requests", "response_time_ms"]
  * ```
  *
- * @category Snapshotting
+ * @category snapshotting
  * @since 2.0.0
  */
 export declare const snapshot: Effect<ReadonlyArray<Metric.Snapshot>>;
@@ -3253,12 +3126,8 @@ export declare const snapshot: Effect<ReadonlyArray<Metric.Snapshot>>;
  *
  * **Example** (Dumping metrics as text)
  *
- * ```ts
- * import { Console, Data, Effect, Metric } from "effect"
- *
- * class DumpError extends Data.TaggedError("DumpError")<{
- *   readonly operation: string
- * }> {}
+ * ```ts import.meta.vitest
+ * import { Effect, Metric } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   // Create and update some metrics for demonstration
@@ -3282,20 +3151,21 @@ export declare const snapshot: Effect<ReadonlyArray<Metric.Snapshot>>;
  *
  *   // Get formatted dump of all metrics
  *   const metricsReport = yield* Metric.dump
- *   yield* Console.log("Current Metrics:")
- *   yield* Console.log(metricsReport)
- *
- *   // Output will look like a formatted table:
- *   // Name                  Description                           Type       State
- *   // http_requests_total   Total HTTP requests                   Counter    [count: 2]
- *   // response_time_ms      Current response time in milliseconds Gauge      [value: 125]
- *   // http_status_codes     Frequency of HTTP status codes       Frequency  [occurrences: 200 -> 2, 404 -> 1]
- *
  *   return metricsReport
  * })
+ *
+ * const report = await Effect.runPromise(
+ *   Effect.provideService(program, Metric.MetricRegistry, new Map())
+ * )
+ * const included = [
+ *   report.includes("http_requests_total"),
+ *   report.includes("response_time_ms"),
+ *   report.includes("http_status_codes")
+ * ]
+ * included // => [true, true, true]
  * ```
  *
- * @category Debugging
+ * @category formatting
  * @since 4.0.0
  */
 export declare const dump: Effect<string>;
@@ -3316,56 +3186,20 @@ export declare const dump: Effect<string>;
  *
  * **Example** (Capturing snapshots from a context)
  *
- * ```ts
- * import { Data, Effect, Metric } from "effect"
- *
- * class UnsafeSnapshotError extends Data.TaggedError("UnsafeSnapshotError")<{
- *   readonly operation: string
- * }> {}
- *
- * // Use unsafeSnapshot in performance-critical scenarios or internal implementations
- * const performanceMetricsExporter = Effect.gen(function*() {
- *   // Create some metrics first
- *   const requestCounter = Metric.counter("http_requests", {
- *     description: "Total HTTP requests"
- *   })
- *   const responseTime = Metric.gauge("response_time_ms", {
- *     description: "Current response time"
- *   })
+ * ```ts import.meta.vitest
+ * import { Effect, Metric } from "effect"
  *
- *   // Update metrics
+ * const requestCounter = Metric.counter("http_requests")
+ * const program = Effect.gen(function*() {
  *   yield* Metric.update(requestCounter, 1)
- *   yield* Metric.update(responseTime, 150)
- *
- *   // Get services context for unsafe operations
- *   const services = yield* Effect.context()
- *
- *   // Use snapshotUnsafe for direct, synchronous access
- *   const snapshots = Metric.snapshotUnsafe(services)
- *   const exportBatchCreatedAt = 1_700_000_000_000
- *
- *   // Process snapshots immediately (useful for exporters, debugging tools)
- *   const exportData = snapshots.map((snapshot) => ({
- *     name: snapshot.id,
- *     type: snapshot.type,
- *     value: snapshot.state,
- *     timestamp: exportBatchCreatedAt
- *   }))
- *
- *   // This is synchronous and doesn't involve Effect overhead
- *   // Useful for performance-critical metric export operations
- *   return exportData
+ *   const context = yield* Effect.context()
+ *   return Metric.snapshotUnsafe(context).map((snapshot) => snapshot.id)
  * })
  *
- * // For normal application use, prefer the safe snapshot function:
- * const safeSnapshotExample = Effect.gen(function*() {
- *   // This automatically handles the services context
- *   const snapshots = yield* Metric.snapshot
- *   return snapshots
- * })
+ * await Effect.runPromise(Effect.provideService(program, Metric.MetricRegistry, new Map())) // => ["http_requests"]
  * ```
  *
- * @category Snapshotting
+ * @category snapshotting
  * @since 4.0.0
  */
 export declare const snapshotUnsafe: (context: Context.Context<never>) => ReadonlyArray<Metric.Snapshot>;
@@ -3380,60 +3214,13 @@ export declare const snapshotUnsafe: (context: Context.Context<never>) => Readon
  *
  * **Example** (Creating boundaries from values)
  *
- * ```ts
- * import { Data, Effect, Metric } from "effect"
- *
- * class BoundaryError extends Data.TaggedError("BoundaryError")<{
- *   readonly operation: string
- * }> {}
- *
- * // Create boundaries from an array of custom values
- * const customBoundaries = Metric.boundariesFromIterable([
- *   10,
- *   25,
- *   50,
- *   100,
- *   250,
- *   500,
- *   1000
- * ])
- * console.log(customBoundaries) // [10, 25, 50, 100, 250, 500, 1000, Infinity]
- *
- * // Automatically removes duplicates and negative values
- * const messyBoundaries = Metric.boundariesFromIterable([
- *   -5,
- *   0,
- *   10,
- *   10,
- *   25,
- *   25,
- *   50,
- *   -1
- * ])
- * console.log(messyBoundaries) // [10, 25, 50, Infinity]
- *
- * // Works with any iterable (Set, generator functions, etc.)
- * const setBoundaries = Metric.boundariesFromIterable(
- *   new Set([100, 200, 300, 200, 100])
- * )
- * console.log(setBoundaries) // [100, 200, 300, Infinity]
- *
- * // Use with histogram metric
- * const responseTimeHistogram = Metric.histogram("response_times", {
- *   description: "API response time distribution",
- *   boundaries: customBoundaries
- * })
- *
- * const program = Effect.gen(function*() {
- *   yield* Metric.update(responseTimeHistogram, 75) // Goes in 50-100ms bucket
- *   yield* Metric.update(responseTimeHistogram, 150) // Goes in 100-250ms bucket
+ * ```ts import.meta.vitest
+ * import { Metric } from "effect"
  *
- *   const value = yield* Metric.value(responseTimeHistogram)
- *   return value
- * })
+ * Metric.boundariesFromIterable([-5, 0, 10, 10, 25, 50]) // => [10, 25, 50, Infinity]
  * ```
  *
- * @category boundaries
+ * @category constructors
  * @since 4.0.0
  */
 export declare const boundariesFromIterable: (iterable: Iterable<number>) => ReadonlyArray<number>;
@@ -3443,46 +3230,20 @@ export declare const boundariesFromIterable: (iterable: Iterable<number>) => Rea
  *
  * **Details**
  *
- * Generates `count - 1` finite boundaries using `start + width + index` for
+ * Generates `count - 1` candidate boundaries using `start + index * width` for
  * each zero-based index, then applies the same normalization as
  * `boundariesFromIterable`: non-positive values are removed, duplicates are
  * collapsed, and `Infinity` is appended.
  *
  * **Example** (Creating linear boundaries)
  *
- * ```ts
- * import { Data, Effect, Metric } from "effect"
- *
- * class BoundaryError extends Data.TaggedError("BoundaryError")<{
- *   readonly operation: string
- * }> {}
- *
- * // Create boundaries for response time histogram
- * const responseBoundaries = Metric.linearBoundaries({
- *   start: 0, // Starting point
- *   width: 100, // Offset used for the first boundary
- *   count: 5 // Creates 4 boundaries + infinity
- * })
- * console.log(responseBoundaries) // [100, 101, 102, 103, Infinity]
- *
- * // Create a histogram using these boundaries
- * const responseTimeHistogram = Metric.histogram("api_response_time", {
- *   description: "API response time distribution",
- *   boundaries: responseBoundaries
- * })
- *
- * const program = Effect.gen(function*() {
- *   // Record some response times
- *   yield* Metric.update(responseTimeHistogram, 85)
- *   yield* Metric.update(responseTimeHistogram, 101)
- *   yield* Metric.update(responseTimeHistogram, 450)
+ * ```ts import.meta.vitest
+ * import { Metric } from "effect"
  *
- *   const value = yield* Metric.value(responseTimeHistogram)
- *   return value
- * })
+ * Metric.linearBoundaries({ start: 10, width: 20, count: 5 }) // => [10, 30, 50, 70, Infinity]
  * ```
  *
- * @category boundaries
+ * @category constructors
  * @since 4.0.0
  */
 export declare const linearBoundaries: (options: {
@@ -3500,47 +3261,13 @@ export declare const linearBoundaries: (options: {
  *
  * **Example** (Creating exponential boundaries)
  *
- * ```ts
- * import { Data, Effect, Metric } from "effect"
- *
- * class BoundaryError extends Data.TaggedError("BoundaryError")<{
- *   readonly operation: string
- * }> {}
- *
- * // Create exponential boundaries for request size histogram
- * // Buckets: 0-1KB, 1-2KB, 2-4KB, 4-8KB, 8KB+
- * const sizeBoundaries = Metric.exponentialBoundaries({
- *   start: 1, // Starting at 1KB
- *   factor: 2, // Each boundary doubles the previous
- *   count: 5 // Creates 4 boundaries + infinity
- * })
- * console.log(sizeBoundaries) // [1, 2, 4, 8, Infinity]
- *
- * // Create a histogram for tracking request payload sizes
- * const requestSizeHistogram = Metric.histogram("request_size_kb", {
- *   description: "Request payload size distribution in KB",
- *   boundaries: sizeBoundaries
- * })
- *
- * // For very wide ranges, use larger factors
- * const latencyBoundaries = Metric.exponentialBoundaries({
- *   start: 0.1, // Start at 0.1ms
- *   factor: 10, // Each boundary is 10x larger
- *   count: 6 // Creates ranges: 0.1ms, 1ms, 10ms, 100ms, 1000ms+
- * })
- *
- * const program = Effect.gen(function*() {
- *   // Record different request sizes
- *   yield* Metric.update(requestSizeHistogram, 1.5) // Goes in 1-2KB bucket
- *   yield* Metric.update(requestSizeHistogram, 3.2) // Goes in 2-4KB bucket
- *   yield* Metric.update(requestSizeHistogram, 12) // Goes in 8KB+ bucket
+ * ```ts import.meta.vitest
+ * import { Metric } from "effect"
  *
- *   const value = yield* Metric.value(requestSizeHistogram)
- *   return value
- * })
+ * Metric.exponentialBoundaries({ start: 1, factor: 2, count: 5 }) // => [1, 2, 4, 8, Infinity]
  * ```
  *
- * @category boundaries
+ * @category constructors
  * @since 4.0.0
  */
 export declare const exponentialBoundaries: (options: {
@@ -3553,36 +3280,13 @@ export declare const exponentialBoundaries: (options: {
  *
  * **Example** (Accessing the fiber runtime metrics key)
  *
- * ```ts
- * import { Data, Effect, Layer, Metric } from "effect"
- *
- * class MetricsError extends Data.TaggedError("MetricsError")<{
- *   readonly operation: string
- * }> {}
- *
- * const program = Effect.gen(function*() {
- *   // The key is used internally by the Effect runtime to manage fiber metrics
- *   const key = Metric.FiberRuntimeMetricsKey
- *   console.log("Fiber metrics key:", key)
- *
- *   // Enable runtime metrics using the key
- *   const layer = Layer.succeed(Metric.FiberRuntimeMetrics)(
- *     Metric.FiberRuntimeMetricsImpl
- *   )
- *
- *   return yield* Effect.gen(function*() {
- *     // This Effect will have fiber metrics automatically collected
- *     yield* Effect.sleep("100 millis")
+ * ```ts import.meta.vitest
+ * import { Metric } from "effect"
  *
- *     // Create a test counter to demonstrate the key usage
- *     const testCounter = Metric.counter("test_counter")
- *     yield* Metric.update(testCounter, 1)
- *     return yield* Metric.value(testCounter)
- *   }).pipe(Effect.provide(layer))
- * })
+ * Metric.FiberRuntimeMetricsKey // => "effect/observability/Metric/FiberRuntimeMetricsKey"
  * ```
  *
- * @category metrics
+ * @category constants
  * @since 4.0.0
  */
 export declare const FiberRuntimeMetricsKey: "effect/observability/Metric/FiberRuntimeMetricsKey";
@@ -3591,38 +3295,25 @@ export declare const FiberRuntimeMetricsKey: "effect/observability/Metric/FiberR
  *
  * **Example** (Providing a custom fiber metrics service)
  *
- * ```ts
- * import { Data, Effect, Layer, Metric } from "effect"
- * import type { Context, Exit } from "effect"
+ * ```ts import.meta.vitest
+ * import { Context, Exit, Metric } from "effect"
  *
- * class MetricsError extends Data.TaggedError("MetricsError")<{
- *   readonly operation: string
- * }> {}
- *
- * // Custom implementation of the metrics service
+ * const events: Array<string> = []
  * const customMetricsService: Metric.FiberRuntimeMetricsService = {
- *   recordFiberStart: (context: Context.Context<never>) => {
- *     console.log("Fiber started")
- *     // Custom logic for tracking fiber starts
+ *   recordFiberStart: () => {
+ *     events.push("start")
  *   },
- *   recordFiberEnd: (
- *     context: Context.Context<never>,
- *     exit: Exit.Exit<unknown, unknown>
- *   ) => {
- *     console.log("Fiber completed with exit:", exit)
- *     // Custom logic for tracking fiber completion based on exit status
+ *   recordFiberEnd: (_context, exit) => {
+ *     events.push(Exit.isSuccess(exit) ? "success" : "failure")
  *   }
  * }
  *
- * const program = Effect.gen(function*() {
- *   // Use the custom metrics service
- *   const layer = Layer.succeed(Metric.FiberRuntimeMetrics)(customMetricsService)
- *
- *   return yield* Effect.sleep("100 millis").pipe(Effect.provide(layer))
- * })
+ * customMetricsService.recordFiberStart(Context.empty())
+ * customMetricsService.recordFiberEnd(Context.empty(), Exit.succeed("ok"))
+ * events // => ["start", "success"]
  * ```
  *
- * @category metrics
+ * @category services
  * @since 4.0.0
  */
 export interface FiberRuntimeMetricsService {
@@ -3646,45 +3337,21 @@ export interface FiberRuntimeMetricsService {
  *
  * **Example** (Accessing the fiber runtime metrics service)
  *
- * ```ts
- * import { Data, Effect, Metric } from "effect"
- *
- * class MetricsError extends Data.TaggedError("MetricsError")<{
- *   readonly operation: string
- * }> {}
+ * ```ts import.meta.vitest
+ * import { Effect, Metric } from "effect"
  *
  * const program = Effect.gen(function*() {
- *   // Access the fiber runtime metrics service
  *   const metricsService = yield* Metric.FiberRuntimeMetrics
- *
- *   if (metricsService) {
- *     console.log("Runtime metrics are enabled")
- *   } else {
- *     console.log("Runtime metrics are disabled")
- *   }
- *
- *   // Enable runtime metrics for the application
- *   const enabledLayer = Metric.enableRuntimeMetricsLayer
- *
- *   return yield* Effect.gen(function*() {
- *     // Create some concurrent fibers to see metrics in action
- *     yield* Effect.all([
- *       Effect.sleep("100 millis"),
- *       Effect.sleep("200 millis"),
- *       Effect.sleep("300 millis")
- *     ], { concurrency: "unbounded" })
- *
- *     // Create test metrics to demonstrate the service
- *     const testCounter = Metric.counter("test_counter")
- *     yield* Metric.update(testCounter, 5)
- *     const counterValue = yield* Metric.value(testCounter)
- *
- *     return { counterValue, metricsEnabled: true }
- *   }).pipe(Effect.provide(enabledLayer))
+ *   return metricsService === Metric.FiberRuntimeMetricsImpl
  * })
+ *
+ * const result = await Effect.runPromise(
+ *   Effect.provideService(program, Metric.FiberRuntimeMetrics, Metric.FiberRuntimeMetricsImpl)
+ * )
+ * const isDefault = result // => true
  * ```
  *
- * @category runtime metrics
+ * @category services
  * @since 4.0.0
  */
 export declare const FiberRuntimeMetrics: Context.Reference<FiberRuntimeMetricsService | undefined>;
@@ -3693,44 +3360,16 @@ export declare const FiberRuntimeMetrics: Context.Reference<FiberRuntimeMetricsS
  *
  * **Example** (Accessing the default fiber metrics implementation)
  *
- * ```ts
- * import { Data, Effect, Layer, Metric } from "effect"
- *
- * class MetricsError extends Data.TaggedError("MetricsError")<{
- *   readonly operation: string
- * }> {}
- *
- * const program = Effect.gen(function*() {
- *   // Use the default metrics implementation
- *   const metrics = Metric.FiberRuntimeMetricsImpl
- *   console.log("Metrics implementation:", metrics)
- *
- *   // Enable runtime metrics using the default implementation
- *   const layer = Layer.succeed(Metric.FiberRuntimeMetrics)(metrics)
- *
- *   return yield* Effect.gen(function*() {
- *     // Run some Effects to trigger metric collection
- *     yield* Effect.forkChild(Effect.sleep("50 millis"))
- *     yield* Effect.forkChild(Effect.sleep("100 millis"))
- *
- *     // Wait a bit and check the metrics
- *     yield* Effect.sleep("200 millis")
- *
- *     // Create test metrics to demonstrate the implementation
- *     const testCounter = Metric.counter("test_counter")
- *     const testGauge = Metric.gauge("test_gauge")
- *     yield* Metric.update(testCounter, 3)
- *     yield* Metric.update(testGauge, 42)
- *
- *     const counterValue = yield* Metric.value(testCounter)
- *     const gaugeValue = yield* Metric.value(testGauge)
+ * ```ts import.meta.vitest
+ * import { Metric } from "effect"
  *
- *     return { counter: counterValue, gauge: gaugeValue }
- *   }).pipe(Effect.provide(layer))
- * })
+ * [
+ *   typeof Metric.FiberRuntimeMetricsImpl.recordFiberStart,
+ *   typeof Metric.FiberRuntimeMetricsImpl.recordFiberEnd
+ * ] // => ["function", "function"]
  * ```
  *
- * @category metrics
+ * @category services
  * @since 4.0.0
  */
 export declare const FiberRuntimeMetricsImpl: FiberRuntimeMetricsService;
@@ -3745,91 +3384,18 @@ export declare const FiberRuntimeMetricsImpl: FiberRuntimeMetricsService;
  *
  * **Example** (Enabling runtime metrics with a layer)
  *
- * ```ts
- * import { Console, Data, Effect, Layer, Metric } from "effect"
- *
- * class AppError extends Data.TaggedError("AppError")<{
- *   readonly operation: string
- * }> {}
- *
- * // Define your application logic
- * const userService = Effect.gen(function*() {
- *   // Simulate user operations with concurrent processing
- *   const fetchUser = (id: number) =>
- *     Effect.gen(function*() {
- *       yield* Effect.sleep(`${50 + id * 10} millis`)
- *       if (id % 7 === 0) {
- *         return yield* new AppError({ operation: `fetch-user-${id}` })
- *       }
- *       return { id, name: `User ${id}`, email: `user${id}@example.com` }
- *     })
- *
- *   // Process multiple users concurrently (ignoring failures for demo)
- *   const userIds = Array.from({ length: 10 }, (_, i) => i + 1)
- *   const userTasks = userIds.map((id) =>
- *     fetchUser(id).pipe(Effect.catchTag("AppError", () => Effect.succeed(null)))
- *   )
- *   const allUsers = yield* Effect.all(userTasks, { concurrency: 4 })
- *   const successfulUsers = allUsers.filter((user) => user !== null)
- *   return successfulUsers
- * })
- *
- * const analyticsService = Effect.gen(function*() {
- *   // Simulate analytics processing
- *   const tasks = Array.from({ length: 8 }, (_, i) =>
- *     Effect.gen(function*() {
- *       yield* Effect.sleep(`${100 + i * 25} millis`)
- *       return `Analytics task ${i} completed`
- *     }))
- *   return yield* Effect.all(tasks, { concurrency: 3 })
- * })
- *
- * // Main application that uses multiple services
- * const application = Effect.gen(function*() {
- *   yield* Console.log("Starting application with runtime metrics...")
- *
- *   // Run services concurrently
- *   const [users, analytics] = yield* Effect.all([
- *     userService,
- *     analyticsService
- *   ], { concurrency: 2 })
- *
- *   yield* Console.log(
- *     `Processed ${users.length} users and ${analytics.length} analytics tasks`
- *   )
- *
- *   // Inspect the automatically collected runtime metrics
- *   const metrics = yield* Metric.snapshot
- *   const runtimeMetrics = metrics.filter((m) => m.id.startsWith("child_fiber"))
- *
- *   yield* Console.log("Runtime Metrics Collected:")
- *   for (const metric of runtimeMetrics) {
- *     yield* Console.log(`  ${metric.id}: ${JSON.stringify(metric.state)}`)
- *   }
+ * ```ts import.meta.vitest
+ * import { Effect, Metric } from "effect"
  *
- *   return { users, analytics, metricsCount: runtimeMetrics.length }
+ * const program = Effect.gen(function*() {
+ *   const service = yield* Metric.FiberRuntimeMetrics
+ *   return service === Metric.FiberRuntimeMetricsImpl
  * })
  *
- * // Create the base application layer
- * const AppLayer = Layer.empty // Add your application layers here (database, HTTP, etc.)
- *
- * // Add runtime metrics layer at the end
- * const AppLayerWithMetrics = AppLayer.pipe(
- *   Layer.provide(Metric.enableRuntimeMetricsLayer)
- * )
- *
- * // Run the application with runtime metrics enabled
- * const program = application.pipe(
- *   Effect.provide(AppLayerWithMetrics)
- * )
- *
- * // Alternative: Provide runtime metrics directly to the application
- * const programWithDirectMetrics = application.pipe(
- *   Effect.provide(Metric.enableRuntimeMetricsLayer)
- * )
+ * await Effect.runPromise(Effect.provide(program, Metric.enableRuntimeMetricsLayer)) // => true
  * ```
  *
- * @category metrics
+ * @category layers
  * @since 4.0.0
  */
 export declare const enableRuntimeMetricsLayer: Layer.Layer<never, never, never>;
@@ -3838,12 +3404,8 @@ export declare const enableRuntimeMetricsLayer: Layer.Layer<never, never, never>
  *
  * **Example** (Disabling runtime metrics with a layer)
  *
- * ```ts
- * import { Data, Effect, Metric } from "effect"
- *
- * class MetricsError extends Data.TaggedError("MetricsError")<{
- *   readonly operation: string
- * }> {}
+ * ```ts import.meta.vitest
+ * import { Effect, Metric } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   // Disable runtime metrics collection
@@ -3852,7 +3414,6 @@ export declare const enableRuntimeMetricsLayer: Layer.Layer<never, never, never>
  *   return yield* Effect.gen(function*() {
  *     // Check that metrics service is disabled
  *     const metricsService = yield* Metric.FiberRuntimeMetrics
- *     console.log("Metrics enabled:", metricsService !== undefined) // false
  *
  *     // Run some Effects - no metrics will be collected
  *     yield* Effect.forkChild(Effect.sleep("50 millis"))
@@ -3867,9 +3428,12 @@ export declare const enableRuntimeMetricsLayer: Layer.Layer<never, never, never>
  *     return { counterValue, metricsEnabled: metricsService !== undefined }
  *   }).pipe(Effect.provide(disabledLayer))
  * })
+ *
+ * const result = await Effect.runPromise(Effect.provideService(program, Metric.MetricRegistry, new Map()))
+ * const values = [result.counterValue.count, result.metricsEnabled] // => [1, false]
  * ```
  *
- * @category metrics
+ * @category layers
  * @since 4.0.0
  */
 export declare const disableRuntimeMetricsLayer: Layer.Layer<never, never, never>;
@@ -3884,75 +3448,18 @@ export declare const disableRuntimeMetricsLayer: Layer.Layer<never, never, never
  *
  * **Example** (Enabling runtime metrics for an effect)
  *
- * ```ts
- * import { Console, Data, Effect, Layer, Metric } from "effect"
- *
- * class RuntimeMetricsError extends Data.TaggedError("RuntimeMetricsError")<{
- *   readonly operation: string
- * }> {}
+ * ```ts import.meta.vitest
+ * import { Effect, Metric } from "effect"
  *
  * const program = Effect.gen(function*() {
- *   // Create a concurrent workload to demonstrate fiber metrics
- *   const heavyWorkload = Effect.gen(function*() {
- *     // Simulate concurrent operations
- *     const tasks = Array.from({ length: 10 }, (_, i) =>
- *       Effect.gen(function*() {
- *         yield* Effect.sleep(`${100 + i * 50} millis`)
- *         if (i % 4 === 0) {
- *           // Simulate some failures
- *           return yield* new RuntimeMetricsError({ operation: `task-${i}` })
- *         }
- *         return `Task ${i} completed`
- *       }).pipe(
- *         Effect.catchTag("RuntimeMetricsError", () =>
- *           Effect.succeed(`Task ${i} failed`))
- *       ))
- *
- *     // Run tasks concurrently
- *     const results = yield* Effect.all(tasks, { concurrency: 5 })
- *     return results
- *   })
- *
- *   // Enable runtime metrics collection for our workload
- *   const workloadWithMetrics = Metric.enableRuntimeMetrics(heavyWorkload)
- *
- *   // Execute the workload
- *   const results = yield* workloadWithMetrics
- *
- *   // After execution, we can inspect the runtime metrics
- *   // The following metrics are automatically collected:
- *   // - child_fibers_active: Current number of active child fibers (Gauge)
- *   // - child_fibers_started: Total child fibers started (Counter, incremental)
- *   // - child_fiber_successes: Total successful child fibers (Counter, incremental)
- *   // - child_fiber_failures: Total failed child fibers (Counter, incremental)
- *
- *   yield* Console.log(`Workload completed with ${results.length} results`)
- *
- *   // Get all metrics including the runtime metrics
- *   const allMetrics = yield* Metric.snapshot
- *   const runtimeMetrics = allMetrics.filter((m) =>
- *     m.id.startsWith("child_fiber") || m.id.includes("fiber")
- *   )
- *
- *   yield* Console.log("Runtime Metrics:")
- *   for (const metric of runtimeMetrics) {
- *     yield* Console.log(`  ${metric.id}: ${JSON.stringify(metric.state)}`)
- *   }
- *
- *   return results
+ *   const service = yield* Metric.FiberRuntimeMetrics
+ *   return service === Metric.FiberRuntimeMetricsImpl
  * })
  *
- * // Alternative: Use the layer version for broader application coverage
- * const BaseAppLayer = Layer.empty // Your base application layers
- * const AppLayerWithMetrics = BaseAppLayer.pipe(
- *   Layer.provide(Metric.enableRuntimeMetricsLayer)
- * )
- * const programWithLayer = program.pipe(
- *   Effect.provide(AppLayerWithMetrics)
- * )
+ * await Effect.runPromise(Metric.enableRuntimeMetrics(program)) // => true
  * ```
  *
- * @category metrics
+ * @category providing services
  * @since 4.0.0
  */
 export declare const enableRuntimeMetrics: <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, R>;
@@ -3966,76 +3473,18 @@ export declare const enableRuntimeMetrics: <A, E, R>(self: Effect<A, E, R>) => E
  *
  * **Example** (Disabling runtime metrics for an effect)
  *
- * ```ts
- * import { Console, Data, Effect, Layer, Metric } from "effect"
- *
- * class DisableMetricsError extends Data.TaggedError("DisableMetricsError")<{
- *   readonly operation: string
- * }> {}
+ * ```ts import.meta.vitest
+ * import { Effect, Metric } from "effect"
  *
  * const program = Effect.gen(function*() {
- *   // This section will have runtime metrics enabled
- *   const normalOperation = Effect.gen(function*() {
- *     const tasks = Array.from({ length: 5 }, (_, i) =>
- *       Effect.gen(function*() {
- *         yield* Effect.sleep(`${100 + i * 20} millis`)
- *         return `Normal task ${i} completed`
- *       }))
- *     return yield* Effect.all(tasks, { concurrency: 3 })
- *   })
- *
- *   // This section will have runtime metrics disabled for performance
- *   const highPerformanceOperation = Metric.disableRuntimeMetrics(
- *     Effect.gen(function*() {
- *       // Performance-critical code where metrics overhead should be avoided
- *       const hotPath = Array.from(
- *         { length: 1000 },
- *         (_, i) =>
- *           Effect.gen(function*() {
- *             // Simulate intensive computation
- *             const result = i * i + (i % 10) / 10
- *             return result
- *           })
- *       )
- *       return yield* Effect.all(hotPath, { concurrency: 100 })
- *     })
- *   )
- *
- *   yield* Console.log("Running operations with selective metrics...")
- *
- *   // Run both operations
- *   const [normalResults, performanceResults] = yield* Effect.all([
- *     normalOperation, // Will generate fiber metrics
- *     highPerformanceOperation // Will NOT generate fiber metrics
- *   ])
- *
- *   // Check collected metrics - should only see metrics from normalOperation
- *   const metrics = yield* Metric.snapshot
- *   const runtimeMetrics = metrics.filter((m) => m.id.startsWith("child_fiber"))
- *
- *   yield* Console.log(`Normal operation results: ${normalResults.length}`)
- *   yield* Console.log(
- *     `Performance operation results: ${performanceResults.length}`
- *   )
- *   yield* Console.log(`Runtime metrics collected: ${runtimeMetrics.length}`)
- *
- *   // The runtime metrics will only reflect the fibers from normalOperation
- *   // The highPerformanceOperation fibers were not tracked due to disableRuntimeMetrics
- *
- *   return { normalResults, performanceResults, runtimeMetrics }
+ *   const service = yield* Metric.FiberRuntimeMetrics
+ *   return service === undefined
  * })
  *
- * // Enable runtime metrics globally, then selectively disable where needed
- * const BaseAppLayer = Layer.empty // Your base application layers
- * const AppLayerWithMetrics = BaseAppLayer.pipe(
- *   Layer.provide(Metric.enableRuntimeMetricsLayer)
- * )
- * const finalProgram = program.pipe(
- *   Effect.provide(AppLayerWithMetrics)
- * )
+ * await Effect.runPromise(Metric.disableRuntimeMetrics(program)) // => true
  * ```
  *
- * @category metrics
+ * @category providing services
  * @since 4.0.0
  */
 export declare const disableRuntimeMetrics: <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, R>;