@eventsdk/sdk 0.0.0-stage → 0.3.1

package/dist/core/outbox/authorize-recovery.d.ts

@@ -0,0 +1,75 @@
+import { type CloudEventV12, type OutboxRecoveryCommand } from '@eventsdk/sdk/contracts';
+import type { AuthorizationPort } from '@eventsdk/sdk/identity-contracts';
+import type { OutboxRecord } from '../ports/outbox.js';
+import type { OriginRefreshPort } from '../ports/origin-refresh.js';
+import type { Clock, Digest, OperationOptions } from '../runtime/dependencies.js';
+export interface HeldOutboxRecord extends OutboxRecord {
+    readonly event: CloudEventV12;
+    readonly status: string;
+    readonly generation: number;
+}
+export declare function authorizeOutboxRecovery(command: OutboxRecoveryCommand, stored: HeldOutboxRecord, deps: {
+    authorization: AuthorizationPort;
+    originRefresh: OriginRefreshPort;
+    clock: Clock;
+    digest: Digest;
+}, options: OperationOptions): Promise<{
+    event: {
+        readonly specversion: "1.0";
+        readonly id: string;
+        readonly source: string;
+        readonly type: string;
+        readonly time: string;
+        readonly dataschema: string;
+        readonly datacontenttype: "application/json";
+        readonly profile: "eventsdk/1.2";
+        readonly kind: "EVENT";
+        readonly serviceorigin: string;
+        readonly sourcetenant: string;
+        readonly audience: string;
+        readonly connectionref: string;
+        readonly grantref: string;
+        readonly grantversion: number;
+        readonly correlationid: string;
+        readonly causationid?: string;
+        readonly subject?: string;
+        readonly data: string | number | boolean | readonly (string | number | boolean | readonly (string | number | boolean | readonly (string | number | boolean | readonly (string | number | boolean | readonly (string | number | boolean | readonly (string | number | boolean | readonly (string | number | boolean | readonly (string | number | boolean | readonly (string | number | boolean | readonly (string | number | boolean | readonly (string | number | boolean | any | {
+            readonly [x: string]: string | number | boolean | any | any | null;
+        } | null)[] | {
+            readonly [x: string]: string | number | boolean | readonly (string | number | boolean | any | any | null)[] | any | null;
+        } | null)[] | {
+            readonly [x: string]: string | number | boolean | readonly (string | number | boolean | readonly (string | number | boolean | any | any | null)[] | any | null)[] | any | null;
+        } | null)[] | {
+            readonly [x: string]: string | number | boolean | readonly (string | number | boolean | readonly (string | number | boolean | readonly (string | number | boolean | any | any | null)[] | any | null)[] | any | null)[] | any | null;
+        } | null)[] | {
+            readonly [x: string]: string | number | boolean | readonly (string | number | boolean | readonly (string | number | boolean | readonly (string | number | boolean | readonly (string | number | boolean | any | any | null)[] | any | null)[] | any | null)[] | any | null)[] | any | null;
+        } | null)[] | {
+            readonly [x: string]: string | number | boolean | readonly (string | number | boolean | readonly (string | number | boolean | readonly (string | number | boolean | readonly (string | number | boolean | readonly (string | number | boolean | any | any | null)[] | any | null)[] | any | null)[] | any | null)[] | any | null)[] | any | null;
+        } | null)[] | {
+            readonly [x: string]: string | number | boolean | readonly (string | number | boolean | readonly (string | number | boolean | readonly (string | number | boolean | readonly (string | number | boolean | readonly (string | number | boolean | readonly (string | number | boolean | any | any | null)[] | any | null)[] | any | null)[] | any | null)[] | any | null)[] | any | null)[] | any | null;
+        } | null)[] | {
+            readonly [x: string]: string | number | boolean | readonly (string | number | boolean | readonly (string | number | boolean | readonly (string | number | boolean | readonly (string | number | boolean | readonly (string | number | boolean | readonly (string | number | boolean | readonly (string | number | boolean | any | any | null)[] | any | null)[] | any | null)[] | any | null)[] | any | null)[] | any | null)[] | any | null)[] | any | null;
+        } | null)[] | {
+            readonly [x: string]: string | number | boolean | readonly (string | number | boolean | readonly (string | number | boolean | readonly (string | number | boolean | readonly (string | number | boolean | readonly (string | number | boolean | readonly (string | number | boolean | readonly (string | number | boolean | readonly (string | number | boolean | any | any | null)[] | any | null)[] | any | null)[] | any | null)[] | any | null)[] | any | null)[] | any | null)[] | any | null)[] | any | null;
+        } | null)[] | {
+            readonly [x: string]: string | number | boolean | readonly (string | number | boolean | readonly (string | number | boolean | readonly (string | number | boolean | readonly (string | number | boolean | readonly (string | number | boolean | readonly (string | number | boolean | readonly (string | number | boolean | readonly (string | number | boolean | readonly (string | number | boolean | any | any | null)[] | any | null)[] | any | null)[] | any | null)[] | any | null)[] | any | null)[] | any | null)[] | any | null)[] | any | null)[] | any | null;
+        } | null)[] | {
+            readonly [x: string]: string | number | boolean | readonly (string | number | boolean | readonly (string | number | boolean | readonly (string | number | boolean | readonly (string | number | boolean | readonly (string | number | boolean | readonly (string | number | boolean | readonly (string | number | boolean | readonly (string | number | boolean | readonly (string | number | boolean | readonly (string | number | boolean | any | any | null)[] | any | null)[] | any | null)[] | any | null)[] | any | null)[] | any | null)[] | any | null)[] | any | null)[] | any | null)[] | any | null)[] | any | null;
+        } | null)[] | {
+            readonly [x: string]: string | number | boolean | readonly (string | number | boolean | readonly (string | number | boolean | readonly (string | number | boolean | readonly (string | number | boolean | readonly (string | number | boolean | readonly (string | number | boolean | readonly (string | number | boolean | readonly (string | number | boolean | readonly (string | number | boolean | readonly (string | number | boolean | readonly (string | number | boolean | any | any | null)[] | any | null)[] | any | null)[] | any | null)[] | any | null)[] | any | null)[] | any | null)[] | any | null)[] | any | null)[] | any | null)[] | any | null)[] | any | null;
+        } | null;
+        readonly orgnamespace?: string;
+        readonly orgref?: string;
+        readonly projectnamespace?: string;
+        readonly projectref?: string;
+        readonly principalnamespace?: string;
+        readonly principalref?: string;
+        readonly resourcenamespace?: string;
+        readonly resourceref?: string;
+        readonly deliveryid: string;
+    };
+    digest: string;
+    generation: number;
+    origin: import("@eventsdk/sdk/identity-contracts").VerifiedOrigin;
+    targetScope: string;
+}>;

package/dist/core/outbox/outbox-relay.d.ts

@@ -0,0 +1,26 @@
+import type { AuthorizationPort } from '@eventsdk/sdk/identity-contracts';
+import type { OutboxRelayPort } from '../ports/outbox.js';
+import type { PublishPort } from '../ports/transport.js';
+import type { Clock, Digest, OperationOptions, Random } from '../runtime/dependencies.js';
+import type { OriginRefreshPort } from '../ports/origin-refresh.js';
+import { type RetryPolicy } from '../runtime/retry.js';
+export interface RelayDependencies {
+    readonly outbox: OutboxRelayPort;
+    readonly publisher: PublishPort;
+    readonly authorization: AuthorizationPort;
+    readonly clock: Clock;
+    readonly digest: Digest;
+    readonly random: Random;
+    readonly originRefresh?: OriginRefreshPort;
+}
+export interface RelayOptions extends OperationOptions {
+    readonly batchSize: number;
+    readonly leaseMs: number;
+    readonly retry: RetryPolicy;
+}
+export interface RelaySummary {
+    readonly published: number;
+    readonly unknown: number;
+    readonly held: number;
+}
+export declare function relayOutbox(deps: RelayDependencies, options: RelayOptions): Promise<RelaySummary>;

package/dist/core/outbox/record-event.d.ts

@@ -0,0 +1,10 @@
+import type { AuthorizationPort, VerifiedOrigin } from '@eventsdk/sdk/identity-contracts';
+import type { OutboxRecordPort } from '../ports/outbox.js';
+import type { Clock, Digest, OperationOptions } from '../runtime/dependencies.js';
+export interface RecordDependencies<TTransaction> {
+    readonly outbox: OutboxRecordPort<TTransaction>;
+    readonly authorization: AuthorizationPort;
+    readonly digest: Digest;
+    readonly clock: Clock;
+}
+export declare function recordEvent<TTransaction>(tx: TTransaction, input: unknown, origin: VerifiedOrigin, dependencies: RecordDependencies<TTransaction>, options: OperationOptions): Promise<void>;

package/dist/core/outbox/record-fanout.d.ts

@@ -0,0 +1,16 @@
+import { type CloudEventV12 } from '@eventsdk/sdk/contracts';
+import type { VerifiedOrigin } from '@eventsdk/sdk/identity-contracts';
+import type { Digest, OperationOptions } from '../runtime/dependencies.js';
+import { type RecordDependencies } from './record-event.js';
+export interface FanoutRoute {
+    readonly audience: string;
+    readonly connectionref: string;
+    readonly grantref: string;
+    readonly grantversion: number;
+}
+export interface FanoutRecipient {
+    readonly route: FanoutRoute;
+    readonly origin: VerifiedOrigin;
+}
+export declare function prepareFanoutDelivery(input: unknown, route: FanoutRoute, digest: Digest): Promise<CloudEventV12>;
+export declare function recordFanoutEvent<T>(tx: T, draft: unknown, recipients: readonly FanoutRecipient[], deps: RecordDependencies<T>, options: OperationOptions): Promise<readonly CloudEventV12[]>;

package/dist/core/ports/dead-letter.d.ts

@@ -0,0 +1,29 @@
+import type { BusinessReceipt } from '@eventsdk/sdk/contracts';
+import type { ClaimedInbox } from './inbox.js';
+import type { InboxKey } from '../runtime/event-identity.js';
+import type { Lease } from '../runtime/lease.js';
+export interface DeadLetterEntry {
+    readonly ref: string;
+    readonly key: InboxKey;
+    readonly originalDeliveryRef: string;
+    readonly reasonCode: string;
+    readonly attempts: number;
+    readonly recordedAt: string;
+}
+export interface DeadLetterPort<TTransaction> {
+    quarantine(claim: ClaimedInbox, entry: DeadLetterEntry, signal: AbortSignal): Promise<void>;
+    transactReplay(entry: DeadLetterEntry, operation: (tx: TTransaction, claim: ClaimedInbox) => Promise<void>, signal: AbortSignal): Promise<void>;
+    requeueInTransaction(tx: TTransaction, claim: ClaimedInbox, signal: AbortSignal): Promise<void>;
+}
+export interface InboxWorkClaim extends ClaimedInbox {
+    readonly attempt: number;
+}
+export interface InboxWorkPort {
+    claimReady(input: {
+        limit: number;
+        now: number;
+        leaseMs: number;
+        signal: AbortSignal;
+    }): Promise<readonly InboxWorkClaim[]>;
+    defer(key: InboxKey, lease: Lease, expectedReceipt: Pick<BusinessReceipt, 'receiptRef' | 'revision' | 'disposition'>, nextAttemptAt: number, reasonCode: string, signal: AbortSignal): Promise<void>;
+}

package/dist/core/ports/inbox.d.ts

@@ -0,0 +1,43 @@
+import type { BusinessReceipt, CloudEvent } from '@eventsdk/sdk/contracts';
+import type { VerifiedOrigin } from '@eventsdk/sdk/identity-contracts';
+import type { InboxKey } from '../runtime/event-identity.js';
+import type { Lease } from '../runtime/lease.js';
+import type { DomainApplyOutcome } from '../inbox/domain-apply-result.js';
+export interface AcceptedEvent {
+    readonly key: InboxKey;
+    readonly event: CloudEvent;
+    readonly origin: VerifiedOrigin;
+    readonly digest: string;
+    readonly deliveryRef: string;
+    readonly receipt: BusinessReceipt;
+}
+export type PersistResult = {
+    readonly kind: 'RECEIVED' | 'DUPLICATE';
+    readonly receipt: BusinessReceipt;
+} | {
+    readonly kind: 'CONFLICT';
+};
+export interface QuarantineRecord {
+    readonly deliveryRef: string;
+    readonly consumerRef: string;
+    readonly reasonCode: string;
+    readonly recordedAt: string;
+}
+export interface FanoutAcceptedEvent extends AcceptedEvent {
+    readonly logicalDigest: string;
+    readonly deliveryId: string;
+}
+export interface InboxAdmissionPort {
+    persistFanoutAccepted?(record: FanoutAcceptedEvent, signal: AbortSignal): Promise<PersistResult>;
+    persistAccepted(record: AcceptedEvent, signal: AbortSignal): Promise<PersistResult>;
+    persistQuarantine(record: QuarantineRecord, signal: AbortSignal): Promise<void>;
+}
+export interface ClaimedInbox extends AcceptedEvent {
+    readonly lease: Lease;
+}
+export interface InboxApplyPort<TTransaction> {
+    transact(claim: ClaimedInbox, operation: (tx: TTransaction) => Promise<BusinessReceipt>, signal: AbortSignal): Promise<BusinessReceipt>;
+    withDomainSavepoint?(tx: TTransaction, operation: () => Promise<DomainApplyOutcome>, signal: AbortSignal): Promise<DomainApplyOutcome>;
+    completeInTransaction(tx: TTransaction, claim: ClaimedInbox, receipt: BusinessReceipt, signal: AbortSignal): Promise<void>;
+    readReceipt(key: InboxKey, signal: AbortSignal): Promise<BusinessReceipt | null>;
+}

package/dist/core/ports/observability.d.ts

@@ -0,0 +1,21 @@
+export interface DeliveryHealth {
+    readonly observedAt: number;
+    readonly outboxPending: number;
+    readonly oldestPendingAt: number | null;
+    readonly consumerLag: number;
+    readonly retryPending: number;
+    readonly quarantined: number;
+    readonly unresolvedReceipts: number;
+    readonly gaps: number;
+    readonly authorizationDenials: number;
+    readonly watermark: string;
+    readonly brokerStoredBytes?: number;
+    readonly brokerQuotaBytes?: number;
+    readonly bridgeUnconfirmed?: number;
+}
+export interface DeliveryHealthPort {
+    read(signal: AbortSignal): Promise<DeliveryHealth>;
+}
+export interface HealthMetricSink {
+    gauge(name: string, value: number): void;
+}

package/dist/core/ports/origin-refresh.d.ts

@@ -0,0 +1,5 @@
+import type { CloudEvent } from '@eventsdk/sdk/contracts';
+import type { VerifiedOrigin } from '@eventsdk/sdk/identity-contracts';
+export interface OriginRefreshPort {
+    refresh(event: CloudEvent, previous: VerifiedOrigin, signal: AbortSignal): Promise<VerifiedOrigin>;
+}

package/dist/core/ports/outbox.d.ts

@@ -0,0 +1,46 @@
+import type { CloudEvent } from '@eventsdk/sdk/contracts';
+import type { VerifiedOrigin } from '@eventsdk/sdk/identity-contracts';
+import type { EventIdentity } from '../runtime/event-identity.js';
+import type { Lease } from '../runtime/lease.js';
+import type { PublishAck } from './transport.js';
+export interface OutboxRecord {
+    readonly event: CloudEvent;
+    readonly digest: string;
+    readonly origin: VerifiedOrigin;
+}
+export interface ClaimedEvent extends OutboxRecord {
+    readonly lease: Lease;
+    readonly attempt: number;
+}
+export type PublishOutcome = {
+    readonly status: 'PUBLISHED';
+    readonly ack: PublishAck;
+} | {
+    readonly status: 'UNKNOWN';
+    readonly nextAttemptAt: number;
+} | {
+    readonly status: 'HOLD';
+    readonly reasonCode: string;
+};
+export interface FanoutOutboxRecord extends OutboxRecord {
+    readonly logicalDigest: string;
+    readonly deliveryId: string;
+}
+export interface OutboxRecordPort<TTransaction> {
+    recordFanoutInTransaction?(tx: TTransaction, record: FanoutOutboxRecord, signal: AbortSignal): Promise<void>;
+    recordInTransaction(tx: TTransaction, record: OutboxRecord, signal: AbortSignal): Promise<void>;
+}
+export interface OutboxRelayPort {
+    settleFanoutPublish?(identity: EventIdentity & {
+        readonly deliveryid: string;
+    }, lease: Lease, outcome: PublishOutcome, signal: AbortSignal): Promise<void>;
+    claimReady(input: {
+        limit: number;
+        now: number;
+        leaseMs: number;
+        signal: AbortSignal;
+    }): Promise<readonly ClaimedEvent[]>;
+    settlePublish(identity: EventIdentity, lease: Lease, outcome: PublishOutcome, signal: AbortSignal): Promise<void>;
+}
+export interface OutboxPort<TTransaction> extends OutboxRecordPort<TTransaction>, OutboxRelayPort {
+}

package/dist/core/ports/result-reader.d.ts

@@ -0,0 +1,14 @@
+import type { CloudEvent, JsonValue, ResultRef } from '@eventsdk/sdk/contracts';
+import type { VerifiedOrigin } from '@eventsdk/sdk/identity-contracts';
+export interface ResultSnapshot {
+    readonly reference: ResultRef;
+    readonly value: JsonValue;
+}
+export interface ResultReadPort {
+    read(reference: ResultRef, context: {
+        event: CloudEvent;
+        origin: VerifiedOrigin;
+        targetScope: string;
+        signal: AbortSignal;
+    }): Promise<ResultSnapshot | null>;
+}

package/dist/core/ports/transport.d.ts

@@ -0,0 +1,13 @@
+import type { CloudEvent } from '@eventsdk/sdk/contracts';
+export interface PublishAck {
+    readonly stream: string;
+    readonly sequence: number;
+    readonly duplicate: boolean;
+}
+export interface PublishContext {
+    readonly messageId: string;
+    readonly signal: AbortSignal;
+}
+export interface PublishPort {
+    publish(event: CloudEvent, context: PublishContext): Promise<PublishAck>;
+}

package/dist/core/receipt/receipt-state.d.ts

@@ -0,0 +1,3 @@
+import { type BusinessReceipt } from '@eventsdk/sdk/contracts';
+export declare function assertReceiptTransition(previous: BusinessReceipt, next: BusinessReceipt): void;
+export declare function classifyReceiptCommit(previous: BusinessReceipt, next: BusinessReceipt): 'UNCHANGED' | 'TRANSITION';

package/dist/core/recovery/event-log.d.ts

@@ -0,0 +1,28 @@
+import type { CloudEvent } from '@eventsdk/sdk/contracts';
+import type { VerifiedOrigin } from '@eventsdk/sdk/identity-contracts';
+import type { OperationOptions } from '../runtime/dependencies.js';
+export interface EventLogItem {
+    readonly cursor: string;
+    readonly revision: string;
+    readonly commitEvidenceRef: string;
+    readonly event: CloudEvent;
+    readonly origin: VerifiedOrigin;
+}
+export type EventLogPage = {
+    readonly kind: 'PAGE';
+    readonly items: readonly EventLogItem[];
+    readonly nextCursor: string;
+} | {
+    readonly kind: 'GAP';
+    readonly oldestAvailableCursor: string;
+};
+export interface NativeEventLogPort {
+    readAfter(cursor: string, limit: number, signal: AbortSignal): Promise<EventLogPage>;
+}
+export interface EventLogCheckpointPort {
+    stageAndAdvance(expectedCursor: string, page: Extract<EventLogPage, {
+        kind: 'PAGE';
+    }>, signal: AbortSignal): Promise<void>;
+    recordGap(expectedCursor: string, oldestAvailableCursor: string, signal: AbortSignal): Promise<void>;
+}
+export declare function stageEventLogPage(cursor: string, limit: number, source: NativeEventLogPort, checkpoint: EventLogCheckpointPort, options: OperationOptions): Promise<EventLogPage['kind']>;

package/dist/core/recovery/gap-baseline-binding.d.ts

@@ -0,0 +1,2 @@
+import type { CloudEvent, GapBaseline } from '@eventsdk/sdk/contracts';
+export declare function assertGapBaselineBinding(event: CloudEvent, value: GapBaseline, targetScope?: string): void;

package/dist/core/recovery/gap-recovery.d.ts

@@ -0,0 +1,15 @@
+import { type JsonValue } from '@eventsdk/sdk/contracts';
+import type { OperationOptions } from '../runtime/dependencies.js';
+export interface AuthorizedSnapshot {
+    readonly source: string;
+    readonly scope: string;
+    readonly revision: string;
+    readonly watermark: string;
+    readonly evidenceRef: string;
+    readonly value: JsonValue;
+}
+export interface SnapshotRecoveryPort {
+    readAuthorized(source: string, scope: string, signal: AbortSignal): Promise<AuthorizedSnapshot | null>;
+    applyAndCheckpoint(expectedWatermark: string, snapshot: AuthorizedSnapshot, signal: AbortSignal): Promise<void>;
+}
+export declare function recoverGap(source: string, scope: string, expectedWatermark: string, port: SnapshotRecoveryPort, options: OperationOptions): Promise<AuthorizedSnapshot>;

package/dist/core/recovery/receipt-identity-recovery.d.ts

@@ -0,0 +1,8 @@
+import { type BusinessReceipt } from '@eventsdk/sdk/contracts';
+import type { InboxKey } from '../runtime/event-identity.js';
+import type { OperationOptions } from '../runtime/dependencies.js';
+import type { RecoveryObservation } from './receipt-recovery.js';
+export interface ReceiptIdentityLookupPort {
+    readByIdentity(key: InboxKey, signal: AbortSignal): Promise<BusinessReceipt | null>;
+}
+export declare function recoverReceiptByIdentity(key: InboxKey, reader: ReceiptIdentityLookupPort, options: OperationOptions): Promise<RecoveryObservation>;

package/dist/core/recovery/receipt-recovery.d.ts

@@ -0,0 +1,14 @@
+import { type BusinessReceipt } from '@eventsdk/sdk/contracts';
+import type { InboxKey } from '../runtime/event-identity.js';
+import type { OperationOptions } from '../runtime/dependencies.js';
+export interface ReceiptLookupPort {
+    read(key: InboxKey, deliveryRef: string, signal: AbortSignal): Promise<BusinessReceipt | null>;
+}
+export type RecoveryObservation = {
+    readonly status: 'RESOLVED';
+    readonly receipt: BusinessReceipt;
+} | {
+    readonly status: 'WAIT';
+    readonly receipt: BusinessReceipt | null;
+};
+export declare function recoverReceipt(key: InboxKey, deliveryRef: string, reader: ReceiptLookupPort, options: OperationOptions): Promise<RecoveryObservation>;

package/dist/core/recovery/replay-dead-letter.d.ts

@@ -0,0 +1,4 @@
+import type { DeadLetterEntry, DeadLetterPort } from '../ports/dead-letter.js';
+import type { ApplyAuthorizationPort } from '../inbox/apply-delivery.js';
+import type { OperationOptions } from '../runtime/dependencies.js';
+export declare function replayDeadLetter<T>(entry: DeadLetterEntry, port: DeadLetterPort<T>, authorization: ApplyAuthorizationPort<T>, options: OperationOptions): Promise<void>;

package/dist/core/runtime/dependencies.d.ts

@@ -0,0 +1,19 @@
+export interface Clock {
+    now(): number;
+}
+export interface IdGenerator {
+    next(): string;
+}
+export interface Digest {
+    sha256(value: string): Promise<string>;
+}
+export interface Random {
+    next(): number;
+}
+export interface OperationOptions {
+    signal?: AbortSignal;
+    timeoutMs: number;
+}
+export interface MetricSink {
+    increment(name: string, labels: Readonly<Record<string, string>>): void;
+}

package/dist/core/runtime/errors.d.ts

@@ -0,0 +1,6 @@
+export type CoreErrorCode = 'ABORTED' | 'TIMEOUT' | 'INVALID_CONFIGURATION' | 'INVALID_DOMAIN_RESULT' | 'ADAPTER_CAPABILITY_REQUIRED' | 'STALE_LEASE' | 'EVENT_ID_CONFLICT' | 'AUTHORIZATION_DENIED' | 'AUTHORIZATION_UNKNOWN' | 'ORIGIN_MISMATCH' | 'TARGET_SCOPE_CHANGED' | 'RESULT_MISMATCH' | 'RECEIPT_MISMATCH' | 'RECOVERY_REQUIRED' | 'GAP' | 'INVALID_TRANSITION';
+export declare class CoreError extends Error {
+    readonly code: CoreErrorCode;
+    constructor(code: CoreErrorCode);
+}
+export declare function assertNotAborted(signal?: AbortSignal): void;

package/dist/core/runtime/event-identity.d.ts

@@ -0,0 +1,14 @@
+import { type CloudEvent } from '@eventsdk/sdk/contracts';
+import type { Digest } from './dependencies.js';
+export interface EventIdentity {
+    readonly source: string;
+    readonly id: string;
+    readonly deliveryid?: string;
+}
+export interface InboxKey extends EventIdentity {
+    readonly consumerRef: string;
+    readonly targetScope: string;
+}
+export declare function eventMessageId(event: EventIdentity, digest: Digest): Promise<string>;
+export declare function eventDigest(event: CloudEvent, digest: Digest): Promise<string>;
+export declare function inboxKey(key: InboxKey): string;

package/dist/core/runtime/exchange-connection.d.ts

@@ -0,0 +1,7 @@
+import { type TenantContext } from '@eventsdk/sdk/contracts';
+import type { Digest } from './dependencies.js';
+export declare function deriveExchangeConnectionRef(input: {
+    source: string;
+    from: TenantContext;
+    to: TenantContext;
+}, digest: Digest): Promise<string>;

package/dist/core/runtime/fanout-identity.d.ts

@@ -0,0 +1,6 @@
+import { type CloudEvent, type CloudEventV12, type FanoutEventDraft } from '@eventsdk/sdk/contracts';
+import type { Digest } from './dependencies.js';
+export declare function fanoutLogicalEvent(event: CloudEventV12): FanoutEventDraft;
+export declare function logicalEventDigest(event: CloudEvent, digest: Digest): Promise<string>;
+export declare function deriveDeliveryId(event: Pick<CloudEventV12, 'source' | 'id' | 'audience' | 'connectionref'>, digest: Digest): Promise<string>;
+export declare function assertDeliveryIdentity(event: CloudEvent, digest: Digest): Promise<void>;

package/dist/core/runtime/lease.d.ts

@@ -0,0 +1,6 @@
+export interface Lease {
+    readonly token: string;
+    readonly generation: number;
+    readonly expiresAt: number;
+}
+export declare function assertLiveLease(lease: Lease, now: number): void;

package/dist/core/runtime/observe-health.d.ts

@@ -0,0 +1,3 @@
+import type { DeliveryHealth, DeliveryHealthPort, HealthMetricSink } from '../ports/observability.js';
+import type { OperationOptions } from './dependencies.js';
+export declare function observeDeliveryHealth(port: DeliveryHealthPort, sink: HealthMetricSink, options: OperationOptions): Promise<DeliveryHealth>;

package/dist/core/runtime/operation.d.ts

@@ -0,0 +1,2 @@
+import type { OperationOptions } from './dependencies.js';
+export declare function boundedOperation<T>(options: OperationOptions, operation: (signal: AbortSignal) => Promise<T>): Promise<T>;

package/dist/core/runtime/retry.d.ts

@@ -0,0 +1,14 @@
+import type { Random } from './dependencies.js';
+export interface RetryPolicy {
+    readonly maxAttempts: number;
+    readonly baseDelayMs: number;
+    readonly maxDelayMs: number;
+    readonly jitterRatio: number;
+}
+export type RetryDecision = {
+    readonly kind: 'RETRY';
+    readonly nextAttemptAt: number;
+} | {
+    readonly kind: 'EXHAUSTED';
+};
+export declare function decideRetry(attempt: number, now: number, policy: RetryPolicy, random: Random): RetryDecision;

package/dist/identity-contracts/authorization/authorization-port.d.ts

@@ -0,0 +1,35 @@
+import type { CloudEvent, ResultRef } from '@eventsdk/sdk/contracts';
+import type { VerifiedOrigin } from '../origin/verified-origin.js';
+export type AuthorizationPhase = 'OUTBOUND' | 'RECEIVE' | 'APPLY' | 'RESULT_READ';
+export interface AuthorizationRequest {
+    readonly phase: AuthorizationPhase;
+    readonly event: CloudEvent;
+    readonly origin: VerifiedOrigin;
+    readonly consumerRef?: string;
+    readonly targetScope?: string;
+    readonly resultRef?: ResultRef;
+    readonly signal?: AbortSignal;
+}
+export type AuthorizationDecision = {
+    readonly decision: 'ALLOW';
+    readonly source: string;
+    readonly targetScope: string;
+    readonly connectionRef: string;
+    readonly grantRef: string;
+    readonly grantVersion: number;
+} | {
+    readonly decision: 'DENY' | 'UNKNOWN';
+    readonly reasonCode: string;
+};
+export interface AuthorizationPort {
+    authorize(request: AuthorizationRequest): Promise<AuthorizationDecision>;
+}
+export interface ResultReadRequest {
+    readonly reference: ResultRef;
+    readonly origin: VerifiedOrigin;
+    readonly targetScope: string;
+    readonly connectionRef: string;
+    readonly grantRef: string;
+    readonly grantVersion: number;
+    readonly signal?: AbortSignal;
+}

package/dist/identity-contracts/index.d.ts

@@ -0,0 +1,2 @@
+export type { VerifiedOrigin, ServicePrincipal, VerifyOriginRequest, OriginVerification, OriginVerifierPort, } from './origin/verified-origin.js';
+export type { AuthorizationPhase, AuthorizationRequest, AuthorizationDecision, AuthorizationPort, ResultReadRequest, } from './authorization/authorization-port.js';

package/dist/identity-contracts/origin/verified-origin.d.ts

@@ -0,0 +1,28 @@
+export interface VerifiedOrigin {
+    readonly serviceRef: string;
+    readonly issuer: string;
+    readonly subject: string;
+    readonly audience: readonly string[];
+    readonly verifiedAt: string;
+    readonly expiresAt: string;
+}
+export interface ServicePrincipal {
+    readonly serviceRef: string;
+    readonly issuer: string;
+    readonly subject: string;
+}
+export interface VerifyOriginRequest {
+    readonly credential: string;
+    readonly expectedAudience: string;
+    readonly signal?: AbortSignal;
+}
+export type OriginVerification = {
+    readonly verified: true;
+    readonly origin: VerifiedOrigin;
+} | {
+    readonly verified: false;
+    readonly reasonCode: string;
+};
+export interface OriginVerifierPort {
+    verify(request: VerifyOriginRequest): Promise<OriginVerification>;
+}

package/dist/identity-verifier/index.d.ts

@@ -0,0 +1,6 @@
+export { createServiceTokenVerifier } from './jwt/service-token-verifier.js';
+export type { ServiceTokenPolicy } from './jwt/service-token-verifier.js';
+export { createEventOriginSigner } from './origin/event-origin-signer.js';
+export { createEventOriginVerifier } from './origin/event-origin-verifier.js';
+export { EventOriginError, eventOriginTyp, validatePublicOriginKeys, } from './origin/event-origin-policy.js';
+export type { EventOriginAlgorithm, EventOriginSignerPolicy, EventOriginVerifierPolicy, } from './origin/event-origin-policy.js';

package/dist/identity-verifier/index.js

@@ -0,0 +1 @@
+import{createLocalJWKSet,decodeProtectedHeader,jwtVerify}from"jose";function createServiceTokenVerifier(input){const policy={...structuredClone({...input,clock:void 0}),clock:input.clock};validatePolicy(policy);const resolve=createLocalJWKSet(policy.jwks);return{async verify(request){try{request.signal?.throwIfAborted();const now=policy.clock();if(!Number.isFinite(now.getTime())||now.getTime()>=Date.parse(policy.keysValidUntil))return{verified:false,reasonCode:"TRUST_SNAPSHOT_EXPIRED"};if(request.expectedAudience!==policy.audience||request.credential.length>16384)return{verified:false,reasonCode:"TOKEN_REJECTED"};const header=decodeProtectedHeader(request.credential);if(typeof header.kid!=="string"||!header.kid||header.jku!==void 0||header.x5u!==void 0)return{verified:false,reasonCode:"TOKEN_REJECTED"};const result=await jwtVerify(request.credential,resolve,{issuer:policy.issuer,audience:policy.audience,subject:policy.subject,algorithms:[...policy.algorithms],typ:"at+jwt",currentDate:now,requiredClaims:["iss","sub","aud","exp","iat","client_id"],maxTokenAge:policy.maxTokenLifetimeSeconds});request.signal?.throwIfAborted();return verifiedClaims(result,policy,policy.clock())}catch{return{verified:false,reasonCode:request.signal?.aborted?"CANCELLED":"TOKEN_REJECTED"}}}}}function validatePolicy(p){if(![p.issuer,p.audience,p.clientId,p.subject,p.serviceRef].every(v=>v.length>0)||!Number.isFinite(Date.parse(p.keysValidUntil))||!Number.isSafeInteger(p.maxTokenLifetimeSeconds)||p.maxTokenLifetimeSeconds<1||!p.algorithms.length||p.algorithms.some(a=>!["RS256","PS256","ES256","EdDSA"].includes(a))||!p.jwks.keys.length||new Set(p.jwks.keys.map(k=>k.kid)).size!==p.jwks.keys.length||p.jwks.keys.some(k=>typeof k.kid!=="string"||!k.kid)||p.jwks.keys.some(k=>k.kty==="oct"||["d","k","p","q","dp","dq","qi","oth"].some(member=>member in k))){throw new Error("INVALID_SERVICE_TOKEN_POLICY")}}function verifiedClaims(result,policy,now){const p=result.payload;if(p.client_id!==policy.clientId||typeof p.exp!=="number"||typeof p.iat!=="number"||p.exp<=p.iat||p.exp-p.iat>policy.maxTokenLifetimeSeconds||!Number.isFinite(now.getTime())||now.getTime()>=p.exp*1e3||now.getTime()<p.iat*1e3||now.getTime()>=Date.parse(policy.keysValidUntil))return{verified:false,reasonCode:"TOKEN_REJECTED"};return{verified:true,origin:{serviceRef:policy.serviceRef,issuer:policy.issuer,subject:policy.subject,audience:[policy.audience],verifiedAt:now.toISOString(),expiresAt:new Date(Math.min(p.exp*1e3,Date.parse(policy.keysValidUntil))).toISOString()}}}import{CompactSign,importPKCS8}from"jose";import{canonicalJson as canonicalJson2,parseCloudEvent,parseEventOriginClaims}from"@eventsdk/sdk/contracts";import{createHash}from"node:crypto";import{canonicalJson}from"@eventsdk/sdk/contracts";function originEventDigest(event){return`sha256:${createHash("sha256").update(canonicalJson(event)).digest("hex")}`}import{EVENTSDK_ORIGIN_PROOF_TYPE}from"@eventsdk/sdk/contracts";var EventOriginError=class extends Error{constructor(code){super(code);this.code=code}code};var eventOriginTyp=EVENTSDK_ORIGIN_PROOF_TYPE;var originAlgorithms=["RS256","PS256","ES256","EdDSA"];var publicJwkFields=new Set(["kty","kid","alg","use","key_ops","ext","n","e","crv","x","y","x5c","x5t","x5t#S256"]);function validateOriginBinding(policy){if(![policy.issuer,policy.subject,policy.serviceRef,policy.source].every(ref)||!Number.isFinite(Date.parse(policy.keysValidUntil))||!Number.isInteger(policy.verificationTtlMs??6e4)||(policy.verificationTtlMs??6e4)<1||(policy.verificationTtlMs??6e4)>3e5)throw new EventOriginError("INVALID_ORIGIN_POLICY")}function validatePublicOriginKeys(jwks){if(!jwks||!Array.isArray(jwks.keys)||jwks.keys.length<1||jwks.keys.length>32||new Set(jwks.keys.map(key=>key.kid)).size!==jwks.keys.length||jwks.keys.some(key=>!ref(key.kid)||key.kty==="oct"||Object.keys(key).some(member=>!publicJwkFields.has(member))||["d","k","p","q","dp","dq","qi","oth"].some(member=>member in key)))throw new EventOriginError("INVALID_ORIGIN_POLICY")}function ref(value){return typeof value==="string"&&value.length>0&&value.length<=2048&&[...value].every(character=>character.charCodeAt(0)>32&&character.charCodeAt(0)!==127)}function assertCurrentOriginTrust(policy,now){if(!Number.isFinite(now.getTime())||now.getTime()>=Date.parse(policy.keysValidUntil))throw new EventOriginError("TRUST_SNAPSHOT_EXPIRED")}function assertOriginEvent(policy,event){if(event.source!==policy.source||event.serviceorigin!==policy.serviceRef)throw new EventOriginError("ORIGIN_PROOF_REJECTED")}function freshEventOrigin(policy,audience){const now=policy.clock();assertCurrentOriginTrust(policy,now);return Object.freeze({serviceRef:policy.serviceRef,issuer:policy.issuer,subject:policy.subject,audience:Object.freeze([audience]),verifiedAt:now.toISOString(),expiresAt:new Date(Math.min(Date.parse(policy.keysValidUntil),now.getTime()+(policy.verificationTtlMs??6e4))).toISOString()})}async function createEventOriginSigner(input){const policy={...structuredClone({...input,clock:void 0}),clock:input.clock};validateOriginBinding(policy);if(!ref(policy.keyId)||!originAlgorithms.includes(policy.algorithm)||!policy.audiences.length||policy.audiences.length>32||policy.audiences.some(a=>!ref(a))||new Set(policy.audiences).size!==policy.audiences.length)throw new EventOriginError("INVALID_ORIGIN_POLICY");let key;try{key=await importPKCS8(policy.privateKeyPkcs8,policy.algorithm)}catch{throw new EventOriginError("INVALID_ORIGIN_POLICY")}const currentOrigin=audience=>{if(!policy.audiences.includes(audience))throw new EventOriginError("ORIGIN_PROOF_REJECTED");return freshEventOrigin(policy,audience)};return{currentOrigin,async sign(raw,signal){signal.throwIfAborted();const event=parseCloudEvent(structuredClone(raw));assertOriginEvent(policy,event);currentOrigin(event.audience);const claims=parseEventOriginClaims({schemaVersion:1,purpose:"eventsdk-origin/1",issuer:policy.issuer,subject:policy.subject,serviceRef:policy.serviceRef,audience:event.audience,source:event.source,eventId:event.id,...event.profile==="eventsdk/1.2"?{deliveryId:event.deliveryid}:{},eventDigest:originEventDigest(event),signedAt:policy.clock().toISOString()});const proof=await new CompactSign(new TextEncoder().encode(canonicalJson2(claims))).setProtectedHeader({typ:eventOriginTyp,alg:policy.algorithm,kid:policy.keyId}).sign(key);signal.throwIfAborted();assertCurrentOriginTrust(policy,policy.clock());if(proof.length>8192)throw new EventOriginError("ORIGIN_PROOF_REJECTED");return proof}}}import{compactVerify,createLocalJWKSet as createLocalJWKSet2,decodeProtectedHeader as decodeProtectedHeader2,errors}from"jose";import{parseCloudEvent as parseCloudEvent2,parseEventOriginClaims as parseEventOriginClaims2,parseJsonStrict}from"@eventsdk/sdk/contracts";function createEventOriginVerifier(input){const policy={...structuredClone({...input,clock:void 0}),clock:input.clock};validateOriginBinding(policy);validatePublicOriginKeys(policy.jwks);if(!ref(policy.audience)||!policy.algorithms.length||policy.algorithms.some(a=>!originAlgorithms.includes(a)))throw new EventOriginError("INVALID_ORIGIN_POLICY");const resolve=createLocalJWKSet2(policy.jwks);return{async verify(eventInput,proof,signal){try{signal.throwIfAborted();assertCurrentOriginTrust(policy,policy.clock());const event=parseCloudEvent2(structuredClone(eventInput));assertOriginEvent(policy,event);if(typeof proof!=="string"||!proof.length||proof.length>8192)throw rejected();const header=decodeProtectedHeader2(proof);if(header.typ!==eventOriginTyp||!ref(header.kid)||Object.keys(header).some(key=>!["typ","alg","kid"].includes(key)))throw rejected();const verified=await compactVerify(proof,resolve,{algorithms:[...policy.algorithms]});const claims=parseEventOriginClaims2(parseJsonStrict(new TextDecoder("utf-8",{fatal:true}).decode(verified.payload)));assertClaims(policy,event,claims);signal.throwIfAborted();assertCurrentOriginTrust(policy,policy.clock());return{verified:true,origin:freshEventOrigin(policy,policy.audience)}}catch(error){return{verified:false,reasonCode:signal.aborted?"CANCELLED":error instanceof errors.JWKSNoMatchingKey?"ORIGIN_KEY_UNAVAILABLE":error instanceof EventOriginError?error.code:"ORIGIN_PROOF_REJECTED"}}}}}function rejected(){return new EventOriginError("ORIGIN_PROOF_REJECTED")}function assertClaims(policy,event,claims){if(claims.issuer!==policy.issuer||claims.subject!==policy.subject||claims.serviceRef!==policy.serviceRef||claims.audience!==policy.audience||event.audience!==policy.audience||claims.source!==event.source||claims.eventId!==event.id||claims.deliveryId!==(event.profile==="eventsdk/1.2"?event.deliveryid:void 0)||claims.eventDigest!==originEventDigest(event)||!Number.isFinite(Date.parse(claims.signedAt)))throw rejected();if(Date.parse(claims.signedAt)>policy.clock().getTime())throw new EventOriginError("ORIGIN_PROOF_NOT_YET_VALID")}export{EventOriginError,createEventOriginSigner,createEventOriginVerifier,createServiceTokenVerifier,eventOriginTyp,validatePublicOriginKeys};

package/dist/identity-verifier/jwt/service-token-verifier.d.ts

@@ -0,0 +1,15 @@
+import type { JSONWebKeySet } from 'jose';
+import type { OriginVerifierPort } from '@eventsdk/sdk/identity-contracts';
+export interface ServiceTokenPolicy {
+    readonly issuer: string;
+    readonly audience: string;
+    readonly clientId: string;
+    readonly subject: string;
+    readonly serviceRef: string;
+    readonly algorithms: readonly ('RS256' | 'PS256' | 'ES256' | 'EdDSA')[];
+    readonly jwks: JSONWebKeySet;
+    readonly keysValidUntil: string;
+    readonly maxTokenLifetimeSeconds: number;
+    readonly clock: () => Date;
+}
+export declare function createServiceTokenVerifier(input: ServiceTokenPolicy): OriginVerifierPort;