@equipe-tech/observability 0.2.0 → 0.3.5

package/dist/TelemetryConfig.d.ts

@@ -1,12 +1,19 @@
 import { Effect, Schema } from "effect";
+import { EnvironmentAliasPolicy, InvalidResourceIdentity, ResourceIdentity } from "./ResourceIdentity.js";
+import type { DuplicateReleaseVariable } from "./profile/ObservabilityConfigError.js";
 export declare const OtlpEndpoint: Schema.URLFromString;
+export interface TelemetryConfigInput {
+    readonly identity: ResourceIdentity;
+    readonly environmentAlias?: EnvironmentAliasPolicy | undefined;
+    readonly otlpEndpoint: URL;
+}
 declare const TelemetryConfig_base: Schema.Class<TelemetryConfig, Schema.Struct<{
-    readonly serviceName: Schema.NonEmptyString;
-    readonly serviceVersion: Schema.NonEmptyString;
-    readonly environment: Schema.NonEmptyString;
+    readonly identity: typeof ResourceIdentity;
+    readonly environmentAlias: Schema.withConstructorDefault<Schema.Literals<readonly ["emitted", "omitted"]>>;
     readonly otlpEndpoint: Schema.URLFromString;
 }>, {}>;
 export declare class TelemetryConfig extends TelemetryConfig_base {
+    constructor(input: TelemetryConfigInput);
 }
 declare const InvalidTelemetryEnvironment_base: Schema.Class<InvalidTelemetryEnvironment, Schema.TaggedStruct<"InvalidTelemetryEnvironment", {
     readonly code: Schema.Literal<"OBS_TELEMETRY_INVALID_ENVIRONMENT">;
@@ -18,5 +25,5 @@ export declare class InvalidTelemetryEnvironment extends InvalidTelemetryEnviron
 export type EnvironmentVariables = {
     readonly [name: string]: string | undefined;
 };
-export declare const telemetryConfigFromEnv: (env: EnvironmentVariables) => Effect.Effect<TelemetryConfig, InvalidTelemetryEnvironment, never>;
+export declare const telemetryConfigFromEnv: (env: EnvironmentVariables) => Effect.Effect<TelemetryConfig, DuplicateReleaseVariable | InvalidResourceIdentity | InvalidTelemetryEnvironment, never>;
 export {};

package/dist/TelemetryConfig.js

@@ -1,13 +1,21 @@
-import { Effect, Schema } from "effect";
+import { Effect, Option, Schema } from "effect";
+import { EnvironmentAliasPolicy, parseResourceIdentity, ResourceIdentity, } from "./ResourceIdentity.js";
+import { rejectSecondReleaseVariables, resolveEnvironmentPolicy, } from "./profile/EnvironmentPolicy.js";
 export const OtlpEndpoint = Schema.URLFromString.check(Schema.makeFilter((url) => (url.protocol === "http:" || url.protocol === "https:") &&
     url.username === "" &&
     url.password === "", { expected: "an HTTP or HTTPS URL without credentials" }));
 export class TelemetryConfig extends Schema.Class("@equipe-tech/observability/TelemetryConfig")({
-    serviceName: Schema.NonEmptyString,
-    serviceVersion: Schema.NonEmptyString,
-    environment: Schema.NonEmptyString,
+    identity: ResourceIdentity,
+    environmentAlias: EnvironmentAliasPolicy.pipe(Schema.withConstructorDefault(Effect.succeed("omitted"))),
     otlpEndpoint: OtlpEndpoint,
 }) {
+    constructor(input) {
+        super({
+            identity: input.identity,
+            environmentAlias: input.environmentAlias ?? "omitted",
+            otlpEndpoint: input.otlpEndpoint,
+        });
+    }
 }
 export class InvalidTelemetryEnvironment extends Schema.TaggedError()("InvalidTelemetryEnvironment", {
     code: Schema.Literal("OBS_TELEMETRY_INVALID_ENVIRONMENT"),
@@ -17,21 +25,41 @@ export class InvalidTelemetryEnvironment extends Schema.TaggedError()("InvalidTe
 }
 const TelemetryEnvironment = Schema.Struct({
     OTEL_SERVICE_NAME: Schema.NonEmptyString,
-    OTEL_SERVICE_VERSION: Schema.NonEmptyString.pipe(Schema.withDecodingDefault(Effect.succeed("0.0.0"))),
-    OTEL_DEPLOYMENT_ENVIRONMENT: Schema.NonEmptyString.pipe(Schema.withDecodingDefault(Effect.succeed("development"))),
-    OTEL_EXPORTER_OTLP_ENDPOINT: OtlpEndpoint.pipe(Schema.withDecodingDefault(Effect.succeed("http://localhost:4318"))),
+    OTEL_SERVICE_VERSION: Schema.Union([Schema.NonEmptyString, Schema.Undefined]).pipe(Schema.optionalKey),
+    OTEL_DEPLOYMENT_ENVIRONMENT: Schema.Union([Schema.NonEmptyString, Schema.Undefined]).pipe(Schema.optionalKey),
+    OTEL_SERVICE_INSTANCE_ID: Schema.Union([Schema.String, Schema.Undefined]).pipe(Schema.optionalKey),
+    OTEL_EXPORTER_OTLP_ENDPOINT: Schema.Union([OtlpEndpoint, Schema.Undefined]).pipe(Schema.optionalKey),
 });
 const decodeTelemetryEnvironment = Schema.decodeUnknownEffect(TelemetryEnvironment);
 export const telemetryConfigFromEnv = Effect.fn("telemetryConfigFromEnv")(function* (env) {
+    yield* rejectSecondReleaseVariables(env);
     const variables = yield* decodeTelemetryEnvironment(env).pipe(Effect.mapError((cause) => new InvalidTelemetryEnvironment({
         code: "OBS_TELEMETRY_INVALID_ENVIRONMENT",
         message: "Telemetry environment is invalid. Set OTEL_SERVICE_NAME and use valid values for the remaining OTEL variables.",
         cause,
     })));
-    return new TelemetryConfig({
-        serviceName: variables.OTEL_SERVICE_NAME,
+    const resolution = resolveEnvironmentPolicy({
+        endpoint: variables.OTEL_EXPORTER_OTLP_ENDPOINT,
         serviceVersion: variables.OTEL_SERVICE_VERSION,
         environment: variables.OTEL_DEPLOYMENT_ENVIRONMENT,
-        otlpEndpoint: variables.OTEL_EXPORTER_OTLP_ENDPOINT,
+    });
+    if (resolution.kind === "missing-remote-identity") {
+        return yield* new InvalidTelemetryEnvironment({
+            code: "OBS_TELEMETRY_INVALID_ENVIRONMENT",
+            message: "A remote OTLP endpoint requires OTEL_SERVICE_VERSION and OTEL_DEPLOYMENT_ENVIRONMENT. Set both canonical identity variables.",
+            cause: resolution.missing,
+        });
+    }
+    const identity = yield* parseResourceIdentity({
+        serviceName: variables.OTEL_SERVICE_NAME,
+        serviceVersion: resolution.serviceVersion,
+        environment: resolution.environment,
+        instance: variables.OTEL_SERVICE_INSTANCE_ID === ""
+            ? Option.none()
+            : Option.fromNullishOr(variables.OTEL_SERVICE_INSTANCE_ID),
+    });
+    return new TelemetryConfig({
+        identity,
+        otlpEndpoint: resolution.endpoint,
     });
 });

package/dist/audit/AuditCommitDocument.d.ts

@@ -0,0 +1,41 @@
+import { Schema } from "effect";
+import { AuditHash } from "./AuditDigest.js";
+import { AuditOccurredAt, type AuditRecord } from "./AuditRecord.js";
+export declare const AuditCommitDocument: Schema.Struct<{
+    readonly schemaVersion: Schema.Literal<1>;
+    readonly recordId: Schema.brand<Schema.NonEmptyString, "AuditRecordId">;
+    readonly action: Schema.brand<Schema.NonEmptyString, "AuditAction">;
+    readonly actor: Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"user">;
+        readonly id: Schema.brand<Schema.NonEmptyString, "AuditActorId">;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"service">;
+        readonly id: Schema.brand<Schema.NonEmptyString, "AuditActorId">;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"system">;
+    }>]>;
+    readonly resource: Schema.Struct<{
+        readonly type: Schema.brand<Schema.NonEmptyString, "AuditResourceType">;
+        readonly id: Schema.brand<Schema.NonEmptyString, "AuditResourceId">;
+    }>;
+    readonly outcome: Schema.Literals<readonly ["success", "failure", "cancelled", "denied"]>;
+    readonly reasonCode: Schema.NullOr<Schema.brand<Schema.NonEmptyString, "AuditReasonCode">>;
+    readonly tenantId: Schema.NullOr<Schema.brand<Schema.NonEmptyString, "AuditTenantId">>;
+    readonly occurredAt: Schema.brand<Schema.String, "AuditOccurredAt">;
+    readonly correlation: Schema.Union<readonly [Schema.Struct<{
+        readonly traceId: Schema.Null;
+        readonly spanId: Schema.Null;
+        readonly requestId: Schema.NullOr<Schema.brand<Schema.NonEmptyString, "RequestId">>;
+        readonly runId: Schema.NullOr<Schema.brand<Schema.NonEmptyString, "RunId">>;
+    }>, Schema.Struct<{
+        readonly traceId: Schema.brand<Schema.String, "TraceId">;
+        readonly spanId: Schema.brand<Schema.String, "SpanId">;
+        readonly requestId: Schema.NullOr<Schema.brand<Schema.NonEmptyString, "RequestId">>;
+        readonly runId: Schema.NullOr<Schema.brand<Schema.NonEmptyString, "RunId">>;
+    }>]>;
+    readonly committedAt: Schema.brand<Schema.String, "AuditOccurredAt">;
+    readonly ledgerHash: Schema.brand<Schema.String, "AuditHash">;
+}>;
+export type AuditCommitDocument = typeof AuditCommitDocument.Type;
+export type AuditCommitDocumentEncoded = typeof AuditCommitDocument.Encoded;
+export declare const auditCommitDocumentFor: (record: AuditRecord, committedAt: AuditOccurredAt, ledgerHash: AuditHash) => AuditCommitDocument;

package/dist/audit/AuditCommitDocument.js

@@ -0,0 +1,58 @@
+import { Option, Schema } from "effect";
+import { RequestId, RunId, SpanId, TraceId } from "../Correlation.js";
+import { AuditHash } from "./AuditDigest.js";
+import { AuditAction, AuditActor, AuditOccurredAt, AuditOutcome, AuditReasonCode, AuditRecordId, AuditResource, AuditTenantId, } from "./AuditRecord.js";
+const AuditCommitCorrelation = Schema.Union([
+    Schema.Struct({
+        traceId: Schema.Null,
+        spanId: Schema.Null,
+        requestId: Schema.NullOr(RequestId),
+        runId: Schema.NullOr(RunId),
+    }),
+    Schema.Struct({
+        traceId: TraceId,
+        spanId: SpanId,
+        requestId: Schema.NullOr(RequestId),
+        runId: Schema.NullOr(RunId),
+    }),
+]);
+export const AuditCommitDocument = Schema.Struct({
+    schemaVersion: Schema.Literal(1),
+    recordId: AuditRecordId,
+    action: AuditAction,
+    actor: AuditActor,
+    resource: AuditResource,
+    outcome: AuditOutcome,
+    reasonCode: Schema.NullOr(AuditReasonCode),
+    tenantId: Schema.NullOr(AuditTenantId),
+    occurredAt: AuditOccurredAt,
+    correlation: AuditCommitCorrelation,
+    committedAt: AuditOccurredAt,
+    ledgerHash: AuditHash,
+});
+export const auditCommitDocumentFor = (record, committedAt, ledgerHash) => ({
+    schemaVersion: record.schemaVersion,
+    recordId: record.recordId,
+    action: record.action,
+    actor: record.actor,
+    resource: record.resource,
+    outcome: record.outcome,
+    reasonCode: Option.getOrNull(record.reasonCode),
+    tenantId: Option.getOrNull(record.tenantId),
+    occurredAt: record.occurredAt,
+    correlation: record.correlation.trace._tag === "Untraced"
+        ? {
+            traceId: null,
+            spanId: null,
+            requestId: Option.getOrNull(record.correlation.requestId),
+            runId: Option.getOrNull(record.correlation.runId),
+        }
+        : {
+            traceId: record.correlation.trace.traceId,
+            spanId: record.correlation.trace.spanId,
+            requestId: Option.getOrNull(record.correlation.requestId),
+            runId: Option.getOrNull(record.correlation.runId),
+        },
+    committedAt,
+    ledgerHash,
+});

package/dist/audit/AuditDigest.d.ts

@@ -0,0 +1,11 @@
+import { Context, Effect, Schema } from "effect";
+import type { AuditOccurredAt, AuditRecord } from "./AuditRecord.js";
+export declare const AuditHash: Schema.brand<Schema.String, "AuditHash">;
+export type AuditHash = typeof AuditHash.Type;
+export declare const canonicalAuditPayload: (record: AuditRecord, committedAt: AuditOccurredAt) => string;
+declare const AuditDigest_base: Context.ServiceClass<AuditDigest, "@equipe-tech/observability/AuditDigest", {
+    readonly hash: (payload: string) => Effect.Effect<AuditHash>;
+}>;
+export declare class AuditDigest extends AuditDigest_base {
+}
+export {};

package/dist/audit/AuditDigest.js

@@ -0,0 +1,25 @@
+import { Context, Schema } from "effect";
+import { Option } from "effect";
+export const AuditHash = Schema.String.check(Schema.isPattern(/^[0-9a-f]{64}$/)).pipe(Schema.brand("AuditHash"));
+export const canonicalAuditPayload = (record, committedAt) => JSON.stringify({
+    action: record.action,
+    actor: record.actor.kind === "system"
+        ? { kind: record.actor.kind }
+        : { id: record.actor.id, kind: record.actor.kind },
+    committedAt,
+    correlation: {
+        requestId: Option.getOrNull(record.correlation.requestId),
+        runId: Option.getOrNull(record.correlation.runId),
+        spanId: Option.getOrNull(record.correlation.spanId),
+        traceId: Option.getOrNull(record.correlation.traceId),
+    },
+    occurredAt: record.occurredAt,
+    outcome: record.outcome,
+    reasonCode: Option.getOrNull(record.reasonCode),
+    recordId: record.recordId,
+    resource: { id: record.resource.id, type: record.resource.type },
+    schemaVersion: record.schemaVersion,
+    tenantId: Option.getOrNull(record.tenantId),
+});
+export class AuditDigest extends Context.Service()("@equipe-tech/observability/AuditDigest") {
+}

package/dist/audit/AuditOutbox.d.ts

@@ -0,0 +1,75 @@
+import { Context, Effect, Schema } from "effect";
+import { AuditDigest } from "./AuditDigest.js";
+import { AuditPublisher, type AuditPublishReceipt } from "./AuditPublisher.js";
+declare const AuditOutboxFailure_base: Schema.Class<AuditOutboxFailure, Schema.TaggedStruct<"AuditOutboxFailure", {
+    readonly code: Schema.Literal<"OBS_AUDIT_OUTBOX_FAILED">;
+    readonly message: Schema.String;
+    readonly operation: Schema.Literals<readonly ["claim", "parse", "publish", "settle"]>;
+    readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+export declare class AuditOutboxFailure extends AuditOutboxFailure_base {
+}
+export declare const AuditOutboxDocument: Schema.Struct<{
+    readonly schemaVersion: Schema.Literal<1>;
+    readonly recordId: Schema.brand<Schema.NonEmptyString, "AuditRecordId">;
+    readonly action: Schema.brand<Schema.NonEmptyString, "AuditAction">;
+    readonly actor: Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"user">;
+        readonly id: Schema.brand<Schema.NonEmptyString, "AuditActorId">;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"service">;
+        readonly id: Schema.brand<Schema.NonEmptyString, "AuditActorId">;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"system">;
+    }>]>;
+    readonly resource: Schema.Struct<{
+        readonly type: Schema.brand<Schema.NonEmptyString, "AuditResourceType">;
+        readonly id: Schema.brand<Schema.NonEmptyString, "AuditResourceId">;
+    }>;
+    readonly outcome: Schema.Literals<readonly ["success", "failure", "cancelled", "denied"]>;
+    readonly reasonCode: Schema.NullOr<Schema.brand<Schema.NonEmptyString, "AuditReasonCode">>;
+    readonly tenantId: Schema.NullOr<Schema.brand<Schema.NonEmptyString, "AuditTenantId">>;
+    readonly occurredAt: Schema.brand<Schema.String, "AuditOccurredAt">;
+    readonly correlation: Schema.Union<readonly [Schema.Struct<{
+        readonly traceId: Schema.Null;
+        readonly spanId: Schema.Null;
+        readonly requestId: Schema.NullOr<Schema.brand<Schema.NonEmptyString, "RequestId">>;
+        readonly runId: Schema.NullOr<Schema.brand<Schema.NonEmptyString, "RunId">>;
+    }>, Schema.Struct<{
+        readonly traceId: Schema.brand<Schema.String, "TraceId">;
+        readonly spanId: Schema.brand<Schema.String, "SpanId">;
+        readonly requestId: Schema.NullOr<Schema.brand<Schema.NonEmptyString, "RequestId">>;
+        readonly runId: Schema.NullOr<Schema.brand<Schema.NonEmptyString, "RunId">>;
+    }>]>;
+    readonly committedAt: Schema.brand<Schema.String, "AuditOccurredAt">;
+    readonly ledgerHash: Schema.brand<Schema.String, "AuditHash">;
+}>;
+export type AuditOutboxDocument = typeof AuditOutboxDocument.Type;
+export declare const AuditOutboxClaimKey: Schema.brand<Schema.NonEmptyString, "AuditOutboxClaimKey">;
+export type AuditOutboxClaimKey = typeof AuditOutboxClaimKey.Type;
+export type AuditOutboxValue = string | number | boolean | null | ReadonlyArray<AuditOutboxValue> | {
+    readonly [field: string]: AuditOutboxValue;
+};
+export type AuditOutboxEntry = {
+    readonly claimKey: AuditOutboxClaimKey;
+    readonly document: AuditOutboxValue;
+};
+export type AuditOutboxSettlement = AuditPublishReceipt | {
+    readonly kind: "quarantined";
+    readonly reason: "invalid-document";
+};
+declare const AuditOutbox_base: Context.ServiceClass<AuditOutbox, "@equipe-tech/observability/AuditOutbox", {
+    readonly claim: (maximum: number) => Effect.Effect<ReadonlyArray<AuditOutboxEntry>, AuditOutboxFailure>;
+    readonly settle: (claimKey: AuditOutboxClaimKey, settlement: AuditOutboxSettlement) => Effect.Effect<void, AuditOutboxFailure>;
+}>;
+export declare class AuditOutbox extends AuditOutbox_base {
+}
+export type AuditOutboxDrainReport = {
+    readonly claimed: number;
+    readonly published: number;
+    readonly deduplicated: number;
+    readonly dropped: number;
+    readonly quarantined: number;
+};
+export declare const drainAuditOutbox: (maximum: number) => Effect.Effect<AuditOutboxDrainReport, AuditOutboxFailure, AuditDigest | AuditOutbox | AuditPublisher>;
+export {};

package/dist/audit/AuditOutbox.js

@@ -0,0 +1,104 @@
+import { Context, Effect, Option, Schema } from "effect";
+import { CorrelationContext } from "../Correlation.js";
+import { AuditCommitDocument as AuditCommitDocumentSchema } from "./AuditCommitDocument.js";
+import { AuditDigest, canonicalAuditPayload } from "./AuditDigest.js";
+import { sealCommittedAuditRecord, } from "./CommittedAuditRecordInternal.js";
+import { reparseAuditRecord } from "./AuditRecord.js";
+import { AuditPublisher } from "./AuditPublisher.js";
+export class AuditOutboxFailure extends Schema.TaggedError()("AuditOutboxFailure", {
+    code: Schema.Literal("OBS_AUDIT_OUTBOX_FAILED"),
+    message: Schema.String,
+    operation: Schema.Literals(["claim", "parse", "publish", "settle"]),
+    cause: Schema.Defect(),
+}) {
+}
+export const AuditOutboxDocument = AuditCommitDocumentSchema;
+export const AuditOutboxClaimKey = Schema.NonEmptyString.check(Schema.isMaxLength(256)).pipe(Schema.brand("AuditOutboxClaimKey"));
+export class AuditOutbox extends Context.Service()("@equipe-tech/observability/AuditOutbox") {
+}
+const decodeDocument = Schema.decodeUnknownEffect(AuditOutboxDocument);
+const failure = (operation, message, cause) => new AuditOutboxFailure({
+    code: "OBS_AUDIT_OUTBOX_FAILED",
+    operation,
+    message,
+    cause,
+});
+const restore = Effect.fn("restoreAuditOutboxRecord")(function* (document) {
+    const decoded = yield* decodeDocument(document).pipe(Effect.mapError(() => failure("parse", "The claimed audit outbox document is invalid.", "invalid document")));
+    const correlation = new CorrelationContext({
+        trace: decoded.correlation.traceId === null
+            ? { _tag: "Untraced" }
+            : {
+                _tag: "Traced",
+                traceId: decoded.correlation.traceId,
+                spanId: decoded.correlation.spanId,
+            },
+        requestId: decoded.correlation.requestId === null
+            ? Option.none()
+            : Option.some(decoded.correlation.requestId),
+        runId: decoded.correlation.runId === null ? Option.none() : Option.some(decoded.correlation.runId),
+    });
+    const record = yield* reparseAuditRecord({
+        schemaVersion: decoded.schemaVersion,
+        recordId: decoded.recordId,
+        action: decoded.action,
+        actor: decoded.actor,
+        resource: decoded.resource,
+        outcome: decoded.outcome,
+        reasonCode: decoded.reasonCode === null ? Option.none() : Option.some(decoded.reasonCode),
+        tenantId: decoded.tenantId === null ? Option.none() : Option.some(decoded.tenantId),
+        occurredAt: decoded.occurredAt,
+        correlation,
+    }).pipe(Effect.orDie);
+    const digest = yield* AuditDigest;
+    const ledgerHash = yield* digest.hash(canonicalAuditPayload(record, decoded.committedAt));
+    if (ledgerHash !== decoded.ledgerHash) {
+        return yield* failure("parse", "The claimed audit outbox document does not match its ledger hash.", "digest mismatch");
+    }
+    return sealCommittedAuditRecord(record, decoded.committedAt, decoded.ledgerHash);
+});
+export const drainAuditOutbox = Effect.fn("drainAuditOutbox")(function* (maximum) {
+    const outbox = yield* AuditOutbox;
+    const publisher = yield* AuditPublisher;
+    const entries = yield* outbox
+        .claim(maximum)
+        .pipe(Effect.mapError(() => failure("claim", "The audit outbox could not claim pending records.", "audit outbox claim failed")));
+    const settle = (claimKey, settlement) => outbox
+        .settle(claimKey, settlement)
+        .pipe(Effect.mapError(() => failure("settle", "The audit outbox could not settle a claimed record.", "audit outbox settlement failed")));
+    let published = 0;
+    let deduplicated = 0;
+    let dropped = 0;
+    let quarantined = 0;
+    for (const entry of entries) {
+        const restored = yield* restore(entry.document).pipe(Effect.match({ onFailure: () => Option.none(), onSuccess: Option.some }));
+        if (Option.isNone(restored)) {
+            yield* settle(entry.claimKey, {
+                kind: "quarantined",
+                reason: "invalid-document",
+            });
+            quarantined += 1;
+            continue;
+        }
+        const receipt = yield* publisher.publish(restored.value);
+        yield* settle(entry.claimKey, receipt);
+        switch (receipt.kind) {
+            case "published":
+                published += 1;
+                break;
+            case "deduplicated":
+                deduplicated += 1;
+                break;
+            case "dropped":
+                dropped += 1;
+                break;
+        }
+    }
+    return {
+        claimed: entries.length,
+        published,
+        deduplicated,
+        dropped,
+        quarantined,
+    };
+});

package/dist/audit/AuditPublisher.d.ts

@@ -0,0 +1,49 @@
+import { Context, Effect, Option } from "effect";
+import { type AuditCommitDocument } from "./AuditCommitDocument.js";
+import { AuditDigest } from "./AuditDigest.js";
+import { type CommittedAuditRecord } from "./CommittedAuditRecordInternal.js";
+import { type AuditRecord } from "./AuditRecord.js";
+import { InvalidAuditRecord } from "./InvalidAuditRecord.js";
+export type { CommittedAuditRecord } from "./CommittedAuditRecordInternal.js";
+export type AuditDropReason = "unbound" | "closed" | "queue-overflow" | "contract-rejected" | "policy-rejected" | "transport";
+export type AuditPublishReceipt = {
+    readonly kind: "published";
+} | {
+    readonly kind: "deduplicated";
+} | {
+    readonly kind: "dropped";
+    readonly reason: AuditDropReason;
+};
+export type AuditPublishReasonCounts = {
+    readonly unbound: number;
+    readonly closed: number;
+    readonly queueOverflow: number;
+    readonly contractRejected: number;
+    readonly policyRejected: number;
+    readonly transport: number;
+};
+export type AuditPublishReport = {
+    readonly published: number;
+    readonly deduplicated: number;
+    readonly dropped: number;
+    readonly firstDroppedAt: Option.Option<string>;
+    readonly lastDroppedAt: Option.Option<string>;
+    readonly reasons: AuditPublishReasonCounts;
+};
+export type AuditPublisherService = {
+    readonly publish: (record: CommittedAuditRecord) => Effect.Effect<AuditPublishReceipt>;
+    readonly report: () => AuditPublishReport;
+};
+export declare const unboundAuditPublisher: () => AuditPublisherService;
+declare const AuditPublisher_base: Context.ServiceClass<AuditPublisher, "@equipe-tech/observability/AuditPublisher", AuditPublisherService>;
+export declare class AuditPublisher extends AuditPublisher_base {
+}
+export type CommitAuditResult<A> = {
+    readonly committed: A;
+    readonly record: CommittedAuditRecord;
+};
+export declare const commitAuditRecord: <A, E, R>(record: AuditRecord, durableWrite: (document: AuditCommitDocument) => Effect.Effect<A, E, R>) => Effect.Effect<CommitAuditResult<A>, E | InvalidAuditRecord, R | AuditDigest>;
+export type RecordAuditResult<A> = CommitAuditResult<A> & {
+    readonly publish: AuditPublishReceipt;
+};
+export declare const recordAudit: <A, E, R>(record: AuditRecord, durableWrite: (document: AuditCommitDocument) => Effect.Effect<A, E, R>) => Effect.Effect<RecordAuditResult<A>, E | InvalidAuditRecord, R | AuditDigest | AuditPublisher>;

package/dist/audit/AuditPublisher.js

@@ -0,0 +1,60 @@
+import { Clock, Context, DateTime, Effect, Option, Schema } from "effect";
+import { auditCommitDocumentFor } from "./AuditCommitDocument.js";
+import { AuditDigest, canonicalAuditPayload } from "./AuditDigest.js";
+import { sealCommittedAuditRecord, } from "./CommittedAuditRecordInternal.js";
+import { AuditOccurredAt, reparseAuditRecord } from "./AuditRecord.js";
+const emptyReport = () => ({
+    published: 0,
+    deduplicated: 0,
+    dropped: 0,
+    firstDroppedAt: Option.none(),
+    lastDroppedAt: Option.none(),
+    reasons: {
+        unbound: 0,
+        closed: 0,
+        queueOverflow: 0,
+        contractRejected: 0,
+        policyRejected: 0,
+        transport: 0,
+    },
+});
+export const unboundAuditPublisher = () => {
+    let drops = 0;
+    let firstDrop = Option.none();
+    let lastDrop = Option.none();
+    return {
+        publish: () => Effect.gen(function* () {
+            const droppedAt = DateTime.formatIso(DateTime.makeUnsafe(yield* Clock.currentTimeMillis));
+            drops += 1;
+            if (Option.isNone(firstDrop))
+                firstDrop = Option.some(droppedAt);
+            lastDrop = Option.some(droppedAt);
+            return { kind: "dropped", reason: "unbound" };
+        }),
+        report: () => ({
+            ...emptyReport(),
+            dropped: drops,
+            firstDroppedAt: firstDrop,
+            lastDroppedAt: lastDrop,
+            reasons: { ...emptyReport().reasons, unbound: drops },
+        }),
+    };
+};
+export class AuditPublisher extends Context.Service()("@equipe-tech/observability/AuditPublisher") {
+}
+export const commitAuditRecord = (record, durableWrite) => Effect.gen(function* () {
+    const reparsed = yield* reparseAuditRecord(record);
+    const committedAt = Schema.decodeUnknownSync(AuditOccurredAt)(DateTime.formatIso(DateTime.makeUnsafe(yield* Clock.currentTimeMillis)));
+    const digest = yield* AuditDigest;
+    const ledgerHash = yield* digest.hash(canonicalAuditPayload(reparsed, committedAt));
+    const document = auditCommitDocumentFor(reparsed, committedAt, ledgerHash);
+    const committed = yield* durableWrite(document);
+    const committedRecord = sealCommittedAuditRecord(reparsed, committedAt, ledgerHash);
+    return { committed, record: committedRecord };
+});
+export const recordAudit = (record, durableWrite) => Effect.gen(function* () {
+    const result = yield* commitAuditRecord(record, durableWrite);
+    const publisher = yield* AuditPublisher;
+    const publish = yield* publisher.publish(result.record);
+    return { ...result, publish };
+});