effect 4.0.0-beta.101 → 4.0.0-beta.103

package/src/Metric.ts

@@ -19,6 +19,7 @@ import type { Exit } from "./Exit.ts"
 import { constUndefined, dual } from "./Function.ts"
 import * as InternalEffect from "./internal/effect.ts"
 import * as InternalMetric from "./internal/metric.ts"
+import * as InternalRecord from "./internal/record.ts"
 import * as Layer from "./Layer.ts"
 import * as Order from "./Order.ts"
 import type { Pipeable } from "./Pipeable.ts"
@@ -48,12 +49,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
@@ -99,6 +96,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
@@ -127,12 +131,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
@@ -178,9 +178,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>> {}
@@ -190,12 +193,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
@@ -220,7 +219,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
@@ -240,9 +238,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> {
@@ -261,32 +262,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
@@ -323,14 +308,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> {}
@@ -340,12 +327,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
@@ -393,7 +376,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(
@@ -413,9 +395,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 {
@@ -432,12 +418,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
@@ -467,7 +449,6 @@ export interface FrequencyState {
  *   const diskState: Metric.GaugeState<bigint> = yield* Metric.value(
  *     diskSpaceGauge
  *   )
- *
  *   // Gauge state contains:
  *   // - value: current instantaneous value
  *
@@ -476,9 +457,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>> {}
@@ -488,12 +472,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
@@ -529,7 +509,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)
  *
@@ -545,9 +524,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> {
@@ -564,14 +547,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
@@ -579,7 +556,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
  *     }
  *   )
  *
@@ -612,7 +589,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
@@ -636,9 +612,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> {}
@@ -648,18 +628,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
@@ -706,7 +682,6 @@ export interface Histogram<Input> extends Metric<Input, HistogramState> {}
  *   }
  *
  *   const bucketAnalysis = analyzeBuckets(state.buckets)
- *
  *   return {
  *     responseTime: {
  *       totalRequests: state.count, // 5
@@ -723,9 +698,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 {
@@ -747,12 +727,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
@@ -811,7 +787,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
@@ -829,9 +804,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> {}
@@ -841,12 +820,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
@@ -889,7 +864,6 @@ export interface Summary<Input> extends Metric<Input, SummaryState> {}
  *   }
  *
  *   const quantileValues = extractQuantiles(state.quantiles)
- *
  *   return {
  *     latencyAnalysis: {
  *       totalRequests: state.count, // 7
@@ -911,9 +885,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 {
@@ -930,12 +909,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
@@ -965,6 +940,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
@@ -975,78 +953,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
    */
   export type Type = "Counter" | "Frequency" | "Gauge" | "Histogram" | "Summary"
@@ -1056,12 +984,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
@@ -1110,19 +1034,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
    */
   export type Attributes = AttributeSet | ReadonlyArray<[string, string]>
@@ -1132,12 +1059,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
@@ -1198,9 +1121,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
    */
   export type AttributeSet = Readonly<Record<string, string>>
@@ -1210,7 +1136,7 @@ export declare namespace Metric {
    *
    * **Example** (Extracting metric input types)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Metric } from "effect"
    *
    * // Create various metric types
@@ -1248,9 +1174,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
    */
   export type Input<A> = A extends Metric<infer _Input, infer _State> ? _Input
@@ -1261,7 +1189,7 @@ export declare namespace Metric {
    *
    * **Example** (Extracting metric state types)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Effect, Metric } from "effect"
    *
    * // Create various metric types
@@ -1299,7 +1227,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 }
@@ -1308,9 +1235,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
    */
   export type State<A> = A extends Metric<infer _Input, infer _State> ? _State
@@ -1321,12 +1252,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
@@ -1354,9 +1281,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
    */
   export interface Hooks<in Input, out State> {
@@ -1370,12 +1300,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
@@ -1420,9 +1346,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
    */
   export interface Metadata<in Input, out State> {
@@ -1438,12 +1367,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
@@ -1493,9 +1418,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
    */
   export interface SnapshotProto<T extends Type, State> {
@@ -1511,12 +1439,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
@@ -1570,9 +1494,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
    */
   export type Snapshot =
@@ -1588,12 +1515,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
@@ -1627,9 +1550,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 const CurrentMetricAttributesKey = "effect/Metric/CurrentMetricAttributes" as const
@@ -1651,17 +1577,12 @@ export const CurrentMetricAttributesKey = "effect/Metric/CurrentMetricAttributes
  *
  * **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" }
@@ -1676,9 +1597,12 @@ export const CurrentMetricAttributesKey = "effect/Metric/CurrentMetricAttributes
  *
  *   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 const CurrentMetricAttributes = Context.Reference<Metric.AttributeSet>(CurrentMetricAttributesKey, {
@@ -1710,7 +1634,7 @@ const MetricRegistryKey = "~effect/observability/Metric/MetricRegistryKey"
  * @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 const MetricRegistry = Context.Reference<Map<string, Metric.Metadata<any, any>>>(
@@ -1912,7 +1836,7 @@ class HistogramMetric extends Metric$<number, HistogramState> {
     let count = 0
     let sum = 0
     let min = Number.MAX_VALUE
-    let max = Number.MIN_VALUE
+    let max = -Number.MAX_VALUE
 
     Arr.map(Arr.sort(bounds, Order.Number), (n, i) => {
       boundaries[i] = n
@@ -1999,7 +1923,7 @@ class SummaryMetric extends Metric$<readonly [value: number, timestamp: number],
     let count = 0
     let sum = 0
     let min = Number.MAX_VALUE
-    let max = Number.MIN_VALUE
+    let max = -Number.MAX_VALUE
 
     const snapshot = (now: number): ReadonlyArray<[number, number | undefined]> => {
       const builder: Array<number> = []
@@ -2021,8 +1945,8 @@ class SummaryMetric extends Metric$<readonly [value: number, timestamp: number],
         return sortedQuantiles.map((q) => [q, undefined])
       }
       // Compute the value of the quantile in terms of rank:
-      // > For a given quantile `q`, return the maximum value `v` such that at
-      // > most `q * n` values are less than or equal to `v`.
+      // For a given quantile `q`, return the maximum value `v` such that at
+      // most `q * n` values are less than or equal to `v`.
       return sortedQuantiles.map((q) => {
         if (q <= 0) return [q, samples[0]]
         if (q >= 1) return [q, samples[sampleSize - 1]]
@@ -2094,24 +2018,18 @@ class MetricTransform<in Input, out State, in Input2> extends Metric$<Input2, St
  *
  * **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 const isMetric = (u: unknown): u is Metric<unknown, never> =>
-  Predicate.hasProperty(u, "~effect/Metric") && u["~effect/Metric"] === "~effect/Metric"
+export const isMetric = (u: unknown): u is Metric<never, unknown> =>
+  Predicate.hasProperty(u, TypeId) && u[TypeId] === TypeId
 
 /**
  * Represents a Counter metric that tracks cumulative numerical values over
@@ -2127,12 +2045,8 @@ export 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
@@ -2166,6 +2080,9 @@ export 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
@@ -2186,12 +2103,8 @@ export 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
@@ -2225,6 +2138,9 @@ export 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
@@ -2253,12 +2169,8 @@ export 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
@@ -2292,6 +2204,9 @@ export 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
@@ -2325,12 +2240,8 @@ export 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
@@ -2369,6 +2280,9 @@ export 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
@@ -2392,12 +2306,8 @@ export 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
@@ -2436,6 +2346,9 @@ export 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
@@ -2466,12 +2379,8 @@ export 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
@@ -2510,6 +2419,9 @@ export 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
@@ -2542,12 +2454,8 @@ export 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
@@ -2597,6 +2505,14 @@ export 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
@@ -2624,19 +2540,15 @@ export 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
@@ -2676,6 +2588,10 @@ export 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
@@ -2705,12 +2621,8 @@ export 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
@@ -2746,24 +2658,16 @@ export 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
@@ -2803,7 +2707,7 @@ export const summary = (name: string, options: {
  *
  * **Example** (Creating summaries with explicit timestamps)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Metric } from "effect"
  *
  * const responseTimesSummary = Metric.summaryWithTimestamp(
@@ -2815,6 +2719,7 @@ export 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
@@ -2842,12 +2747,8 @@ export 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", {
@@ -2861,13 +2762,17 @@ export 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
@@ -2900,10 +2805,10 @@ export 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]
  * })
@@ -2915,16 +2820,19 @@ export 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
@@ -2951,7 +2859,7 @@ export const value = <Input, State>(
  *
  * **Example** (Modifying metric values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Metric } from "effect"
  *
  * const temperatureGauge = Metric.gauge("temperature")
@@ -2971,10 +2879,10 @@ export const value = <Input, State>(
  *
  *   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
@@ -2994,7 +2902,7 @@ export const modify: {
    *
    * **Example** (Modifying metric values)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Effect, Metric } from "effect"
    *
    * const temperatureGauge = Metric.gauge("temperature")
@@ -3014,10 +2922,10 @@ export 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
@@ -3037,7 +2945,7 @@ export const modify: {
    *
    * **Example** (Modifying metric values)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Effect, Metric } from "effect"
    *
    * const temperatureGauge = Metric.gauge("temperature")
@@ -3057,10 +2965,10 @@ export 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
@@ -3081,7 +2989,7 @@ export const modify: {
    *
    * **Example** (Modifying metric values)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Effect, Metric } from "effect"
    *
    * const temperatureGauge = Metric.gauge("temperature")
@@ -3101,10 +3009,10 @@ export 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
@@ -3124,7 +3032,7 @@ export const modify: {
    *
    * **Example** (Modifying metric values)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Effect, Metric } from "effect"
    *
    * const temperatureGauge = Metric.gauge("temperature")
@@ -3144,10 +3052,10 @@ export 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
@@ -3173,7 +3081,7 @@ export const modify: {
  *
  * **Example** (Updating metric values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Metric } from "effect"
  *
  * const cpuUsage = Metric.gauge("cpu_usage_percent")
@@ -3201,11 +3109,10 @@ export 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
@@ -3225,7 +3132,7 @@ export const update: {
    *
    * **Example** (Updating metric values)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Effect, Metric } from "effect"
    *
    * const cpuUsage = Metric.gauge("cpu_usage_percent")
@@ -3253,11 +3160,10 @@ export 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
@@ -3277,7 +3183,7 @@ export const update: {
    *
    * **Example** (Updating metric values)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Effect, Metric } from "effect"
    *
    * const cpuUsage = Metric.gauge("cpu_usage_percent")
@@ -3305,11 +3211,10 @@ export 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
@@ -3330,7 +3235,7 @@ export const update: {
    *
    * **Example** (Updating metric values)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Effect, Metric } from "effect"
    *
    * const cpuUsage = Metric.gauge("cpu_usage_percent")
@@ -3358,11 +3263,10 @@ export 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
@@ -3382,7 +3286,7 @@ export const update: {
    *
    * **Example** (Updating metric values)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Effect, Metric } from "effect"
    *
    * const cpuUsage = Metric.gauge("cpu_usage_percent")
@@ -3410,11 +3314,10 @@ export 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
@@ -3434,36 +3337,30 @@ export 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 const mapInput: {
@@ -3474,36 +3371,30 @@ export 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>
@@ -3514,36 +3405,30 @@ export 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>(
@@ -3558,36 +3443,30 @@ export 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>,
@@ -3598,36 +3477,30 @@ export 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>(
@@ -3652,12 +3525,8 @@ export 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", {
@@ -3676,9 +3545,12 @@ export 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 const withConstantInput: {
@@ -3689,12 +3561,8 @@ export 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", {
@@ -3713,9 +3581,12 @@ export 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>
@@ -3726,12 +3597,8 @@ export 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", {
@@ -3750,9 +3617,12 @@ export 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>
@@ -3764,12 +3634,8 @@ export 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", {
@@ -3788,9 +3654,12 @@ export 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>,
@@ -3801,12 +3670,8 @@ export 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", {
@@ -3825,9 +3690,12 @@ export 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>
@@ -3844,7 +3712,7 @@ export const withConstantInput: {
  *
  * **Example** (Applying metric attributes)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Metric } from "effect"
  *
  * const requestCounter = Metric.counter("http_requests_total", {
@@ -3877,18 +3745,17 @@ export 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 const withAttributes: {
@@ -3903,7 +3770,7 @@ export const withAttributes: {
    *
    * **Example** (Applying metric attributes)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Effect, Metric } from "effect"
    *
    * const requestCounter = Metric.counter("http_requests_total", {
@@ -3936,18 +3803,17 @@ export 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>
@@ -3962,7 +3828,7 @@ export const withAttributes: {
    *
    * **Example** (Applying metric attributes)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Effect, Metric } from "effect"
    *
    * const requestCounter = Metric.counter("http_requests_total", {
@@ -3995,18 +3861,17 @@ export 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>
@@ -4022,7 +3887,7 @@ export const withAttributes: {
    *
    * **Example** (Applying metric attributes)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Effect, Metric } from "effect"
    *
    * const requestCounter = Metric.counter("http_requests_total", {
@@ -4055,18 +3920,17 @@ export 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>,
@@ -4081,7 +3945,7 @@ export const withAttributes: {
    *
    * **Example** (Applying metric attributes)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Effect, Metric } from "effect"
    *
    * const requestCounter = Metric.counter("http_requests_total", {
@@ -4114,18 +3978,17 @@ export 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>
@@ -4152,12 +4015,8 @@ export 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
@@ -4178,19 +4037,16 @@ export 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 const snapshot: Effect<ReadonlyArray<Metric.Snapshot>> = InternalEffect.map(
@@ -4210,12 +4066,8 @@ export const snapshot: Effect<ReadonlyArray<Metric.Snapshot>> = InternalEffect.m
  *
  * **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
@@ -4239,20 +4091,21 @@ export const snapshot: Effect<ReadonlyArray<Metric.Snapshot>> = InternalEffect.m
  *
  *   // 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 const dump: Effect<string> = InternalEffect.flatMap(InternalEffect.context(), (context) => {
@@ -4307,56 +4160,20 @@ export const dump: Effect<string> = InternalEffect.flatMap(InternalEffect.contex
  *
  * **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 const snapshotUnsafe = (context: Context.Context<never>): ReadonlyArray<Metric.Snapshot> => {
@@ -4439,60 +4256,13 @@ const attributesToString = (attributes: Metric.AttributeSet): string => {
  *
  * **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 const boundariesFromIterable = (iterable: Iterable<number>): ReadonlyArray<number> =>
@@ -4504,46 +4274,20 @@ export const boundariesFromIterable = (iterable: Iterable<number>): ReadonlyArra
  *
  * **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 const linearBoundaries = (options: {
@@ -4551,7 +4295,7 @@ export const linearBoundaries = (options: {
   readonly width: number
   readonly count: number
 }): ReadonlyArray<number> =>
-  boundariesFromIterable(Arr.makeBy(options.count - 1, (n) => options.start + n + options.width))
+  boundariesFromIterable(Arr.makeBy(options.count - 1, (n) => options.start + n * options.width))
 
 /**
  * Creates histogram bucket boundaries with exponentially increasing values.
@@ -4563,47 +4307,13 @@ export 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 const exponentialBoundaries = (options: {
@@ -4636,36 +4346,13 @@ const fiberFailures = counter("child_fiber_failures", {
  *
  * **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 const FiberRuntimeMetricsKey: "effect/observability/Metric/FiberRuntimeMetricsKey" =
@@ -4676,38 +4363,25 @@ export const FiberRuntimeMetricsKey: "effect/observability/Metric/FiberRuntimeMe
  *
  * **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 {
@@ -4732,50 +4406,26 @@ 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 const FiberRuntimeMetrics = Context.Reference<FiberRuntimeMetricsService | undefined>(
   InternalMetric.FiberRuntimeMetricsKey,
-  { defaultValue: constUndefined }
+  { fiberCached: true, defaultValue: constUndefined }
 )
 
 /**
@@ -4783,44 +4433,16 @@ export const FiberRuntimeMetrics = Context.Reference<FiberRuntimeMetricsService
  *
  * **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 const FiberRuntimeMetricsImpl: FiberRuntimeMetricsService = {
@@ -4849,91 +4471,18 @@ export 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 const enableRuntimeMetricsLayer = Layer.succeed(FiberRuntimeMetrics)(FiberRuntimeMetricsImpl)
@@ -4943,12 +4492,8 @@ export const enableRuntimeMetricsLayer = Layer.succeed(FiberRuntimeMetrics)(Fibe
  *
  * **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
@@ -4957,7 +4502,6 @@ export const enableRuntimeMetricsLayer = Layer.succeed(FiberRuntimeMetrics)(Fibe
  *   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"))
@@ -4972,9 +4516,12 @@ export const enableRuntimeMetricsLayer = Layer.succeed(FiberRuntimeMetrics)(Fibe
  *     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 const disableRuntimeMetricsLayer = Layer.succeed(FiberRuntimeMetrics)(undefined)
@@ -4990,75 +4537,18 @@ export const disableRuntimeMetricsLayer = Layer.succeed(FiberRuntimeMetrics)(und
  *
  * **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 const enableRuntimeMetrics: <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, R> = InternalEffect.provideService(
@@ -5076,76 +4566,18 @@ export const enableRuntimeMetrics: <A, E, R>(self: Effect<A, E, R>) => Effect<A,
  *
  * **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 const disableRuntimeMetrics: <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, R> = InternalEffect.provideService(
@@ -5178,11 +4610,7 @@ function makeHooks<Input, State>(
 }
 
 function serializeAttributes(attributes: Metric.Attributes): string {
-  return serializeEntries(Array.isArray(attributes) ? attributes : Object.entries(attributes))
-}
-
-function serializeEntries(entries: ReadonlyArray<[string, string]>): string {
-  return entries.map(([key, value]) => `${key}=${value}`).join(",")
+  return JSON.stringify(Array.isArray(attributes) ? attributes : Object.entries(attributes))
 }
 
 function mergeAttributes(
@@ -5195,7 +4623,7 @@ function mergeAttributes(
 function attributesToRecord(attributes?: Metric.Attributes): Metric.AttributeSet | undefined {
   if (Predicate.isNotUndefined(attributes) && Array.isArray(attributes)) {
     return attributes.reduce((acc, [key, value]) => {
-      acc[key] = value
+      InternalRecord.assignProperty(acc, key, value)
       return acc
     }, {} as Metric.AttributeSet)
   }