@kensio/yulin 1.21.26 → 1.21.27

package/dist/service/eventbridge/delivery/sim-event-bridge-delivery-retries.test-support.js

@@ -0,0 +1,60 @@
+import { BackgroundTasks } from "../../../util/background/background.js";
+import { SimClockControl } from "../../../util/clock/sim-clock-control.js";
+import { SimControllableClock } from "../../../util/clock/sim-controllable-clock.js";
+import { SimFixedClock } from "../../../util/clock/sim-clock.js";
+import { SimEventBridge } from "../sim-event-bridge.js";
+import { SimEventBridgeFailingTargets, } from "./sim-event-bridge-failing-targets.test-support.js";
+const startedAt = new Date("2026-10-07T09:00:00.000Z");
+/**
+ * A simulated EventBridge whose targets fail as the options say.
+ */
+export function retrySimulation(options) {
+    const clock = new SimControllableClock({
+        base: new SimFixedClock(startedAt),
+    });
+    const background = new BackgroundTasks({ clock });
+    const targets = new SimEventBridgeFailingTargets(clock, options);
+    return {
+        eventBridge: new SimEventBridge({ background, deliveryTargets: targets }),
+        clock: new SimClockControl({ clock, background }),
+        attempts: targets.attempts,
+        deadLetters: targets.deadLetters,
+    };
+}
+/**
+ * Add a rule with one target carrying the given retry policy and a
+ * dead-letter queue, and put one matching event.
+ */
+export async function putOrder(simulation, target) {
+    const { eventBridge } = simulation;
+    await eventBridge.putRule({
+        input: {
+            Name: "orders",
+            EventPattern: JSON.stringify({ source: ["orders.service"] }),
+        },
+    });
+    await eventBridge.putTargets({
+        input: {
+            Rule: "orders",
+            Targets: [
+                {
+                    Id: "fulfilment",
+                    Arn: "arn:aws:sqs:us-east-1:888888888888:fulfilment",
+                    ...target,
+                },
+            ],
+        },
+    });
+    await eventBridge.putEvents({
+        input: {
+            Entries: [
+                {
+                    Source: "orders.service",
+                    DetailType: "OrderPlaced",
+                    Detail: JSON.stringify({ orderId: "order-1" }),
+                },
+            ],
+        },
+    });
+    await simulation.clock.advanceBy({ milliseconds: 0 });
+}

package/dist/service/eventbridge/delivery/sim-event-bridge-delivery.d.ts

@@ -37,6 +37,28 @@ export interface SimEventBridgeDeliveryTargets {
      * EventBridge.
      */
     deliver(request: SimEventBridgeDeliveryRequest): Promise<void>;
+    /**
+     * Send an event EventBridge gave up delivering to its target's dead-letter
+     * queue, refusing if the queue does not admit EventBridge.
+     */
+    deadLetter(request: SimEventBridgeDeadLetterRequest): Promise<void>;
+}
+/**
+ * Which of a target's retry limits ran out, as the dead-letter message's
+ * `EXHAUSTED_RETRY_CONDITION` names it.
+ */
+export type SimEventBridgeExhaustedRetryCondition = "MaximumEventAgeInSeconds" | "MaximumRetryAttempts";
+/**
+ * One event on its way to a target's dead-letter queue, and why.
+ *
+ * A failure EventBridge does not retry, such as a target that is missing or
+ * refuses EventBridge, carries no exhausted condition.
+ */
+export interface SimEventBridgeDeadLetterRequest {
+    readonly delivery: SimEventBridgeDeliveryRequest;
+    readonly error: unknown;
+    readonly retryAttempts: number;
+    readonly exhaustedCondition: SimEventBridgeExhaustedRetryCondition | undefined;
 }
 /**
  * What a target's policy is asked about, as IAM condition values.

package/dist/service/eventbridge/delivery/sim-event-bridge-failing-targets.test-support.d.ts

@@ -0,0 +1,23 @@
+import type { SimClock } from "../../../util/clock/sim-clock.js";
+import type { SimEventBridgeDeadLetterRequest, SimEventBridgeDeliveryTargets } from "./sim-event-bridge-delivery.js";
+/**
+ * How a set of failing targets behaves.
+ */
+export interface SimEventBridgeFailingTargetsOptions {
+    readonly succeedsOnAttempt?: number;
+    readonly error?: Error;
+    readonly deadLetterRefused?: boolean;
+}
+/**
+ * Targets that fail with an error until a given attempt, and whose
+ * dead-letter queue takes or refuses what it is sent, keeping both.
+ */
+export declare class SimEventBridgeFailingTargets implements SimEventBridgeDeliveryTargets {
+    private readonly clock;
+    private readonly options;
+    readonly attempts: Date[];
+    readonly deadLetters: SimEventBridgeDeadLetterRequest[];
+    constructor(clock: SimClock, options: SimEventBridgeFailingTargetsOptions);
+    deliver(): Promise<void>;
+    deadLetter(request: SimEventBridgeDeadLetterRequest): Promise<void>;
+}

package/dist/service/eventbridge/delivery/sim-event-bridge-failing-targets.test-support.js

@@ -0,0 +1,28 @@
+/**
+ * Targets that fail with an error until a given attempt, and whose
+ * dead-letter queue takes or refuses what it is sent, keeping both.
+ */
+export class SimEventBridgeFailingTargets {
+    clock;
+    options;
+    attempts = [];
+    deadLetters = [];
+    constructor(clock, options) {
+        this.clock = clock;
+        this.options = options;
+    }
+    deliver() {
+        this.attempts.push(this.clock.now());
+        if (this.attempts.length === this.options.succeedsOnAttempt) {
+            return Promise.resolve();
+        }
+        return Promise.reject(this.options.error ?? new Error("fulfilment is unavailable"));
+    }
+    deadLetter(request) {
+        if (this.options.deadLetterRefused === true) {
+            return Promise.reject(new Error("dead-letter queue refused"));
+        }
+        this.deadLetters.push(request);
+        return Promise.resolve();
+    }
+}

package/dist/service/eventbridge/delivery/sim-event-bridge-no-delivery-targets.d.ts

@@ -1,4 +1,4 @@
-import type { SimEventBridgeDeliveryRequest, SimEventBridgeDeliveryTargets } from "./sim-event-bridge-delivery.js";
+import type { SimEventBridgeDeadLetterRequest, SimEventBridgeDeliveryRequest, SimEventBridgeDeliveryTargets } from "./sim-event-bridge-delivery.js";
 /**
  * The targets of a simulated EventBridge built on its own, which are none.
  *
@@ -13,4 +13,8 @@ export declare class SimEventBridgeNoDeliveryTargets implements SimEventBridgeDe
      * Refuse the delivery, saying why there was nowhere to make it.
      */
     deliver(request: SimEventBridgeDeliveryRequest): Promise<void>;
+    /**
+     * Refuse the dead letter, saying why there was nowhere to send it.
+     */
+    deadLetter(request: SimEventBridgeDeadLetterRequest): Promise<void>;
 }

package/dist/service/eventbridge/delivery/sim-event-bridge-no-delivery-targets.js

@@ -17,4 +17,13 @@ export class SimEventBridgeNoDeliveryTargets {
             `${request.target.arn.value} was not reached. Reach EventBridge ` +
             `through SimAws for a rule that delivers.`));
     }
+    /**
+     * Refuse the dead letter, saying why there was nowhere to send it.
+     */
+    deadLetter(request) {
+        return Promise.reject(new SimEventBridgeTargetNotFound(`This simulated EventBridge has no queues to send dead letters to, ` +
+            `so the dead-letter queue of target ${request.delivery.target.id} ` +
+            `was not reached. Reach EventBridge through SimAws for a ` +
+            `dead-letter queue that receives.`));
+    }
 }

package/dist/service/eventbridge/delivery/sim-event-bridge-queue-message.d.ts

@@ -0,0 +1,28 @@
+import type { SimAwsAccountRegionContainer } from "../../aws/sim-aws-account-region-scope.js";
+import { type SimEventBridgeDeliverySource } from "./sim-event-bridge-delivery.js";
+/**
+ * One SQS message attribute, as SendMessage takes it.
+ */
+export interface SimEventBridgeStringAttribute {
+    readonly DataType: string;
+    readonly StringValue: string;
+}
+/**
+ * One message EventBridge sends to a queue, and the queue it is for.
+ */
+export interface SimEventBridgeQueueMessage {
+    readonly queueName: string;
+    readonly queueArn: string;
+    readonly body: string;
+    readonly attributes?: Readonly<Record<string, SimEventBridgeStringAttribute>>;
+    readonly source: SimEventBridgeDeliverySource;
+}
+/**
+ * Send a message to a queue as EventBridge, if the queue admits it for the
+ * rule.
+ *
+ * A target queue and a dead-letter queue are reached the same way. Both are
+ * sent to as `events.amazonaws.com`, and both need the queue policy to admit
+ * that principal for the rule.
+ */
+export declare function sendEventBridgeQueueMessage(scope: SimAwsAccountRegionContainer, message: SimEventBridgeQueueMessage): Promise<void>;

package/dist/service/eventbridge/delivery/sim-event-bridge-queue-message.js

@@ -0,0 +1,45 @@
+import { simScopeIamAuthZ } from "../../iam/authorize/sim-iam-region-auth-z.js";
+import { SimSqsServiceSendAuthorizer } from "../../sqs/command/authorize/sim-sqs-service-send-authorizer.js";
+import { SimEventBridgeDeliveryNotPermitted, SimEventBridgeTargetNotFound, } from "../error/sim-event-bridge-delivery.error.js";
+import { simEventBridgeServicePrincipal, } from "./sim-event-bridge-delivery.js";
+/**
+ * Send a message to a queue as EventBridge, if the queue admits it for the
+ * rule.
+ *
+ * A target queue and a dead-letter queue are reached the same way. Both are
+ * sent to as `events.amazonaws.com`, and both need the queue policy to admit
+ * that principal for the rule.
+ */
+export async function sendEventBridgeQueueMessage(scope, message) {
+    const { queueArn, source } = message;
+    const queue = scope.sqs().findQueue(message.queueName);
+    if (queue === undefined) {
+        throw new SimEventBridgeTargetNotFound(`${queueArn} is not a simulated SQS queue.`);
+    }
+    const decision = new SimSqsServiceSendAuthorizer({
+        iam: simScopeIamAuthZ(scope),
+    }).authorize({
+        queue,
+        servicePrincipal: simEventBridgeServicePrincipal,
+        ...source,
+    });
+    if (decision.isDenied) {
+        throw new SimEventBridgeDeliveryNotPermitted(`The queue policy of ${queueArn} does not allow ` +
+            `${simEventBridgeServicePrincipal} to send to it for ` +
+            `${source.sourceArn}. Grant sqs:SendMessage with the queue's ` +
+            `Policy attribute.`);
+    }
+    // Sent through the ordinary SendMessage path, so a delivered event is the
+    // same thing an SDK caller would have sent, and is authorized again on the
+    // way in.
+    await scope.sqs().sendMessage({
+        input: {
+            QueueUrl: queue.arn.url,
+            MessageBody: message.body,
+            MessageAttributes: message.attributes,
+        },
+    }, {
+        caller: { kind: "service", service: simEventBridgeServicePrincipal },
+        ...source,
+    });
+}

package/dist/service/eventbridge/delivery/sim-event-bridge-target-delivery.d.ts

@@ -1,10 +1,12 @@
+import type { BackgroundScheduler } from "../../../util/background/background.js";
 import type { SimEventBridgeDeliveryRequest, SimEventBridgeDeliveryTargets } from "./sim-event-bridge-delivery.js";
 import type { SimEventBridgeDeliveryFailure } from "./sim-event-bridge-delivery-failures.js";
 interface SimEventBridgeTargetDeliveryProperties {
     readonly endpoints: SimEventBridgeDeliveryTargets;
+    readonly background: BackgroundScheduler;
 }
 /**
- * Makes one delivery and keeps whatever went wrong.
+ * Makes one delivery, with its retries, and keeps whatever went wrong.
  *
  * A failure is recorded rather than thrown, because these run as background
  * tasks and one left rejected would fail an unrelated
@@ -14,6 +16,7 @@ interface SimEventBridgeTargetDeliveryProperties {
  */
 export declare class SimEventBridgeTargetDelivery {
     private readonly endpoints;
+    private readonly background;
     private readonly failures;
     constructor(properties: SimEventBridgeTargetDeliveryProperties);
     /**

package/dist/service/eventbridge/delivery/sim-event-bridge-target-delivery.js

@@ -1,6 +1,7 @@
+import { SimEventBridgeDeliveryAttempt } from "./sim-event-bridge-delivery-attempt.js";
 import { SimEventBridgeDeliveryFailures } from "./sim-event-bridge-delivery-failures.js";
 /**
- * Makes one delivery and keeps whatever went wrong.
+ * Makes one delivery, with its retries, and keeps whatever went wrong.
  *
  * A failure is recorded rather than thrown, because these run as background
  * tasks and one left rejected would fail an unrelated
@@ -10,9 +11,11 @@ import { SimEventBridgeDeliveryFailures } from "./sim-event-bridge-delivery-fail
  */
 export class SimEventBridgeTargetDelivery {
     endpoints;
+    background;
     failures = new SimEventBridgeDeliveryFailures();
     constructor(properties) {
         this.endpoints = properties.endpoints;
+        this.background = properties.background;
     }
     /**
      * Every delivery that could not be made.
@@ -24,18 +27,20 @@ export class SimEventBridgeTargetDelivery {
      * Send one event to one target.
      */
     async deliver(request) {
-        try {
-            await this.endpoints.deliver(request);
-        }
-        catch (error) {
-            this.failures.record({
-                ruleName: request.ruleName,
-                ruleArn: request.ruleArn,
-                targetId: request.target.id,
-                targetArn: request.target.arn.value,
-                eventId: request.event.id,
-                error,
-            });
-        }
+        await new SimEventBridgeDeliveryAttempt({
+            request,
+            endpoints: this.endpoints,
+            background: this.background,
+            record: (error) => {
+                this.failures.record({
+                    ruleName: request.ruleName,
+                    ruleArn: request.ruleArn,
+                    targetId: request.target.id,
+                    targetArn: request.target.arn.value,
+                    eventId: request.event.id,
+                    error,
+                });
+            },
+        }).start();
     }
 }

package/dist/service/eventbridge/index.d.ts

@@ -12,4 +12,6 @@ export { SimEventRuleName } from "./rule/sim-event-rule-name.js";
 export { SimEventRuleState } from "./rule/sim-event-rule-state.js";
 export { SimEventPattern } from "./pattern/sim-event-pattern.js";
 export type { SimEventBusReceipt } from "./bus/sim-event-bus.js";
+export { partnerEventSourceArn, SimPartnerEventSource, type SimPartnerEventSourceState, } from "./source/sim-partner-event-source.js";
+export { isPartnerEventSourceName, SimPartnerEventSourceName, } from "./source/sim-partner-event-source-name.js";
 export { SimEventBridgeAccessDeniedException, SimEventBridgeError, SimEventBridgeInvalidEventPatternException, SimEventBridgeResourceAlreadyExistsException, SimEventBridgeResourceNotFoundException, SimEventBridgeUnsimulatedInputException, SimEventBridgeValidationException, } from "./error/sim-event-bridge.error.js";

package/dist/service/eventbridge/index.js

@@ -10,4 +10,6 @@ export { eventRuleArn } from "./rule/sim-event-rule-arn.js";
 export { SimEventRuleName } from "./rule/sim-event-rule-name.js";
 export { SimEventRuleState } from "./rule/sim-event-rule-state.js";
 export { SimEventPattern } from "./pattern/sim-event-pattern.js";
+export { partnerEventSourceArn, SimPartnerEventSource, } from "./source/sim-partner-event-source.js";
+export { isPartnerEventSourceName, SimPartnerEventSourceName, } from "./source/sim-partner-event-source-name.js";
 export { SimEventBridgeAccessDeniedException, SimEventBridgeError, SimEventBridgeInvalidEventPatternException, SimEventBridgeResourceAlreadyExistsException, SimEventBridgeResourceNotFoundException, SimEventBridgeUnsimulatedInputException, SimEventBridgeValidationException, } from "./error/sim-event-bridge.error.js";

package/dist/service/eventbridge/routing/sim-event-bridge-router.js

@@ -26,6 +26,7 @@ export class SimEventBridgeRouter {
         this.accountId = properties.accountId;
         this.delivery = new SimEventBridgeTargetDelivery({
             endpoints: properties.endpoints,
+            background: properties.background,
         });
     }
     /**

package/dist/service/eventbridge/sdk/sim-event-bridge-sdk-command-router.js

@@ -22,6 +22,10 @@ export class SimEventBridgeSdkCommandRouter {
                 "ListEventBusesCommand",
                 async (command, context) => await simEventBridge.listEventBuses(command, simSdkCallerOptions(context)),
             ],
+            [
+                "DescribeEventSourceCommand",
+                async (command, context) => await simEventBridge.describeEventSource(command, simSdkCallerOptions(context)),
+            ],
             [
                 "PutEventsCommand",
                 async (command, context) => await simEventBridge.putEvents(command, simSdkCallerOptions(context)),

package/dist/service/eventbridge/sim-event-bridge-inspection.d.ts

@@ -1,4 +1,6 @@
 import type { SimEventBusStore } from "./bus/sim-event-bus-store.js";
+import type { SimEventBridgeCommands } from "./command/sim-event-bridge-commands.js";
+import type { SimEventBridgeDeliveryFailure } from "./delivery/sim-event-bridge-delivery-failures.js";
 import type { SimEventBusReceipt } from "./bus/sim-event-bus.js";
 import type { SimEventBus } from "./bus/sim-event-bus.js";
 import type { SimEventBridgeEvent } from "./event/sim-event-bridge-event.js";
@@ -20,6 +22,14 @@ export declare abstract class SimEventBridgeInspection {
     protected abstract readonly buses: SimEventBusStore;
     protected abstract readonly rules: SimEventRuleStore;
     protected abstract readonly targets: SimEventTargetStore;
+    protected abstract readonly commands: SimEventBridgeCommands;
+    /**
+     * Every event this scope's rules could not get to a target.
+     *
+     * Real EventBridge tells the caller nothing about a failed delivery, and
+     * neither does this. A target that is unexpectedly empty is explained here.
+     */
+    get deliveryFailures(): readonly SimEventBridgeDeliveryFailure[];
     /**
      * Find an event bus by name.
      *

package/dist/service/eventbridge/sim-event-bridge-inspection.js

@@ -10,6 +10,15 @@ import { defaultEventBusName } from "./bus/sim-event-bus-name.js";
  * job that happens to live on the same object.
  */
 export class SimEventBridgeInspection {
+    /**
+     * Every event this scope's rules could not get to a target.
+     *
+     * Real EventBridge tells the caller nothing about a failed delivery, and
+     * neither does this. A target that is unexpectedly empty is explained here.
+     */
+    get deliveryFailures() {
+        return this.commands.router.deliveryFailures;
+    }
     /**
      * Find an event bus by name.
      *

package/dist/service/eventbridge/sim-event-bridge-partners.d.ts

@@ -0,0 +1,38 @@
+import type { BackgroundScheduler } from "../../util/background/background.js";
+import type { SimAwsAccountRegionScope } from "../aws/sim-aws-account-region-scope.js";
+import type { SimPutPartnerEventsCommand, SimPutPartnerEventsCommandOutput } from "./command/source/source.command.js";
+import { SimEventBridgeInspection } from "./sim-event-bridge-inspection.js";
+import { SimPartnerEventSource } from "./source/sim-partner-event-source.js";
+import type { SimPartnerEventSourceStore } from "./source/sim-partner-event-source-store.js";
+/**
+ * What a test does as a SaaS partner sending events to a simulated Account.
+ *
+ * A partner such as Stripe works from its own Account, which is outside the
+ * simulation. It creates a partner event source shared with the receiving
+ * Account, and puts events onto it. Both are simulator accessors here rather
+ * than SDK commands, because the receiving Account's own clients never send
+ * either request.
+ */
+export declare abstract class SimEventBridgePartners extends SimEventBridgeInspection {
+    protected abstract readonly partnerSources: SimPartnerEventSourceStore;
+    protected abstract readonly background: BackgroundScheduler;
+    protected abstract readonly accountRegionScope: SimAwsAccountRegionScope;
+    /**
+     * Share a partner event source with this Account and Region, as the
+     * partner's CreatePartnerEventSource does.
+     *
+     * The source starts pending. Creating a bus with the same `Name` and
+     * `EventSourceName` activates it, and that bus then receives what
+     * `putPartnerEvents` sends.
+     */
+    addPartnerEventSource(name: string): SimPartnerEventSource;
+    /**
+     * Put events onto partner event buses as their partner would, taking the
+     * shape of the partner's PutPartnerEvents request.
+     *
+     * Each entry's `Source` has to name a source `addPartnerEventSource` shared
+     * with this scope. The event goes to the bus of the same name, or nowhere if
+     * that bus has not been created yet.
+     */
+    putPartnerEvents(command: SimPutPartnerEventsCommand): Promise<SimPutPartnerEventsCommandOutput>;
+}

package/dist/service/eventbridge/sim-event-bridge-partners.js

@@ -0,0 +1,43 @@
+import { SimEventBridgeInspection } from "./sim-event-bridge-inspection.js";
+import { SimPartnerEventSource } from "./source/sim-partner-event-source.js";
+import { SimPartnerEventSourceName } from "./source/sim-partner-event-source-name.js";
+/**
+ * What a test does as a SaaS partner sending events to a simulated Account.
+ *
+ * A partner such as Stripe works from its own Account, which is outside the
+ * simulation. It creates a partner event source shared with the receiving
+ * Account, and puts events onto it. Both are simulator accessors here rather
+ * than SDK commands, because the receiving Account's own clients never send
+ * either request.
+ */
+export class SimEventBridgePartners extends SimEventBridgeInspection {
+    /**
+     * Share a partner event source with this Account and Region, as the
+     * partner's CreatePartnerEventSource does.
+     *
+     * The source starts pending. Creating a bus with the same `Name` and
+     * `EventSourceName` activates it, and that bus then receives what
+     * `putPartnerEvents` sends.
+     */
+    addPartnerEventSource(name) {
+        const source = new SimPartnerEventSource({
+            name: SimPartnerEventSourceName.of(name, "Name"),
+            accountRegionScope: this.accountRegionScope,
+            createdAt: this.background.now(),
+        });
+        this.partnerSources.add(source);
+        return source;
+    }
+    /**
+     * Put events onto partner event buses as their partner would, taking the
+     * shape of the partner's PutPartnerEvents request.
+     *
+     * Each entry's `Source` has to name a source `addPartnerEventSource` shared
+     * with this scope. The event goes to the bus of the same name, or nowhere if
+     * that bus has not been created yet.
+     */
+    async putPartnerEvents(command) {
+        await this.background.sequence();
+        return this.commands.putPartnerEvents.handle(command);
+    }
+}

package/dist/service/eventbridge/sim-event-bridge.d.ts

@@ -4,13 +4,14 @@ import type { SimAwsAccountRegionScope } from "../aws/sim-aws-account-region-sco
 import type { SimIamInterServiceAuthZ } from "../iam/authorize/sim-iam-inter-service-auth-z.js";
 import { SimEventBusStore } from "./bus/sim-event-bus-store.js";
 import type * as simEventBridgeCommands from "./command/sim-event-bridge-command.types.js";
+import { SimEventBridgeCommands } from "./command/sim-event-bridge-commands.js";
 import type { SimEventBridgeRequestOptions } from "./command/sim-event-bridge-request-options.js";
 import { SimEventRuleStore } from "./rule/sim-event-rule-store.js";
 import { SimEventTargetStore } from "./target/sim-event-target-store.js";
 import type { SimEventBridgeDeliveryTargets } from "./delivery/sim-event-bridge-delivery.js";
-import type { SimEventBridgeDeliveryFailure } from "./delivery/sim-event-bridge-delivery-failures.js";
 import { SimEventBridgeCfnResourceFactory } from "./cfn/sim-event-bridge-cfn-resource-factory.js";
-import { SimEventBridgeInspection } from "./sim-event-bridge-inspection.js";
+import { SimEventBridgePartners } from "./sim-event-bridge-partners.js";
+import { SimPartnerEventSourceStore } from "./source/sim-partner-event-source-store.js";
 interface SimEventBridgeProperties {
     readonly accountRegionScope?: SimAwsAccountRegionScope;
     readonly iam?: SimIamInterServiceAuthZ;
@@ -36,22 +37,17 @@ interface SimEventBridgeProperties {
  * matches nothing is gone. A rule carrying a schedule instead fires on the
  * simulation's own clock, so advancing time is what sends its event.
  */
-export declare class SimEventBridge extends SimEventBridgeInspection {
+export declare class SimEventBridge extends SimEventBridgePartners {
     protected readonly buses: SimEventBusStore;
     protected readonly rules: SimEventRuleStore;
     protected readonly targets: SimEventTargetStore;
-    private readonly commands;
-    private readonly background;
+    protected readonly partnerSources: SimPartnerEventSourceStore;
+    protected readonly commands: SimEventBridgeCommands;
+    protected readonly background: BackgroundScheduler;
+    protected readonly accountRegionScope: SimAwsAccountRegionScope;
     private readonly sdkRouter;
     private readonly cfnFactory;
     constructor(properties?: SimEventBridgeProperties);
-    /**
-     * Every event this scope's rules could not get to a target.
-     *
-     * Real EventBridge tells the caller nothing about a failed delivery, and
-     * neither does this. A target that is unexpectedly empty is explained here.
-     */
-    get deliveryFailures(): readonly SimEventBridgeDeliveryFailure[];
     /**
      * Handle a CreateEventBus Command from the SDK.
      */
@@ -68,6 +64,10 @@ export declare class SimEventBridge extends SimEventBridgeInspection {
      * Handle a ListEventBuses Command from the SDK.
      */
     listEventBuses(command: simEventBridgeCommands.SimListEventBusesCommand, options?: SimEventBridgeRequestOptions): Promise<simEventBridgeCommands.SimListEventBusesCommandOutput>;
+    /**
+     * Handle a DescribeEventSource Command from the SDK.
+     */
+    describeEventSource(command: simEventBridgeCommands.SimDescribeEventSourceCommand, options?: SimEventBridgeRequestOptions): Promise<simEventBridgeCommands.SimDescribeEventSourceCommandOutput>;
     /**
      * Handle a PutEvents Command from the SDK.
      */

package/dist/service/eventbridge/sim-event-bridge.js

@@ -8,7 +8,8 @@ import { SimEventRuleStore } from "./rule/sim-event-rule-store.js";
 import { SimEventTargetStore } from "./target/sim-event-target-store.js";
 import { SimEventBridgeCfnResourceFactory } from "./cfn/sim-event-bridge-cfn-resource-factory.js";
 import { SimEventBridgeSdkCommandRouter } from "./sdk/sim-event-bridge-sdk-command-router.js";
-import { SimEventBridgeInspection } from "./sim-event-bridge-inspection.js";
+import { SimEventBridgePartners } from "./sim-event-bridge-partners.js";
+import { SimPartnerEventSourceStore } from "./source/sim-partner-event-source-store.js";
 /**
  * Simulated EventBridge. Handles SDK commands. Emulates AWS behaviour and
  * state.
@@ -22,12 +23,14 @@ import { SimEventBridgeInspection } from "./sim-event-bridge-inspection.js";
  * matches nothing is gone. A rule carrying a schedule instead fires on the
  * simulation's own clock, so advancing time is what sends its event.
  */
-export class SimEventBridge extends SimEventBridgeInspection {
+export class SimEventBridge extends SimEventBridgePartners {
     buses;
     rules = new SimEventRuleStore();
     targets = new SimEventTargetStore();
+    partnerSources = new SimPartnerEventSourceStore();
     commands;
     background;
+    accountRegionScope;
     sdkRouter = new SimEventBridgeSdkCommandRouter(this);
     cfnFactory = new SimEventBridgeCfnResourceFactory({
         eventBridge: this,
@@ -37,26 +40,19 @@ export class SimEventBridge extends SimEventBridgeInspection {
         const { accountRegionScope = simAwsAccountRegionScopeFactory.make(), background = new BackgroundTasks(), } = properties;
         const iam = simIamInRegion(properties.iam, accountRegionScope.regionName);
         this.background = background;
+        this.accountRegionScope = accountRegionScope;
         this.buses = new SimEventBusStore(SimEventBus.default({ accountRegionScope, createdAt: background.now() }));
         this.commands = new SimEventBridgeCommands({
             buses: this.buses,
             rules: this.rules,
             targets: this.targets,
+            partnerSources: this.partnerSources,
             deliveryTargets: properties.deliveryTargets,
             iam,
             background,
             accountRegionScope,
         });
     }
-    /**
-     * Every event this scope's rules could not get to a target.
-     *
-     * Real EventBridge tells the caller nothing about a failed delivery, and
-     * neither does this. A target that is unexpectedly empty is explained here.
-     */
-    get deliveryFailures() {
-        return this.commands.router.deliveryFailures;
-    }
     /**
      * Handle a CreateEventBus Command from the SDK.
      */
@@ -85,6 +81,13 @@ export class SimEventBridge extends SimEventBridgeInspection {
         await this.background.sequence();
         return this.commands.buses.listEventBuses(command, options);
     }
+    /**
+     * Handle a DescribeEventSource Command from the SDK.
+     */
+    async describeEventSource(command, options) {
+        await this.background.sequence();
+        return this.commands.eventSources.handle(command, options);
+    }
     /**
      * Handle a PutEvents Command from the SDK.
      */

package/dist/service/eventbridge/source/sim-partner-event-source-name.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Whether a string has the shape of a partner event source name.
+ *
+ * A partner event bus takes the name of its source, so this is also the one
+ * shape of bus name that may carry a `/`.
+ */
+export declare function isPartnerEventSourceName(value: string): boolean;
+/**
+ * The name of one partner event source.
+ *
+ * A SaaS partner names the source when it creates it, in the form
+ * `aws.partner/<partner>/<name>`. The receiving Account never chooses the
+ * name. It creates a bus under the same one.
+ */
+export declare class SimPartnerEventSourceName {
+    readonly value: string;
+    private constructor();
+    /**
+     * Read a partner event source name from request input, refusing one real
+     * EventBridge would refuse.
+     */
+    static of(value: string, parameterName: string): SimPartnerEventSourceName;
+    /**
+     * The partner that created the source, which is the segment after
+     * `aws.partner`.
+     */
+    get partner(): string;
+}