@smthrs/observability 0.34.0 → 1.0.0-rc.3

package/dist/cjs/Metric.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Effect metric registry for flows runtime signals.
+ *
+ * @since 0.1.0
+ */
+import * as Metric from "effect/Metric";
+/**
+ * Counts flow runs that reached a terminal state.
+ *
+ * @category metrics
+ * @since 0.1.0
+ */
+export declare const runThroughput: Metric.Counter<number>;
+/**
+ * The number of execution seats currently held.
+ *
+ * @category metrics
+ * @since 0.1.0
+ */
+export declare const activeSeats: Metric.Gauge<number>;
+/**
+ * Counts runs parked because a quota was exhausted.
+ *
+ * @category metrics
+ * @since 0.1.0
+ */
+export declare const quotaParks: Metric.Counter<number>;
+/**
+ * Counts agent answers refused by their declared output schema.
+ *
+ * @category metrics
+ * @since 1.0.0-rc.1
+ */
+export declare const structuredOutputRejections: Metric.Counter<number>;
+/**
+ * Counts agent steps that failed after spending every output correction.
+ *
+ * @category metrics
+ * @since 1.0.0-rc.1
+ */
+export declare const structuredOutputExhausted: Metric.Counter<number>;
+/**
+ * Counts operational log records lost before durable delivery.
+ *
+ * Advances once per record dropped by a saturated forwarding queue, once per
+ * journal delivery failure, and once per defect the forwarding worker recovers
+ * from, so telemetry loss is distinguishable from an idle logger.
+ *
+ * @category metrics
+ * @since 1.0.0-rc.0
+ */
+export declare const droppedLogRecords: Metric.Counter<number>;
+/**
+ * All metrics declared by this package.
+ *
+ * @category registry
+ * @since 0.1.0
+ */
+export declare const registry: {
+    readonly runThroughput: Metric.Counter<number>;
+    readonly activeSeats: Metric.Gauge<number>;
+    readonly quotaParks: Metric.Counter<number>;
+    readonly structuredOutputRejections: Metric.Counter<number>;
+    readonly structuredOutputExhausted: Metric.Counter<number>;
+    readonly droppedLogRecords: Metric.Counter<number>;
+};
+//# sourceMappingURL=Metric.d.ts.map

package/dist/cjs/Metric.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Metric.d.ts","sourceRoot":"","sources":["../../src/Metric.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAIvC;;;;;GAKG;AACH,eAAO,MAAM,aAAa,wBAExB,CAAA;AAEF;;;;;GAKG;AACH,eAAO,MAAM,WAAW,sBAEtB,CAAA;AAEF;;;;;GAKG;AACH,eAAO,MAAM,UAAU,wBAErB,CAAA;AAEF;;;;;GAKG;AACH,eAAO,MAAM,0BAA0B,wBAErC,CAAA;AAEF;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB,wBAEpC,CAAA;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,iBAAiB,wBAE5B,CAAA;AAEF;;;;;GAKG;AACH,eAAO,MAAM,QAAQ;;;;;;;CAOX,CAAA"}

package/dist/cjs/Metric.js

@@ -0,0 +1,68 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Metric_exports = {};
+__export(Metric_exports, {
+  activeSeats: () => activeSeats,
+  droppedLogRecords: () => droppedLogRecords,
+  quotaParks: () => quotaParks,
+  registry: () => registry,
+  runThroughput: () => runThroughput,
+  structuredOutputExhausted: () => structuredOutputExhausted,
+  structuredOutputRejections: () => structuredOutputRejections
+});
+module.exports = __toCommonJS(Metric_exports);
+var Metric = __toESM(require("effect/Metric"), 1);
+const prefix = "flows_";
+const runThroughput = Metric.counter(`${prefix}run_throughput`, {
+  description: "Completed flow runs"
+});
+const activeSeats = Metric.gauge(`${prefix}seat_active`, {
+  description: "Currently active execution seats"
+});
+const quotaParks = Metric.counter(`${prefix}quota_park`, {
+  description: "Runs parked by quota enforcement"
+});
+const structuredOutputRejections = Metric.counter(`${prefix}agent_structured_output_rejections`, {
+  description: "Agent answers refused by their declared output schema"
+});
+const structuredOutputExhausted = Metric.counter(`${prefix}agent_structured_output_exhausted`, {
+  description: "Agent steps whose output corrections were exhausted"
+});
+const droppedLogRecords = Metric.counter(`${prefix}observability_log_dropped`, {
+  description: "Operational log records dropped before durable delivery"
+});
+const registry = {
+  runThroughput,
+  activeSeats,
+  quotaParks,
+  structuredOutputRejections,
+  structuredOutputExhausted,
+  droppedLogRecords
+};
+//# sourceMappingURL=Metric.js.map

package/dist/cjs/Metric.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/Metric.ts"],
+  "sourcesContent": ["/**\n * Effect metric registry for flows runtime signals.\n *\n * @since 0.1.0\n */\n\nimport * as Metric from \"effect/Metric\"\n\nconst prefix = \"flows_\"\n\n/**\n * Counts flow runs that reached a terminal state.\n *\n * @category metrics\n * @since 0.1.0\n */\nexport const runThroughput = Metric.counter(`${prefix}run_throughput`, {\n  description: \"Completed flow runs\"\n})\n\n/**\n * The number of execution seats currently held.\n *\n * @category metrics\n * @since 0.1.0\n */\nexport const activeSeats = Metric.gauge(`${prefix}seat_active`, {\n  description: \"Currently active execution seats\"\n})\n\n/**\n * Counts runs parked because a quota was exhausted.\n *\n * @category metrics\n * @since 0.1.0\n */\nexport const quotaParks = Metric.counter(`${prefix}quota_park`, {\n  description: \"Runs parked by quota enforcement\"\n})\n\n/**\n * Counts agent answers refused by their declared output schema.\n *\n * @category metrics\n * @since 1.0.0-rc.1\n */\nexport const structuredOutputRejections = Metric.counter(`${prefix}agent_structured_output_rejections`, {\n  description: \"Agent answers refused by their declared output schema\"\n})\n\n/**\n * Counts agent steps that failed after spending every output correction.\n *\n * @category metrics\n * @since 1.0.0-rc.1\n */\nexport const structuredOutputExhausted = Metric.counter(`${prefix}agent_structured_output_exhausted`, {\n  description: \"Agent steps whose output corrections were exhausted\"\n})\n\n/**\n * Counts operational log records lost before durable delivery.\n *\n * Advances once per record dropped by a saturated forwarding queue, once per\n * journal delivery failure, and once per defect the forwarding worker recovers\n * from, so telemetry loss is distinguishable from an idle logger.\n *\n * @category metrics\n * @since 1.0.0-rc.0\n */\nexport const droppedLogRecords = Metric.counter(`${prefix}observability_log_dropped`, {\n  description: \"Operational log records dropped before durable delivery\"\n})\n\n/**\n * All metrics declared by this package.\n *\n * @category registry\n * @since 0.1.0\n */\nexport const registry = {\n  runThroughput,\n  activeSeats,\n  quotaParks,\n  structuredOutputRejections,\n  structuredOutputExhausted,\n  droppedLogRecords\n} as const\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,aAAwB;AAExB,MAAM,SAAS;AAQR,MAAM,gBAAgB,OAAO,QAAQ,GAAG,MAAM,kBAAkB;AAAA,EACrE,aAAa;AACf,CAAC;AAQM,MAAM,cAAc,OAAO,MAAM,GAAG,MAAM,eAAe;AAAA,EAC9D,aAAa;AACf,CAAC;AAQM,MAAM,aAAa,OAAO,QAAQ,GAAG,MAAM,cAAc;AAAA,EAC9D,aAAa;AACf,CAAC;AAQM,MAAM,6BAA6B,OAAO,QAAQ,GAAG,MAAM,sCAAsC;AAAA,EACtG,aAAa;AACf,CAAC;AAQM,MAAM,4BAA4B,OAAO,QAAQ,GAAG,MAAM,qCAAqC;AAAA,EACpG,aAAa;AACf,CAAC;AAYM,MAAM,oBAAoB,OAAO,QAAQ,GAAG,MAAM,6BAA6B;AAAA,EACpF,aAAa;AACf,CAAC;AAQM,MAAM,WAAW;AAAA,EACtB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;",
+  "names": []
+}

package/dist/cjs/NodeOtel.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Node-only OTLP/HTTP OpenTelemetry setup.
+ *
+ * @since 0.1.0
+ */
+import type * as Duration from "effect/Duration";
+import * as Layer from "effect/Layer";
+import * as Endpoint from "./Endpoint.ts";
+import * as Resource from "./Resource.ts";
+import type { Configuration as ResourceConfiguration } from "./Resource.ts";
+/**
+ * Node OTLP/HTTP layer options.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export interface Options {
+    /**
+     * The collector base URL. It must be an absolute `http:` or `https:` URL
+     * without credentials and free of spaces and control characters; anything
+     * else fails layer acquisition with
+     * {@link Endpoint.InvalidExporterEndpoint}.
+     */
+    readonly endpoint: string;
+    readonly resource: ResourceConfiguration;
+    readonly shutdownTimeout?: Duration.Input | undefined;
+    readonly exportIntervalMillis?: number | undefined;
+}
+/**
+ * Builds a scoped Node OTLP/HTTP layer for all three telemetry signals.
+ * Exporter objects are created only when this layer is built.
+ * Resource metadata is explicit: ambient OTEL resource configuration cannot
+ * enlarge it after validation. The OpenTelemetry exporters still read the
+ * standard `OTEL_EXPORTER_OTLP_*` transport variables (headers, timeout,
+ * compression, TLS files) from the process environment and send them to the
+ * explicit endpoint, which always wins over `OTEL_EXPORTER_OTLP_ENDPOINT`.
+ *
+ * @category layers
+ * @since 0.1.0
+ */
+export declare const layerOtel: (options: Options) => Layer.Layer<never, Resource.InvalidResourceConfiguration | Endpoint.InvalidExporterEndpoint>;
+//# sourceMappingURL=NodeOtel.d.ts.map

package/dist/cjs/NodeOtel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeOtel.d.ts","sourceRoot":"","sources":["../../src/NodeOtel.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAUH,OAAO,KAAK,KAAK,QAAQ,MAAM,iBAAiB,CAAA;AAEhD,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AACrC,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAA;AACzC,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAA;AACzC,OAAO,KAAK,EAAE,aAAa,IAAI,qBAAqB,EAAE,MAAM,eAAe,CAAA;AAE3E;;;;;GAKG;AACH,MAAM,WAAW,OAAO;IACtB;;;;;OAKG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,QAAQ,EAAE,qBAAqB,CAAA;IACxC,QAAQ,CAAC,eAAe,CAAC,EAAE,QAAQ,CAAC,KAAK,GAAG,SAAS,CAAA;IACrD,QAAQ,CAAC,oBAAoB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CACnD;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,SAAS,GACpB,SAAS,OAAO,KACf,KAAK,CAAC,KAAK,CAAC,KAAK,EAAE,QAAQ,CAAC,4BAA4B,GAAG,QAAQ,CAAC,uBAAuB,CAmC3F,CAAA"}

package/dist/cjs/NodeOtel.js

@@ -0,0 +1,78 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var NodeOtel_exports = {};
+__export(NodeOtel_exports, {
+  layerOtel: () => layerOtel
+});
+module.exports = __toCommonJS(NodeOtel_exports);
+var NodeSdk = __toESM(require("@effect/opentelemetry/NodeSdk"), 1);
+var import_exporter_logs_otlp_http = require("@opentelemetry/exporter-logs-otlp-http");
+var import_exporter_metrics_otlp_http = require("@opentelemetry/exporter-metrics-otlp-http");
+var import_exporter_trace_otlp_http = require("@opentelemetry/exporter-trace-otlp-http");
+var import_sdk_logs = require("@opentelemetry/sdk-logs");
+var import_sdk_metrics = require("@opentelemetry/sdk-metrics");
+var import_sdk_trace_base = require("@opentelemetry/sdk-trace-base");
+var ConfigProvider = __toESM(require("effect/ConfigProvider"), 1);
+var Effect = __toESM(require("effect/Effect"), 1);
+var Layer = __toESM(require("effect/Layer"), 1);
+var Endpoint = __toESM(require("./Endpoint.js"), 1);
+var Resource = __toESM(require("./Resource.js"), 1);
+const layerOtel = (options) => Layer.unwrap(
+  Effect.map(
+    Effect.all([Resource.decode(options.resource), Endpoint.decode(options.endpoint, "endpoint")]),
+    ([decoded, endpoint]) => NodeSdk.layer(() => {
+      const resource = Resource.toOpenTelemetryConfiguration(decoded);
+      const spanProcessor = new import_sdk_trace_base.BatchSpanProcessor(
+        new import_exporter_trace_otlp_http.OTLPTraceExporter({ url: Endpoint.signalUrl(endpoint, "traces") })
+      );
+      const logRecordProcessor = new import_sdk_logs.BatchLogRecordProcessor({
+        exporter: new import_exporter_logs_otlp_http.OTLPLogExporter({ url: Endpoint.signalUrl(endpoint, "logs") })
+      });
+      const metricReader = options.exportIntervalMillis === void 0 ? new import_sdk_metrics.PeriodicExportingMetricReader({
+        exporter: new import_exporter_metrics_otlp_http.OTLPMetricExporter({ url: Endpoint.signalUrl(endpoint, "metrics") })
+      }) : new import_sdk_metrics.PeriodicExportingMetricReader({
+        exporter: new import_exporter_metrics_otlp_http.OTLPMetricExporter({ url: Endpoint.signalUrl(endpoint, "metrics") }),
+        exportIntervalMillis: options.exportIntervalMillis
+      });
+      return {
+        resource,
+        spanProcessor,
+        logRecordProcessor,
+        metricReader,
+        shutdownTimeout: options.shutdownTimeout
+      };
+    }).pipe(
+      // NodeSdk merges Resource.layerFromEnv after our admission check.
+      // Isolate that lookup so only the validated explicit resource and
+      // the SDK metadata already included in its budget reach exporters.
+      Layer.provide(ConfigProvider.layer(ConfigProvider.fromUnknown({})))
+    )
+  )
+);
+//# sourceMappingURL=NodeOtel.js.map

package/dist/cjs/NodeOtel.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/NodeOtel.ts"],
+  "sourcesContent": ["/**\n * Node-only OTLP/HTTP OpenTelemetry setup.\n *\n * @since 0.1.0\n */\n\nimport * as NodeSdk from \"@effect/opentelemetry/NodeSdk\"\nimport { OTLPLogExporter } from \"@opentelemetry/exporter-logs-otlp-http\"\nimport { OTLPMetricExporter } from \"@opentelemetry/exporter-metrics-otlp-http\"\nimport { OTLPTraceExporter } from \"@opentelemetry/exporter-trace-otlp-http\"\nimport { BatchLogRecordProcessor } from \"@opentelemetry/sdk-logs\"\nimport { PeriodicExportingMetricReader } from \"@opentelemetry/sdk-metrics\"\nimport { BatchSpanProcessor } from \"@opentelemetry/sdk-trace-base\"\nimport * as ConfigProvider from \"effect/ConfigProvider\"\nimport type * as Duration from \"effect/Duration\"\nimport * as Effect from \"effect/Effect\"\nimport * as Layer from \"effect/Layer\"\nimport * as Endpoint from \"./Endpoint.ts\"\nimport * as Resource from \"./Resource.ts\"\nimport type { Configuration as ResourceConfiguration } from \"./Resource.ts\"\n\n/**\n * Node OTLP/HTTP layer options.\n *\n * @category models\n * @since 0.1.0\n */\nexport interface Options {\n  /**\n   * The collector base URL. It must be an absolute `http:` or `https:` URL\n   * without credentials and free of spaces and control characters; anything\n   * else fails layer acquisition with\n   * {@link Endpoint.InvalidExporterEndpoint}.\n   */\n  readonly endpoint: string\n  readonly resource: ResourceConfiguration\n  readonly shutdownTimeout?: Duration.Input | undefined\n  readonly exportIntervalMillis?: number | undefined\n}\n\n/**\n * Builds a scoped Node OTLP/HTTP layer for all three telemetry signals.\n * Exporter objects are created only when this layer is built.\n * Resource metadata is explicit: ambient OTEL resource configuration cannot\n * enlarge it after validation. The OpenTelemetry exporters still read the\n * standard `OTEL_EXPORTER_OTLP_*` transport variables (headers, timeout,\n * compression, TLS files) from the process environment and send them to the\n * explicit endpoint, which always wins over `OTEL_EXPORTER_OTLP_ENDPOINT`.\n *\n * @category layers\n * @since 0.1.0\n */\nexport const layerOtel = (\n  options: Options\n): Layer.Layer<never, Resource.InvalidResourceConfiguration | Endpoint.InvalidExporterEndpoint> =>\n  Layer.unwrap(\n    Effect.map(\n      Effect.all([Resource.decode(options.resource), Endpoint.decode(options.endpoint, \"endpoint\")]),\n      ([decoded, endpoint]) =>\n        NodeSdk.layer(() => {\n          const resource = Resource.toOpenTelemetryConfiguration(decoded)\n          const spanProcessor = new BatchSpanProcessor(\n            new OTLPTraceExporter({ url: Endpoint.signalUrl(endpoint, \"traces\") })\n          )\n          const logRecordProcessor = new BatchLogRecordProcessor({\n            exporter: new OTLPLogExporter({ url: Endpoint.signalUrl(endpoint, \"logs\") })\n          })\n          const metricReader = options.exportIntervalMillis === undefined\n            ? new PeriodicExportingMetricReader({\n              exporter: new OTLPMetricExporter({ url: Endpoint.signalUrl(endpoint, \"metrics\") })\n            })\n            : new PeriodicExportingMetricReader({\n              exporter: new OTLPMetricExporter({ url: Endpoint.signalUrl(endpoint, \"metrics\") }),\n              exportIntervalMillis: options.exportIntervalMillis\n            })\n          return {\n            resource,\n            spanProcessor,\n            logRecordProcessor,\n            metricReader,\n            shutdownTimeout: options.shutdownTimeout\n          }\n        }).pipe(\n          // NodeSdk merges Resource.layerFromEnv after our admission check.\n          // Isolate that lookup so only the validated explicit resource and\n          // the SDK metadata already included in its budget reach exporters.\n          Layer.provide(ConfigProvider.layer(ConfigProvider.fromUnknown({})))\n        )\n    )\n  )\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,cAAyB;AACzB,qCAAgC;AAChC,wCAAmC;AACnC,sCAAkC;AAClC,sBAAwC;AACxC,yBAA8C;AAC9C,4BAAmC;AACnC,qBAAgC;AAEhC,aAAwB;AACxB,YAAuB;AACvB,eAA0B;AAC1B,eAA0B;AAkCnB,MAAM,YAAY,CACvB,YAEA,MAAM;AAAA,EACJ,OAAO;AAAA,IACL,OAAO,IAAI,CAAC,SAAS,OAAO,QAAQ,QAAQ,GAAG,SAAS,OAAO,QAAQ,UAAU,UAAU,CAAC,CAAC;AAAA,IAC7F,CAAC,CAAC,SAAS,QAAQ,MACjB,QAAQ,MAAM,MAAM;AAClB,YAAM,WAAW,SAAS,6BAA6B,OAAO;AAC9D,YAAM,gBAAgB,IAAI;AAAA,QACxB,IAAI,kDAAkB,EAAE,KAAK,SAAS,UAAU,UAAU,QAAQ,EAAE,CAAC;AAAA,MACvE;AACA,YAAM,qBAAqB,IAAI,wCAAwB;AAAA,QACrD,UAAU,IAAI,+CAAgB,EAAE,KAAK,SAAS,UAAU,UAAU,MAAM,EAAE,CAAC;AAAA,MAC7E,CAAC;AACD,YAAM,eAAe,QAAQ,yBAAyB,SAClD,IAAI,iDAA8B;AAAA,QAClC,UAAU,IAAI,qDAAmB,EAAE,KAAK,SAAS,UAAU,UAAU,SAAS,EAAE,CAAC;AAAA,MACnF,CAAC,IACC,IAAI,iDAA8B;AAAA,QAClC,UAAU,IAAI,qDAAmB,EAAE,KAAK,SAAS,UAAU,UAAU,SAAS,EAAE,CAAC;AAAA,QACjF,sBAAsB,QAAQ;AAAA,MAChC,CAAC;AACH,aAAO;AAAA,QACL;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA,iBAAiB,QAAQ;AAAA,MAC3B;AAAA,IACF,CAAC,EAAE;AAAA;AAAA;AAAA;AAAA,MAID,MAAM,QAAQ,eAAe,MAAM,eAAe,YAAY,CAAC,CAAC,CAAC,CAAC;AAAA,IACpE;AAAA,EACJ;AACF;",
+  "names": []
+}

package/dist/cjs/Otel.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Provider-neutral composition for injected OpenTelemetry providers.
+ *
+ * @since 0.1.0
+ */
+import * as OtelMetrics from "@effect/opentelemetry/OtelMetrics";
+import type * as Api from "@opentelemetry/api";
+import type { LoggerProvider } from "@opentelemetry/sdk-logs";
+import type { MetricReader } from "@opentelemetry/sdk-metrics";
+import * as Layer from "effect/Layer";
+import { type Configuration as ResourceConfiguration, type InvalidResourceConfiguration, Resource } from "./Resource.ts";
+/**
+ * Injected providers used by the provider-neutral OTEL layer.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export interface Options {
+    /** Validated resource for metrics, tracer scope, and provider factories. */
+    readonly resource: ResourceConfiguration;
+    /**
+     * Borrowed: the layer bridges onto this provider and never flushes or shuts
+     * it down, including a provider a factory returns. Existing providers retain
+     * their resource. Factories must pass the supplied resource to the SDK.
+     */
+    readonly tracerProvider?: Api.TracerProvider | ((resource: typeof Resource.Service) => Api.TracerProvider) | undefined;
+    /** Borrowed on the same terms as `tracerProvider`. */
+    readonly loggerProvider?: LoggerProvider | ((resource: typeof Resource.Service) => LoggerProvider) | undefined;
+    /**
+     * Owned: the factory runs once during layer acquisition, after resource
+     * validation, and every reader it returns is shut down when the scope
+     * closes. Build the readers inside the factory rather than returning one a
+     * longer-lived composition still exports through, which that shutdown would
+     * disable. An empty array registers no reader at all.
+     */
+    readonly metricReader?: (() => MetricReader | ReadonlyArray<MetricReader>) | undefined;
+    readonly loggerMergeWithExisting?: boolean | undefined;
+    readonly metricTemporality?: OtelMetrics.TemporalityPreference | undefined;
+}
+/**
+ * Composes Effect tracer, logger, and metric bridges from already-created
+ * OpenTelemetry providers or provider factories, and from metric readers this
+ * layer acquires. Factories run during layer acquisition after resource
+ * validation, and the provider factories receive the metric resource.
+ * Already-created providers keep the resource captured at construction; the
+ * resource option only sets metrics and tracer instrumentation scope for them.
+ * Ownership splits: callers own provider flushing and shutdown, including
+ * factory-built providers, while the layer scope shuts down every reader the
+ * `metricReader` factory returned. No exporter is allocated by this module.
+ *
+ * @category layers
+ * @since 0.1.0
+ */
+export declare const layerOtel: (options: Options) => Layer.Layer<never, InvalidResourceConfiguration>;
+/**
+ * A no-op OTEL layer for callers that want an explicit optional slot.
+ *
+ * @category layers
+ * @since 0.1.0
+ */
+export declare const layerNoop: Layer.Layer<never>;
+//# sourceMappingURL=Otel.d.ts.map

package/dist/cjs/Otel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Otel.d.ts","sourceRoot":"","sources":["../../src/Otel.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,WAAW,MAAM,mCAAmC,CAAA;AAEhE,OAAO,KAAK,KAAK,GAAG,MAAM,oBAAoB,CAAA;AAC9C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAA;AAC7D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAA;AAE9D,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AACrC,OAAO,EACL,KAAK,aAAa,IAAI,qBAAqB,EAC3C,KAAK,4BAA4B,EAEjC,QAAQ,EACT,MAAM,eAAe,CAAA;AAEtB;;;;;GAKG;AACH,MAAM,WAAW,OAAO;IACtB,4EAA4E;IAC5E,QAAQ,CAAC,QAAQ,EAAE,qBAAqB,CAAA;IACxC;;;;OAIG;IACH,QAAQ,CAAC,cAAc,CAAC,EACpB,GAAG,CAAC,cAAc,GAClB,CAAC,CAAC,QAAQ,EAAE,OAAO,QAAQ,CAAC,OAAO,KAAK,GAAG,CAAC,cAAc,CAAC,GAC3D,SAAS,CAAA;IACb,sDAAsD;IACtD,QAAQ,CAAC,cAAc,CAAC,EACpB,cAAc,GACd,CAAC,CAAC,QAAQ,EAAE,OAAO,QAAQ,CAAC,OAAO,KAAK,cAAc,CAAC,GACvD,SAAS,CAAA;IACb;;;;;;OAMG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,CAAC,MAAM,YAAY,GAAG,aAAa,CAAC,YAAY,CAAC,CAAC,GAAG,SAAS,CAAA;IACtF,QAAQ,CAAC,uBAAuB,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;IACtD,QAAQ,CAAC,iBAAiB,CAAC,EAAE,WAAW,CAAC,qBAAqB,GAAG,SAAS,CAAA;CAC3E;AAED;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,SAAS,GAAI,SAAS,OAAO,KAAG,KAAK,CAAC,KAAK,CAAC,KAAK,EAAE,4BAA4B,CAsC3F,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,SAAS,EAAE,KAAK,CAAC,KAAK,CAAC,KAAK,CAAe,CAAA"}

package/dist/cjs/Otel.js

@@ -0,0 +1,75 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Otel_exports = {};
+__export(Otel_exports, {
+  layerNoop: () => layerNoop,
+  layerOtel: () => layerOtel
+});
+module.exports = __toCommonJS(Otel_exports);
+var OtelLogger = __toESM(require("@effect/opentelemetry/OtelLogger"), 1);
+var OtelMetrics = __toESM(require("@effect/opentelemetry/OtelMetrics"), 1);
+var OtelTracer = __toESM(require("@effect/opentelemetry/OtelTracer"), 1);
+var Effect = __toESM(require("effect/Effect"), 1);
+var Layer = __toESM(require("effect/Layer"), 1);
+var import_Resource = require("./Resource.js");
+const layerOtel = (options) => {
+  const resource = (0, import_Resource.layer)(options.resource);
+  const tracerProvider = options.tracerProvider;
+  const loggerProvider = options.loggerProvider;
+  const tracer = tracerProvider === void 0 ? Layer.empty : Layer.provide(
+    OtelTracer.layer,
+    Layer.effect(
+      OtelTracer.OtelTracerProvider,
+      Effect.map(
+        import_Resource.Resource,
+        (resource2) => typeof tracerProvider === "function" ? tracerProvider(resource2) : tracerProvider
+      )
+    )
+  );
+  const logger = loggerProvider === void 0 ? Layer.empty : Layer.provide(
+    OtelLogger.layer({ mergeWithExisting: options.loggerMergeWithExisting }),
+    Layer.effect(
+      OtelLogger.OtelLoggerProvider,
+      Effect.map(
+        import_Resource.Resource,
+        (resource2) => typeof loggerProvider === "function" ? loggerProvider(resource2) : loggerProvider
+      )
+    )
+  );
+  const acquireMetricReader = options.metricReader;
+  const metrics = acquireMetricReader === void 0 ? Layer.empty : OtelMetrics.layer(
+    () => acquireMetricReader(),
+    {
+      temporality: options.metricTemporality
+    }
+  );
+  return Layer.mergeAll(tracer, logger, metrics).pipe(Layer.provideMerge(resource));
+};
+const layerNoop = Layer.empty;
+//# sourceMappingURL=Otel.js.map

package/dist/cjs/Otel.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/Otel.ts"],
+  "sourcesContent": ["/**\n * Provider-neutral composition for injected OpenTelemetry providers.\n *\n * @since 0.1.0\n */\n\nimport * as OtelLogger from \"@effect/opentelemetry/OtelLogger\"\nimport * as OtelMetrics from \"@effect/opentelemetry/OtelMetrics\"\nimport * as OtelTracer from \"@effect/opentelemetry/OtelTracer\"\nimport type * as Api from \"@opentelemetry/api\"\nimport type { LoggerProvider } from \"@opentelemetry/sdk-logs\"\nimport type { MetricReader } from \"@opentelemetry/sdk-metrics\"\nimport * as Effect from \"effect/Effect\"\nimport * as Layer from \"effect/Layer\"\nimport {\n  type Configuration as ResourceConfiguration,\n  type InvalidResourceConfiguration,\n  layer as resourceLayer,\n  Resource\n} from \"./Resource.ts\"\n\n/**\n * Injected providers used by the provider-neutral OTEL layer.\n *\n * @category models\n * @since 0.1.0\n */\nexport interface Options {\n  /** Validated resource for metrics, tracer scope, and provider factories. */\n  readonly resource: ResourceConfiguration\n  /**\n   * Borrowed: the layer bridges onto this provider and never flushes or shuts\n   * it down, including a provider a factory returns. Existing providers retain\n   * their resource. Factories must pass the supplied resource to the SDK.\n   */\n  readonly tracerProvider?:\n    | Api.TracerProvider\n    | ((resource: typeof Resource.Service) => Api.TracerProvider)\n    | undefined\n  /** Borrowed on the same terms as `tracerProvider`. */\n  readonly loggerProvider?:\n    | LoggerProvider\n    | ((resource: typeof Resource.Service) => LoggerProvider)\n    | undefined\n  /**\n   * Owned: the factory runs once during layer acquisition, after resource\n   * validation, and every reader it returns is shut down when the scope\n   * closes. Build the readers inside the factory rather than returning one a\n   * longer-lived composition still exports through, which that shutdown would\n   * disable. An empty array registers no reader at all.\n   */\n  readonly metricReader?: (() => MetricReader | ReadonlyArray<MetricReader>) | undefined\n  readonly loggerMergeWithExisting?: boolean | undefined\n  readonly metricTemporality?: OtelMetrics.TemporalityPreference | undefined\n}\n\n/**\n * Composes Effect tracer, logger, and metric bridges from already-created\n * OpenTelemetry providers or provider factories, and from metric readers this\n * layer acquires. Factories run during layer acquisition after resource\n * validation, and the provider factories receive the metric resource.\n * Already-created providers keep the resource captured at construction; the\n * resource option only sets metrics and tracer instrumentation scope for them.\n * Ownership splits: callers own provider flushing and shutdown, including\n * factory-built providers, while the layer scope shuts down every reader the\n * `metricReader` factory returned. No exporter is allocated by this module.\n *\n * @category layers\n * @since 0.1.0\n */\nexport const layerOtel = (options: Options): Layer.Layer<never, InvalidResourceConfiguration> => {\n  const resource = resourceLayer(options.resource)\n  const tracerProvider = options.tracerProvider\n  const loggerProvider = options.loggerProvider\n  const tracer = tracerProvider === undefined\n    ? Layer.empty\n    : Layer.provide(\n      OtelTracer.layer,\n      Layer.effect(\n        OtelTracer.OtelTracerProvider,\n        Effect.map(\n          Resource,\n          (resource) => typeof tracerProvider === \"function\" ? tracerProvider(resource) : tracerProvider\n        )\n      )\n    )\n  const logger = loggerProvider === undefined\n    ? Layer.empty\n    : Layer.provide(\n      OtelLogger.layer({ mergeWithExisting: options.loggerMergeWithExisting }),\n      Layer.effect(\n        OtelLogger.OtelLoggerProvider,\n        Effect.map(\n          Resource,\n          (resource) => typeof loggerProvider === \"function\" ? loggerProvider(resource) : loggerProvider\n        )\n      )\n    )\n  const acquireMetricReader = options.metricReader\n  const metrics = acquireMetricReader === undefined\n    ? Layer.empty\n    : OtelMetrics.layer(\n      () => acquireMetricReader() as unknown as MetricReader | readonly [MetricReader, ...Array<MetricReader>],\n      {\n        temporality: options.metricTemporality\n      }\n    )\n  return Layer.mergeAll(tracer, logger, metrics).pipe(Layer.provideMerge(resource))\n}\n\n/**\n * A no-op OTEL layer for callers that want an explicit optional slot.\n *\n * @category layers\n * @since 0.1.0\n */\nexport const layerNoop: Layer.Layer<never> = Layer.empty\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,iBAA4B;AAC5B,kBAA6B;AAC7B,iBAA4B;AAI5B,aAAwB;AACxB,YAAuB;AACvB,sBAKO;AAmDA,MAAM,YAAY,CAAC,YAAuE;AAC/F,QAAM,eAAW,gBAAAA,OAAc,QAAQ,QAAQ;AAC/C,QAAM,iBAAiB,QAAQ;AAC/B,QAAM,iBAAiB,QAAQ;AAC/B,QAAM,SAAS,mBAAmB,SAC9B,MAAM,QACN,MAAM;AAAA,IACN,WAAW;AAAA,IACX,MAAM;AAAA,MACJ,WAAW;AAAA,MACX,OAAO;AAAA,QACL;AAAA,QACA,CAACC,cAAa,OAAO,mBAAmB,aAAa,eAAeA,SAAQ,IAAI;AAAA,MAClF;AAAA,IACF;AAAA,EACF;AACF,QAAM,SAAS,mBAAmB,SAC9B,MAAM,QACN,MAAM;AAAA,IACN,WAAW,MAAM,EAAE,mBAAmB,QAAQ,wBAAwB,CAAC;AAAA,IACvE,MAAM;AAAA,MACJ,WAAW;AAAA,MACX,OAAO;AAAA,QACL;AAAA,QACA,CAACA,cAAa,OAAO,mBAAmB,aAAa,eAAeA,SAAQ,IAAI;AAAA,MAClF;AAAA,IACF;AAAA,EACF;AACF,QAAM,sBAAsB,QAAQ;AACpC,QAAM,UAAU,wBAAwB,SACpC,MAAM,QACN,YAAY;AAAA,IACZ,MAAM,oBAAoB;AAAA,IAC1B;AAAA,MACE,aAAa,QAAQ;AAAA,IACvB;AAAA,EACF;AACF,SAAO,MAAM,SAAS,QAAQ,QAAQ,OAAO,EAAE,KAAK,MAAM,aAAa,QAAQ,CAAC;AAClF;AAQO,MAAM,YAAgC,MAAM;",
+  "names": ["resourceLayer", "resource"]
+}

package/dist/cjs/Otlp.d.ts

@@ -0,0 +1,200 @@
+/**
+ * Default OTLP export wiring for flows telemetry.
+ *
+ * The store packages already open spans through Effect's tracer and update
+ * `Metric` counters on their hot paths; what they deliberately do not do is
+ * ship an exporter. This module is that exporter: one layer that installs
+ * Effect's own OTLP logger, metrics exporter, and tracer
+ * (`effect/unstable/observability/Otlp`) against a collector endpoint, with
+ * the flows service identity filled in. Nothing beyond `effect` is involved;
+ * no OpenTelemetry SDK dependency.
+ *
+ * Browser support is met by construction rather than by a no-op variant:
+ * export happens over Effect's `HttpClient`, and {@link layerFetch} binds the
+ * `fetch` implementation the host already has, so no entry point here ever
+ * resolves a `node:` built-in. See the
+ * {@link https://smithers.sh/docs/reference/api/observability | observability API contract}.
+ *
+ * @since 0.1.0
+ */
+import type * as Duration from "effect/Duration";
+import * as Layer from "effect/Layer";
+import * as Headers from "effect/unstable/http/Headers";
+import * as HttpClient from "effect/unstable/http/HttpClient";
+import * as Endpoint from "./Endpoint.ts";
+import * as Resource from "./Resource.ts";
+/**
+ * The `service.name` resource attribute installed when the caller supplies
+ * none: the flows distribution itself. Override it per application with
+ * {@link Options.serviceName}.
+ *
+ * @category resource
+ * @since 0.1.0
+ */
+export declare const defaultServiceName = "flows";
+/**
+ * The `service.version` resource attribute installed when the caller supplies
+ * none. Mirrors the release version in this package's `package.json`.
+ *
+ * A published package cannot read its own manifest on every runtime it
+ * supports, so the version lives here as a literal.
+ * `scripts/set-release-version.mjs` rewrites this declaration with the
+ * manifests, and its `--check` mode reports drift, so a release bump cannot
+ * leave it behind.
+ *
+ * @category resource
+ * @since 0.1.0
+ */
+export declare const defaultServiceVersion = "1.0.0-rc.3";
+/**
+ * Maximum encoded export request size, in bytes.
+ * @category transport
+ * @since 1.0.0-rc.0
+ */
+export declare const maxRequestBytes: number;
+/**
+ * Reserved bytes for request wrappers and the escaped instrumentation scope.
+ * @category transport
+ * @since 1.0.0-rc.0
+ */
+export declare const maximumEnvelopeBytes: number;
+/**
+ * Bytes of every export request kept free for the signal batch itself.
+ *
+ * The transport discards a request over 1 MiB, and the resource rides in every
+ * request, so the largest resource `Resource.decode` admits
+ * (`Resource.maximumResourceBytes`, 128 KiB) and the envelope that repeats the
+ * service name (under 8 KiB) come off the top. The 888 KiB left gives each
+ * record of a full 1,000-record logger or tracer batch about 900 bytes, three
+ * to four times a bare log record or span, and gives the metrics snapshot room
+ * for several thousand series. Every resource the decoder accepts therefore
+ * leaves an ordinary batch of any signal exportable; what this reserve does
+ * not bound is a single application record or a registry large enough to
+ * exceed it on its own.
+ *
+ * @category transport
+ * @since 1.0.0-rc.0
+ */
+export declare const reservedBatchBytes: number;
+/**
+ * Configuration for the default OTLP wiring.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export interface Options {
+    /**
+     * The collector base URL, for example `http://localhost:4318`. Signals are
+     * posted below it at `/v1/logs`, `/v1/metrics`, and `/v1/traces`. It must be
+     * an absolute `http://` or `https://` URL without credentials, a query,
+     * fragment, backslashes, spaces, or controls. A base path is allowed. Invalid
+     * values fail acquisition with {@link Endpoint.InvalidExporterEndpoint}.
+     * Use {@link Options.headers} for authentication.
+     */
+    readonly baseUrl: string;
+    /** Overrides {@link defaultServiceName} as the `service.name` attribute. */
+    readonly serviceName?: string | undefined;
+    /** Overrides {@link defaultServiceVersion} as the `service.version` attribute. */
+    readonly serviceVersion?: string | undefined;
+    /**
+     * Additional resource attributes attached to every exported signal, decoded
+     * by `Resource.Attributes`. The whole resource must encode to at most
+     * `Resource.maximumResourceBytes`; a larger one fails acquisition with
+     * {@link Resource.InvalidResourceConfiguration} rather than making every
+     * request oversized.
+     */
+    readonly attributes?: Record<string, unknown> | undefined;
+    /**
+     * Headers sent with every export request, for example vendor auth. A header
+     * whose name names a credential (`authorization`, `x-api-key`, anything
+     * `Redaction.isSensitiveKey` recognizes, plus `x-honeycomb-team`) requires
+     * an `https://` baseUrl unless the host is loopback; otherwise acquisition
+     * fails with
+     * {@link Endpoint.InvalidExporterEndpoint}.
+     */
+    readonly headers?: Headers.Input | undefined;
+    /** Export cadence for all three signals; each signal's Effect default applies when omitted. */
+    readonly exportInterval?: Duration.Input | undefined;
+    /** Upper bound on the shutdown flush when the layer's scope closes. */
+    readonly shutdownTimeout?: Duration.Input | undefined;
+}
+/**
+ * Creates the OTLP logs, metrics, and traces layer with flows resource
+ * defaults, JSON-serialized. Exports share a four-request limit with no waiting
+ * queue. Requests larger than 1 MiB or stalled for ten seconds are discarded;
+ * `flows_observability_otlp_dropped` counts discarded batches, and at most
+ * once a minute a `Warn` record with code `otlp_export_discarded` names the
+ * reason, the request size, and the running total through the loggers that
+ * were installed when the layer was acquired, never through this exporter.
+ *
+ * **Details**
+ *
+ * The layer still requires an `HttpClient`, which is how it stays
+ * platform-neutral: a Node host may hand it `@effect/platform-node`'s Undici
+ * client (re-exported by `@smthrs/platform-node`), a browser or test
+ * hands it something else. Use {@link layerFetch} when the host's global
+ * `fetch` is good enough. On Node 26 and every browser it is.
+ * Fetch redirects are refused. Supply `FetchHttpClient.RequestInit` around
+ * the whole exporting effect to retain other fetch options; options scoped
+ * only to the supplied client's layer are replaced by the redirect policy.
+ * Other HTTP transports must independently refuse automatic redirects.
+ *
+ * @category layers
+ * @since 0.1.0
+ */
+export declare const layer: (options: Options) => Layer.Layer<never, Resource.InvalidResourceConfiguration | Endpoint.InvalidExporterEndpoint, HttpClient.HttpClient>;
+/**
+ * Provides {@link layer} over the host's global `fetch`, the default wiring
+ * for a Node host, and browser-safe by construction because it never touches
+ * a `node:` built-in.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import * as Otlp from "@smthrs/observability/Otlp"
+ *
+ * const Telemetry = Otlp.layerFetch({ baseUrl: "http://localhost:4318" })
+ * ```
+ *
+ * @category layers
+ * @since 0.1.0
+ */
+export declare const layerFetch: (options: Options) => Layer.Layer<never, Resource.InvalidResourceConfiguration | Endpoint.InvalidExporterEndpoint>;
+/**
+ * Why an OTLP layer refused to start.
+ *
+ * @category errors
+ * @since 1.0.0
+ */
+export type LayerError = Resource.InvalidResourceConfiguration | Endpoint.InvalidExporterEndpoint;
+/**
+ * Parses `OTEL_EXPORTER_OTLP_HEADERS`: comma-separated `key=value` pairs whose
+ * values are percent-decoded, as the OpenTelemetry exporter specification
+ * defines. A pair without `=` or with an empty key is skipped.
+ *
+ * @category environment
+ * @since 1.0.0
+ */
+export declare const parseHeaders: (value: string | undefined) => Record<string, string>;
+/**
+ * {@link layerFetch} when the environment names a collector, otherwise
+ * {@link layerNoop}.
+ *
+ * `OTEL_EXPORTER_OTLP_ENDPOINT` is the collector base URL and
+ * `OTEL_EXPORTER_OTLP_HEADERS` the headers sent with every export. An unset or
+ * empty endpoint installs no exporter at all.
+ *
+ * @category layers
+ * @since 1.0.0
+ */
+export declare const layerEnvironment: (environment: Readonly<Record<string, string | undefined>>, options?: Omit<Options, "baseUrl" | "headers">) => Layer.Layer<never, LayerError>;
+/**
+ * Exports nothing. The explicit stand-in for hosts with no collector, such as
+ * a development shell, a test, or a browser deployment that has not opted in, so
+ * wiring code can switch layers rather than branch.
+ *
+ * @category layers
+ * @since 0.1.0
+ */
+export declare const layerNoop: Layer.Layer<never>;
+//# sourceMappingURL=Otlp.d.ts.map