@eventsdk/sdk 0.0.0-stage → 0.3.1

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2013-2018 The NATS Authors
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/NOTICE

@@ -0,0 +1,9 @@
+EventSDK
+Copyright 2026 EventSDK contributors
+Licensed under Apache-2.0.
+
+Includes modified @nats-io/transport-node 3.4.0.
+Copyright 2013-2020 The NATS Authors.
+Copyright 2020-2024 The NATS Authors.
+EventSDK modifications: bounded initial dial, INFO and TLS socket cleanup.
+Distributed under Apache-2.0; see licenses/NATS-LICENSE.

package/dist/compatibility-http/bridge/receive.d.ts

@@ -0,0 +1,3 @@
+import type { DurableAdmission, OperationOptions } from '@eventsdk/sdk/core';
+import type { BridgeDependencies, LegacyHttpRequest } from './types.js';
+export declare function receiveLegacyHttp(input: LegacyHttpRequest, deps: BridgeDependencies, options: OperationOptions): Promise<DurableAdmission>;

package/dist/compatibility-http/bridge/types.d.ts

@@ -0,0 +1,44 @@
+import type { CloudEvent } from '@eventsdk/sdk/contracts';
+import type { VerifiedOrigin } from '@eventsdk/sdk/identity-contracts';
+import type { AdmissionDependencies } from '@eventsdk/sdk/core';
+export interface MigrationPolicy {
+    readonly migrationRef: string;
+    readonly owner: string;
+    readonly mappingVersion: string;
+    readonly expiresAt: string;
+    readonly decommissionRef: string;
+    readonly maxBodyBytes: number;
+    readonly source: string;
+    readonly sourceService: string;
+    readonly idField: string;
+    readonly timeField: string;
+    readonly allowedTypes: readonly string[];
+}
+export interface LegacyHttpRequest {
+    readonly body: Uint8Array;
+    readonly contentType: string;
+    readonly sourceProof: string;
+    readonly deliveryRef: string;
+    readonly consumerRef: string;
+}
+export interface SourceProofPort {
+    verify(input: {
+        readonly body: Uint8Array;
+        readonly proof: string;
+        readonly sourceService: string;
+        readonly signal: AbortSignal;
+    }): Promise<VerifiedOrigin>;
+}
+export interface LegacyMappingPort {
+    map(input: unknown, mappingVersion: string): CloudEvent;
+}
+export interface BridgeDependencies {
+    readonly policy: MigrationPolicy;
+    readonly proof: SourceProofPort;
+    readonly mapping: LegacyMappingPort;
+    readonly admission: AdmissionDependencies;
+}
+export declare class BridgeError extends Error {
+    readonly code: string;
+    constructor(code: string);
+}

package/dist/compatibility-http/index.d.ts

@@ -0,0 +1,4 @@
+export { BridgeError } from './bridge/types.js';
+export type { MigrationPolicy, LegacyHttpRequest, SourceProofPort, LegacyMappingPort, BridgeDependencies, } from './bridge/types.js';
+export { receiveLegacyHttp } from './bridge/receive.js';
+export { assertMigrationActive, assertNoCredentials } from './policy/validate-policy.js';

package/dist/compatibility-http/index.js

@@ -0,0 +1 @@
+var BridgeError=class extends Error{constructor(code){super(code);this.code=code;this.name="BridgeError"}code};import{parseCloudEvent,parseJsonStrict}from"@eventsdk/sdk/contracts";import{acceptDelivery,boundedOperation}from"@eventsdk/sdk/core";function assertMigrationActive(policy,now){if(!policy.migrationRef||!policy.owner||!policy.mappingVersion||!policy.decommissionRef||!policy.source||!policy.sourceService||!policy.idField||!policy.timeField||!policy.allowedTypes.length||!Number.isSafeInteger(policy.maxBodyBytes)||policy.maxBodyBytes<1||policy.maxBodyBytes>1048576)throw new BridgeError("INVALID_MIGRATION_POLICY");const deadline=Date.parse(policy.expiresAt);if(!Number.isFinite(deadline)||!Number.isFinite(now)||deadline<=now){throw new BridgeError("MIGRATION_EXPIRED")}}var credentialKey=/^(?:password|passwd|secret|token|access[_-]?token|refresh[_-]?token|api[_-]?key|private[_-]?key|authorization|cookie|credential|credentials|recovery[_-]?key)$/i;function assertNoCredentials(value,depth=0){if(depth>64)throw new BridgeError("PAYLOAD_TOO_DEEP");if(Array.isArray(value)){for(const entry of value)assertNoCredentials(entry,depth+1)}else if(value&&typeof value==="object"){for(const[key,entry]of Object.entries(value)){if(credentialKey.test(key))throw new BridgeError("CREDENTIAL_PAYLOAD_REJECTED");assertNoCredentials(entry,depth+1)}}}function decode(request,policy){if(!/^application\/json(?:\s*;\s*charset=utf-8)?$/i.test(request.contentType)){throw new BridgeError("UNSUPPORTED_CONTENT_TYPE")}if(request.body.byteLength>policy.maxBodyBytes)throw new BridgeError("BODY_TOO_LARGE");if(!request.sourceProof||request.sourceProof.length>16384){throw new BridgeError("SOURCE_PROOF_REQUIRED")}const value=parseJsonStrict(request.body);assertNoCredentials(value);return value}function identity(value,field){if(!value||typeof value!=="object"||Array.isArray(value))throw new BridgeError("INVALID_LEGACY_EVENT");const id=value[field];if(typeof id!=="string"||!id||id.length>512)throw new BridgeError("STABLE_EVENT_ID_REQUIRED");return id}async function receiveLegacyHttp(input,deps,options){const request={...input,body:new Uint8Array(input.body)};const policy=structuredClone(deps.policy);assertMigrationActive(policy,deps.admission.clock.now());const value=decode(request,policy);const id=identity(value,policy.idField);const occurredAt=identity(value,policy.timeField);return boundedOperation(options,async signal=>{const origin=await deps.proof.verify({body:new Uint8Array(request.body),proof:request.sourceProof,sourceService:policy.sourceService,signal});if(origin.serviceRef!==policy.sourceService)throw new BridgeError("SOURCE_PROOF_MISMATCH");assertMigrationActive(policy,deps.admission.clock.now());const event=parseCloudEvent(deps.mapping.map(structuredClone(value),policy.mappingVersion));assertNoCredentials(event.data);if(event.id!==id||event.time!==occurredAt||event.source!==policy.source||event.serviceorigin!==policy.sourceService||!policy.allowedTypes.includes(event.type))throw new BridgeError("MAPPING_IDENTITY_MISMATCH");return acceptDelivery({event,origin,deliveryRef:request.deliveryRef,consumerRef:request.consumerRef},{...deps.admission,authorization:{authorize:async authorizationRequest=>{const decision=await deps.admission.authorization.authorize(authorizationRequest);assertMigrationActive(policy,deps.admission.clock.now());return decision}}},{signal,timeoutMs:options.timeoutMs})})}export{BridgeError,assertMigrationActive,assertNoCredentials,receiveLegacyHttp};

package/dist/compatibility-http/policy/validate-policy.d.ts

@@ -0,0 +1,3 @@
+import type { MigrationPolicy } from '../bridge/types.js';
+export declare function assertMigrationActive(policy: MigrationPolicy, now: number): void;
+export declare function assertNoCredentials(value: unknown, depth?: number): void;

package/dist/conformance/admission/harness.d.ts

@@ -0,0 +1,20 @@
+import type { CloudEvent } from '@eventsdk/sdk/contracts';
+import type { AdmissionDependencies, AcceptedEvent, QuarantineRecord } from '@eventsdk/sdk/core';
+import type { AuthorizationDecision, VerifiedOrigin } from '@eventsdk/sdk/identity-contracts';
+export interface AdmissionHarness {
+    readonly event: CloudEvent;
+    readonly origin: VerifiedOrigin;
+    dependencies(): AdmissionDependencies;
+    setAuthorization(decision: AuthorizationDecision): void;
+    failNextCommit(): void;
+    accepted(): Promise<readonly AcceptedEvent[]>;
+    quarantined(): Promise<readonly QuarantineRecord[]>;
+    reopen(): Promise<void>;
+    close(): Promise<void>;
+}
+export type AdmissionHarnessFactory = () => Promise<AdmissionHarness>;
+export interface ConformanceCaseResult {
+    readonly id: string;
+    readonly passed: boolean;
+    readonly failureCode?: 'ASSERTION_FAILED';
+}

package/dist/conformance/admission/run-suite.d.ts

@@ -0,0 +1,2 @@
+import type { AdmissionHarnessFactory, ConformanceCaseResult } from './harness.js';
+export declare function runAdmissionConformance(factory: AdmissionHarnessFactory): Promise<readonly ConformanceCaseResult[]>;

package/dist/conformance/consumer/harness.d.ts

@@ -0,0 +1,24 @@
+import type { BusinessReceipt } from '@eventsdk/sdk/contracts';
+import type { ApplyDependencies, ClaimedInbox, DeadLetterEntry, DeadLetterPort, InboxWorkPort, OperationOptions } from '@eventsdk/sdk/core';
+export interface ConsumerObservation {
+    readonly receipt: BusinessReceipt;
+    readonly effects: number;
+    readonly quarantined: boolean;
+    readonly deadLetters: readonly DeadLetterEntry[];
+}
+export interface ConsumerHarness<T> {
+    readonly options: OperationOptions;
+    dependencies(): Omit<ApplyDependencies<T>, 'domain'>;
+    work(): InboxWorkPort;
+    deadLetters(): DeadLetterPort<T>;
+    claim(): Promise<ClaimedInbox>;
+    writeEffect(tx: T, claim: ClaimedInbox): Promise<void>;
+    inspect(): Promise<ConsumerObservation>;
+    setAuthorized(allowed: boolean): Promise<void>;
+    invalidateLease(): Promise<void>;
+    failNextReceiptCommit(): Promise<void>;
+    seedUnknown(): Promise<void>;
+    reopen(): Promise<void>;
+    close(): Promise<void>;
+}
+export type ConsumerHarnessFactory<T> = () => Promise<ConsumerHarness<T>>;

package/dist/conformance/consumer/run-apply-suite.d.ts

@@ -0,0 +1,2 @@
+import type { ConsumerHarnessFactory } from './harness.js';
+export declare function runApplyConformance<T>(factory: ConsumerHarnessFactory<T>): Promise<readonly import("../index.js").ConformanceCaseResult[]>;

package/dist/conformance/consumer/run-worker-suite.d.ts

@@ -0,0 +1,2 @@
+import type { ConsumerHarnessFactory } from './harness.js';
+export declare function runWorkerConformance<T>(factory: ConsumerHarnessFactory<T>): Promise<readonly import("../index.js").ConformanceCaseResult[]>;

package/dist/conformance/fanout/harness.d.ts

@@ -0,0 +1,39 @@
+import type { CloudEventV12, FanoutEventDraft, BusinessReceipt } from '@eventsdk/sdk/contracts';
+import type { AdmissionDependencies, ApplyDependencies, ClaimedInbox, FanoutRecipient, InboxKey, OperationOptions, RecordDependencies, RelayDependencies } from '@eventsdk/sdk/core';
+export interface FanoutTarget {
+    readonly recipient: FanoutRecipient;
+    readonly consumerRef: string;
+    readonly targetScope: string;
+}
+export interface FanoutObservation {
+    readonly domainWrites: number;
+    readonly logicalFacts: number;
+    readonly outbound: readonly {
+        readonly event: CloudEventV12;
+        readonly status: string;
+    }[];
+    readonly accepted: readonly {
+        readonly key: InboxKey;
+        readonly event: CloudEventV12;
+        readonly receipt: BusinessReceipt;
+    }[];
+    readonly inboundDeliveries: number;
+    readonly effects: readonly InboxKey[];
+}
+export interface FanoutHarness<T> {
+    readonly draft: FanoutEventDraft;
+    readonly targets: readonly [FanoutTarget, FanoutTarget, FanoutTarget];
+    readonly options: OperationOptions;
+    producer(): RecordDependencies<T> & Omit<RelayDependencies, 'publisher'>;
+    admission(target: FanoutTarget): AdmissionDependencies;
+    application(): ApplyDependencies<T>;
+    claim(key: InboxKey): Promise<ClaimedInbox | null>;
+    transaction(operation: (tx: T) => Promise<void>): Promise<void>;
+    writeDomain(tx: T): Promise<void>;
+    inspect(): Promise<FanoutObservation>;
+    setAuthorized(target: FanoutTarget, allowed: boolean): Promise<void>;
+    replacementGrant(target: FanoutTarget): Promise<FanoutTarget>;
+    reopen(): Promise<void>;
+    close(): Promise<void>;
+}
+export type FanoutHarnessFactory<T> = () => Promise<FanoutHarness<T>>;

package/dist/conformance/fanout/run-suite.d.ts

@@ -0,0 +1,2 @@
+import type { FanoutHarnessFactory } from './harness.js';
+export declare function runFanoutConformance<T>(factory: FanoutHarnessFactory<T>): Promise<readonly import("../index.js").ConformanceCaseResult[]>;

package/dist/conformance/gap/harness.d.ts

@@ -0,0 +1,19 @@
+import type { AuthorizedSnapshot, OperationOptions, SnapshotRecoveryPort } from '@eventsdk/sdk/core';
+export interface GapObservation {
+    readonly watermark: string;
+    readonly snapshot: AuthorizedSnapshot;
+}
+export interface GapHarness {
+    readonly source: string;
+    readonly scope: string;
+    readonly initialWatermark: string;
+    readonly expected: AuthorizedSnapshot;
+    readonly options: OperationOptions;
+    port(): SnapshotRecoveryPort;
+    inspect(): Promise<GapObservation>;
+    setAuthorized(side: 'SOURCE' | 'TARGET', allowed: boolean): Promise<void>;
+    failAfterCheckpoint(): Promise<void>;
+    reopen(): Promise<void>;
+    close(): Promise<void>;
+}
+export type GapHarnessFactory = () => Promise<GapHarness>;

package/dist/conformance/gap/run-suite.d.ts

@@ -0,0 +1,2 @@
+import type { GapHarnessFactory } from './harness.js';
+export declare function runGapConformance(factory: GapHarnessFactory): Promise<readonly import("../index.js").ConformanceCaseResult[]>;

package/dist/conformance/index.d.ts

@@ -0,0 +1,20 @@
+export { runAdmissionConformance } from './admission/run-suite.js';
+export type { AdmissionHarness, AdmissionHarnessFactory, ConformanceCaseResult, } from './admission/harness.js';
+export { checkCompatibility } from './version/compatibility.js';
+export type { VersionSet, Compatibility } from './version/compatibility.js';
+export { checkRetryAndFence, checkGapIsNotSkipped, checkUnknownReceipt, } from './reliability/checks.js';
+export { runProducerConformance } from './producer/run-suite.js';
+export type { ProducerHarness, ProducerHarnessFactory, ProducerObservation, } from './producer/harness.js';
+export { runReceiptConformance } from './receipt/run-suite.js';
+export type { ReceiptHarness, ReceiptHarnessFactory } from './receipt/harness.js';
+export { runResultConformance } from './result/run-suite.js';
+export type { ResultHarness, ResultHarnessFactory } from './result/harness.js';
+export { runApplyConformance } from './consumer/run-apply-suite.js';
+export { runWorkerConformance } from './consumer/run-worker-suite.js';
+export type { ConsumerHarness, ConsumerHarnessFactory, ConsumerObservation, } from './consumer/harness.js';
+export { runGapConformance } from './gap/run-suite.js';
+export type { GapHarness, GapHarnessFactory, GapObservation } from './gap/harness.js';
+export { runReceiptProjectionConformance } from './receipt/run-projection-suite.js';
+export type { ReceiptProjectionHarness, ReceiptProjectionHarnessFactory, } from './receipt/projection-harness.js';
+export { runFanoutConformance } from './fanout/run-suite.js';
+export type { FanoutHarness, FanoutHarnessFactory, FanoutTarget, FanoutObservation, } from './fanout/harness.js';

package/dist/conformance/index.js

@@ -0,0 +1 @@
+import assert from"node:assert/strict";import{acceptDelivery}from"@eventsdk/sdk/core";var options={timeoutMs:1e3};function input(harness,consumerRef="conformance-consumer"){return{event:harness.event,origin:harness.origin,deliveryRef:"delivery-1",consumerRef}}async function duplicateCase(harness){const first=await acceptDelivery(input(harness),harness.dependencies(),options);const second=await acceptDelivery(input(harness),harness.dependencies(),options);assert.equal(first.kind,"RECEIVED");assert.equal(second.kind,"DUPLICATE");assert.equal((await harness.accepted()).length,1)}async function conflictCase(harness){await acceptDelivery(input(harness),harness.dependencies(),options);const changed={...input(harness),event:{...harness.event,data:{conflict:true}}};const result=await acceptDelivery(changed,harness.dependencies(),options);assert.equal(result.kind,"REJECTED");assert.equal((await harness.accepted()).length,1);assert.equal((await harness.quarantined())[0]?.reasonCode,"EVENT_ID_CONFLICT")}async function consumerIsolationCase(harness){await acceptDelivery(input(harness,"consumer-a"),harness.dependencies(),options);await acceptDelivery(input(harness,"consumer-b"),harness.dependencies(),options);assert.equal((await harness.accepted()).length,2)}async function tenantIsolationCase(harness){await acceptDelivery(input(harness),harness.dependencies(),options);harness.setAuthorization({decision:"ALLOW",source:harness.event.source,targetScope:"urn:target:tenant:other",connectionRef:harness.event.connectionref,grantRef:harness.event.grantref,grantVersion:harness.event.grantversion});await acceptDelivery(input(harness),harness.dependencies(),options);const records=await harness.accepted();assert.equal(records.length,2);assert.notEqual(records[0]?.key.targetScope,records[1]?.key.targetScope)}async function commitFailureCase(harness){harness.failNextCommit();await assert.rejects(acceptDelivery(input(harness),harness.dependencies(),options));assert.equal((await harness.accepted()).length,0);const retry=await acceptDelivery(input(harness),harness.dependencies(),options);assert.equal(retry.kind,"RECEIVED")}async function reopenCase(harness){await acceptDelivery(input(harness),harness.dependencies(),options);await harness.reopen();const retry=await acceptDelivery(input(harness),harness.dependencies(),options);assert.equal(retry.kind,"DUPLICATE")}async function revokedCase(harness){harness.setAuthorization({decision:"DENY",reasonCode:"GRANT_REVOKED"});const result=await acceptDelivery(input(harness),harness.dependencies(),options);assert.equal(result.kind,"REJECTED");assert.equal((await harness.accepted()).length,0)}async function unknownCase(harness){harness.setAuthorization({decision:"UNKNOWN",reasonCode:"AUTHORITY_UNAVAILABLE"});await assert.rejects(acceptDelivery(input(harness),harness.dependencies(),options),{code:"AUTHORIZATION_UNKNOWN"});assert.equal((await harness.accepted()).length,0)}async function spoofedOriginCase(harness){const delivery={...input(harness),origin:{...harness.origin,serviceRef:"spoofed"}};const result=await acceptDelivery(delivery,harness.dependencies(),options);assert.equal(result.kind,"REJECTED");assert.equal((await harness.accepted()).length,0)}var scenarios=[["E4.DEDUPLICATE",duplicateCase],["E1.EVENT_ID_CONFLICT",conflictCase],["E4.CONSUMER_ISOLATION",consumerIsolationCase],["E2.TENANT_ISOLATION",tenantIsolationCase],["E4.COMMIT_BEFORE_ACK",commitFailureCase],["E5.REOPEN_DEDUPLICATION",reopenCase],["E2.GRANT_REVOKED",revokedCase],["E2.UNKNOWN_FAIL_CLOSED",unknownCase],["E2.ORIGIN_MISMATCH",spoofedOriginCase]];async function runAdmissionConformance(factory){const results=[];for(const[id,scenario]of scenarios){const harness=await factory();try{await scenario(harness);results.push({id,passed:true})}catch{results.push({id,passed:false,failureCode:"ASSERTION_FAILED"})}finally{await harness.close()}}return results}var profilesBySdk={"0.1.0":["eventsdk/1.0"],"0.2.0":["eventsdk/1.0","eventsdk/1.1"],"0.3.0":["eventsdk/1.0","eventsdk/1.1","eventsdk/1.2"],"0.3.1":["eventsdk/1.0","eventsdk/1.1","eventsdk/1.2"]};function checkCompatibility(producer,consumer){for(const version of[producer,consumer]){if(!Object.hasOwn(profilesBySdk,version.sdkVersion)||version.schemaMajor!==1||version.cloudEvents!=="1.0")return{compatible:false,reason:"UNSUPPORTED_VERSION"}}if(producer.profile!==consumer.profile)return{compatible:false,reason:"PROFILE_MISMATCH"};for(const version of[producer,consumer]){if(!profilesBySdk[version.sdkVersion]?.includes(version.profile))return{compatible:false,reason:"UNSUPPORTED_VERSION"}}return{compatible:true}}import assert2 from"node:assert/strict";import{assertLiveLease,decideRetry,recoverGap,recoverReceipt,stageEventLogPage}from"@eventsdk/sdk/core";function checkRetryAndFence(){const policy={maxAttempts:4,baseDelayMs:100,maxDelayMs:250,jitterRatio:.25};for(const sample of[0,.5,.999999]){for(let attempt=1;attempt<4;attempt++){const result=decideRetry(attempt,1e3,policy,{next:()=>sample});assert2.equal(result.kind,"RETRY");if(result.kind==="RETRY")assert2.ok(result.nextAttemptAt>=1e3&&result.nextAttemptAt<=1250)}}assert2.deepEqual(decideRetry(4,1e3,policy,{next:()=>0}),{kind:"EXHAUSTED"});for(const lease of[{token:"old",generation:1,expiresAt:999},{token:"",generation:1,expiresAt:2e3},{token:"token",generation:0,expiresAt:2e3}])assert2.throws(()=>assertLiveLease(lease,1e3),{code:"STALE_LEASE"})}async function checkGapIsNotSkipped(){let staged=false;let gapRecorded=false;const result=await stageEventLogPage("3",10,{readAfter:async()=>({kind:"GAP",oldestAvailableCursor:"9"})},{recordGap:async(expected,oldest)=>{assert2.equal(expected,"3");assert2.equal(oldest,"9");gapRecorded=true},stageAndAdvance:async()=>{staged=true}},{timeoutMs:1e3});assert2.equal(result,"GAP");assert2.equal(gapRecorded,true);assert2.equal(staged,false);await assert2.rejects(recoverGap("source-a","tenant-a","3",{readAuthorized:async()=>null,applyAndCheckpoint:async()=>{staged=true}},{timeoutMs:1e3}),{code:"RECOVERY_REQUIRED"});assert2.equal(staged,false)}async function checkUnknownReceipt(receipt){const key2={source:receipt.originSource,id:receipt.originEventId,consumerRef:receipt.consumerRef,targetScope:receipt.targetScope};for(const disposition of["RECEIVED","UNKNOWN","HOLD"]){const observation=await recoverReceipt(key2,receipt.deliveryRef,{read:async()=>({...receipt,disposition})},{timeoutMs:1e3});assert2.equal(observation.status,"WAIT")}await assert2.rejects(recoverReceipt(key2,receipt.deliveryRef,{read:async()=>({...receipt,originEventId:"different-event"})},{timeoutMs:1e3}),{code:"RECEIPT_MISMATCH"})}async function runCases(factory,cases){const results=[];for(const[id,check]of cases){const harness=await factory();try{await check(harness);results.push({id,passed:true})}catch{results.push({id,passed:false,failureCode:"ASSERTION_FAILED"})}finally{await harness.close()}}return results}import assert3 from"node:assert/strict";import{recordEvent,relayOutbox}from"@eventsdk/sdk/core";var options2={timeoutMs:2e3};var relayOptions={...options2,batchSize:1,leaseMs:1e4,retry:{maxAttempts:4,baseDelayMs:0,maxDelayMs:1,jitterRatio:0}};async function record(h){await h.transaction(async tx=>{await h.writeDomain(tx);await recordEvent(tx,h.event,h.origin,h.dependencies(),options2)})}async function rollbackCase(h){await assert3.rejects(h.transaction(async tx=>{await h.writeDomain(tx);await recordEvent(tx,h.event,h.origin,h.dependencies(),options2);throw new Error("SYNTHETIC_DOMAIN_ROLLBACK")}),{message:"SYNTHETIC_DOMAIN_ROLLBACK"});assert3.deepEqual(await h.inspect(),{domainCount:0,outboxCount:0,states:[]})}async function unknownReopenCase(h){await record(h);const ids=[];const first=await relayOutbox({...h.dependencies(),publisher:{publish:async(event,context)=>{assert3.equal(event.source,h.event.source);assert3.equal(event.id,h.event.id);ids.push(context.messageId);throw new Error("SYNTHETIC_PUBACK_LOSS")}}},relayOptions);assert3.equal(first.unknown,1);assert3.deepEqual((await h.inspect()).states,["UNKNOWN"]);await h.reopen();assert3.deepEqual((await h.inspect()).states,["UNKNOWN"]);const second=await relayOutbox({...h.dependencies(),publisher:{publish:async(event,context)=>{assert3.equal(event.id,h.event.id);ids.push(context.messageId);return{stream:"probe",sequence:1,duplicate:true}}}},relayOptions);assert3.equal(second.published,1);assert3.equal(ids.length,2);assert3.equal(ids[0],ids[1]);assert3.deepEqual(await h.inspect(),{domainCount:1,outboxCount:1,states:["PUBLISHED"]})}function settleClaim(outbox,claim,outcome,signal){if(claim.event.profile==="eventsdk/1.2"){assert3.ok(outbox.settleFanoutPublish,"profile1.2 requires per-delivery fenced settlement");return outbox.settleFanoutPublish(claim.event,claim.lease,outcome,signal)}return outbox.settlePublish(claim.event,claim.lease,outcome,signal)}async function fencingCase(h){await record(h);const deps=h.dependencies();const claimInput={limit:1,now:deps.clock.now(),leaseMs:1e4,signal:AbortSignal.timeout(2e3)};const old=(await deps.outbox.claimReady(claimInput))[0];assert3.ok(old);await h.expireLease();const fresh=(await deps.outbox.claimReady({...claimInput,now:deps.clock.now()}))[0];assert3.ok(fresh);assert3.ok(fresh.lease.generation>old.lease.generation);const published={status:"PUBLISHED",ack:{stream:"probe",sequence:1,duplicate:false}};await assert3.rejects(settleClaim(deps.outbox,old,published,claimInput.signal),{code:"STALE_LEASE"});await settleClaim(deps.outbox,fresh,published,claimInput.signal);assert3.deepEqual((await h.inspect()).states,["PUBLISHED"])}async function revocationCase(h){await record(h);await h.setAuthorized(false);let calls=0;const result=await relayOutbox({...h.dependencies(),publisher:{publish:async()=>{calls++;return{stream:"probe",sequence:1,duplicate:false}}}},relayOptions);assert3.equal(result.held,1);assert3.equal(calls,0);assert3.deepEqual((await h.inspect()).states,["HOLD"])}function runProducerConformance(factory){return runCases(factory,[["E4.PRODUCER_ATOMIC_ROLLBACK",rollbackCase],["E5.PRODUCER_UNKNOWN_REOPEN_STABLE_ID",unknownReopenCase],["E5.PRODUCER_FENCING",fencingCase],["E2.PRODUCER_CURRENT_AUTHORIZATION",revocationCase]])}import assert4 from"node:assert/strict";import{recoverReceipt as recoverReceipt2}from"@eventsdk/sdk/core";var read=h=>recoverReceipt2(h.key,h.receipt.deliveryRef,h.reader(),{timeoutMs:2e3});async function waiting(h){for(const disposition of["RECEIVED","HOLD","UNKNOWN"]){await h.persist({...h.receipt,disposition});assert4.equal((await read(h)).status,"WAIT")}}async function correlation(h){for(const field of["originSource","originEventId","deliveryRef","consumerRef","targetScope"]){await h.persist({...h.receipt,[field]:h.receipt[field]+"-wrong"});await assert4.rejects(read(h),{code:"RECEIPT_MISMATCH"})}}async function durable(h){const receipt={...h.receipt,disposition:"APPLIED"};await h.persist(receipt);await h.reopen();assert4.deepEqual(await read(h),{status:"RESOLVED",receipt})}async function rejected(h){const receipt={...h.receipt,disposition:"REJECTED",reasonCode:"BUSINESS_REFUSED"};await h.persist(receipt);await h.reopen();assert4.deepEqual(await read(h),{status:"RESOLVED",receipt})}async function denial(h){await h.persist(h.receipt);await h.setAuthorized(false);await assert4.rejects(read(h),{code:"AUTHORIZATION_DENIED"})}function runReceiptConformance(factory){return runCases(factory,[["E6.RECEIPT_UNKNOWN_WAIT",waiting],["E6.RECEIPT_EXACT_CORRELATION",correlation],["E6.RECEIPT_DURABLE_REOPEN",durable],["E6.RECEIPT_REJECTED_DURABLE_REOPEN",rejected],["E2.RECEIPT_CURRENT_AUTHORIZATION",denial]])}import assert5 from"node:assert/strict";import{readAuthorizedResult}from"@eventsdk/sdk/core";var read2=h=>readAuthorizedResult(h.request,h.reader,h.authorization,h.digest,AbortSignal.timeout(2e3),h.clock);async function exact(h){assert5.deepEqual((await read2(h)).reference,h.request.reference)}async function revision(h){await h.mutateSource("REVISION");await assert5.rejects(read2(h),{code:"RESULT_MISMATCH"})}async function digest(h){await h.mutateSource("VALUE");await assert5.rejects(read2(h),{code:"RESULT_MISMATCH"})}async function missing(h){await h.mutateSource("ABSENT");await assert5.rejects(read2(h),{code:"RECOVERY_REQUIRED"})}async function sourceDenial(h){await h.setSourceAuthorized(false);await assert5.rejects(read2(h),{code:"AUTHORIZATION_DENIED"})}async function sourceScope(h){await assert5.rejects(h.reader.read(h.request.reference,{event:h.request.event,origin:h.request.origin,targetScope:h.request.targetScope+"-unauthorized",signal:AbortSignal.timeout(2e3)}),{code:"AUTHORIZATION_DENIED"})}async function receiverDenial(h){await h.setReceiverAuthorized(false);await assert5.rejects(read2(h),{code:"AUTHORIZATION_DENIED"});assert5.equal(h.sourceReads(),0)}function runResultConformance(factory){return runCases(factory,[["E7.RESULT_EXACT_REFERENCE",exact],["E7.RESULT_REVISION_MISMATCH",revision],["E7.RESULT_DIGEST_MISMATCH",digest],["E7.RESULT_MISSING",missing],["E2.RESULT_SOURCE_AUTHORIZATION",sourceDenial],["E2.RESULT_SOURCE_SCOPE",sourceScope],["E2.RESULT_RECEIVER_DENIAL_NO_READ",receiverDenial]])}import assert6 from"node:assert/strict";import{applyDelivery}from"@eventsdk/sdk/core";function observedEffect(h,claim){let calls=0;return{calls:()=>calls,domain:{apply:async tx=>{calls++;await h.writeEffect(tx,claim)}}}}async function rollback(h){const claim=await h.claim();const before=await h.inspect();await assert6.rejects(applyDelivery(claim,{...h.dependencies(),domain:{apply:async(tx,current)=>{await h.writeEffect(tx,current);throw new Error("CONFORMANCE_AFTER_EFFECT")}}},h.options));assert6.deepEqual(await h.inspect(),before)}async function terminal(h){const claim=await h.claim();const effect=observedEffect(h,claim);const deps={...h.dependencies(),domain:effect.domain};const receipt=await applyDelivery(claim,deps,h.options);assert6.equal(receipt.disposition,"APPLIED");await assert6.rejects(applyDelivery(claim,deps,h.options));assert6.equal(effect.calls(),1);await h.reopen();const actual=await h.inspect();assert6.deepEqual(actual.receipt,receipt);assert6.equal(actual.effects,1)}async function receiptFailure(h){const claim=await h.claim();const effect=observedEffect(h,claim);const before=await h.inspect();await h.failNextReceiptCommit();await assert6.rejects(applyDelivery(claim,{...h.dependencies(),domain:effect.domain},h.options));assert6.equal(effect.calls(),1);assert6.deepEqual(await h.inspect(),before)}async function staleFence(h){const claim=await h.claim();const effect=observedEffect(h,claim);const before=await h.inspect();await h.invalidateLease();await assert6.rejects(applyDelivery(claim,{...h.dependencies(),domain:effect.domain},h.options));assert6.equal(effect.calls(),0);assert6.deepEqual(await h.inspect(),before)}async function revoked(h){const claim=await h.claim();const effect=observedEffect(h,claim);await h.setAuthorized(false);const receipt=await applyDelivery(claim,{...h.dependencies(),domain:effect.domain},h.options);assert6.equal(effect.calls(),0);assert6.equal(receipt.disposition,"REJECTED");assert6.equal((await h.inspect()).effects,0);await h.reopen();assert6.deepEqual((await h.inspect()).receipt,receipt)}async function businessOutcome(h,disposition){const claim=await h.claim();const receipt=await applyDelivery(claim,{...h.dependencies(),domain:{apply:async tx=>{await h.writeEffect(tx,claim);return{disposition,reasonCode:"BUSINESS_CONDITION_UNMET"}}}},h.options);assert6.equal(receipt.disposition,disposition);assert6.equal(receipt.reasonCode,"BUSINESS_CONDITION_UNMET");assert6.equal((await h.inspect()).effects,0);await h.reopen();assert6.deepEqual((await h.inspect()).receipt,receipt)}function runApplyConformance(factory){return runCases(factory,[["E4.APPLY_EFFECT_ROLLBACK",rollback],["E4.APPLY_TERMINAL_DURABLE_ONCE",terminal],["E4.APPLY_RECEIPT_FAILURE_ROLLBACK",receiptFailure],["E5.APPLY_STALE_FENCE",staleFence],["E2.APPLY_REVOKED",revoked],["E6.BUSINESS_REJECTED_NO_EFFECT",h=>businessOutcome(h,"REJECTED")],["E6.BUSINESS_HOLD_NO_EFFECT",h=>businessOutcome(h,"HOLD")]])}import assert7 from"node:assert/strict";import{applyDelivery as applyDelivery2}from"@eventsdk/sdk/core";function gate(){let resolve=()=>{};const promise=new Promise(done=>{resolve=done});return{promise,resolve}}async function lateCommit(h){const claim=await h.claim();const before=await h.inspect();const entered=gate();const release=gate();let called=false;const applying=applyDelivery2(claim,{...h.dependencies(),domain:{apply:async tx=>{await h.writeEffect(tx,claim);called=true;entered.resolve();await release.promise}}},h.options);try{await Promise.race([entered.promise,applying]);assert7.equal(called,true);const deferring=h.work().defer(claim.key,claim.lease,claim.receipt,0,"CONFORMANCE_CONCURRENT_DEFER",AbortSignal.timeout(h.options.timeoutMs));const joined=Promise.allSettled([applying,deferring]);release.resolve();const results=await joined;assert7.equal(results.filter(result=>result.status==="fulfilled").length,1);const actual=await h.inspect();if(results[0]?.status==="fulfilled"){assert7.equal(actual.receipt.disposition,"APPLIED");assert7.equal(actual.effects,1)}else{assert7.deepEqual(actual.receipt,before.receipt);assert7.equal(actual.effects,0)}await h.reopen();assert7.deepEqual(await h.inspect(),actual)}finally{release.resolve();await applying.catch(()=>{})}}import assert8 from"node:assert/strict";import{applyDelivery as applyDelivery3,replayDeadLetter,runInboxWorker}from"@eventsdk/sdk/core";function options3(h){return{...h.options,batchSize:1,leaseMs:h.options.timeoutMs*4,retry:{maxAttempts:2,baseDelayMs:0,maxDelayMs:0,jitterRatio:0}}}function dependencies(h){let sequence=0;return{work:h.work(),receipts:h.dependencies().inbox,deadLetters:h.deadLetters(),clock:h.dependencies().clock,random:{next:()=>0},ids:{next:()=>`conformance-dlq-${++sequence}`},process:claim=>applyDelivery3(claim,{...h.dependencies(),domain:{apply:tx=>h.writeEffect(tx,claim)}},h.options)}}async function exhaust(h){const deps={...dependencies(h),process:async()=>{throw new Error("CONFORMANCE_POISON")}};assert8.equal((await runInboxWorker(deps,options3(h))).RETRY,1);assert8.equal((await runInboxWorker(deps,options3(h))).QUARANTINED,1);const before=await h.inspect();assert8.equal(before.effects,0);assert8.equal(before.quarantined,true);assert8.equal(before.deadLetters.length,1);const entry=before.deadLetters[0];assert8.ok(entry);assert8.equal(entry.originalDeliveryRef,before.receipt.deliveryRef);assert8.equal(entry.key.id,before.receipt.originEventId);assert8.equal(entry.attempts,2);await h.reopen();assert8.deepEqual(await h.inspect(),before);return entry}async function lostReply(h){const deps=dependencies(h);const result=await runInboxWorker({...deps,process:async(claim,opts)=>{await deps.process(claim,opts);throw new Error("CONFORMANCE_COMMITTED_REPLY_LOST")}},options3(h));assert8.equal(result.APPLIED,1);await h.reopen();assert8.equal((await h.inspect()).effects,1);assert8.equal((await h.inspect()).receipt.disposition,"APPLIED");assert8.equal((await runInboxWorker(dependencies(h),options3(h))).APPLIED,0);assert8.equal((await h.inspect()).effects,1)}async function replay(h){const entry=await exhaust(h);await h.setAuthorized(false);await assert8.rejects(replayDeadLetter(entry,h.deadLetters(),h.dependencies().authorization,h.options));assert8.equal((await h.inspect()).quarantined,true);await h.setAuthorized(true);const letters=h.deadLetters();const races=await Promise.allSettled([1,2].map(()=>replayDeadLetter(entry,letters,h.dependencies().authorization,h.options)));assert8.equal(races.filter(r=>r.status==="fulfilled").length,1);assert8.equal((await runInboxWorker(dependencies(h),options3(h))).APPLIED,1);const actual=await h.inspect();assert8.equal(actual.effects,1);assert8.equal(actual.receipt.originEventId,entry.key.id);assert8.equal(actual.receipt.deliveryRef,entry.originalDeliveryRef)}async function unknown(h){await h.seedUnknown();let called=0;const result=await runInboxWorker({...dependencies(h),process:async()=>{called++;throw new Error("UNKNOWN_MUST_NOT_PROCESS")}},options3(h));assert8.equal(called,0);assert8.equal(result.QUARANTINED,1);await h.reopen();const actual=await h.inspect();assert8.equal(actual.effects,0);assert8.equal(actual.receipt.disposition,"UNKNOWN");assert8.equal(actual.quarantined,true);const entry=actual.deadLetters[0];assert8.ok(entry);await assert8.rejects(replayDeadLetter(entry,h.deadLetters(),h.dependencies().authorization,h.options));assert8.deepEqual(await h.inspect(),actual)}async function exclusive(h){const request={limit:1,now:h.dependencies().clock.now(),leaseMs:h.options.timeoutMs*4,signal:new AbortController().signal};const results=await Promise.all([h.work().claimReady(request),h.work().claimReady(request)]);assert8.equal(results.flat().length,1)}async function deferFence(h){const claim=await h.claim();const before=await h.inspect();await h.work().defer(claim.key,claim.lease,claim.receipt,0,"CONFORMANCE_DEFER",new AbortController().signal);await assert8.rejects(applyDelivery3(claim,{...h.dependencies(),domain:{apply:tx=>h.writeEffect(tx,claim)}},h.options));assert8.deepEqual(await h.inspect(),before);assert8.equal((await runInboxWorker(dependencies(h),options3(h))).APPLIED,1);assert8.equal((await h.inspect()).effects,1)}function runWorkerConformance(factory){return runCases(factory,[["E5.WORKER_LOST_REPLY_READBACK",lostReply],["E5.DLQ_DURABLE_AUTHORIZED_REPLAY",replay],["E5.UNKNOWN_NEVER_REAPPLIED",unknown],["E5.WORKER_EXCLUSIVE_CLAIM",exclusive],["E5.WORKER_DEFER_FENCES_OLD_APPLY",deferFence],["E5.WORKER_LATE_COMMIT_VS_DEFER",lateCommit]])}import assert9 from"node:assert/strict";import{recoverGap as recoverGap2}from"@eventsdk/sdk/core";var recover=(h,expected=h.initialWatermark)=>recoverGap2(h.source,h.scope,expected,h.port(),h.options);async function denied(h){const before=await h.inspect();for(const side of["SOURCE","TARGET"]){await h.setAuthorized(side,false);await assert9.rejects(recover(h));assert9.deepEqual(await h.inspect(),before);await h.setAuthorized(side,true)}}async function rollback2(h){const before=await h.inspect();await h.failAfterCheckpoint();await assert9.rejects(recover(h));assert9.deepEqual(await h.inspect(),before);await h.reopen();assert9.deepEqual(await h.inspect(),before)}async function stale(h){const before=await h.inspect();await assert9.rejects(recover(h,h.initialWatermark+"-stale"));assert9.deepEqual(await h.inspect(),before)}async function durableWinner(h){const results=await Promise.allSettled([recover(h),recover(h)]);assert9.equal(results.filter(result=>result.status==="fulfilled").length,1);const expected={watermark:h.expected.watermark,snapshot:h.expected};assert9.deepEqual(await h.inspect(),expected);await h.reopen();assert9.deepEqual(await h.inspect(),expected);await assert9.rejects(recover(h));assert9.deepEqual(await h.inspect(),expected)}function runGapConformance(factory){return runCases(factory,[["E5.GAP_CURRENT_BOTH_AUTHORIZATIONS",denied],["E5.GAP_SNAPSHOT_CHECKPOINT_ROLLBACK",rollback2],["E5.GAP_STALE_WATERMARK_NO_EFFECT",stale],["E5.GAP_DURABLE_SINGLE_WINNER",durableWinner]])}import assert10 from"node:assert/strict";async function terminal2(h,disposition){const initial=h.initial;const final={...initial,revision:initial.revision+2,disposition,...disposition==="REJECTED"?{reasonCode:"BUSINESS_REFUSED"}:{}};await h.deliver(initial);await h.deliver(final);await h.deliver(final);await h.deliver({...initial,revision:initial.revision+1,disposition:"HOLD",reasonCode:"OLDER_HOLD"});assert10.deepEqual(await h.read(),final);await h.reopen();assert10.deepEqual(await h.read(),final);await assert10.rejects(h.deliver({...final,revision:final.revision+1,disposition:disposition==="APPLIED"?"REJECTED":"APPLIED"}));assert10.deepEqual(await h.read(),final)}async function conflict(h){await h.deliver(h.initial);await assert10.rejects(h.deliver({...h.initial,disposition:"HOLD",reasonCode:"CONFLICTING_REVISION"}));assert10.deepEqual(await h.read(),h.initial)}function runReceiptProjectionConformance(factory){return runCases(factory,[["E6.PROJECTION_APPLIED_TERMINAL_ORDERING",h=>terminal2(h,"APPLIED")],["E6.PROJECTION_REJECTED_TERMINAL_ORDERING",h=>terminal2(h,"REJECTED")],["E6.PROJECTION_SAME_REVISION_CONFLICT",conflict]])}import assert12 from"node:assert/strict";import{relayOutbox as relayOutbox2}from"@eventsdk/sdk/core";import assert11 from"node:assert/strict";import{acceptDelivery as acceptDelivery2,applyDelivery as applyDelivery4,prepareFanoutDelivery,recordFanoutEvent}from"@eventsdk/sdk/core";function key(h,target){return{source:h.draft.source,id:h.draft.id,consumerRef:target.consumerRef,targetScope:target.targetScope}}async function record2(h,targets=h.targets.slice(0,2),draft=h.draft){let deliveries=[];await h.transaction(async tx=>{deliveries=await recordFanoutEvent(tx,draft,targets.map(t=>t.recipient),h.producer(),h.options)});return deliveries}async function receive(h,target,event){const delivery=event??await prepareFanoutDelivery(h.draft,target.recipient.route,h.producer().digest);return acceptDelivery2({event:delivery,origin:target.recipient.origin,deliveryRef:`fanout-${delivery.deliveryid}`,consumerRef:target.consumerRef},h.admission(target),h.options)}async function apply(h,target){const claim=await h.claim(key(h,target));assert11.ok(claim);return applyDelivery4(claim,h.application(),h.options)}async function independentRoutes(h){const deliveries=await record2(h);assert12.equal(deliveries.length,2);assert12.equal(new Set(deliveries.map(event=>event.deliveryid)).size,2);assert12.ok(deliveries.every(event=>event.source===h.draft.source&&event.id===h.draft.id));assert12.notDeepEqual(key(h,h.targets[0]),key(h,h.targets[1]));const failed=deliveries[1];assert12.ok(failed);await settleIndependently(h,failed.deliveryid);for(const target of h.targets.slice(0,2)){assert12.equal((await receive(h,target)).kind,"RECEIVED");assert12.equal((await apply(h,target)).disposition,"APPLIED");assert12.equal((await receive(h,target)).kind,"DUPLICATE")}const actual=await h.inspect();assert12.equal(actual.effects.length,2);for(const target of h.targets.slice(0,2))assert12.deepEqual(actual.effects.find(item=>item.targetScope===target.targetScope&&item.consumerRef===target.consumerRef),key(h,target));assert12.equal(actual.accepted.length,2);assert12.equal(actual.inboundDeliveries,2)}async function settleIndependently(h,failedDelivery){const options4={...h.options,batchSize:2,leaseMs:h.options.timeoutMs*4,retry:{maxAttempts:3,baseDelayMs:0,maxDelayMs:0,jitterRatio:0}};const first=await relayOutbox2({...h.producer(),publisher:{publish:async event=>{if(event.profile!=="eventsdk/1.2")throw new Error("WRONG_FANOUT_PROFILE");if(event.deliveryid===failedDelivery)throw new Error("CONFORMANCE_ONE_ROUTE_ACK_LOST");return{stream:"conformance",sequence:1,duplicate:false}}}},options4);assert12.deepEqual(first,{published:1,unknown:1,held:0});const before=await h.inspect();assert12.equal(before.logicalFacts,1);assert12.equal(before.outbound.find(r=>r.event.deliveryid===failedDelivery)?.status,"UNKNOWN");assert12.equal(before.outbound.find(r=>r.event.deliveryid!==failedDelivery)?.status,"PUBLISHED");await h.reopen();assert12.deepEqual(await h.inspect(),before);const published=[];const retry=await relayOutbox2({...h.producer(),publisher:{publish:async event=>{if(event.profile!=="eventsdk/1.2")throw new Error("WRONG_FANOUT_PROFILE");published.push(event.deliveryid);return{stream:"conformance",sequence:2,duplicate:true}}}},options4);assert12.deepEqual(retry,{published:1,unknown:0,held:0});assert12.deepEqual(published,[failedDelivery])}import assert13 from"node:assert/strict";import{prepareFanoutDelivery as prepareFanoutDelivery2,recordFanoutEvent as recordFanoutEvent2}from"@eventsdk/sdk/core";async function logicalConflict(h){await record2(h);assert13.equal((await receive(h,h.targets[0])).kind,"RECEIVED");const before=await h.inspect();const changedDraft={...h.draft,data:{conformanceOriginal:h.draft.data}};await assert13.rejects(record2(h,h.targets.slice(0,2),changedDraft),{code:"EVENT_ID_CONFLICT"});const alias=h.targets[2];const changed=await prepareFanoutDelivery2(changedDraft,alias.recipient.route,h.producer().digest);assert13.deepEqual(await receive(h,alias,changed),{kind:"REJECTED",reasonCode:"EVENT_ID_CONFLICT"});assert13.deepEqual(await h.inspect(),before)}async function deliveryConflict(h){const target=h.targets[0];await record2(h,[target]);assert13.equal((await receive(h,target)).kind,"RECEIVED");const before=await h.inspect();const replacement=await h.replacementGrant(target);const original=await prepareFanoutDelivery2(h.draft,target.recipient.route,h.producer().digest);const changed=await prepareFanoutDelivery2(h.draft,replacement.recipient.route,h.producer().digest);assert13.equal(original.deliveryid,changed.deliveryid);await assert13.rejects(record2(h,[replacement]),{code:"EVENT_ID_CONFLICT"});assert13.deepEqual(await receive(h,replacement,changed),{kind:"REJECTED",reasonCode:"EVENT_ID_CONFLICT"});assert13.deepEqual(await h.inspect(),before)}async function aliasDedup(h){const first=h.targets[0];const alias=h.targets[2];assert13.deepEqual(key(h,alias),key(h,first));assert13.notEqual(first.recipient.route.connectionref,alias.recipient.route.connectionref);await record2(h,[first,alias]);assert13.equal((await receive(h,first)).kind,"RECEIVED");assert13.equal((await apply(h,first)).disposition,"APPLIED");const accepted=(await h.inspect()).accepted;assert13.equal((await receive(h,alias)).kind,"DUPLICATE");assert13.equal(await h.claim(key(h,alias)),null);const actual=await h.inspect();assert13.deepEqual(actual.accepted,accepted);assert13.deepEqual(actual.effects,[key(h,first)]);assert13.equal(actual.inboundDeliveries,2);await h.reopen();assert13.equal((await receive(h,alias)).kind,"DUPLICATE");assert13.deepEqual(await h.inspect(),actual)}async function rollback3(h){const before=await h.inspect();await assert13.rejects(h.transaction(async tx=>{await h.writeDomain(tx);await recordFanoutEvent2(tx,h.draft,h.targets.map(t=>t.recipient),h.producer(),h.options);throw new Error("CONFORMANCE_AFTER_ALL_ROUTES")}),/CONFORMANCE_AFTER_ALL_ROUTES/);assert13.deepEqual(await h.inspect(),before);await h.reopen();assert13.deepEqual(await h.inspect(),before)}async function deniedRouteRollback(h){const before=await h.inspect();await h.setAuthorized(h.targets[1],false);await assert13.rejects(h.transaction(async tx=>{await h.writeDomain(tx);await recordFanoutEvent2(tx,h.draft,h.targets.slice(0,2).map(t=>t.recipient),h.producer(),h.options)}),{code:"AUTHORIZATION_DENIED"});assert13.deepEqual(await h.inspect(),before)}async function concurrentRecord(h){await Promise.all([record2(h),record2(h)]);const actual=await h.inspect();assert13.equal(actual.logicalFacts,1);assert13.equal(actual.outbound.length,2);await h.reopen();await record2(h);assert13.deepEqual(await h.inspect(),actual)}function runFanoutConformance(factory){return runCases(factory,[["E4.FANOUT_INDEPENDENT_DELIVERY_SETTLEMENT",independentRoutes],["E1.FANOUT_LOGICAL_CONTENT_CONFLICT",logicalConflict],["E2.FANOUT_DELIVERY_GRANT_CONFLICT",deliveryConflict],["E4.FANOUT_SAME_SCOPE_ALIAS_DEDUP",aliasDedup],["E4.FANOUT_ENTIRE_TRANSACTION_ROLLBACK",rollback3],["E2.FANOUT_DENIED_ROUTE_ROLLBACK",deniedRouteRollback],["E5.FANOUT_CONCURRENT_RECORD_REOPEN",concurrentRecord]])}export{checkCompatibility,checkGapIsNotSkipped,checkRetryAndFence,checkUnknownReceipt,runAdmissionConformance,runApplyConformance,runFanoutConformance,runGapConformance,runProducerConformance,runReceiptConformance,runReceiptProjectionConformance,runResultConformance,runWorkerConformance};

package/dist/conformance/producer/harness.d.ts

@@ -0,0 +1,21 @@
+import type { CloudEvent } from '@eventsdk/sdk/contracts';
+import type { VerifiedOrigin } from '@eventsdk/sdk/identity-contracts';
+import type { RelayDependencies, RecordDependencies } from '@eventsdk/sdk/core';
+export interface ProducerObservation {
+    readonly domainCount: number;
+    readonly outboxCount: number;
+    readonly states: readonly string[];
+}
+export interface ProducerHarness<TTransaction> {
+    readonly event: CloudEvent;
+    readonly origin: VerifiedOrigin;
+    dependencies(): Omit<RelayDependencies, 'publisher'> & RecordDependencies<TTransaction>;
+    transaction(operation: (tx: TTransaction) => Promise<void>): Promise<void>;
+    writeDomain(tx: TTransaction): Promise<void>;
+    inspect(): Promise<ProducerObservation>;
+    expireLease(): Promise<void>;
+    setAuthorized(authorized: boolean): Promise<void>;
+    reopen(): Promise<void>;
+    close(): Promise<void>;
+}
+export type ProducerHarnessFactory<TTransaction> = () => Promise<ProducerHarness<TTransaction>>;

package/dist/conformance/producer/run-suite.d.ts

@@ -0,0 +1,2 @@
+import type { ProducerHarnessFactory } from './harness.js';
+export declare function runProducerConformance<T>(factory: ProducerHarnessFactory<T>): Promise<readonly import("../index.js").ConformanceCaseResult[]>;

package/dist/conformance/receipt/harness.d.ts

@@ -0,0 +1,12 @@
+import type { BusinessReceipt } from '@eventsdk/sdk/contracts';
+import type { InboxKey, ReceiptLookupPort } from '@eventsdk/sdk/core';
+export interface ReceiptHarness {
+    readonly key: InboxKey;
+    readonly receipt: BusinessReceipt;
+    reader(): ReceiptLookupPort;
+    persist(receipt: BusinessReceipt): Promise<void>;
+    setAuthorized(authorized: boolean): Promise<void>;
+    reopen(): Promise<void>;
+    close(): Promise<void>;
+}
+export type ReceiptHarnessFactory = () => Promise<ReceiptHarness>;

package/dist/conformance/receipt/projection-harness.d.ts

@@ -0,0 +1,9 @@
+import type { BusinessReceipt } from '@eventsdk/sdk/contracts';
+export interface ReceiptProjectionHarness {
+    readonly initial: BusinessReceipt;
+    deliver(receipt: BusinessReceipt): Promise<void>;
+    read(): Promise<BusinessReceipt | null>;
+    reopen(): Promise<void>;
+    close(): Promise<void>;
+}
+export type ReceiptProjectionHarnessFactory = () => Promise<ReceiptProjectionHarness>;

package/dist/conformance/receipt/run-projection-suite.d.ts

@@ -0,0 +1,2 @@
+import type { ReceiptProjectionHarnessFactory } from './projection-harness.js';
+export declare function runReceiptProjectionConformance(factory: ReceiptProjectionHarnessFactory): Promise<readonly import("../index.js").ConformanceCaseResult[]>;

package/dist/conformance/receipt/run-suite.d.ts

@@ -0,0 +1,2 @@
+import type { ReceiptHarnessFactory } from './harness.js';
+export declare function runReceiptConformance(factory: ReceiptHarnessFactory): Promise<readonly import("../index.js").ConformanceCaseResult[]>;

package/dist/conformance/reliability/checks.d.ts

@@ -0,0 +1,4 @@
+import type { BusinessReceipt } from '@eventsdk/sdk/contracts';
+export declare function checkRetryAndFence(): void;
+export declare function checkGapIsNotSkipped(): Promise<void>;
+export declare function checkUnknownReceipt(receipt: BusinessReceipt): Promise<void>;

package/dist/conformance/result/harness.d.ts

@@ -0,0 +1,15 @@
+import type { AuthorizationPort } from '@eventsdk/sdk/identity-contracts';
+import type { Clock, Digest, ResultReadPort, ResultReadRequest } from '@eventsdk/sdk/core';
+export interface ResultHarness {
+    readonly request: ResultReadRequest;
+    readonly digest: Digest;
+    readonly clock: Clock;
+    readonly authorization: AuthorizationPort;
+    readonly reader: ResultReadPort;
+    mutateSource(change: 'REVISION' | 'VALUE' | 'ABSENT'): Promise<void>;
+    setSourceAuthorized(authorized: boolean): Promise<void>;
+    setReceiverAuthorized(authorized: boolean): Promise<void>;
+    sourceReads(): number;
+    close(): Promise<void>;
+}
+export type ResultHarnessFactory = () => Promise<ResultHarness>;

package/dist/conformance/result/run-suite.d.ts

@@ -0,0 +1,2 @@
+import type { ResultHarnessFactory } from './harness.js';
+export declare function runResultConformance(factory: ResultHarnessFactory): Promise<readonly import("../index.js").ConformanceCaseResult[]>;

package/dist/conformance/version/compatibility.d.ts

@@ -0,0 +1,13 @@
+export interface VersionSet {
+    readonly sdkVersion: string;
+    readonly profile: string;
+    readonly cloudEvents: string;
+    readonly schemaMajor: number;
+}
+export type Compatibility = {
+    readonly compatible: true;
+} | {
+    readonly compatible: false;
+    readonly reason: 'UNSUPPORTED_VERSION' | 'PROFILE_MISMATCH';
+};
+export declare function checkCompatibility(producer: VersionSet, consumer: VersionSet): Compatibility;

package/dist/contracts/canonical/canonical-json.d.ts

@@ -0,0 +1 @@
+export declare function canonicalJson(value: unknown): string;