@equipe-tech/observability 0.2.0 → 0.3.5

package/dist/audit/AuditRecord.d.ts

@@ -0,0 +1,128 @@
+import { Effect, Option, Schema } from "effect";
+import { CorrelationContext } from "../Correlation.js";
+import type { TelemetryContract, TelemetryContractInput } from "../contract/TelemetryContract.js";
+import { InvalidAuditRecord } from "./InvalidAuditRecord.js";
+export declare const AuditRecordId: Schema.brand<Schema.NonEmptyString, "AuditRecordId">;
+export type AuditRecordId = typeof AuditRecordId.Type;
+export declare const AuditTenantId: Schema.brand<Schema.NonEmptyString, "AuditTenantId">;
+export type AuditTenantId = typeof AuditTenantId.Type;
+export declare const AuditActorId: Schema.brand<Schema.NonEmptyString, "AuditActorId">;
+export type AuditActorId = typeof AuditActorId.Type;
+export declare const AuditResourceId: Schema.brand<Schema.NonEmptyString, "AuditResourceId">;
+export type AuditResourceId = typeof AuditResourceId.Type;
+export declare const AuditResourceType: Schema.brand<Schema.NonEmptyString, "AuditResourceType">;
+export type AuditResourceType = typeof AuditResourceType.Type;
+export declare const AuditAction: Schema.brand<Schema.NonEmptyString, "AuditAction">;
+export type AuditAction = typeof AuditAction.Type;
+export declare const AuditReasonCode: Schema.brand<Schema.NonEmptyString, "AuditReasonCode">;
+export type AuditReasonCode = typeof AuditReasonCode.Type;
+export declare const AuditOutcome: Schema.Literals<readonly ["success", "failure", "cancelled", "denied"]>;
+export type AuditOutcome = typeof AuditOutcome.Type;
+export declare const AuditActor: 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">;
+}>]>;
+export type AuditActor = typeof AuditActor.Type;
+export type AuditActorInput = {
+    readonly kind: "user";
+    readonly id: string;
+} | {
+    readonly kind: "service";
+    readonly id: string;
+} | {
+    readonly kind: "system";
+};
+export declare const AuditResource: Schema.Struct<{
+    readonly type: Schema.brand<Schema.NonEmptyString, "AuditResourceType">;
+    readonly id: Schema.brand<Schema.NonEmptyString, "AuditResourceId">;
+}>;
+export type AuditResource = typeof AuditResource.Type;
+export declare const AuditContext: Schema.Struct<{
+    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 resourceType: Schema.brand<Schema.NonEmptyString, "AuditResourceType">;
+    readonly resourceId: Schema.brand<Schema.NonEmptyString, "AuditResourceId">;
+    readonly reasonCode: Schema.optionalKey<Schema.String>;
+}>;
+export type AuditContext = typeof AuditContext.Type;
+export declare const AuditOccurredAt: Schema.brand<Schema.String, "AuditOccurredAt">;
+export type AuditOccurredAt = typeof AuditOccurredAt.Type;
+declare const AuditRecordFields: 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.Option<Schema.brand<Schema.NonEmptyString, "AuditReasonCode">>;
+    readonly tenantId: Schema.Option<Schema.brand<Schema.NonEmptyString, "AuditTenantId">>;
+    readonly occurredAt: Schema.brand<Schema.String, "AuditOccurredAt">;
+    readonly correlation: typeof CorrelationContext;
+}>;
+type AuditRecordFields = typeof AuditRecordFields.Type;
+declare const parsedAuditRecordBrand: unique symbol;
+export type AuditRecord = AuditRecordFields & {
+    readonly [parsedAuditRecordBrand]: true;
+};
+export type AuditRecordInput = {
+    readonly recordId: string;
+    readonly action: string;
+    readonly actor: AuditActorInput;
+    readonly resource: {
+        readonly id: string;
+    };
+    readonly outcome: AuditOutcome;
+    readonly reasonCode?: string | Option.Option<string>;
+    readonly tenantId?: string | Option.Option<string>;
+    readonly occurredAt: string;
+    readonly correlation?: CorrelationContext;
+};
+export declare const reparseAuditRecord: (record: {
+    readonly schemaVersion: 1;
+    readonly recordId: string & import("effect/Brand").Brand<"AuditRecordId">;
+    readonly action: string & import("effect/Brand").Brand<"AuditAction">;
+    readonly actor: {
+        readonly kind: "user";
+        readonly id: string & import("effect/Brand").Brand<"AuditActorId">;
+    } | {
+        readonly kind: "service";
+        readonly id: string & import("effect/Brand").Brand<"AuditActorId">;
+    } | {
+        readonly kind: "system";
+    };
+    readonly resource: {
+        readonly type: string & import("effect/Brand").Brand<"AuditResourceType">;
+        readonly id: string & import("effect/Brand").Brand<"AuditResourceId">;
+    };
+    readonly outcome: "cancelled" | "denied" | "failure" | "success";
+    readonly reasonCode: Option.Option<string & import("effect/Brand").Brand<"AuditReasonCode">>;
+    readonly tenantId: Option.Option<string & import("effect/Brand").Brand<"AuditTenantId">>;
+    readonly occurredAt: string & import("effect/Brand").Brand<"AuditOccurredAt">;
+    readonly correlation: CorrelationContext;
+}) => Effect.Effect<AuditRecord, InvalidAuditRecord, never>;
+export declare const parseAuditRecord: <Definition extends TelemetryContractInput>(contract: TelemetryContract<Definition>, input: AuditRecordInput) => Effect.Effect<AuditRecord, InvalidAuditRecord, never>;
+export {};

package/dist/audit/AuditRecord.js

@@ -0,0 +1,172 @@
+import { Effect, Option, Predicate, Schema } from "effect";
+import { CorrelationContext, CurrentCorrelation } from "../Correlation.js";
+import { InvalidAuditRecord } from "./InvalidAuditRecord.js";
+const isControlCharacterFree = (value) => {
+    for (const character of value) {
+        const codePoint = character.codePointAt(0);
+        if (codePoint !== undefined && (codePoint <= 31 || codePoint === 127))
+            return false;
+    }
+    return true;
+};
+const withoutControlCharacters = Schema.makeFilter(isControlCharacterFree, {
+    expected: "a value without control characters",
+});
+const boundedIdentifier = Schema.NonEmptyString.check(withoutControlCharacters, Schema.isMaxLength(128));
+export const AuditRecordId = boundedIdentifier.pipe(Schema.brand("AuditRecordId"));
+export const AuditTenantId = boundedIdentifier.pipe(Schema.brand("AuditTenantId"));
+export const AuditActorId = boundedIdentifier.pipe(Schema.brand("AuditActorId"));
+export const AuditResourceId = boundedIdentifier.pipe(Schema.brand("AuditResourceId"));
+export const AuditResourceType = Schema.NonEmptyString.check(withoutControlCharacters, Schema.isMaxLength(64), Schema.isPattern(/^[a-z][a-z0-9_]*(?:\.[a-z][a-z0-9_]*)*$/)).pipe(Schema.brand("AuditResourceType"));
+export const AuditAction = Schema.NonEmptyString.check(withoutControlCharacters, Schema.isMinLength(3), Schema.isMaxLength(128), Schema.isPattern(/^[a-z][a-z0-9_]*(?:\.[a-z][a-z0-9_]*)+$/)).pipe(Schema.brand("AuditAction"));
+export const AuditReasonCode = Schema.NonEmptyString.check(withoutControlCharacters, Schema.isMaxLength(64), Schema.isPattern(/^[a-z][a-z0-9_]*(?:\.[a-z][a-z0-9_]*)*$/)).pipe(Schema.brand("AuditReasonCode"));
+export const AuditOutcome = Schema.Literals(["success", "failure", "cancelled", "denied"]);
+export const AuditActor = Schema.Union([
+    Schema.Struct({ kind: Schema.Literal("user"), id: AuditActorId }),
+    Schema.Struct({ kind: Schema.Literal("service"), id: AuditActorId }),
+    Schema.Struct({ kind: Schema.Literal("system") }),
+]);
+export const AuditResource = Schema.Struct({
+    type: AuditResourceType,
+    id: AuditResourceId,
+});
+export const AuditContext = Schema.Struct({
+    action: AuditAction,
+    actor: AuditActor,
+    resourceType: AuditResourceType,
+    resourceId: AuditResourceId,
+    reasonCode: Schema.String.pipe(Schema.optionalKey),
+});
+const canonicalOccurredAtPattern = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
+export const AuditOccurredAt = Schema.String.check(Schema.makeFilter((value) => canonicalOccurredAtPattern.test(value) &&
+    isControlCharacterFree(value) &&
+    Date.parse(value) >= 0 &&
+    new Date(value).toISOString() === value, { expected: "a canonical RFC 3339 UTC timestamp with millisecond precision" })).pipe(Schema.brand("AuditOccurredAt"));
+const AuditRecordFields = Schema.Struct({
+    schemaVersion: Schema.Literal(1),
+    recordId: AuditRecordId,
+    action: AuditAction,
+    actor: AuditActor,
+    resource: AuditResource,
+    outcome: AuditOutcome,
+    reasonCode: Schema.Option(AuditReasonCode),
+    tenantId: Schema.Option(AuditTenantId),
+    occurredAt: AuditOccurredAt,
+    correlation: CorrelationContext,
+});
+const parsedAuditRecordBrand = Symbol("@equipe-tech/observability/ParsedAuditRecord");
+const AuditRecordInputDocument = Schema.Struct({
+    recordId: Schema.Any,
+    action: Schema.Any,
+    actor: Schema.Any,
+    resource: Schema.Any,
+    outcome: Schema.Any,
+    reasonCode: Schema.optional(Schema.Any),
+    tenantId: Schema.optional(Schema.Any),
+    occurredAt: Schema.Any,
+    correlation: Schema.optional(Schema.Any),
+});
+const AuditResourceInputDocument = Schema.Struct({ id: Schema.Any });
+const AuditOptionalStringInput = Schema.Union([
+    Schema.String,
+    Schema.Option(Schema.String),
+    Schema.Undefined,
+]);
+const decodeAuditRecordInput = Schema.decodeUnknownEffect(AuditRecordInputDocument);
+const decodeAuditResourceInput = Schema.decodeUnknownEffect(AuditResourceInputDocument);
+const decodeOptionalStringInput = Schema.decodeUnknownEffect(AuditOptionalStringInput);
+const decodeSchemaVersion = Schema.decodeUnknownEffect(Schema.Literal(1));
+const decodeAction = Schema.decodeUnknownEffect(AuditAction);
+const decodeRecordId = Schema.decodeUnknownEffect(AuditRecordId);
+const decodeActor = Schema.decodeUnknownEffect(AuditActor);
+const decodeResourceId = Schema.decodeUnknownEffect(AuditResourceId);
+const decodeResourceType = Schema.decodeUnknownEffect(AuditResourceType);
+const decodeOutcome = Schema.decodeUnknownEffect(AuditOutcome);
+const decodeReasonCode = Schema.decodeUnknownEffect(AuditReasonCode);
+const decodeTenantId = Schema.decodeUnknownEffect(AuditTenantId);
+const decodeOccurredAt = Schema.decodeUnknownEffect(AuditOccurredAt);
+const decodeCorrelation = Schema.decodeUnknownEffect(CorrelationContext);
+const decodeReasonCodeOption = Schema.decodeUnknownEffect(Schema.Option(AuditReasonCode));
+const decodeTenantIdOption = Schema.decodeUnknownEffect(Schema.Option(AuditTenantId));
+const invalid = (code, message, field, action) => action === undefined
+    ? new InvalidAuditRecord({ code, message, field })
+    : new InvalidAuditRecord({ code, message, field, action });
+const optionalString = (value) => value === undefined ? Option.none() : Predicate.isString(value) ? Option.some(value) : value;
+export const reparseAuditRecord = Effect.fn("reparseAuditRecord")(function* (record) {
+    const invalidField = (field) => invalid("OBS_AUDIT_INVALID_FIELD", `Audit record field ${field} is invalid. Parse the record before committing it.`, field);
+    const schemaVersion = yield* decodeSchemaVersion(record.schemaVersion).pipe(Effect.mapError(() => invalidField("schemaVersion")));
+    const recordId = yield* decodeRecordId(record.recordId).pipe(Effect.mapError(() => invalidField("recordId")));
+    const action = yield* Schema.decodeUnknownEffect(AuditAction)(record.action).pipe(Effect.mapError(() => invalidField("action")));
+    const actor = yield* decodeActor(record.actor).pipe(Effect.mapError(() => invalidField("actor")));
+    const resource = yield* Schema.decodeUnknownEffect(AuditResource)(record.resource).pipe(Effect.mapError(() => invalidField("resource")));
+    const outcome = yield* decodeOutcome(record.outcome).pipe(Effect.mapError(() => invalidField("outcome")));
+    const reasonCode = yield* decodeReasonCodeOption(record.reasonCode).pipe(Effect.mapError(() => invalidField("reasonCode")));
+    const tenantId = yield* decodeTenantIdOption(record.tenantId).pipe(Effect.mapError(() => invalidField("tenantId")));
+    const occurredAt = yield* decodeOccurredAt(record.occurredAt).pipe(Effect.mapError(() => invalidField("occurredAt")));
+    const correlation = yield* decodeCorrelation(record.correlation).pipe(Effect.mapError(() => invalidField("correlation")));
+    const parsed = {
+        schemaVersion,
+        recordId,
+        action,
+        actor: Object.freeze(actor),
+        resource: Object.freeze(resource),
+        outcome,
+        reasonCode,
+        tenantId,
+        occurredAt,
+        correlation,
+        [parsedAuditRecordBrand]: true,
+    };
+    return Object.freeze(parsed);
+});
+export const parseAuditRecord = Effect.fn("parseAuditRecord")(function* (contract, input) {
+    const document = yield* decodeAuditRecordInput(input).pipe(Effect.mapError(() => invalid("OBS_AUDIT_INVALID_FIELD", "Audit record input is malformed. Provide every required audit field with its documented type.", "record")));
+    const parsedAction = yield* decodeAction(document.action).pipe(Effect.mapError(() => invalid("OBS_AUDIT_UNKNOWN_ACTION", "Audit action is malformed. Use a declared dotted lowercase action up to 128 characters.", "action")));
+    const action = contract.auditActionByName.get(parsedAction);
+    if (action === undefined) {
+        return yield* invalid("OBS_AUDIT_UNKNOWN_ACTION", "Audit action is not declared by the telemetry contract. Use a declared action.", "action", parsedAction);
+    }
+    const recordId = yield* decodeRecordId(document.recordId).pipe(Effect.mapError(() => invalid("OBS_AUDIT_INVALID_FIELD", "Audit record ID is invalid. Use 1 to 128 characters without control characters.", "recordId", parsedAction)));
+    const actor = yield* decodeActor(document.actor).pipe(Effect.mapError(() => invalid("OBS_AUDIT_INVALID_ACTOR", "Audit actor is invalid. Use a bounded user or service snapshot, or the system actor.", "actor", parsedAction)));
+    const resource = yield* decodeAuditResourceInput(document.resource).pipe(Effect.mapError(() => invalid("OBS_AUDIT_INVALID_RESOURCE", "Audit resource is malformed. Provide an object with a bounded ID.", "resource", parsedAction)));
+    const resourceId = yield* decodeResourceId(resource.id).pipe(Effect.mapError(() => invalid("OBS_AUDIT_INVALID_RESOURCE", "Audit resource ID is invalid. Use 1 to 128 characters without control characters.", "resource.id", parsedAction)));
+    const resourceType = yield* decodeResourceType(action.resourceType).pipe(Effect.orDie);
+    const outcome = yield* decodeOutcome(document.outcome).pipe(Effect.mapError(() => invalid("OBS_AUDIT_INVALID_OUTCOME", "Audit outcome is invalid. Use success, failure, cancelled, or denied.", "outcome", parsedAction)));
+    if (!action.allowedOutcomes.includes(outcome)) {
+        return yield* invalid("OBS_AUDIT_INVALID_OUTCOME", "Audit outcome is not declared for this action. Use an allowed outcome.", "outcome", parsedAction);
+    }
+    const reasonCodeInput = yield* decodeOptionalStringInput(document.reasonCode).pipe(Effect.mapError(() => invalid("OBS_AUDIT_UNKNOWN_REASON_CODE", "Audit reason code is malformed. Use a dotted lowercase code up to 64 characters.", "reasonCode", parsedAction)));
+    const rawReasonCode = optionalString(reasonCodeInput);
+    const reasonCode = yield* Option.match(rawReasonCode, {
+        onNone: () => Effect.succeed(Option.none()),
+        onSome: (value) => Effect.gen(function* () {
+            const parsed = yield* decodeReasonCode(value).pipe(Effect.mapError(() => invalid("OBS_AUDIT_UNKNOWN_REASON_CODE", "Audit reason code is malformed. Use a dotted lowercase code up to 64 characters.", "reasonCode", parsedAction)));
+            if (!action.reasonCodes.includes(parsed)) {
+                return yield* invalid("OBS_AUDIT_UNKNOWN_REASON_CODE", "Audit reason code is not declared for this action. Use a declared reason code or omit it.", "reasonCode", parsedAction);
+            }
+            return Option.some(parsed);
+        }),
+    });
+    const tenantIdInput = yield* decodeOptionalStringInput(document.tenantId).pipe(Effect.mapError(() => invalid("OBS_AUDIT_INVALID_FIELD", "Audit tenant ID is invalid. Use 1 to 128 characters without control characters.", "tenantId", parsedAction)));
+    const rawTenantId = optionalString(tenantIdInput);
+    const tenantId = yield* Option.match(rawTenantId, {
+        onNone: () => Effect.succeed(Option.none()),
+        onSome: (value) => decodeTenantId(value).pipe(Effect.map(Option.some), Effect.mapError(() => invalid("OBS_AUDIT_INVALID_FIELD", "Audit tenant ID is invalid. Use 1 to 128 characters without control characters.", "tenantId", parsedAction))),
+    });
+    const occurredAt = yield* decodeOccurredAt(document.occurredAt).pipe(Effect.mapError(() => invalid("OBS_AUDIT_INVALID_FIELD", "Audit occurrence time is invalid. Use an RFC 3339 UTC timestamp.", "occurredAt", parsedAction)));
+    const correlation = document.correlation === undefined
+        ? yield* CurrentCorrelation
+        : yield* decodeCorrelation(document.correlation).pipe(Effect.mapError(() => invalid("OBS_AUDIT_INVALID_FIELD", "Audit correlation is invalid. Use a canonical traced or untraced correlation context.", "correlation", parsedAction)));
+    return yield* reparseAuditRecord({
+        schemaVersion: 1,
+        recordId,
+        action: action.action,
+        actor,
+        resource: { type: resourceType, id: resourceId },
+        outcome,
+        reasonCode,
+        tenantId,
+        occurredAt,
+        correlation,
+    });
+});

package/dist/audit/CommittedAuditRecordInternal.d.ts

@@ -0,0 +1,11 @@
+import type { AuditHash } from "./AuditDigest.js";
+import type { AuditOccurredAt, AuditRecord } from "./AuditRecord.js";
+declare const committedAuditRecordBrand: unique symbol;
+export type CommittedAuditRecord = AuditRecord & {
+    readonly committedAt: AuditOccurredAt;
+    readonly ledgerHash: AuditHash;
+    readonly [committedAuditRecordBrand]: true;
+};
+export declare const sealCommittedAuditRecord: (record: AuditRecord, committedAt: AuditOccurredAt, ledgerHash: AuditHash) => CommittedAuditRecord;
+export declare const isCommittedAuditRecord: (record: CommittedAuditRecord) => boolean;
+export {};

package/dist/audit/CommittedAuditRecordInternal.js

@@ -0,0 +1,13 @@
+const committedAuditRecordBrand = Symbol("CommittedAuditRecord");
+const committedAuditRecords = new WeakSet();
+export const sealCommittedAuditRecord = (record, committedAt, ledgerHash) => {
+    const committed = {
+        ...record,
+        committedAt,
+        ledgerHash,
+        [committedAuditRecordBrand]: true,
+    };
+    committedAuditRecords.add(committed);
+    return Object.freeze(committed);
+};
+export const isCommittedAuditRecord = (record) => committedAuditRecords.has(record);

package/dist/audit/InvalidAuditRecord.d.ts

@@ -0,0 +1,12 @@
+import { Schema } from "effect";
+export declare const AuditRecordErrorCode: Schema.Literals<readonly ["OBS_AUDIT_UNKNOWN_ACTION", "OBS_AUDIT_INVALID_ACTOR", "OBS_AUDIT_INVALID_RESOURCE", "OBS_AUDIT_INVALID_OUTCOME", "OBS_AUDIT_UNKNOWN_REASON_CODE", "OBS_AUDIT_INVALID_FIELD"]>;
+export type AuditRecordErrorCode = typeof AuditRecordErrorCode.Type;
+declare const InvalidAuditRecord_base: Schema.Class<InvalidAuditRecord, Schema.TaggedStruct<"InvalidAuditRecord", {
+    readonly code: Schema.Literals<readonly ["OBS_AUDIT_UNKNOWN_ACTION", "OBS_AUDIT_INVALID_ACTOR", "OBS_AUDIT_INVALID_RESOURCE", "OBS_AUDIT_INVALID_OUTCOME", "OBS_AUDIT_UNKNOWN_REASON_CODE", "OBS_AUDIT_INVALID_FIELD"]>;
+    readonly message: Schema.String;
+    readonly field: Schema.String;
+    readonly action: Schema.optionalKey<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
+export declare class InvalidAuditRecord extends InvalidAuditRecord_base {
+}
+export {};

package/dist/audit/InvalidAuditRecord.js

@@ -0,0 +1,16 @@
+import { Schema } from "effect";
+export const AuditRecordErrorCode = Schema.Literals([
+    "OBS_AUDIT_UNKNOWN_ACTION",
+    "OBS_AUDIT_INVALID_ACTOR",
+    "OBS_AUDIT_INVALID_RESOURCE",
+    "OBS_AUDIT_INVALID_OUTCOME",
+    "OBS_AUDIT_UNKNOWN_REASON_CODE",
+    "OBS_AUDIT_INVALID_FIELD",
+]);
+export class InvalidAuditRecord extends Schema.TaggedError()("InvalidAuditRecord", {
+    code: AuditRecordErrorCode,
+    message: Schema.String,
+    field: Schema.String,
+    action: Schema.String.pipe(Schema.optionalKey),
+}) {
+}

package/dist/audit/index.d.ts

@@ -0,0 +1,7 @@
+export { AuditCommitDocument } from "./AuditCommitDocument.js";
+export { AuditDigest, AuditHash, canonicalAuditPayload } from "./AuditDigest.js";
+export { AuditOutbox, AuditOutboxClaimKey, AuditOutboxDocument, AuditOutboxFailure, drainAuditOutbox, type AuditOutboxDrainReport, type AuditOutboxEntry, type AuditOutboxSettlement, type AuditOutboxValue, } from "./AuditOutbox.js";
+export { isCommittedAuditRecord } from "./CommittedAuditRecordInternal.js";
+export { AuditPublisher, commitAuditRecord, recordAudit, unboundAuditPublisher, type AuditDropReason, type AuditPublisherService, type AuditPublishReasonCounts, type AuditPublishReceipt, type AuditPublishReport, type CommitAuditResult, type CommittedAuditRecord, type RecordAuditResult, } from "./AuditPublisher.js";
+export { AuditAction, AuditActor, AuditActorId, AuditContext, AuditOccurredAt, AuditOutcome, AuditReasonCode, AuditRecordId, AuditResource, AuditResourceId, AuditResourceType, AuditTenantId, parseAuditRecord, type AuditActorInput, type AuditRecord, type AuditRecordInput, } from "./AuditRecord.js";
+export { AuditRecordErrorCode, InvalidAuditRecord } from "./InvalidAuditRecord.js";

package/dist/audit/index.js

@@ -0,0 +1,7 @@
+export { AuditCommitDocument } from "./AuditCommitDocument.js";
+export { AuditDigest, AuditHash, canonicalAuditPayload } from "./AuditDigest.js";
+export { AuditOutbox, AuditOutboxClaimKey, AuditOutboxDocument, AuditOutboxFailure, drainAuditOutbox, } from "./AuditOutbox.js";
+export { isCommittedAuditRecord } from "./CommittedAuditRecordInternal.js";
+export { AuditPublisher, commitAuditRecord, recordAudit, unboundAuditPublisher, } from "./AuditPublisher.js";
+export { AuditAction, AuditActor, AuditActorId, AuditContext, AuditOccurredAt, AuditOutcome, AuditReasonCode, AuditRecordId, AuditResource, AuditResourceId, AuditResourceType, AuditTenantId, parseAuditRecord, } from "./AuditRecord.js";
+export { AuditRecordErrorCode, InvalidAuditRecord } from "./InvalidAuditRecord.js";

package/dist/browser/BrowserClient.d.ts

@@ -1,17 +1,63 @@
 export type BrowserTelemetryClientFields = {
     readonly [field: string]: string | number | boolean;
 };
+export type BrowserTelemetryClientError = {
+    readonly type: string;
+    readonly message: string;
+    readonly retryable: boolean;
+};
+export type BrowserTraceContext = {
+    readonly traceId: string;
+    readonly spanId: string;
+};
 export type BrowserTelemetryClientEvent = {
     readonly id: string;
     readonly name: string;
     readonly occurredAt: number;
     readonly fields: BrowserTelemetryClientFields;
+    readonly error?: BrowserTelemetryClientError;
+    readonly trace?: BrowserTraceContext;
+};
+export type BrowserTelemetryClientSpan = BrowserTraceContext & {
+    readonly parentSpanId?: string;
+    readonly name: string;
+    readonly startedAt: number;
+    readonly endedAt: number;
+    readonly fields: BrowserTelemetryClientFields;
+};
+export type BrowserTelemetryClientMetric = {
+    readonly name: string;
+    readonly value: number;
+    readonly occurredAt: number;
+    readonly fields: BrowserTelemetryClientFields;
+};
+export type BrowserTraceHandle = {
+    readonly context: BrowserTraceContext;
+    readonly end: (fields?: BrowserTelemetryClientFields) => void;
+};
+export type BrowserCounter = {
+    readonly add: (value?: number, fields?: BrowserTelemetryClientFields) => void;
+};
+export type BrowserTelemetryDefectInput = {
+    readonly id?: string;
+    readonly name: string;
+    readonly error: BrowserTelemetryClientError;
+    readonly fields?: BrowserTelemetryClientFields;
+};
+export type BrowserTelemetryClientResource = {
+    readonly serviceName: string;
+    readonly serviceVersion: string;
+    readonly environment: string;
 };
 export type BrowserTelemetryClientBatch = {
-    readonly version: 1;
+    readonly version: number;
+    readonly resource?: BrowserTelemetryClientResource;
     readonly events: ReadonlyArray<BrowserTelemetryClientEvent>;
+    readonly spans?: ReadonlyArray<BrowserTelemetryClientSpan>;
+    readonly metrics?: ReadonlyArray<BrowserTelemetryClientMetric>;
 };
 export type BrowserTelemetryClientTransport = (batch: BrowserTelemetryClientBatch, signal: AbortSignal) => Promise<void>;
+export type BrowserTelemetryFieldTransform = (fields: BrowserTelemetryClientFields) => BrowserTelemetryClientFields;
 export type BrowserTelemetryClientConfig = {
     readonly disabled?: boolean;
     readonly endpoint?: string;
@@ -19,12 +65,23 @@ export type BrowserTelemetryClientConfig = {
     readonly maxQueueSize?: number;
     readonly flushIntervalMs?: number;
     readonly shutdownTimeoutMs?: number;
+    readonly metrics?: boolean;
+    readonly resource?: BrowserTelemetryClientResource;
     readonly transport?: BrowserTelemetryClientTransport;
+    readonly policy?: BrowserTelemetryFieldTransform;
 };
 export type BrowserTelemetryClient = {
-    emit(name: string, fields?: BrowserTelemetryClientFields): void;
+    emit(name: string, fields?: BrowserTelemetryClientFields, trace?: BrowserTraceContext): void;
+    emitDefect(input: BrowserTelemetryDefectInput): void;
+    readonly traces: {
+        readonly startSpan: (name: string, fields?: BrowserTelemetryClientFields, parent?: BrowserTraceContext) => BrowserTraceHandle;
+    };
+    readonly metrics: {
+        readonly counter: (name: string) => BrowserCounter;
+    };
     flush(): Promise<void>;
     pending(): number;
+    dropped(): number;
     dispose(): Promise<void>;
 };
 export declare class BrowserTelemetryClientDeliveryError extends Error {
@@ -40,6 +97,7 @@ export declare class BrowserTelemetryClientShutdownError extends Error {
     readonly retryable = true;
     constructor(timeoutMs: number);
 }
+export declare const browserBatchByteLength: (batch: BrowserTelemetryClientBatch) => number;
 export declare const normalizePositiveInteger: (value: number | undefined, fallback: number) => number;
 type BrowserClientEngineOptions = {
     readonly disabled: boolean;
@@ -47,12 +105,18 @@ type BrowserClientEngineOptions = {
     readonly maxQueueSize: number;
     readonly flushIntervalMs: number;
     readonly shutdownTimeoutMs: number;
+    readonly metrics: boolean;
+    readonly resource: BrowserTelemetryClientResource | undefined;
     readonly transport: BrowserTelemetryClientTransport;
+    readonly policy: BrowserTelemetryFieldTransform | undefined;
     readonly startTimer: boolean;
 };
 export declare class BrowserClientEngine implements BrowserTelemetryClient {
     private readonly options;
     private events;
+    private spans;
+    private metricPoints;
+    private activeSpans;
     private activeFlush;
     private activeDelivery;
     private readonly activeControllers;
@@ -61,13 +125,28 @@ export declare class BrowserClientEngine implements BrowserTelemetryClient {
     private timer;
     private droppedEvents;
     constructor(options: BrowserClientEngineOptions);
-    emit(name: string, fields?: BrowserTelemetryClientFields): void;
+    readonly traces: {
+        startSpan: (name: string, fields?: BrowserTelemetryClientFields, parent?: BrowserTraceContext) => BrowserTraceHandle;
+    };
+    readonly metrics: {
+        counter: (name: string) => BrowserCounter;
+    };
+    emit(name: string, fields?: BrowserTelemetryClientFields, trace?: BrowserTraceContext): void;
+    emitDefect(input: BrowserTelemetryDefectInput): void;
+    private sanitizeFields;
+    private batchWithResource;
+    private deliveryBatch;
+    private enqueue;
+    private enqueueSpan;
+    private enqueueMetric;
+    private ensureQueueCapacity;
     flush(): Promise<void>;
     pending(): number;
     dropped(): number;
     dispose(): Promise<void>;
     private shutdown;
     private abandonActiveDelivery;
+    private dropPending;
     private flushQueued;
 }
 export declare const createBrowserTelemetryClient: (config?: BrowserTelemetryClientConfig) => BrowserTelemetryClient;