@equipe-tech/observability 0.2.1 → 0.3.5

package/dist/profile/ObservabilityProfile.d.ts

@@ -0,0 +1,49 @@
+export type ProfileName = "nestjs-api" | "worker" | "react-web" | "cli" | "library";
+export type AdapterCapability = "events" | "traces" | "metrics" | "defects" | "browser-ingest";
+export type ExternalAdapterCapability = "events" | "defects" | "browser-ingest";
+export type CapabilityRequirement = "required" | "required-in-production" | "optional" | "forbidden";
+export type LifecycleStage = "server" | "metrics" | "browser";
+type StageDeadline = readonly [stage: LifecycleStage, deadlineMillis: number];
+type StageCapabilityOrder = readonly [
+    stage: LifecycleStage,
+    capabilities: ReadonlyArray<AdapterCapability>
+];
+type ProfileCapabilities = {
+    readonly name: ProfileName;
+    readonly events: CapabilityRequirement;
+    readonly traces: CapabilityRequirement;
+    readonly metrics: CapabilityRequirement;
+    readonly defects: CapabilityRequirement;
+    readonly browserIngest: CapabilityRequirement;
+    readonly stages: ReadonlyArray<LifecycleStage>;
+    readonly stageDeadlineMillis: ReadonlyArray<StageDeadline>;
+    readonly capabilityOrder: ReadonlyArray<StageCapabilityOrder>;
+    readonly shutdownDeadlineMillis: number;
+};
+export type NodeObservabilityProfile = ProfileCapabilities & {
+    readonly runtime: "node-global";
+};
+export type BrowserObservabilityProfile = ProfileCapabilities & {
+    readonly runtime: "browser-global";
+};
+export type LibraryObservabilityProfile = ProfileCapabilities & {
+    readonly runtime: "none";
+};
+export type ObservabilityProfile = NodeObservabilityProfile | BrowserObservabilityProfile | LibraryObservabilityProfile;
+export declare const nestjsApiProfile: NodeObservabilityProfile;
+export declare const workerProfile: NodeObservabilityProfile;
+export declare const reactWebProfile: BrowserObservabilityProfile;
+export declare const cliProfile: NodeObservabilityProfile;
+export declare const libraryProfile: LibraryObservabilityProfile;
+type ObservabilityProfiles = {
+    readonly "nestjs-api": NodeObservabilityProfile;
+    readonly worker: NodeObservabilityProfile;
+    readonly "react-web": BrowserObservabilityProfile;
+    readonly cli: NodeObservabilityProfile;
+    readonly library: LibraryObservabilityProfile;
+};
+export declare const observabilityProfiles: ObservabilityProfiles;
+export declare const profileCapabilityRequirement: (value: ObservabilityProfile, capability: AdapterCapability) => CapabilityRequirement;
+export declare const profileStageDeadlineMillis: (profile: ObservabilityProfile, stage: LifecycleStage) => number | undefined;
+export declare const profileCapabilityRank: (profile: ObservabilityProfile, stage: LifecycleStage, capability: AdapterCapability) => number;
+export {};

package/dist/profile/ObservabilityProfile.js

@@ -0,0 +1,121 @@
+import { reactWebLifecycle } from "./ReactWebProfile.js";
+const stageDeadline = (stage, deadlineMillis) => Object.freeze([stage, deadlineMillis]);
+const stageCapabilities = (stage, capabilities) => Object.freeze([stage, Object.freeze([...capabilities])]);
+const nodeProfile = (value) => Object.freeze({
+    ...value,
+    stages: Object.freeze([...value.stages]),
+    stageDeadlineMillis: Object.freeze([...value.stageDeadlineMillis]),
+    capabilityOrder: Object.freeze([...value.capabilityOrder]),
+});
+const browserProfile = (value) => Object.freeze({
+    ...value,
+    stages: Object.freeze([...value.stages]),
+    stageDeadlineMillis: Object.freeze([...value.stageDeadlineMillis]),
+    capabilityOrder: Object.freeze([...value.capabilityOrder]),
+});
+const libraryProfileDescriptor = (value) => Object.freeze({
+    ...value,
+    stages: Object.freeze([...value.stages]),
+    stageDeadlineMillis: Object.freeze([...value.stageDeadlineMillis]),
+    capabilityOrder: Object.freeze([...value.capabilityOrder]),
+});
+export const nestjsApiProfile = nodeProfile({
+    name: "nestjs-api",
+    runtime: "node-global",
+    events: "required",
+    traces: "required",
+    metrics: "required",
+    defects: "required-in-production",
+    browserIngest: "optional",
+    stages: ["server", "metrics"],
+    stageDeadlineMillis: [stageDeadline("server", 5_000), stageDeadline("metrics", 3_000)],
+    capabilityOrder: [
+        stageCapabilities("server", ["browser-ingest", "events", "traces", "defects"]),
+        stageCapabilities("metrics", ["metrics"]),
+    ],
+    shutdownDeadlineMillis: 5_000,
+});
+export const workerProfile = nodeProfile({
+    name: "worker",
+    runtime: "node-global",
+    events: "required",
+    traces: "required",
+    metrics: "required",
+    defects: "required-in-production",
+    browserIngest: "forbidden",
+    stages: ["server", "metrics"],
+    stageDeadlineMillis: [stageDeadline("server", 5_000), stageDeadline("metrics", 3_000)],
+    capabilityOrder: [
+        stageCapabilities("server", ["events", "traces", "defects"]),
+        stageCapabilities("metrics", ["metrics"]),
+    ],
+    shutdownDeadlineMillis: 5_000,
+});
+export const reactWebProfile = browserProfile({
+    name: "react-web",
+    runtime: "browser-global",
+    events: "required",
+    traces: "required",
+    metrics: "optional",
+    defects: "required-in-production",
+    browserIngest: "required",
+    stages: ["browser"],
+    stageDeadlineMillis: [stageDeadline("browser", reactWebLifecycle.shutdownDeadlineMillis)],
+    capabilityOrder: [
+        stageCapabilities("browser", ["browser-ingest", "events", "traces", "defects", "metrics"]),
+    ],
+    shutdownDeadlineMillis: reactWebLifecycle.shutdownDeadlineMillis,
+});
+export const cliProfile = nodeProfile({
+    name: "cli",
+    runtime: "node-global",
+    events: "required",
+    traces: "optional",
+    metrics: "optional",
+    defects: "optional",
+    browserIngest: "forbidden",
+    stages: ["server", "metrics"],
+    stageDeadlineMillis: [stageDeadline("server", 5_000), stageDeadline("metrics", 3_000)],
+    capabilityOrder: [
+        stageCapabilities("server", ["events", "traces", "defects"]),
+        stageCapabilities("metrics", ["metrics"]),
+    ],
+    shutdownDeadlineMillis: 5_000,
+});
+export const libraryProfile = libraryProfileDescriptor({
+    name: "library",
+    runtime: "none",
+    events: "forbidden",
+    traces: "forbidden",
+    metrics: "forbidden",
+    defects: "forbidden",
+    browserIngest: "forbidden",
+    stages: [],
+    stageDeadlineMillis: [],
+    capabilityOrder: [],
+    shutdownDeadlineMillis: 0,
+});
+export const observabilityProfiles = Object.freeze({
+    "nestjs-api": nestjsApiProfile,
+    worker: workerProfile,
+    "react-web": reactWebProfile,
+    cli: cliProfile,
+    library: libraryProfile,
+});
+export const profileCapabilityRequirement = (value, capability) => {
+    switch (capability) {
+        case "events":
+            return value.events;
+        case "traces":
+            return value.traces;
+        case "metrics":
+            return value.metrics;
+        case "defects":
+            return value.defects;
+        case "browser-ingest":
+            return value.browserIngest;
+    }
+};
+export const profileStageDeadlineMillis = (profile, stage) => profile.stageDeadlineMillis.find(([candidate]) => candidate === stage)?.[1];
+export const profileCapabilityRank = (profile, stage, capability) => profile.capabilityOrder.find(([candidate]) => candidate === stage)?.[1].indexOf(capability) ??
+    Number.MAX_SAFE_INTEGER;

package/dist/profile/ReactWebProfile.d.ts

@@ -0,0 +1,8 @@
+export type ReactWebLifecycle = {
+    readonly environmentRequiringDefects: "production";
+    readonly shutdownDeadlineMillis: 2_000;
+    readonly eventShutdownDeadlineMillis: 1_150;
+    readonly sentryDeadlineMillis: 800;
+    readonly flushDeadlineMillis: 5_000;
+};
+export declare const reactWebLifecycle: ReactWebLifecycle;

package/dist/profile/ReactWebProfile.js

@@ -0,0 +1,7 @@
+export const reactWebLifecycle = Object.freeze({
+    environmentRequiringDefects: "production",
+    shutdownDeadlineMillis: 2_000,
+    eventShutdownDeadlineMillis: 1_150,
+    sentryDeadlineMillis: 800,
+    flushDeadlineMillis: 5_000,
+});

package/dist/profile/index.d.ts

@@ -0,0 +1,5 @@
+export { AdapterFailure, AdapterName, registerOfficialAdapter, type AdapterOutcome, type AdapterRegistration, type ContractRegistry, type LifecycleCleanupResult, type LifecycleOutcome, type LifecycleOutcomeResult, type LifecycleReport, type ObservabilityAdapter, type ObservabilityAdapterContext, type ObservabilityAdapterHandle, type OfficialAdapterRegistration, type RuntimeDisposalOutcome, } from "./ObservabilityAdapter.js";
+export { ObservabilityLifecycleError } from "./LifecycleRegistry.js";
+export { nodeObservabilityConfigFromEnv, parseNodeObservabilityConfig, type DeploymentScope, type EnvBootstrapInput, type NodeObservabilityConfig, type NodeObservabilityConfigDisabled, type NodeObservabilityConfigEnabled, type NodeObservabilityConfigInput, type SentryConfig, } from "./ObservabilityConfig.js";
+export { DuplicateReleaseVariable, InvalidObservabilityConfig, ObservabilityConfigField, SecondReleaseVariable, } from "./ObservabilityConfigError.js";
+export { cliProfile, libraryProfile, nestjsApiProfile, observabilityProfiles, reactWebProfile, workerProfile, type AdapterCapability, type BrowserObservabilityProfile, type CapabilityRequirement, type LibraryObservabilityProfile, type LifecycleStage, type NodeObservabilityProfile, type ObservabilityProfile, type ProfileName, } from "./ObservabilityProfile.js";

package/dist/profile/index.js

@@ -0,0 +1,5 @@
+export { AdapterFailure, AdapterName, registerOfficialAdapter, } from "./ObservabilityAdapter.js";
+export { ObservabilityLifecycleError } from "./LifecycleRegistry.js";
+export { nodeObservabilityConfigFromEnv, parseNodeObservabilityConfig, } from "./ObservabilityConfig.js";
+export { DuplicateReleaseVariable, InvalidObservabilityConfig, ObservabilityConfigField, SecondReleaseVariable, } from "./ObservabilityConfigError.js";
+export { cliProfile, libraryProfile, nestjsApiProfile, observabilityProfiles, reactWebProfile, workerProfile, } from "./ObservabilityProfile.js";

package/dist/testing/conformance/ConformanceAssertions.d.ts

@@ -0,0 +1,5 @@
+import { Effect } from "effect";
+import { ConformanceAssertionError } from "./ConformanceFailure.js";
+import type { ConformanceCheckId, ConformanceProfileReport, ConformanceReport } from "./ConformanceModel.js";
+export declare const assertConforms: (report: ConformanceProfileReport | ConformanceReport) => Effect.Effect<void, ConformanceAssertionError>;
+export declare const assertConformanceFailure: (report: ConformanceProfileReport, expected: ConformanceCheckId) => Effect.Effect<void, ConformanceAssertionError>;

package/dist/testing/conformance/ConformanceAssertions.js

@@ -0,0 +1,31 @@
+import { Effect } from "effect";
+import { ConformanceAssertionError } from "./ConformanceFailure.js";
+const assertionError = (code, message, offendingValue) => new ConformanceAssertionError({
+    code,
+    message,
+    offendingValue,
+    cause: offendingValue,
+});
+const failureNames = (report) => report.checks
+    .filter((check) => check.status === "fail")
+    .map((check) => `${check.id} (${check.failure.code}: ${check.failure.offendingValue})`);
+export const assertConforms = (report) => {
+    if (report.conforms)
+        return Effect.void;
+    const reports = "profiles" in report ? report.profiles : [report];
+    const failures = reports.flatMap(failureNames);
+    return Effect.fail(assertionError("OBS_CONFORMANCE_NOT_CONFORMANT", `The conformance report does not conform. Failing checks: ${failures.join("; ")}.`, failures.join(", ")));
+};
+export const assertConformanceFailure = (report, expected) => {
+    if (report.conforms) {
+        return Effect.fail(assertionError("OBS_CONFORMANCE_NEGATIVE_FIXTURE_PASSED", `The negative fixture conformed unexpectedly. The check ${expected} must fail.`, expected));
+    }
+    const result = report.checks.find((check) => check.id === expected);
+    if (result === undefined) {
+        return Effect.fail(assertionError("OBS_CONFORMANCE_EXPECTED_FAILURE_ABSENT", `The conformance report does not contain the check ${expected}.`, expected));
+    }
+    if (result.status === "pass" || result.status === "not-applicable") {
+        return Effect.fail(assertionError("OBS_CONFORMANCE_NEGATIVE_FIXTURE_PASSED", `The check ${expected} reported ${result.status} where the negative fixture requires a failure.`, expected));
+    }
+    return Effect.void;
+};

package/dist/testing/conformance/ConformanceFailure.d.ts

@@ -0,0 +1,35 @@
+import { Schema } from "effect";
+export declare const conformanceFailureCodes: readonly ["OBS_CONFORMANCE_PROFILE_INVALID", "OBS_CONFORMANCE_IDENTITY_INVALID", "OBS_CONFORMANCE_CONTRACT_INVALID", "OBS_CONFORMANCE_MANIFEST_INVALID", "OBS_CONFORMANCE_PRODUCER_INVALID", "OBS_CONFORMANCE_QUERY_INVALID", "OBS_CONFORMANCE_CORRELATION_INVALID", "OBS_CONFORMANCE_POLICY_INVALID", "OBS_CONFORMANCE_EVENT_PATH_INVALID", "OBS_CONFORMANCE_SENTRY_BOUNDARY_INVALID", "OBS_CONFORMANCE_LIFECYCLE_INVALID", "OBS_CONFORMANCE_AUDIT_DURABILITY_MISSING", "OBS_CONFORMANCE_LOCAL_OTLP_PIPELINE", "OBS_CONFORMANCE_TELEMETRY_CANARY_FAILED", "OBS_CONFORMANCE_SENTRY_CANARY_FAILED", "OBS_CONFORMANCE_BROWSER_CANARY_FAILED", "OBS_CONFORMANCE_AUDIT_CANARY_FAILED"];
+export type ConformanceFailureCode = (typeof conformanceFailureCodes)[number];
+export declare const ConformanceFailureCodeSchema: Schema.Literals<readonly ["OBS_CONFORMANCE_PROFILE_INVALID", "OBS_CONFORMANCE_IDENTITY_INVALID", "OBS_CONFORMANCE_CONTRACT_INVALID", "OBS_CONFORMANCE_MANIFEST_INVALID", "OBS_CONFORMANCE_PRODUCER_INVALID", "OBS_CONFORMANCE_QUERY_INVALID", "OBS_CONFORMANCE_CORRELATION_INVALID", "OBS_CONFORMANCE_POLICY_INVALID", "OBS_CONFORMANCE_EVENT_PATH_INVALID", "OBS_CONFORMANCE_SENTRY_BOUNDARY_INVALID", "OBS_CONFORMANCE_LIFECYCLE_INVALID", "OBS_CONFORMANCE_AUDIT_DURABILITY_MISSING", "OBS_CONFORMANCE_LOCAL_OTLP_PIPELINE", "OBS_CONFORMANCE_TELEMETRY_CANARY_FAILED", "OBS_CONFORMANCE_SENTRY_CANARY_FAILED", "OBS_CONFORMANCE_BROWSER_CANARY_FAILED", "OBS_CONFORMANCE_AUDIT_CANARY_FAILED"]>;
+declare const ConformanceFailure_base: Schema.Class<ConformanceFailure, Schema.TaggedStruct<"ConformanceFailure", {
+    readonly code: Schema.Literals<readonly ["OBS_CONFORMANCE_PROFILE_INVALID", "OBS_CONFORMANCE_IDENTITY_INVALID", "OBS_CONFORMANCE_CONTRACT_INVALID", "OBS_CONFORMANCE_MANIFEST_INVALID", "OBS_CONFORMANCE_PRODUCER_INVALID", "OBS_CONFORMANCE_QUERY_INVALID", "OBS_CONFORMANCE_CORRELATION_INVALID", "OBS_CONFORMANCE_POLICY_INVALID", "OBS_CONFORMANCE_EVENT_PATH_INVALID", "OBS_CONFORMANCE_SENTRY_BOUNDARY_INVALID", "OBS_CONFORMANCE_LIFECYCLE_INVALID", "OBS_CONFORMANCE_AUDIT_DURABILITY_MISSING", "OBS_CONFORMANCE_LOCAL_OTLP_PIPELINE", "OBS_CONFORMANCE_TELEMETRY_CANARY_FAILED", "OBS_CONFORMANCE_SENTRY_CANARY_FAILED", "OBS_CONFORMANCE_BROWSER_CANARY_FAILED", "OBS_CONFORMANCE_AUDIT_CANARY_FAILED"]>;
+    readonly checkId: Schema.String;
+    readonly profile: Schema.String;
+    readonly rule: Schema.Struct<{
+        readonly document: Schema.String;
+        readonly heading: Schema.String;
+    }>;
+    readonly message: Schema.String;
+    readonly offendingValue: Schema.String;
+    readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+export declare class ConformanceFailure extends ConformanceFailure_base {
+}
+declare const InvalidConformanceSuite_base: Schema.Class<InvalidConformanceSuite, Schema.TaggedStruct<"InvalidConformanceSuite", {
+    readonly code: Schema.Literals<readonly ["OBS_CONFORMANCE_TARGET_INVALID", "OBS_CONFORMANCE_PROVIDER_DUPLICATE", "OBS_CONFORMANCE_PROVIDER_MISSING"]>;
+    readonly message: Schema.String;
+    readonly offendingValue: Schema.String;
+    readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+export declare class InvalidConformanceSuite extends InvalidConformanceSuite_base {
+}
+declare const ConformanceAssertionError_base: Schema.Class<ConformanceAssertionError, Schema.TaggedStruct<"ConformanceAssertionError", {
+    readonly code: Schema.Literals<readonly ["OBS_CONFORMANCE_NOT_CONFORMANT", "OBS_CONFORMANCE_NEGATIVE_FIXTURE_PASSED", "OBS_CONFORMANCE_EXPECTED_FAILURE_ABSENT"]>;
+    readonly message: Schema.String;
+    readonly offendingValue: Schema.String;
+    readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+export declare class ConformanceAssertionError extends ConformanceAssertionError_base {
+}
+export {};

package/dist/testing/conformance/ConformanceFailure.js

@@ -0,0 +1,56 @@
+import { Schema } from "effect";
+export const conformanceFailureCodes = [
+    "OBS_CONFORMANCE_PROFILE_INVALID",
+    "OBS_CONFORMANCE_IDENTITY_INVALID",
+    "OBS_CONFORMANCE_CONTRACT_INVALID",
+    "OBS_CONFORMANCE_MANIFEST_INVALID",
+    "OBS_CONFORMANCE_PRODUCER_INVALID",
+    "OBS_CONFORMANCE_QUERY_INVALID",
+    "OBS_CONFORMANCE_CORRELATION_INVALID",
+    "OBS_CONFORMANCE_POLICY_INVALID",
+    "OBS_CONFORMANCE_EVENT_PATH_INVALID",
+    "OBS_CONFORMANCE_SENTRY_BOUNDARY_INVALID",
+    "OBS_CONFORMANCE_LIFECYCLE_INVALID",
+    "OBS_CONFORMANCE_AUDIT_DURABILITY_MISSING",
+    "OBS_CONFORMANCE_LOCAL_OTLP_PIPELINE",
+    "OBS_CONFORMANCE_TELEMETRY_CANARY_FAILED",
+    "OBS_CONFORMANCE_SENTRY_CANARY_FAILED",
+    "OBS_CONFORMANCE_BROWSER_CANARY_FAILED",
+    "OBS_CONFORMANCE_AUDIT_CANARY_FAILED",
+];
+export const ConformanceFailureCodeSchema = Schema.Literals(conformanceFailureCodes);
+export class ConformanceFailure extends Schema.TaggedError()("ConformanceFailure", {
+    code: ConformanceFailureCodeSchema,
+    checkId: Schema.String,
+    profile: Schema.String,
+    rule: Schema.Struct({
+        document: Schema.String,
+        heading: Schema.String,
+    }),
+    message: Schema.String,
+    offendingValue: Schema.String,
+    cause: Schema.Defect(),
+}) {
+}
+export class InvalidConformanceSuite extends Schema.TaggedError()("InvalidConformanceSuite", {
+    code: Schema.Literals([
+        "OBS_CONFORMANCE_TARGET_INVALID",
+        "OBS_CONFORMANCE_PROVIDER_DUPLICATE",
+        "OBS_CONFORMANCE_PROVIDER_MISSING",
+    ]),
+    message: Schema.String,
+    offendingValue: Schema.String,
+    cause: Schema.Defect(),
+}) {
+}
+export class ConformanceAssertionError extends Schema.TaggedError()("ConformanceAssertionError", {
+    code: Schema.Literals([
+        "OBS_CONFORMANCE_NOT_CONFORMANT",
+        "OBS_CONFORMANCE_NEGATIVE_FIXTURE_PASSED",
+        "OBS_CONFORMANCE_EXPECTED_FAILURE_ABSENT",
+    ]),
+    message: Schema.String,
+    offendingValue: Schema.String,
+    cause: Schema.Defect(),
+}) {
+}

package/dist/testing/conformance/ConformanceModel.d.ts

@@ -0,0 +1,97 @@
+import { Schema, type Effect } from "effect";
+import type { ContractIndex } from "../../contract/ContractIndex.js";
+import type { ObservabilityProfile, ProfileName } from "../../profile/ObservabilityProfile.js";
+import type { ConformanceFailure } from "./ConformanceFailure.js";
+export type ConformanceCheckId = "profile.official" | "identity.canonical" | "contract.compiles" | "manifest.valid" | "producers.contract-derived" | "queries.contract-derived" | "correlation.canonical" | "policy.compiles" | "server-events.evlog-collector" | "sentry.unexpected-defects-only" | "lifecycle.profile-compliant" | "audit.durable-before-operational" | "pipeline.no-application-otlp" | "canary.telemetry-destination" | "canary.sentry" | "canary.browser-route" | "canary.audit";
+export type SourceRuleReference = {
+    readonly document: string;
+    readonly heading: string;
+};
+export type ConformanceOwner = "telemetry" | "cli" | "evlog" | "sentry" | "nestjs" | "react" | "application";
+export type ConformanceTopology = "local" | "deployed";
+export type ConformanceCapabilitySelection = {
+    readonly traces: boolean;
+    readonly metrics: boolean;
+    readonly defects: boolean;
+    readonly browserIngest: boolean;
+    readonly audit: boolean;
+};
+export type ConformanceTargetBinding = {
+    readonly identity: {
+        readonly serviceName: string;
+        readonly serviceVersion: string;
+        readonly environment: string;
+    };
+    readonly contract: ContractIndex;
+    readonly producerContractProvenance: string;
+};
+export type ConformanceTargetContext = {
+    readonly name: string;
+    readonly profile: ObservabilityProfile;
+    readonly environment: string;
+    readonly topology: ConformanceTopology;
+    readonly capabilities: ConformanceCapabilitySelection;
+    readonly binding: ConformanceTargetBinding;
+};
+export type ConformanceEvidence = {
+    readonly owner: ConformanceOwner;
+    readonly receiptType: string;
+    readonly receiptId: string;
+    readonly summary: string;
+};
+declare const ConformanceViolation_base: Schema.Class<ConformanceViolation, Schema.TaggedStruct<"ConformanceViolation", {
+    readonly message: Schema.String;
+    readonly offendingValue: Schema.String;
+    readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+export declare class ConformanceViolation extends ConformanceViolation_base {
+}
+export type ConformanceEvidenceProvider<Id extends ConformanceCheckId = ConformanceCheckId> = {
+    readonly id: Id;
+    readonly owner: ConformanceOwner;
+    readonly verify: (target: ConformanceTargetContext) => Effect.Effect<ConformanceEvidence, ConformanceViolation>;
+};
+export type ConformanceTarget = {
+    readonly name: string;
+    readonly profile: ProfileName;
+    readonly environment: string;
+    readonly topology: ConformanceTopology;
+    readonly capabilities: ConformanceCapabilitySelection;
+    readonly binding: ConformanceTargetBinding;
+    readonly providers: ReadonlyArray<ConformanceEvidenceProvider>;
+};
+export type ConformancePass = {
+    readonly status: "pass";
+    readonly id: ConformanceCheckId;
+    readonly profile: ProfileName;
+    readonly rule: SourceRuleReference;
+    readonly evidence: ConformanceEvidence;
+};
+export type ConformanceNotApplicable = {
+    readonly status: "not-applicable";
+    readonly id: ConformanceCheckId;
+    readonly profile: ProfileName;
+    readonly rule: SourceRuleReference;
+    readonly reason: string;
+};
+export type ConformanceFail = {
+    readonly status: "fail";
+    readonly id: ConformanceCheckId;
+    readonly profile: ProfileName;
+    readonly rule: SourceRuleReference;
+    readonly failure: ConformanceFailure;
+};
+export type ConformanceResult = ConformancePass | ConformanceFail | ConformanceNotApplicable;
+export type ConformanceProfileReport = {
+    readonly target: string;
+    readonly profile: ProfileName;
+    readonly conforms: boolean;
+    readonly checks: ReadonlyArray<ConformanceResult>;
+};
+export type ConformanceReport = {
+    readonly version: 1;
+    readonly conforms: boolean;
+    readonly profiles: ReadonlyArray<ConformanceProfileReport>;
+};
+export declare const defineConformanceEvidenceProvider: <Id extends ConformanceCheckId>(provider: ConformanceEvidenceProvider<Id>) => ConformanceEvidenceProvider<Id>;
+export {};

package/dist/testing/conformance/ConformanceModel.js

@@ -0,0 +1,8 @@
+import { Schema } from "effect";
+export class ConformanceViolation extends Schema.TaggedError()("ConformanceViolation", {
+    message: Schema.String,
+    offendingValue: Schema.String,
+    cause: Schema.Defect(),
+}) {
+}
+export const defineConformanceEvidenceProvider = (provider) => provider;

package/dist/testing/conformance/ConformanceRegistry.d.ts

@@ -0,0 +1,13 @@
+import type { Effect } from "effect";
+import type { ConformanceFailureCode } from "./ConformanceFailure.js";
+import type { ConformanceCheckId, ConformanceEvidence, ConformanceEvidenceProvider, ConformanceOwner, ConformanceTargetContext, ConformanceViolation, SourceRuleReference } from "./ConformanceModel.js";
+export type ConformanceCheck = {
+    readonly id: ConformanceCheckId;
+    readonly owner: ConformanceOwner;
+    readonly code: ConformanceFailureCode;
+    readonly rule: SourceRuleReference;
+    readonly applies: (target: ConformanceTargetContext) => boolean;
+    readonly notApplicableReason: (target: ConformanceTargetContext) => string;
+    readonly run: (target: ConformanceTargetContext, provider: ConformanceEvidenceProvider<ConformanceCheckId>) => Effect.Effect<ConformanceEvidence, ConformanceViolation>;
+};
+export declare const conformanceChecks: ReadonlyArray<ConformanceCheck>;

package/dist/testing/conformance/ConformanceRegistry.js

@@ -0,0 +1,190 @@
+const rule = (document, heading) => ({
+    document,
+    heading,
+});
+const profilesRule = rule("docs/profiles.md", "Perfis oficiais de observabilidade");
+const nodeConfigRule = rule("docs/profiles.md", "Configuração de Node");
+const contractRule = rule("docs/telemetry-contract.md", "Contrato de telemetria");
+const manifestRule = rule("docs/operations-manifest.md", "Manifesto de operações");
+const emitReceiptRule = rule("docs/telemetry-contract.md", "Recibo de emissão");
+const managedQueriesRule = rule("docs/operations-manifest.md", "Queries gerenciadas");
+const correlationRule = rule("docs/telemetry-contract.md", "Correlação tipada");
+const policyRule = rule("docs/data-policy.md", "Declaração da política");
+const sentryRule = rule("docs/sentry-adapters.md", "Adaptadores Sentry");
+const lifecycleRule = rule("docs/profiles.md", "Ciclo de vida");
+const auditRule = rule("docs/audit.md", "Ordem durável");
+const boundariesRule = rule("docs/coding-standards.md", "Fronteiras do monorepo");
+const canaryRule = rule("docs/testing.md", "Canário do pipeline");
+const browserRule = rule("docs/profiles.md", "Runtime React web");
+const manifestProfiles = new Set(["nestjs-api", "worker", "react-web", "cli"]);
+const serverEventProfiles = new Set(["nestjs-api", "worker", "cli"]);
+const nodeCanaryProfiles = new Set(["nestjs-api", "worker", "cli"]);
+const capabilitiesSummary = (target) => [
+    target.capabilities.traces ? "traces" : undefined,
+    target.capabilities.metrics ? "metrics" : undefined,
+    target.capabilities.defects ? "defects" : undefined,
+    target.capabilities.browserIngest ? "browser-ingest" : undefined,
+    target.capabilities.audit ? "audit" : undefined,
+]
+    .filter((value) => value !== undefined)
+    .join(",");
+const notApplicableWithoutCapability = (capability) => (target) => `the target does not select the ${capability} capability (selected: ${capabilitiesSummary(target)})`;
+export const conformanceChecks = Object.freeze([
+    {
+        id: "profile.official",
+        owner: "telemetry",
+        code: "OBS_CONFORMANCE_PROFILE_INVALID",
+        rule: profilesRule,
+        applies: () => true,
+        notApplicableReason: () => "every target must prove one official profile",
+        run: (target, provider) => provider.verify(target),
+    },
+    {
+        id: "identity.canonical",
+        owner: "telemetry",
+        code: "OBS_CONFORMANCE_IDENTITY_INVALID",
+        rule: nodeConfigRule,
+        applies: (target) => target.profile.name !== "library",
+        notApplicableReason: () => "the library profile owns no runtime resource identity",
+        run: (target, provider) => provider.verify(target),
+    },
+    {
+        id: "contract.compiles",
+        owner: "telemetry",
+        code: "OBS_CONFORMANCE_CONTRACT_INVALID",
+        rule: contractRule,
+        applies: () => true,
+        notApplicableReason: () => "every application must compile its telemetry contract",
+        run: (target, provider) => provider.verify(target),
+    },
+    {
+        id: "manifest.valid",
+        owner: "cli",
+        code: "OBS_CONFORMANCE_MANIFEST_INVALID",
+        rule: manifestRule,
+        applies: (target) => manifestProfiles.has(target.profile.name),
+        notApplicableReason: () => "the library profile declares no operations manifest",
+        run: (target, provider) => provider.verify(target),
+    },
+    {
+        id: "producers.contract-derived",
+        owner: "telemetry",
+        code: "OBS_CONFORMANCE_PRODUCER_INVALID",
+        rule: emitReceiptRule,
+        applies: (target) => target.profile.events !== "forbidden",
+        notApplicableReason: () => "the library profile forbids events and producers",
+        run: (target, provider) => provider.verify(target),
+    },
+    {
+        id: "queries.contract-derived",
+        owner: "cli",
+        code: "OBS_CONFORMANCE_QUERY_INVALID",
+        rule: managedQueriesRule,
+        applies: (target) => manifestProfiles.has(target.profile.name),
+        notApplicableReason: () => "the library profile declares no managed queries",
+        run: (target, provider) => provider.verify(target),
+    },
+    {
+        id: "correlation.canonical",
+        owner: "telemetry",
+        code: "OBS_CONFORMANCE_CORRELATION_INVALID",
+        rule: correlationRule,
+        applies: (target) => target.profile.events !== "forbidden" || target.profile.traces !== "forbidden",
+        notApplicableReason: () => "the library profile emits no events and no traces to correlate",
+        run: (target, provider) => provider.verify(target),
+    },
+    {
+        id: "policy.compiles",
+        owner: "telemetry",
+        code: "OBS_CONFORMANCE_POLICY_INVALID",
+        rule: policyRule,
+        applies: (target) => target.profile.events !== "forbidden" ||
+            target.profile.traces !== "forbidden" ||
+            target.profile.metrics !== "forbidden",
+        notApplicableReason: () => "the library profile exports no runtime signals",
+        run: (target, provider) => provider.verify(target),
+    },
+    {
+        id: "server-events.evlog-collector",
+        owner: "evlog",
+        code: "OBS_CONFORMANCE_EVENT_PATH_INVALID",
+        rule: nodeConfigRule,
+        applies: (target) => serverEventProfiles.has(target.profile.name),
+        notApplicableReason: () => "the profile owns no Node server event path through evlog and the Collector",
+        run: (target, provider) => provider.verify(target),
+    },
+    {
+        id: "sentry.unexpected-defects-only",
+        owner: "sentry",
+        code: "OBS_CONFORMANCE_SENTRY_BOUNDARY_INVALID",
+        rule: sentryRule,
+        applies: (target) => target.capabilities.defects,
+        notApplicableReason: notApplicableWithoutCapability("defects"),
+        run: (target, provider) => provider.verify(target),
+    },
+    {
+        id: "lifecycle.profile-compliant",
+        owner: "telemetry",
+        code: "OBS_CONFORMANCE_LIFECYCLE_INVALID",
+        rule: lifecycleRule,
+        applies: () => true,
+        notApplicableReason: () => "every target proves lifecycle compliance or runtime absence",
+        run: (target, provider) => provider.verify(target),
+    },
+    {
+        id: "audit.durable-before-operational",
+        owner: "telemetry",
+        code: "OBS_CONFORMANCE_AUDIT_DURABILITY_MISSING",
+        rule: auditRule,
+        applies: (target) => target.capabilities.audit,
+        notApplicableReason: notApplicableWithoutCapability("audit"),
+        run: (target, provider) => provider.verify(target),
+    },
+    {
+        id: "pipeline.no-application-otlp",
+        owner: "cli",
+        code: "OBS_CONFORMANCE_LOCAL_OTLP_PIPELINE",
+        rule: boundariesRule,
+        applies: () => true,
+        notApplicableReason: () => "every application source tree must reject local OTLP pipelines",
+        run: (target, provider) => provider.verify(target),
+    },
+    {
+        id: "canary.telemetry-destination",
+        owner: "telemetry",
+        code: "OBS_CONFORMANCE_TELEMETRY_CANARY_FAILED",
+        rule: canaryRule,
+        applies: (target) => nodeCanaryProfiles.has(target.profile.name) ||
+            target.capabilities.traces ||
+            target.capabilities.metrics,
+        notApplicableReason: () => "the target selects no telemetry signal requiring destination proof",
+        run: (target, provider) => provider.verify(target),
+    },
+    {
+        id: "canary.sentry",
+        owner: "sentry",
+        code: "OBS_CONFORMANCE_SENTRY_CANARY_FAILED",
+        rule: sentryRule,
+        applies: (target) => target.capabilities.defects,
+        notApplicableReason: notApplicableWithoutCapability("defects"),
+        run: (target, provider) => provider.verify(target),
+    },
+    {
+        id: "canary.browser-route",
+        owner: "react",
+        code: "OBS_CONFORMANCE_BROWSER_CANARY_FAILED",
+        rule: browserRule,
+        applies: (target) => target.capabilities.browserIngest,
+        notApplicableReason: notApplicableWithoutCapability("browser-ingest"),
+        run: (target, provider) => provider.verify(target),
+    },
+    {
+        id: "canary.audit",
+        owner: "telemetry",
+        code: "OBS_CONFORMANCE_AUDIT_CANARY_FAILED",
+        rule: auditRule,
+        applies: (target) => target.capabilities.audit,
+        notApplicableReason: notApplicableWithoutCapability("audit"),
+        run: (target, provider) => provider.verify(target),
+    },
+]);

package/dist/testing/conformance/ConformanceRunner.d.ts

@@ -0,0 +1,5 @@
+import { Effect } from "effect";
+import { InvalidConformanceSuite } from "./ConformanceFailure.js";
+import type { ConformanceProfileReport, ConformanceReport, ConformanceTarget } from "./ConformanceModel.js";
+export declare const runConformance: (target: ConformanceTarget) => Effect.Effect<ConformanceProfileReport, InvalidConformanceSuite>;
+export declare const runConformanceSuite: (targets: ReadonlyArray<ConformanceTarget>) => Effect.Effect<ConformanceReport, InvalidConformanceSuite>;