@equipe-tech/observability 0.2.1 → 0.3.5

package/dist/browser/BrowserTelemetry.js

@@ -0,0 +1,105 @@
+import { Cause, Context, Duration, Effect, Exit, Layer, Option, Schema } from "effect";
+import { BrowserEvent, BrowserEventBatch, browserEnvelopeVersion, encodeBrowserEventBatch, maxEventsPerBatch, } from "../BrowserEvents.js";
+import { parseDataPolicy } from "../policy/DataPolicy.js";
+import { transformSignalFields } from "../policy/PolicyTransform.js";
+import { BrowserClientEngine, normalizePositiveInteger } from "./BrowserClient.js";
+export { BrowserTelemetryClientDeliveryError, BrowserTelemetryClientShutdownError, browserBatchByteLength, createBrowserTelemetryClient, } from "./BrowserClient.js";
+export { BrowserEvent, BrowserEventBatch, BrowserEventError, BrowserMetricPoint, BrowserResourceIdentity, BrowserTraceContext as BrowserTraceContextSchema, BrowserTraceSpan, browserRequestByteBudget, maxEventNameLength, maxEventsPerBatch, maxBrowserEventOccurredAt, maxFieldKeyLength, maxFieldsPerEvent, maxFieldValueLength, } from "../BrowserEvents.js";
+export const defaultEventsEndpoint = "/_telemetry/events";
+export class BrowserEventDeliveryError extends Schema.TaggedError()("BrowserEventDeliveryError", {
+    code: Schema.Literal("OBS_BROWSER_EVENTS_DELIVERY_FAILED"),
+    message: Schema.String,
+    retryable: Schema.Boolean,
+    cause: Schema.Defect(),
+}) {
+}
+export class BrowserEventTransport extends Context.Service()("@equipe-tech/observability/BrowserEventTransport") {
+    static layerFetch = (options) => {
+        const endpoint = options?.endpoint ?? defaultEventsEndpoint;
+        return Layer.succeed(BrowserEventTransport, BrowserEventTransport.of({
+            send: (batch) => Effect.gen(function* () {
+                const payload = yield* encodeBrowserEventBatch(batch).pipe(Effect.orDie);
+                const response = yield* Effect.tryPromise({
+                    try: (signal) => fetch(endpoint, {
+                        method: "POST",
+                        headers: { "content-type": "application/json" },
+                        body: JSON.stringify(payload),
+                        keepalive: true,
+                        signal,
+                    }),
+                    catch: (cause) => new BrowserEventDeliveryError({
+                        code: "OBS_BROWSER_EVENTS_DELIVERY_FAILED",
+                        message: "The browser events could not be sent. The events stay queued and the next flush retries the same batch.",
+                        retryable: true,
+                        cause,
+                    }),
+                });
+                if (!response.ok) {
+                    return yield* new BrowserEventDeliveryError({
+                        code: "OBS_BROWSER_EVENTS_DELIVERY_FAILED",
+                        message: `The telemetry endpoint rejected the batch with status ${response.status}. Check the /_telemetry/events route of the project API.`,
+                        retryable: response.status === 429 || response.status >= 500,
+                        cause: response.status,
+                    });
+                }
+            }),
+        }));
+    };
+}
+const makeBrowserTelemetry = Effect.fn("makeBrowserTelemetry")(function* (options) {
+    const transport = yield* BrowserEventTransport;
+    const flushInterval = Duration.fromInputUnsafe(options?.flushInterval ?? "5 seconds");
+    const policy = options?.policy === undefined
+        ? undefined
+        : yield* parseDataPolicy(options.policy).pipe(Effect.orDie);
+    const engine = new BrowserClientEngine({
+        disabled: false,
+        maxBatchSize: Math.min(normalizePositiveInteger(options?.maxBatchSize, 32), maxEventsPerBatch),
+        maxQueueSize: normalizePositiveInteger(options?.maxQueueSize, 256),
+        flushIntervalMs: normalizePositiveInteger(Duration.toMillis(flushInterval), 5_000),
+        shutdownTimeoutMs: 2_000,
+        metrics: options?.metrics ?? false,
+        resource: undefined,
+        policy: policy === undefined
+            ? undefined
+            : (fields) => transformSignalFields(policy, "browser-ingest", fields).value,
+        transport: (batch) => new Promise((resolve, reject) => {
+            Effect.runCallback(transport.send(new BrowserEventBatch({
+                version: browserEnvelopeVersion,
+                events: batch.events.map((event) => new BrowserEvent(event)),
+            })), {
+                onExit: (exit) => {
+                    if (Exit.isSuccess(exit)) {
+                        resolve();
+                        return;
+                    }
+                    const failure = Cause.findErrorOption(exit.cause);
+                    reject(Option.isSome(failure) ? failure.value : Cause.squash(exit.cause));
+                },
+            });
+        }),
+        startTimer: false,
+    });
+    const flush = Effect.tryPromise({
+        try: () => engine.flush(),
+        catch: (cause) => cause instanceof BrowserEventDeliveryError
+            ? cause
+            : new BrowserEventDeliveryError({
+                code: "OBS_BROWSER_EVENTS_DELIVERY_FAILED",
+                message: "The browser events could not be sent. The events stay queued and the next flush retries the same batch.",
+                retryable: true,
+                cause,
+            }),
+    });
+    yield* Effect.forkScoped(flush.pipe(Effect.ignore, Effect.delay(flushInterval), Effect.forever));
+    yield* Effect.addFinalizer(() => Effect.tryPromise({ try: () => engine.dispose(), catch: () => undefined }).pipe(Effect.ignore));
+    return {
+        emit: (name, fields) => Effect.sync(() => engine.emit(name, fields ?? {})),
+        flush: () => flush,
+        pending: () => Effect.sync(() => engine.pending()),
+        dropped: () => Effect.sync(() => engine.dropped()),
+    };
+});
+export class BrowserTelemetry extends Context.Service()("@equipe-tech/observability/BrowserTelemetry") {
+    static layer = (options) => Layer.effect(BrowserTelemetry, makeBrowserTelemetry(options));
+}

package/dist/browser/ClientPolicy.d.ts

@@ -0,0 +1,3 @@
+import type { BrowserTelemetryClientFields } from "./BrowserClient.js";
+export declare const sanitizeClientFields: (fields: BrowserTelemetryClientFields) => BrowserTelemetryClientFields;
+export declare const sanitizeClientEventName: (name: string) => string;

package/dist/browser/ClientPolicy.js

@@ -0,0 +1,52 @@
+import { baseBlockedValuePatterns, isSensitiveFieldKey, replaceEmailCandidates, sensitiveFieldReplacement, sensitiveTextReplacement, } from "../policy/PolicyVocabulary.js";
+import { maxEventNameLength, maxFieldKeyLength, maxFieldsPerEvent, maxFieldValueLength, } from "./BrowserEventLimits.js";
+const maximumInputLength = 16_384;
+const assignmentPattern = /(?:authorization|proxy[._-]?authorization|cookie|set[._-]?cookie|password|passwd|secret|token|api[._-]?key|apikey|access[._-]?key|client[._-]?secret|private[._-]?key|email|phone|cpf|cnpj|document)(?:[._-]|[A-Z0-9]|\]|\[|["'`])?\s*[:=]\s*(?:\\?["'`])?[^,;&#}\]]*/gi;
+const sanitizeText = (value, limit) => {
+    if (value.length > maximumInputLength)
+        return sensitiveTextReplacement;
+    let sanitized = value;
+    for (const pattern of baseBlockedValuePatterns) {
+        pattern.lastIndex = 0;
+        sanitized = sanitized.replace(pattern, sensitiveTextReplacement);
+    }
+    sanitized = replaceEmailCandidates(sanitized).replace(assignmentPattern, (assignment) => {
+        const separator = Math.max(assignment.indexOf(":"), assignment.indexOf("="));
+        return `${assignment.slice(0, separator + 1)}${sensitiveTextReplacement}`;
+    });
+    return sanitized.slice(0, limit);
+};
+const sanitizeValue = (value) => {
+    try {
+        if (String(value) === value)
+            return sanitizeText(value, maxFieldValueLength);
+        if (Number(value) === value && Number.isFinite(value))
+            return value;
+        if (value === true || value === false)
+            return value;
+        return undefined;
+    }
+    catch {
+        return undefined;
+    }
+};
+export const sanitizeClientFields = (fields) => {
+    const entries = [];
+    const keys = new Set();
+    for (const [key, value] of Object.entries(fields)) {
+        if (key.length === 0 || key.length > 2_048)
+            continue;
+        const boundedKey = key.slice(0, maxFieldKeyLength);
+        if (keys.has(boundedKey))
+            continue;
+        const sanitized = isSensitiveFieldKey(key) ? sensitiveFieldReplacement : sanitizeValue(value);
+        if (sanitized === undefined)
+            continue;
+        entries.push([boundedKey, sanitized]);
+        keys.add(boundedKey);
+        if (keys.size === maxFieldsPerEvent)
+            break;
+    }
+    return Object.fromEntries(entries);
+};
+export const sanitizeClientEventName = (name) => sanitizeText(name, maxEventNameLength);

package/dist/browser/client.d.ts

@@ -1,2 +1,3 @@
-export { BrowserTelemetryClientDeliveryError, BrowserTelemetryClientShutdownError, createBrowserTelemetryClient, } from "./BrowserClient.js";
-export type { BrowserTelemetryClient, BrowserTelemetryClientBatch, BrowserTelemetryClientConfig, BrowserTelemetryClientEvent, BrowserTelemetryClientFields, BrowserTelemetryClientTransport, } from "./BrowserClient.js";
+export { browserEnvelopeVersion } from "./BrowserEventLimits.js";
+export { BrowserTelemetryClientDeliveryError, BrowserTelemetryClientShutdownError, browserBatchByteLength, createBrowserTelemetryClient, } from "./BrowserClient.js";
+export type { BrowserTelemetryClient, BrowserTelemetryClientBatch, BrowserTelemetryClientConfig, BrowserTelemetryClientError, BrowserTelemetryClientEvent, BrowserTelemetryClientFields, BrowserTelemetryClientMetric, BrowserTelemetryClientResource, BrowserTelemetryClientSpan, BrowserTelemetryDefectInput, BrowserCounter, BrowserTraceContext, BrowserTraceHandle, BrowserTelemetryFieldTransform, BrowserTelemetryClientTransport, } from "./BrowserClient.js";

package/dist/browser/client.js

@@ -1 +1,2 @@
-export { BrowserTelemetryClientDeliveryError, BrowserTelemetryClientShutdownError, createBrowserTelemetryClient, } from "./BrowserClient.js";
+export { browserEnvelopeVersion } from "./BrowserEventLimits.js";
+export { BrowserTelemetryClientDeliveryError, BrowserTelemetryClientShutdownError, browserBatchByteLength, createBrowserTelemetryClient, } from "./BrowserClient.js";

package/dist/browser/index.d.ts

@@ -1,37 +1,4 @@
-import { Cause, Context, Duration, Effect, Layer, Schema } from "effect";
-import { BrowserEventBatch } from "../BrowserEvents.js";
-import type { WideEventFields } from "../WideEvent.js";
-export { BrowserTelemetryClientDeliveryError, BrowserTelemetryClientShutdownError, createBrowserTelemetryClient, } from "./BrowserClient.js";
-export type { BrowserTelemetryClient, BrowserTelemetryClientBatch, BrowserTelemetryClientConfig, BrowserTelemetryClientEvent, BrowserTelemetryClientFields, BrowserTelemetryClientTransport, } from "./BrowserClient.js";
-export { BrowserEvent, BrowserEventBatch, maxEventNameLength, maxEventsPerBatch, maxFieldKeyLength, maxFieldsPerEvent, maxFieldValueLength, } from "../BrowserEvents.js";
-export declare const defaultEventsEndpoint = "/_telemetry/events";
-declare const BrowserEventDeliveryError_base: Schema.Class<BrowserEventDeliveryError, Schema.TaggedStruct<"BrowserEventDeliveryError", {
-    readonly code: Schema.Literal<"OBS_BROWSER_EVENTS_DELIVERY_FAILED">;
-    readonly message: Schema.String;
-    readonly retryable: Schema.Boolean;
-    readonly cause: Schema.Defect;
-}>, Cause.YieldableError>;
-export declare class BrowserEventDeliveryError extends BrowserEventDeliveryError_base {
-}
-declare const BrowserEventTransport_base: Context.ServiceClass<BrowserEventTransport, "@equipe-tech/observability/BrowserEventTransport", {
-    send(batch: BrowserEventBatch): Effect.Effect<void, BrowserEventDeliveryError>;
-}>;
-export declare class BrowserEventTransport extends BrowserEventTransport_base {
-    static readonly layerFetch: (options?: {
-        readonly endpoint?: string;
-    }) => Layer.Layer<BrowserEventTransport>;
-}
-export type BrowserTelemetryOptions = {
-    readonly maxBatchSize?: number;
-    readonly maxQueueSize?: number;
-    readonly flushInterval?: Duration.Input;
-};
-declare const BrowserTelemetry_base: Context.ServiceClass<BrowserTelemetry, "@equipe-tech/observability/BrowserTelemetry", {
-    emit(name: string, fields?: WideEventFields): Effect.Effect<void>;
-    flush(): Effect.Effect<void, BrowserEventDeliveryError>;
-    pending(): Effect.Effect<number>;
-    dropped(): Effect.Effect<number>;
-}>;
-export declare class BrowserTelemetry extends BrowserTelemetry_base {
-    static readonly layer: (options?: BrowserTelemetryOptions) => Layer.Layer<BrowserTelemetry, never, BrowserEventTransport>;
-}
+export { BrowserEventDeliveryError, BrowserEventTransport, BrowserTelemetry, defaultEventsEndpoint, type BrowserTelemetryOptions, } from "./BrowserTelemetry.js";
+export { BrowserTelemetryClientDeliveryError, BrowserTelemetryClientShutdownError, browserBatchByteLength, createBrowserTelemetryClient, } from "./BrowserClient.js";
+export type { BrowserTelemetryClient, BrowserTelemetryClientBatch, BrowserTelemetryClientConfig, BrowserTelemetryClientError, BrowserTelemetryClientEvent, BrowserTelemetryClientFields, BrowserTelemetryClientMetric, BrowserTelemetryClientResource, BrowserTelemetryClientSpan, BrowserTelemetryDefectInput, BrowserCounter, BrowserTraceContext, BrowserTraceHandle, BrowserTelemetryFieldTransform, BrowserTelemetryClientTransport, } from "./BrowserClient.js";
+export { BrowserEvent, BrowserEventBatch, BrowserEventError, BrowserMetricPoint, BrowserResourceIdentity, BrowserTraceContext as BrowserTraceContextSchema, BrowserTraceSpan, browserEnvelopeMetadata, browserEnvelopeVersion, browserRequestByteBudget, maxEventNameLength, maxEventsPerBatch, maxBrowserEventOccurredAt, maxFieldKeyLength, maxFieldsPerEvent, maxFieldValueLength, } from "../BrowserEvents.js";

package/dist/browser/index.js

@@ -1,95 +1,3 @@
-import { Cause, Context, Duration, Effect, Exit, Layer, Option, Schema } from "effect";
-import { BrowserEvent, BrowserEventBatch, encodeBrowserEventBatch, maxEventsPerBatch, } from "../BrowserEvents.js";
-import { BrowserClientEngine, normalizePositiveInteger } from "./BrowserClient.js";
-export { BrowserTelemetryClientDeliveryError, BrowserTelemetryClientShutdownError, createBrowserTelemetryClient, } from "./BrowserClient.js";
-export { BrowserEvent, BrowserEventBatch, maxEventNameLength, maxEventsPerBatch, maxFieldKeyLength, maxFieldsPerEvent, maxFieldValueLength, } from "../BrowserEvents.js";
-export const defaultEventsEndpoint = "/_telemetry/events";
-export class BrowserEventDeliveryError extends Schema.TaggedError()("BrowserEventDeliveryError", {
-    code: Schema.Literal("OBS_BROWSER_EVENTS_DELIVERY_FAILED"),
-    message: Schema.String,
-    retryable: Schema.Boolean,
-    cause: Schema.Defect(),
-}) {
-}
-export class BrowserEventTransport extends Context.Service()("@equipe-tech/observability/BrowserEventTransport") {
-    static layerFetch = (options) => {
-        const endpoint = options?.endpoint ?? defaultEventsEndpoint;
-        return Layer.succeed(BrowserEventTransport, BrowserEventTransport.of({
-            send: (batch) => Effect.gen(function* () {
-                const payload = yield* encodeBrowserEventBatch(batch).pipe(Effect.orDie);
-                const response = yield* Effect.tryPromise({
-                    try: (signal) => fetch(endpoint, {
-                        method: "POST",
-                        headers: { "content-type": "application/json" },
-                        body: JSON.stringify(payload),
-                        keepalive: true,
-                        signal,
-                    }),
-                    catch: (cause) => new BrowserEventDeliveryError({
-                        code: "OBS_BROWSER_EVENTS_DELIVERY_FAILED",
-                        message: "The browser events could not be sent. The events stay queued and the next flush retries the same batch.",
-                        retryable: true,
-                        cause,
-                    }),
-                });
-                if (!response.ok) {
-                    return yield* new BrowserEventDeliveryError({
-                        code: "OBS_BROWSER_EVENTS_DELIVERY_FAILED",
-                        message: `The telemetry endpoint rejected the batch with status ${response.status}. Check the /_telemetry/events route of the project API.`,
-                        retryable: response.status === 429 || response.status >= 500,
-                        cause: response.status,
-                    });
-                }
-            }),
-        }));
-    };
-}
-const makeBrowserTelemetry = Effect.fn("makeBrowserTelemetry")(function* (options) {
-    const transport = yield* BrowserEventTransport;
-    const flushInterval = Duration.fromInputUnsafe(options?.flushInterval ?? "5 seconds");
-    const engine = new BrowserClientEngine({
-        disabled: false,
-        maxBatchSize: Math.min(normalizePositiveInteger(options?.maxBatchSize, 32), maxEventsPerBatch),
-        maxQueueSize: normalizePositiveInteger(options?.maxQueueSize, 256),
-        flushIntervalMs: normalizePositiveInteger(Duration.toMillis(flushInterval), 5_000),
-        shutdownTimeoutMs: 2_000,
-        transport: (batch) => new Promise((resolve, reject) => {
-            Effect.runCallback(transport.send(new BrowserEventBatch({
-                version: 1,
-                events: batch.events.map((event) => new BrowserEvent(event)),
-            })), {
-                onExit: (exit) => {
-                    if (Exit.isSuccess(exit)) {
-                        resolve();
-                        return;
-                    }
-                    const failure = Cause.findErrorOption(exit.cause);
-                    reject(Option.isSome(failure) ? failure.value : Cause.squash(exit.cause));
-                },
-            });
-        }),
-        startTimer: false,
-    });
-    const flush = Effect.tryPromise({
-        try: () => engine.flush(),
-        catch: (cause) => cause instanceof BrowserEventDeliveryError
-            ? cause
-            : new BrowserEventDeliveryError({
-                code: "OBS_BROWSER_EVENTS_DELIVERY_FAILED",
-                message: "The browser events could not be sent. The events stay queued and the next flush retries the same batch.",
-                retryable: true,
-                cause,
-            }),
-    });
-    yield* Effect.forkScoped(flush.pipe(Effect.ignore, Effect.delay(flushInterval), Effect.forever));
-    yield* Effect.addFinalizer(() => Effect.tryPromise({ try: () => engine.dispose(), catch: () => undefined }).pipe(Effect.ignore));
-    return {
-        emit: (name, fields) => Effect.sync(() => engine.emit(name, fields ?? {})),
-        flush: () => flush,
-        pending: () => Effect.sync(() => engine.pending()),
-        dropped: () => Effect.sync(() => engine.dropped()),
-    };
-});
-export class BrowserTelemetry extends Context.Service()("@equipe-tech/observability/BrowserTelemetry") {
-    static layer = (options) => Layer.effect(BrowserTelemetry, makeBrowserTelemetry(options));
-}
+export { BrowserEventDeliveryError, BrowserEventTransport, BrowserTelemetry, defaultEventsEndpoint, } from "./BrowserTelemetry.js";
+export { BrowserTelemetryClientDeliveryError, BrowserTelemetryClientShutdownError, browserBatchByteLength, createBrowserTelemetryClient, } from "./BrowserClient.js";
+export { BrowserEvent, BrowserEventBatch, BrowserEventError, BrowserMetricPoint, BrowserResourceIdentity, BrowserTraceContext as BrowserTraceContextSchema, BrowserTraceSpan, browserEnvelopeMetadata, browserEnvelopeVersion, browserRequestByteBudget, maxEventNameLength, maxEventsPerBatch, maxBrowserEventOccurredAt, maxFieldKeyLength, maxFieldsPerEvent, maxFieldValueLength, } from "../BrowserEvents.js";

package/dist/contract/ContractCompatibility.d.ts

@@ -0,0 +1,31 @@
+import { Schema } from "effect";
+import type { ContractSurface } from "./ContractSurface.js";
+export declare const CompatibilityCode: Schema.Literals<readonly ["OBS_COMPAT_SERVICE_CHANGED", "OBS_COMPAT_EVENT_ADDED", "OBS_COMPAT_EVENT_REMOVED", "OBS_COMPAT_EVENT_RENAMED", "OBS_COMPAT_EVENT_KIND_CHANGED", "OBS_COMPAT_OUTCOME_MEANING_CHANGED", "OBS_COMPAT_ATTRIBUTE_ADDED", "OBS_COMPAT_ATTRIBUTE_REMOVED", "OBS_COMPAT_ATTRIBUTE_REQUIRED", "OBS_COMPAT_ATTRIBUTE_CLASSIFICATION_CHANGED", "OBS_COMPAT_ATTRIBUTE_METRIC_LABEL_CHANGED", "OBS_COMPAT_METRIC_ADDED", "OBS_COMPAT_METRIC_REMOVED", "OBS_COMPAT_METRIC_RENAMED", "OBS_COMPAT_METRIC_KIND_CHANGED", "OBS_COMPAT_METRIC_UNIT_CHANGED", "OBS_COMPAT_METRIC_BOUNDARIES_CHANGED", "OBS_COMPAT_METRIC_ATTRIBUTE_ADDED", "OBS_COMPAT_METRIC_ATTRIBUTE_REMOVED", "OBS_COMPAT_METRIC_ATTRIBUTE_CLASSIFICATION_CHANGED", "OBS_COMPAT_METRIC_CARDINALITY_LOWERED", "OBS_COMPAT_METRIC_ALLOWED_VALUES_NARROWED", "OBS_COMPAT_AUDIT_ACTION_ADDED", "OBS_COMPAT_AUDIT_ACTION_REMOVED", "OBS_COMPAT_AUDIT_ACTION_CHANGED", "OBS_COMPAT_ALIAS_ADDED", "OBS_COMPAT_ALIAS_REMOVED_EARLY", "OBS_COMPAT_ALIAS_WINDOW_RESET", "OBS_COMPAT_ALIAS_WINDOW_EXPIRED", "OBS_COMPAT_BROWSER_ENVELOPE_CHANGED", "OBS_COMPAT_RETENTION_WINDOW_RESET"]>;
+export type CompatibilityCode = typeof CompatibilityCode.Type;
+export type CompatibilitySeverity = "compatible" | "breaking" | "notice";
+export type CompatibilityAliasStatus = "not-required" | "missing" | "active" | "expiring" | "expired";
+export type CompatibilityFinding = {
+    readonly code: CompatibilityCode;
+    readonly path: string;
+    readonly severity: CompatibilitySeverity;
+    readonly requiredContractVersion: number;
+    readonly declaredContractVersion: number;
+    readonly aliasStatus: CompatibilityAliasStatus;
+    readonly satisfied: boolean;
+};
+export type CompatibilityReport = {
+    readonly report: 1;
+    readonly service: string;
+    readonly baselineContractVersion: number;
+    readonly candidateContractVersion: number;
+    readonly requiredContractVersion: number;
+    readonly accepted: boolean;
+    readonly findings: ReadonlyArray<CompatibilityFinding>;
+};
+export type ContractCompatibilityInput = {
+    readonly baseline: ContractSurface;
+    readonly candidate: ContractSurface;
+    readonly now: string;
+};
+export declare const classifyContractChange: (input: ContractCompatibilityInput) => CompatibilityReport;
+export declare const encodeCompatibilityReport: (report: CompatibilityReport) => string;

package/dist/contract/ContractCompatibility.js

@@ -0,0 +1,274 @@
+import { Schema } from "effect";
+export const CompatibilityCode = Schema.Literals([
+    "OBS_COMPAT_SERVICE_CHANGED",
+    "OBS_COMPAT_EVENT_ADDED",
+    "OBS_COMPAT_EVENT_REMOVED",
+    "OBS_COMPAT_EVENT_RENAMED",
+    "OBS_COMPAT_EVENT_KIND_CHANGED",
+    "OBS_COMPAT_OUTCOME_MEANING_CHANGED",
+    "OBS_COMPAT_ATTRIBUTE_ADDED",
+    "OBS_COMPAT_ATTRIBUTE_REMOVED",
+    "OBS_COMPAT_ATTRIBUTE_REQUIRED",
+    "OBS_COMPAT_ATTRIBUTE_CLASSIFICATION_CHANGED",
+    "OBS_COMPAT_ATTRIBUTE_METRIC_LABEL_CHANGED",
+    "OBS_COMPAT_METRIC_ADDED",
+    "OBS_COMPAT_METRIC_REMOVED",
+    "OBS_COMPAT_METRIC_RENAMED",
+    "OBS_COMPAT_METRIC_KIND_CHANGED",
+    "OBS_COMPAT_METRIC_UNIT_CHANGED",
+    "OBS_COMPAT_METRIC_BOUNDARIES_CHANGED",
+    "OBS_COMPAT_METRIC_ATTRIBUTE_ADDED",
+    "OBS_COMPAT_METRIC_ATTRIBUTE_REMOVED",
+    "OBS_COMPAT_METRIC_ATTRIBUTE_CLASSIFICATION_CHANGED",
+    "OBS_COMPAT_METRIC_CARDINALITY_LOWERED",
+    "OBS_COMPAT_METRIC_ALLOWED_VALUES_NARROWED",
+    "OBS_COMPAT_AUDIT_ACTION_ADDED",
+    "OBS_COMPAT_AUDIT_ACTION_REMOVED",
+    "OBS_COMPAT_AUDIT_ACTION_CHANGED",
+    "OBS_COMPAT_ALIAS_ADDED",
+    "OBS_COMPAT_ALIAS_REMOVED_EARLY",
+    "OBS_COMPAT_ALIAS_WINDOW_RESET",
+    "OBS_COMPAT_ALIAS_WINDOW_EXPIRED",
+    "OBS_COMPAT_BROWSER_ENVELOPE_CHANGED",
+    "OBS_COMPAT_RETENTION_WINDOW_RESET",
+]);
+const mapByName = (entries) => new Map(entries.map((entry) => [entry.name, entry]));
+const mapByAction = (entries) => new Map(entries.map((entry) => [entry.action, entry]));
+const same = (left, right) => left.length === right.length && left.every((value, index) => value === right[index]);
+const scalarKey = (value) => JSON.stringify(value);
+const containsAllowedScalars = (candidate, baseline) => {
+    if (candidate.length === 0)
+        return true;
+    if (baseline.length === 0)
+        return false;
+    const candidateKeys = new Set(candidate.map(scalarKey));
+    return baseline.every((value) => candidateKeys.has(scalarKey(value)));
+};
+const containsStrings = (candidate, baseline) => {
+    const candidates = new Set(candidate);
+    return baseline.every((value) => candidates.has(value));
+};
+const classificationRank = (classification) => classification === "public"
+    ? 0
+    : classification === "internal"
+        ? 1
+        : classification === "sensitive"
+            ? 2
+            : 3;
+const eventAliasCompatible = (baseline, candidate) => candidate !== undefined &&
+    baseline.kind === candidate.kind &&
+    same(baseline.attributes
+        .map((attribute) => `${attribute.name}\u0000${attribute.classification}`)
+        .sort(), candidate.attributes
+        .map((attribute) => `${attribute.name}\u0000${attribute.classification}`)
+        .sort());
+const metricAliasCompatible = (baseline, candidate) => candidate !== undefined &&
+    baseline.kind === candidate.kind &&
+    baseline.unit === candidate.unit &&
+    same(baseline.attributes.map((attribute) => attribute.name).sort(), candidate.attributes.map((attribute) => attribute.name).sort());
+const aliasKey = (alias) => `${alias.kind}\u0000${alias.from}\u0000${alias.to}`;
+const dateDay = (date) => {
+    const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(date);
+    if (match === null)
+        return undefined;
+    const year = Number(match[1]);
+    const month = Number(match[2]);
+    const day = Number(match[3]);
+    const value = Date.UTC(year, month - 1, day);
+    const normalized = new Date(value).toISOString().slice(0, 10);
+    return normalized === date ? Math.floor(value / 86_400_000) : undefined;
+};
+const aliasStatus = (alias, now, retentionWindowDays) => {
+    if (alias === undefined)
+        return "missing";
+    const since = dateDay(alias.since);
+    const today = dateDay(now);
+    if (since === undefined || today === undefined)
+        return "missing";
+    const remaining = retentionWindowDays - (today - since);
+    if (remaining <= 0)
+        return "expired";
+    return remaining <= Math.min(7, retentionWindowDays) ? "expiring" : "active";
+};
+const finding = (code, path, severity, baselineVersion, candidateVersion, status = "not-required", extraSatisfied = true) => {
+    const requiredContractVersion = severity === "breaking" ? baselineVersion + 1 : baselineVersion;
+    return {
+        code,
+        path,
+        severity,
+        requiredContractVersion,
+        declaredContractVersion: candidateVersion,
+        aliasStatus: status,
+        satisfied: extraSatisfied && (severity !== "breaking" || candidateVersion >= requiredContractVersion),
+    };
+};
+const eventAlias = (aliases, name) => aliases.find((alias) => alias.kind === "event" && alias.from === name);
+const metricAlias = (aliases, name) => aliases.find((alias) => alias.kind === "metric" && alias.from === name);
+const compareEventAttributes = (baseline, candidate, baselineVersion, candidateVersion) => {
+    const findings = [];
+    const baselineAttributes = mapByName(baseline.attributes);
+    const candidateAttributes = mapByName(candidate.attributes);
+    for (const attribute of candidate.attributes) {
+        if (!baselineAttributes.has(attribute.name)) {
+            findings.push(finding("OBS_COMPAT_ATTRIBUTE_ADDED", `events/${baseline.name}/attributes/${attribute.name}`, attribute.required ? "breaking" : "compatible", baselineVersion, candidateVersion));
+        }
+    }
+    for (const attribute of baseline.attributes) {
+        const next = candidateAttributes.get(attribute.name);
+        const path = `events/${baseline.name}/attributes/${attribute.name}`;
+        if (next === undefined) {
+            findings.push(finding("OBS_COMPAT_ATTRIBUTE_REMOVED", path, "breaking", baselineVersion, candidateVersion));
+            continue;
+        }
+        if (!attribute.required && next.required) {
+            findings.push(finding("OBS_COMPAT_ATTRIBUTE_REQUIRED", path, "breaking", baselineVersion, candidateVersion));
+        }
+        if (classificationRank(next.classification) > classificationRank(attribute.classification)) {
+            findings.push(finding("OBS_COMPAT_ATTRIBUTE_CLASSIFICATION_CHANGED", path, "breaking", baselineVersion, candidateVersion));
+        }
+        if (attribute.metricLabel !== next.metricLabel) {
+            findings.push(finding("OBS_COMPAT_ATTRIBUTE_METRIC_LABEL_CHANGED", path, "breaking", baselineVersion, candidateVersion));
+        }
+    }
+    return findings;
+};
+const compareMetricAttributes = (baseline, candidate, baselineVersion, candidateVersion) => {
+    const findings = [];
+    const baselineAttributes = mapByName(baseline.attributes);
+    const candidateAttributes = mapByName(candidate.attributes);
+    for (const attribute of candidate.attributes) {
+        if (!baselineAttributes.has(attribute.name)) {
+            findings.push(finding("OBS_COMPAT_METRIC_ATTRIBUTE_ADDED", `metrics/${baseline.name}/attributes/${attribute.name}`, "compatible", baselineVersion, candidateVersion));
+        }
+    }
+    for (const attribute of baseline.attributes) {
+        const next = candidateAttributes.get(attribute.name);
+        const path = `metrics/${baseline.name}/attributes/${attribute.name}`;
+        if (next === undefined) {
+            findings.push(finding("OBS_COMPAT_METRIC_ATTRIBUTE_REMOVED", path, "breaking", baselineVersion, candidateVersion));
+            continue;
+        }
+        if (classificationRank(next.classification) > classificationRank(attribute.classification)) {
+            findings.push(finding("OBS_COMPAT_METRIC_ATTRIBUTE_CLASSIFICATION_CHANGED", path, "breaking", baselineVersion, candidateVersion));
+        }
+        if (next.maximumCardinality < attribute.maximumCardinality) {
+            findings.push(finding("OBS_COMPAT_METRIC_CARDINALITY_LOWERED", path, "breaking", baselineVersion, candidateVersion));
+        }
+        if (!containsAllowedScalars(next.allowedValues, attribute.allowedValues)) {
+            findings.push(finding("OBS_COMPAT_METRIC_ALLOWED_VALUES_NARROWED", path, "breaking", baselineVersion, candidateVersion));
+        }
+    }
+    return findings;
+};
+const auditChanged = (baseline, candidate) => baseline.resourceType !== candidate.resourceType ||
+    !same([...baseline.allowedOutcomes].sort(), [...candidate.allowedOutcomes].sort()) ||
+    !containsStrings(candidate.reasonCodes, baseline.reasonCodes);
+export const classifyContractChange = (input) => {
+    const baselineVersion = input.baseline.contractVersion;
+    const candidateVersion = input.candidate.contractVersion;
+    const findings = [];
+    if (input.baseline.service !== input.candidate.service)
+        findings.push(finding("OBS_COMPAT_SERVICE_CHANGED", "service", "breaking", baselineVersion, candidateVersion, "not-required", false));
+    const baselineEvents = mapByName(input.baseline.events);
+    const candidateEvents = mapByName(input.candidate.events);
+    for (const event of input.candidate.events) {
+        if (!baselineEvents.has(event.name)) {
+            findings.push(finding("OBS_COMPAT_EVENT_ADDED", `events/${event.name}`, "compatible", baselineVersion, candidateVersion));
+        }
+    }
+    for (const event of input.baseline.events) {
+        const next = candidateEvents.get(event.name);
+        if (next === undefined) {
+            const alias = eventAlias(input.candidate.aliases, event.name);
+            const status = aliasStatus(alias, input.now, input.baseline.retentionWindowDays);
+            const target = alias === undefined ? undefined : candidateEvents.get(alias.to);
+            findings.push(finding(alias === undefined ? "OBS_COMPAT_EVENT_REMOVED" : "OBS_COMPAT_EVENT_RENAMED", `events/${event.name}`, "breaking", baselineVersion, candidateVersion, status, alias !== undefined && status !== "missing" && eventAliasCompatible(event, target)));
+            continue;
+        }
+        if (event.kind !== next.kind) {
+            findings.push(finding("OBS_COMPAT_EVENT_KIND_CHANGED", `events/${event.name}/kind`, "breaking", baselineVersion, candidateVersion));
+        }
+        if (!same(event.outcomeMeaning, next.outcomeMeaning)) {
+            findings.push(finding("OBS_COMPAT_OUTCOME_MEANING_CHANGED", `events/${event.name}/outcomeMeaning`, "breaking", baselineVersion, candidateVersion, "not-required", false));
+        }
+        findings.push(...compareEventAttributes(event, next, baselineVersion, candidateVersion));
+    }
+    const baselineMetrics = mapByName(input.baseline.metrics);
+    const candidateMetrics = mapByName(input.candidate.metrics);
+    for (const metric of input.candidate.metrics) {
+        if (!baselineMetrics.has(metric.name)) {
+            findings.push(finding("OBS_COMPAT_METRIC_ADDED", `metrics/${metric.name}`, "compatible", baselineVersion, candidateVersion));
+        }
+    }
+    for (const metric of input.baseline.metrics) {
+        const next = candidateMetrics.get(metric.name);
+        if (next === undefined) {
+            const alias = metricAlias(input.candidate.aliases, metric.name);
+            const status = aliasStatus(alias, input.now, input.baseline.retentionWindowDays);
+            const target = alias === undefined ? undefined : candidateMetrics.get(alias.to);
+            findings.push(finding(alias === undefined ? "OBS_COMPAT_METRIC_REMOVED" : "OBS_COMPAT_METRIC_RENAMED", `metrics/${metric.name}`, "breaking", baselineVersion, candidateVersion, status, alias !== undefined && status !== "missing" && metricAliasCompatible(metric, target)));
+            continue;
+        }
+        if (metric.kind !== next.kind)
+            findings.push(finding("OBS_COMPAT_METRIC_KIND_CHANGED", `metrics/${metric.name}/kind`, "breaking", baselineVersion, candidateVersion, "not-required", false));
+        if (metric.unit !== next.unit)
+            findings.push(finding("OBS_COMPAT_METRIC_UNIT_CHANGED", `metrics/${metric.name}/unit`, "breaking", baselineVersion, candidateVersion, "not-required", false));
+        if (!same(metric.boundaries, next.boundaries))
+            findings.push(finding("OBS_COMPAT_METRIC_BOUNDARIES_CHANGED", `metrics/${metric.name}/boundaries`, "breaking", baselineVersion, candidateVersion, "not-required", false));
+        findings.push(...compareMetricAttributes(metric, next, baselineVersion, candidateVersion));
+    }
+    const baselineActions = mapByAction(input.baseline.auditActions);
+    const candidateActions = mapByAction(input.candidate.auditActions);
+    for (const action of input.candidate.auditActions) {
+        if (!baselineActions.has(action.action))
+            findings.push(finding("OBS_COMPAT_AUDIT_ACTION_ADDED", `auditActions/${action.action}`, "compatible", baselineVersion, candidateVersion));
+    }
+    for (const action of input.baseline.auditActions) {
+        const next = candidateActions.get(action.action);
+        if (next === undefined)
+            findings.push(finding("OBS_COMPAT_AUDIT_ACTION_REMOVED", `auditActions/${action.action}`, "breaking", baselineVersion, candidateVersion));
+        else if (auditChanged(action, next))
+            findings.push(finding("OBS_COMPAT_AUDIT_ACTION_CHANGED", `auditActions/${action.action}`, "breaking", baselineVersion, candidateVersion));
+    }
+    const baselineAliases = new Map(input.baseline.aliases.map((alias) => [aliasKey(alias), alias]));
+    const candidateAliases = new Map(input.candidate.aliases.map((alias) => [aliasKey(alias), alias]));
+    for (const alias of input.candidate.aliases) {
+        const previous = baselineAliases.get(aliasKey(alias));
+        const status = aliasStatus(alias, input.now, input.baseline.retentionWindowDays);
+        if (previous === undefined)
+            findings.push(finding("OBS_COMPAT_ALIAS_ADDED", `aliases/${alias.kind}/${alias.from}/${alias.to}`, "compatible", baselineVersion, candidateVersion, status));
+        else if (previous.since !== alias.since)
+            findings.push(finding("OBS_COMPAT_ALIAS_WINDOW_RESET", `aliases/${alias.kind}/${alias.from}/${alias.to}/since`, "breaking", baselineVersion, candidateVersion, status, false));
+        if (status === "expired")
+            findings.push(finding("OBS_COMPAT_ALIAS_WINDOW_EXPIRED", `aliases/${alias.kind}/${alias.from}/${alias.to}`, "notice", baselineVersion, candidateVersion, status));
+    }
+    for (const alias of input.baseline.aliases) {
+        if (candidateAliases.has(aliasKey(alias)))
+            continue;
+        const status = aliasStatus(alias, input.now, input.baseline.retentionWindowDays);
+        if (status !== "expired")
+            findings.push(finding("OBS_COMPAT_ALIAS_REMOVED_EARLY", `aliases/${alias.kind}/${alias.from}/${alias.to}`, "breaking", baselineVersion, candidateVersion, status, false));
+    }
+    const baselineBrowser = input.baseline.browserEnvelope;
+    const candidateBrowser = input.candidate.browserEnvelope;
+    const browserFieldsChanged = !same(baselineBrowser.batchFields, candidateBrowser.batchFields) ||
+        !same(baselineBrowser.eventFields, candidateBrowser.eventFields);
+    if (browserFieldsChanged && candidateBrowser.version <= baselineBrowser.version) {
+        findings.push(finding("OBS_COMPAT_BROWSER_ENVELOPE_CHANGED", "browserEnvelope", "breaking", baselineVersion, candidateVersion, "not-required", false));
+    }
+    if (input.candidate.retentionWindowDays < input.baseline.retentionWindowDays) {
+        findings.push(finding("OBS_COMPAT_RETENTION_WINDOW_RESET", "retentionWindowDays", "breaking", baselineVersion, candidateVersion, "not-required", false));
+    }
+    findings.sort((left, right) => `${left.path}\u0000${left.code}`.localeCompare(`${right.path}\u0000${right.code}`));
+    const requiredContractVersion = findings.reduce((required, entry) => Math.max(required, entry.requiredContractVersion), baselineVersion);
+    return {
+        report: 1,
+        service: input.candidate.service,
+        baselineContractVersion: baselineVersion,
+        candidateContractVersion: candidateVersion,
+        requiredContractVersion,
+        accepted: findings.every((entry) => entry.satisfied),
+        findings,
+    };
+};
+export const encodeCompatibilityReport = (report) => `${JSON.stringify(report, null, 2)}\n`;