@equipe-tech/observability 0.2.0 → 0.3.5

package/dist/contract/TelemetryEvent.js

@@ -0,0 +1,54 @@
+import { DateTime, Option, Schema } from "effect";
+export const EventSeverity = Schema.Literals(["debug", "info", "warn", "error", "fatal"]);
+export const EventOutcome = Schema.Literals(["success", "failure", "cancelled"]);
+export const EventKind = Schema.Literals(["request", "operation", "domain", "defect", "audit"]);
+export const HttpContext = Schema.Struct({
+    method: Schema.NonEmptyString,
+    route: Schema.NonEmptyString,
+    statusCode: Schema.Int.check(Schema.makeFilter((statusCode) => statusCode >= 100 && statusCode <= 599, {
+        expected: "an HTTP status code from 100 to 599",
+    })),
+});
+export const ErrorContext = Schema.Struct({
+    type: Schema.NonEmptyString,
+    message: Schema.String,
+    retryable: Schema.Boolean,
+});
+export const maxOtlpUnixTimestampMillis = 18_446_744_073_709;
+const rfc3339UtcPattern = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.\d{1,9})?Z$/;
+const isLeapYear = (year) => year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+const daysInMonth = (year, month) => {
+    if (month === 2) {
+        return isLeapYear(year) ? 29 : 28;
+    }
+    return [4, 6, 9, 11].includes(month) ? 30 : 31;
+};
+const isValidTimestamp = (timestamp) => {
+    const parts = rfc3339UtcPattern.exec(timestamp);
+    if (parts === null) {
+        return false;
+    }
+    const year = Number(parts[1]);
+    const month = Number(parts[2]);
+    const day = Number(parts[3]);
+    const hour = Number(parts[4]);
+    const minute = Number(parts[5]);
+    const second = Number(parts[6]);
+    const milliseconds = Date.parse(timestamp);
+    return (month >= 1 &&
+        month <= 12 &&
+        day >= 1 &&
+        day <= daysInMonth(year, month) &&
+        hour <= 23 &&
+        minute <= 59 &&
+        second <= 59 &&
+        Option.isSome(DateTime.make(timestamp)) &&
+        milliseconds >= 0 &&
+        milliseconds <= maxOtlpUnixTimestampMillis);
+};
+export const EventTimestamp = Schema.String.check(Schema.makeFilter(isValidTimestamp, {
+    expected: `an RFC 3339 UTC timestamp from 1970-01-01T00:00:00.000Z through ${new Date(maxOtlpUnixTimestampMillis).toISOString()}`,
+})).pipe(Schema.brand("EventTimestamp"));
+export const EventDuration = Schema.Finite.check(Schema.makeFilter((durationMs) => durationMs >= 0, {
+    expected: "a finite non-negative duration",
+})).pipe(Schema.brand("EventDuration"));

package/dist/contract/index.d.ts

@@ -0,0 +1,11 @@
+export * from "./ContractCompatibility.js";
+export * from "./ContractIndex.js";
+export * from "./ContractSurface.js";
+export * from "./EventName.js";
+export * from "./EventProducer.js";
+export * from "./MetricContractError.js";
+export * from "./MetricProducer.js";
+export * from "./OrganizationEvents.js";
+export * from "./TelemetryContract.js";
+export * from "./TelemetryContractError.js";
+export * from "./TelemetryEvent.js";

package/dist/contract/index.js

@@ -0,0 +1,11 @@
+export * from "./ContractCompatibility.js";
+export * from "./ContractIndex.js";
+export * from "./ContractSurface.js";
+export * from "./EventName.js";
+export * from "./EventProducer.js";
+export * from "./MetricContractError.js";
+export * from "./MetricProducer.js";
+export * from "./OrganizationEvents.js";
+export * from "./TelemetryContract.js";
+export * from "./TelemetryContractError.js";
+export * from "./TelemetryEvent.js";

package/dist/effect/WideEvent.d.ts

@@ -0,0 +1,3 @@
+import { Effect } from "effect";
+import type { EventAttributes } from "../contract/TelemetryEvent.js";
+export declare const emit: (name: string, fields: EventAttributes) => Effect.Effect<void>;

package/dist/effect/WideEvent.js

@@ -0,0 +1,20 @@
+import { Effect } from "effect";
+import { sanitizeEventName } from "../policy/BrowserFieldPolicy.js";
+import { CurrentDataPolicy } from "../policy/DataPolicy.js";
+import { transformSignalFields } from "../policy/PolicyTransform.js";
+import { effectDroppedAttributesKey } from "../policy/PolicyVocabulary.js";
+export const emit = (name, fields) => Effect.flatMap(CurrentDataPolicy, (policy) => {
+    const applicationFields = { ...fields };
+    delete applicationFields["event.name"];
+    delete applicationFields["event.kind"];
+    const eventName = sanitizeEventName(name);
+    const decision = transformSignalFields(policy, "log", {
+        "event.name": eventName,
+        "event.kind": "wide",
+        ...applicationFields,
+    });
+    return Effect.logInfo(eventName).pipe(Effect.annotateLogs({
+        ...decision.value,
+        [effectDroppedAttributesKey]: decision.dropped,
+    }));
+});

package/dist/effect/WideEventSink.d.ts

@@ -0,0 +1,3 @@
+import { Layer } from "effect";
+import { TelemetryEventSink } from "../contract/EventProducer.js";
+export declare const layerWideEvent: Layer.Layer<TelemetryEventSink>;

package/dist/effect/WideEventSink.js

@@ -0,0 +1,79 @@
+import { Effect, Layer, Option, Tracer } from "effect";
+import { TelemetryEventSink } from "../contract/EventProducer.js";
+import * as WideEvent from "./WideEvent.js";
+const fieldsForEvent = (event) => {
+    const fields = {
+        "event.type": event.kind,
+        "event.severity": event.severity,
+        "event.outcome": event.outcome,
+        "event.timestamp": event.timestamp,
+    };
+    for (const [name, value] of Object.entries(event.attributes)) {
+        fields[name] = value;
+    }
+    if (Option.isSome(event.correlation.requestId)) {
+        fields["request.id"] = event.correlation.requestId.value;
+    }
+    if (Option.isSome(event.correlation.runId)) {
+        fields["run.id"] = event.correlation.runId.value;
+    }
+    switch (event.kind) {
+        case "request":
+            fields["event.duration_ms"] = event.durationMs;
+            fields["http.request.method"] = event.http.method;
+            fields["http.route"] = event.http.route;
+            fields["http.response.status_code"] = event.http.statusCode;
+            break;
+        case "operation":
+            fields["event.duration_ms"] = event.durationMs;
+            break;
+        case "defect":
+            fields["error.type"] = event.error.type;
+            fields["error.message"] = event.error.message;
+            fields["error.retryable"] = event.error.retryable;
+            break;
+        case "audit":
+            fields["event.outcome"] = event.outcome === "success" ? "success" : "failure";
+            fields["audit.outcome"] = event.outcome;
+            fields["audit.action"] = event.audit.action;
+            fields["audit.actor.kind"] = event.audit.actor.kind;
+            fields["audit.actor.id"] =
+                event.audit.actor.kind === "system" ? "system" : event.audit.actor.id;
+            fields["audit.resource.type"] = event.audit.resourceType;
+            fields["audit.resource.id"] = event.audit.resourceId;
+            if (event.audit.reasonCode !== undefined)
+                fields["audit.reason_code"] = event.audit.reasonCode;
+            break;
+    }
+    return fields;
+};
+export const layerWideEvent = Layer.succeed(TelemetryEventSink, TelemetryEventSink.of({
+    record: (event, admission) => WideEvent.emit(event.name, {
+        ...fieldsForEvent(event),
+        "event.policy_dropped_attributes": admission.policyDroppedAttributes,
+    }),
+    admitBrowserBatch: (events) => Effect.succeed({
+        commit: Effect.forEach(events, (event) => {
+            const fields = {
+                ...event.attributes,
+                "event.source": "browser",
+                "event.outcome": event.error === undefined ? "success" : "failure",
+                "browser.event.id": event.id,
+                "browser.event.occurred_at": event.occurredAt,
+                "event.policy_dropped_attributes": event.admission.policyDroppedAttributes,
+            };
+            if (event.error !== undefined) {
+                fields["error.type"] = event.error.type;
+                fields["error.message"] = event.error.message;
+                fields["error.retryable"] = event.error.retryable;
+            }
+            const emission = WideEvent.emit(event.name, fields);
+            return event.trace === undefined
+                ? emission
+                : emission.pipe(Effect.withParentSpan(Tracer.externalSpan({
+                    traceId: event.trace.traceId,
+                    spanId: event.trace.spanId,
+                })));
+        }, { discard: true }),
+    }),
+}));

package/dist/effect/index.d.ts

@@ -0,0 +1,2 @@
+export * as WideEvent from "./WideEvent.js";
+export { layerWideEvent } from "./WideEventSink.js";

package/dist/effect/index.js

@@ -0,0 +1,2 @@
+export * as WideEvent from "./WideEvent.js";
+export { layerWideEvent } from "./WideEventSink.js";

package/dist/index.d.ts

@@ -1,4 +1,19 @@
 export * as BrowserEvents from "./BrowserEvents.js";
+export * from "./audit/index.js";
+export * as Contract from "./contract/index.js";
+export { CorrelationContext, CorrelationField, CurrentCorrelation, generateRunId, InvalidCorrelationContext, parseRequestId, parseRunId, parseSpanId, parseTraceId, RequestId, RunId, SpanId, TraceId, TraceLinkage, withBackgroundCorrelation, withCorrelation, } from "./Correlation.js";
+export { defineTelemetryContract, validateContractEvent } from "./contract/TelemetryContract.js";
+export type { BrowserTelemetryEvent, EventPayloadOf, EventProducer, EventAdmissionMetadata, EmitReceipt, } from "./contract/EventProducer.js";
+export { makeEventProducer, TelemetryEventSink } from "./contract/EventProducer.js";
+export { makeMetricProducer } from "./contract/MetricProducer.js";
+export type { ContractCounter, ContractGaugeObservation, ContractHistogram, MetricAttributesOf, MetricAttributeValueOf, MetricProducer, } from "./contract/MetricProducer.js";
+export { InvalidMetricMeasurement } from "./contract/MetricContractError.js";
+export type { MetricMeasurementErrorCode } from "./contract/MetricContractError.js";
+export type { AuditActionDefinition, AuditActionDefinitionInput, TelemetryContract, TelemetryContractInput, } from "./contract/TelemetryContract.js";
+export type { EventAttributes, TelemetryEvent } from "./contract/TelemetryEvent.js";
 export * as Telemetry from "./Telemetry.js";
-export { InvalidTelemetryEnvironment, TelemetryConfig, telemetryConfigFromEnv, } from "./TelemetryConfig.js";
-export * as WideEvent from "./WideEvent.js";
+export * from "./profile/index.js";
+export * from "./policy/index.js";
+export { EnvironmentAliasPolicy, EnvironmentName, InvalidResourceIdentity, instanceResourceAttributes, parseResourceIdentity, ResourceIdentity, ResourceIdentityField, ServiceInstanceId, ServiceName, serviceNamespace, serviceResourceAttributes, ServiceVersion, } from "./ResourceIdentity.js";
+export type { ResourceAttributes, ResourceIdentityInput } from "./ResourceIdentity.js";
+export { InvalidTelemetryEnvironment, OtlpEndpoint, TelemetryConfig, telemetryConfigFromEnv, } from "./TelemetryConfig.js";

package/dist/index.js

@@ -1,4 +1,13 @@
 export * as BrowserEvents from "./BrowserEvents.js";
+export * from "./audit/index.js";
+export * as Contract from "./contract/index.js";
+export { CorrelationContext, CorrelationField, CurrentCorrelation, generateRunId, InvalidCorrelationContext, parseRequestId, parseRunId, parseSpanId, parseTraceId, RequestId, RunId, SpanId, TraceId, TraceLinkage, withBackgroundCorrelation, withCorrelation, } from "./Correlation.js";
+export { defineTelemetryContract, validateContractEvent } from "./contract/TelemetryContract.js";
+export { makeEventProducer, TelemetryEventSink } from "./contract/EventProducer.js";
+export { makeMetricProducer } from "./contract/MetricProducer.js";
+export { InvalidMetricMeasurement } from "./contract/MetricContractError.js";
 export * as Telemetry from "./Telemetry.js";
-export { InvalidTelemetryEnvironment, TelemetryConfig, telemetryConfigFromEnv, } from "./TelemetryConfig.js";
-export * as WideEvent from "./WideEvent.js";
+export * from "./profile/index.js";
+export * from "./policy/index.js";
+export { EnvironmentAliasPolicy, EnvironmentName, InvalidResourceIdentity, instanceResourceAttributes, parseResourceIdentity, ResourceIdentity, ResourceIdentityField, ServiceInstanceId, ServiceName, serviceNamespace, serviceResourceAttributes, ServiceVersion, } from "./ResourceIdentity.js";
+export { InvalidTelemetryEnvironment, OtlpEndpoint, TelemetryConfig, telemetryConfigFromEnv, } from "./TelemetryConfig.js";

package/dist/metrics/InstrumentGrammar.d.ts

@@ -0,0 +1,5 @@
+export declare const instrumentNamePattern: RegExp;
+export declare const unitPattern: RegExp;
+export declare const maximumMetricAttributes = 16;
+export declare const maximumMetricAttributeCardinality = 100;
+export declare const containsControlCharacter: (value: string) => boolean;

package/dist/metrics/InstrumentGrammar.js

@@ -0,0 +1,12 @@
+export const instrumentNamePattern = /^[A-Za-z][A-Za-z0-9_.\-/]{0,254}$/;
+export const unitPattern = /^(?:1|%|[A-Za-z][A-Za-z0-9]*(?:[./*^][A-Za-z0-9]+)*)$/;
+export const maximumMetricAttributes = 16;
+export const maximumMetricAttributeCardinality = 100;
+export const containsControlCharacter = (value) => {
+    for (const character of value) {
+        const codePoint = character.codePointAt(0);
+        if (codePoint !== undefined && (codePoint <= 31 || codePoint === 127))
+            return true;
+    }
+    return false;
+};

package/dist/metrics/MetricScalar.d.ts

@@ -0,0 +1,3 @@
+import type { MetricAttributeValue } from "../Metrics.js";
+export declare const isFiniteMetricScalar: (value: MetricAttributeValue) => boolean;
+export declare const metricScalarIdentity: (value: MetricAttributeValue) => string;

package/dist/metrics/MetricScalar.js

@@ -0,0 +1,5 @@
+import { Predicate, Schema } from "effect";
+const metricScalarSchema = Schema.Union([Schema.String, Schema.Number, Schema.Boolean]);
+const isMetricScalar = Schema.is(metricScalarSchema);
+export const isFiniteMetricScalar = (value) => isMetricScalar(value) && (!Predicate.isNumber(value) || Number.isFinite(value));
+export const metricScalarIdentity = (value) => `${Predicate.isString(value) ? "string" : Predicate.isNumber(value) ? "number" : "boolean"}:${String(value)}`;

package/dist/node/AuditDigest.d.ts

@@ -0,0 +1,3 @@
+import { Layer } from "effect";
+import { AuditDigest } from "../audit/AuditDigest.js";
+export declare const layerNodeAuditDigest: Layer.Layer<AuditDigest, never, never>;

package/dist/node/AuditDigest.js

@@ -0,0 +1,6 @@
+import { createHash } from "node:crypto";
+import { Effect, Layer, Schema } from "effect";
+import { AuditDigest, AuditHash } from "../audit/AuditDigest.js";
+export const layerNodeAuditDigest = Layer.succeed(AuditDigest, AuditDigest.of({
+    hash: (payload) => Effect.sync(() => Schema.decodeUnknownSync(AuditHash)(createHash("sha256").update(payload).digest("hex"))),
+}));

package/dist/node/BrowserEventIngest.d.ts

@@ -1,5 +1,6 @@
 import { Effect, Schema } from "effect";
 import { BrowserEventBatch } from "../BrowserEvents.js";
+import { TelemetryEventSink } from "../contract/EventProducer.js";
 declare const InvalidBrowserEventBatch_base: Schema.Class<InvalidBrowserEventBatch, Schema.TaggedStruct<"InvalidBrowserEventBatch", {
     readonly code: Schema.Literal<"OBS_BROWSER_EVENTS_INVALID_BATCH">;
     readonly message: Schema.String;
@@ -10,7 +11,11 @@ export declare class InvalidBrowserEventBatch extends InvalidBrowserEventBatch_b
 export declare const parseBrowserEventBatch: (input: unknown, options?: import("effect/SchemaAST").ParseOptions | undefined) => Effect.Effect<BrowserEventBatch, InvalidBrowserEventBatch, never>;
 export type BrowserEventIngestReceipt = {
     readonly accepted: number;
+    readonly redacted: number;
+    readonly dropped: number;
+    readonly spans?: number;
+    readonly metrics?: number;
 };
-export declare const ingestBrowserEventBatch: (batch: BrowserEventBatch) => Effect.Effect<BrowserEventIngestReceipt, never, never>;
-export declare const ingestBrowserEvents: (input: unknown, options?: import("effect/SchemaAST").ParseOptions | undefined) => Effect.Effect<BrowserEventIngestReceipt, InvalidBrowserEventBatch, never>;
+export declare const ingestBrowserEventBatch: (batch: BrowserEventBatch) => Effect.Effect<BrowserEventIngestReceipt, InvalidBrowserEventBatch | import("../contract/TelemetryContractError.js").InvalidTelemetryEvent, TelemetryEventSink>;
+export declare const ingestBrowserEvents: (input: unknown, options?: import("effect/SchemaAST").ParseOptions | undefined) => Effect.Effect<BrowserEventIngestReceipt, InvalidBrowserEventBatch | import("../contract/TelemetryContractError.js").InvalidTelemetryEvent, TelemetryEventSink>;
 export {};

package/dist/node/BrowserEventIngest.js

@@ -1,6 +1,11 @@
-import { Effect, flow, Schema } from "effect";
+import { Effect, flow, Option, Schema } from "effect";
 import { BrowserEventBatch } from "../BrowserEvents.js";
-import * as WideEvent from "../WideEvent.js";
+import { parseResourceIdentity } from "../ResourceIdentity.js";
+import { BrowserSignalExporter } from "../trace/HttpServerOtlpTracer.js";
+import { TelemetryEventSink } from "../contract/EventProducer.js";
+import { CurrentDataPolicy } from "../policy/DataPolicy.js";
+import { transformSignalFields } from "../policy/PolicyTransform.js";
+import { BrowserMetricRecorder, unavailableBrowserMetricRecorder, } from "../browser/BrowserMetricRecorder.js";
 export class InvalidBrowserEventBatch extends Schema.TaggedError()("InvalidBrowserEventBatch", {
     code: Schema.Literal("OBS_BROWSER_EVENTS_INVALID_BATCH"),
     message: Schema.String,
@@ -10,29 +15,116 @@ export class InvalidBrowserEventBatch extends Schema.TaggedError()("InvalidBrows
 const decodeBrowserEventBatch = Schema.decodeUnknownEffect(BrowserEventBatch);
 export const parseBrowserEventBatch = flow(decodeBrowserEventBatch, Effect.mapError((cause) => new InvalidBrowserEventBatch({
     code: "OBS_BROWSER_EVENTS_INVALID_BATCH",
-    message: "The browser event batch is invalid. Send a version 1 batch with bounded events and scalar fields.",
+    message: "The browser event batch is invalid. Send a batch with a positive safe integer version (version 1 or newer), bounded events, and scalar fields.",
     cause,
 })));
-const reservedFieldPrefixes = ["event.", "browser."];
-const trustedFields = (fields) => {
-    const sanitized = {};
-    for (const [key, value] of Object.entries(fields)) {
-        if (reservedFieldPrefixes.some((prefix) => key.startsWith(prefix))) {
-            continue;
+const invalidSignalBatch = (cause) => new InvalidBrowserEventBatch({
+    code: "OBS_BROWSER_EVENTS_INVALID_BATCH",
+    message: "The browser event batch has invalid signal correlation. Send completed spans with valid parent and event references in the same trace.",
+    cause,
+});
+export const ingestBrowserEventBatch = Effect.fn("ingestBrowserEventBatch")(function* (batch) {
+    const policy = yield* CurrentDataPolicy;
+    const sink = yield* TelemetryEventSink;
+    const signalExporter = yield* BrowserSignalExporter;
+    const metricRecorder = yield* Effect.serviceOption(BrowserMetricRecorder).pipe(Effect.map(Option.getOrElse(() => unavailableBrowserMetricRecorder)));
+    const spans = batch.spans ?? [];
+    const metrics = batch.metrics ?? [];
+    const resource = batch.resource === undefined
+        ? undefined
+        : yield* parseResourceIdentity(batch.resource).pipe(Effect.mapError(() => invalidSignalBatch("invalid browser resource identity")));
+    const spanById = new Map(spans.map((span) => [span.spanId, span]));
+    if (spanById.size !== spans.length)
+        return yield* invalidSignalBatch("duplicate span id");
+    for (const span of spans) {
+        if (span.endedAt < span.startedAt)
+            return yield* invalidSignalBatch("span ended before start");
+        if (span.parentSpanId !== undefined) {
+            const parent = spanById.get(span.parentSpanId);
+            if (parent === undefined ||
+                parent.traceId !== span.traceId ||
+                parent.spanId === span.spanId) {
+                return yield* invalidSignalBatch("invalid span parent");
+            }
+        }
+    }
+    for (const span of spans) {
+        const ancestors = new Set([span.spanId]);
+        let parentId = span.parentSpanId;
+        while (parentId !== undefined) {
+            if (ancestors.has(parentId))
+                return yield* invalidSignalBatch("cyclic span parent");
+            ancestors.add(parentId);
+            parentId = spanById.get(parentId)?.parentSpanId;
         }
-        sanitized[key] = value;
     }
-    return sanitized;
-};
-export const ingestBrowserEventBatch = Effect.fn("ingestBrowserEventBatch")(function* (batch) {
     for (const event of batch.events) {
-        yield* WideEvent.emit(event.name, {
-            ...trustedFields(event.fields),
-            "event.source": "browser",
-            "browser.event.id": event.id,
-            "browser.event.occurred_at": event.occurredAt,
+        if (event.trace !== undefined) {
+            const span = spanById.get(event.trace.spanId);
+            if (span === undefined || span.traceId !== event.trace.traceId) {
+                return yield* invalidSignalBatch("invalid event trace reference");
+            }
+        }
+    }
+    let redacted = 0;
+    let dropped = 0;
+    const events = batch.events.map((event) => {
+        const decision = transformSignalFields(policy, "browser-ingest", event.fields);
+        const errorDecision = event.error === undefined
+            ? undefined
+            : transformSignalFields(policy, "browser-ingest", {
+                "error.type": event.error.type,
+                "error.message": event.error.message,
+            });
+        const eventDropped = decision.dropped + (errorDecision?.dropped ?? 0);
+        dropped += eventDropped;
+        redacted += [...decision.redactions, ...(errorDecision?.redactions ?? [])].filter((redaction) => redaction.action !== "dropped").length;
+        const ingested = {
+            id: event.id,
+            name: event.name,
+            occurredAt: event.occurredAt,
+            attributes: decision.value,
+            admission: { policyDroppedAttributes: eventDropped },
+        };
+        if (event.trace !== undefined)
+            Object.assign(ingested, { trace: event.trace });
+        if (event.error === undefined || errorDecision === undefined)
+            return ingested;
+        return {
+            ...ingested,
+            error: {
+                type: String(errorDecision.value["error.type"] ?? "Error"),
+                message: String(errorDecision.value["error.message"] ?? ""),
+                retryable: event.error.retryable,
+            },
+        };
+    });
+    const eventAdmission = yield* sink.admitBrowserBatch(events);
+    let commitMetrics = () => undefined;
+    if (metrics.length > 0) {
+        commitMetrics = yield* Effect.try({
+            try: () => metricRecorder.admit(metrics).commit,
+            catch: (cause) => invalidSignalBatch(cause),
         });
     }
-    return { accepted: batch.events.length };
+    yield* eventAdmission.commit;
+    commitMetrics();
+    const signals = { spans };
+    yield* signalExporter.export(resource === undefined
+        ? signals
+        : {
+            ...signals,
+            resource: {
+                serviceName: resource.serviceName,
+                serviceVersion: resource.serviceVersion,
+                environment: resource.environment,
+            },
+        });
+    const receipt = { accepted: events.length, redacted, dropped };
+    if (batch.spans !== undefined)
+        Object.assign(receipt, { spans: spans.length });
+    if (batch.metrics !== undefined)
+        Object.assign(receipt, { metrics: metrics.length });
+    return receipt;
 });
 export const ingestBrowserEvents = flow(parseBrowserEventBatch, Effect.flatMap(ingestBrowserEventBatch));

package/dist/node/LocalCollector.d.ts

@@ -0,0 +1,20 @@
+import { Schema } from "effect";
+import type { ConformanceTargetBinding } from "../testing/conformance/ConformanceModel.js";
+import { type TelemetryDestinationReceipt } from "../testing/conformance/TelemetryEvidence.js";
+import { type CapturedTelemetry, type OtlpCaptureServer } from "../testing/index.js";
+declare const LocalCollectorError_base: Schema.Class<LocalCollectorError, Schema.TaggedStruct<"LocalCollectorError", {
+    readonly code: Schema.Literal<"OBS_CONFORMANCE_LOCAL_COLLECTOR_FAILED">;
+    readonly message: Schema.String;
+    readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+export declare class LocalCollectorError extends LocalCollectorError_base {
+}
+export type LocalCollectorDestination = OtlpCaptureServer & {
+    readonly destinationTelemetry: () => CapturedTelemetry;
+    readonly destinationEndpoint: URL;
+    readonly collectorInstance: string;
+    readonly awaitDestination: (runId: string, eventRunIdAttribute?: string) => Promise<void>;
+    readonly destinationReceipt: (runId: string, binding: ConformanceTargetBinding) => TelemetryDestinationReceipt;
+};
+export declare const startLocalCollectorDestination: () => Promise<LocalCollectorDestination>;
+export {};