@kensio/yulin 1.21.0 → 1.21.1

package/dist/service/s3/sim-s3-version-operations.d.ts

@@ -0,0 +1,32 @@
+import type * as simS3Commands from "./command/sim-s3-command.types.js";
+import type { SimS3RequestOptions } from "./command/sim-s3-request-options.js";
+import type { SimS3Commands } from "./sim-s3-commands.js";
+/**
+ * The AWS operations that make a Bucket keep what it held.
+ *
+ * Versioning is what a Bucket keeps its history in, and Object Lock is what
+ * stops anything taking that history away. Object Lock refuses a Bucket
+ * without versioning underneath it, so the two are one subject and sit
+ * together.
+ *
+ * `SimS3Operations` extends this, and `SimS3` extends that, so a caller
+ * reaches all of them on the one service object.
+ */
+export declare abstract class SimS3VersionOperations {
+    protected readonly commands: SimS3Commands;
+    protected constructor(commands: SimS3Commands);
+    /** Handle a Put Bucket Versioning Command from the SDK. */
+    putBucketVersioning(command: simS3Commands.SimPutBucketVersioningCommand, options?: SimS3RequestOptions): Promise<simS3Commands.SimPutBucketVersioningCommandOutput>;
+    /** Handle a Get Bucket Versioning Command from the SDK. */
+    getBucketVersioning(command: simS3Commands.SimGetBucketVersioningCommand, options?: SimS3RequestOptions): Promise<simS3Commands.SimGetBucketVersioningCommandOutput>;
+    /** Handle a List Object Versions Command from the SDK. */
+    listObjectVersions(command: simS3Commands.SimListObjectVersionsCommand, options?: SimS3RequestOptions): Promise<simS3Commands.SimListObjectVersionsCommandOutput>;
+    /** Handle a Put Object Lock Configuration Command from the SDK. */
+    putObjectLockConfiguration(command: simS3Commands.SimPutObjectLockConfigurationCommand, options?: SimS3RequestOptions): Promise<simS3Commands.SimPutObjectLockConfigurationCommandOutput>;
+    /** Handle a Get Object Lock Configuration Command from the SDK. */
+    getObjectLockConfiguration(command: simS3Commands.SimGetObjectLockConfigurationCommand, options?: SimS3RequestOptions): Promise<simS3Commands.SimGetObjectLockConfigurationCommandOutput>;
+    /** Handle a Put Object Retention Command from the SDK. */
+    putObjectRetention(command: simS3Commands.SimPutObjectRetentionCommand, options?: SimS3RequestOptions): Promise<simS3Commands.SimPutObjectRetentionCommandOutput>;
+    /** Handle a Put Object Legal Hold Command from the SDK. */
+    putObjectLegalHold(command: simS3Commands.SimPutObjectLegalHoldCommand, options?: SimS3RequestOptions): Promise<simS3Commands.SimPutObjectLegalHoldCommandOutput>;
+}

package/dist/service/s3/sim-s3-version-operations.js

@@ -0,0 +1,45 @@
+/**
+ * The AWS operations that make a Bucket keep what it held.
+ *
+ * Versioning is what a Bucket keeps its history in, and Object Lock is what
+ * stops anything taking that history away. Object Lock refuses a Bucket
+ * without versioning underneath it, so the two are one subject and sit
+ * together.
+ *
+ * `SimS3Operations` extends this, and `SimS3` extends that, so a caller
+ * reaches all of them on the one service object.
+ */
+export class SimS3VersionOperations {
+    commands;
+    constructor(commands) {
+        this.commands = commands;
+    }
+    /** Handle a Put Bucket Versioning Command from the SDK. */
+    async putBucketVersioning(command, options) {
+        return await this.commands.versioning.put(command, options);
+    }
+    /** Handle a Get Bucket Versioning Command from the SDK. */
+    async getBucketVersioning(command, options) {
+        return await this.commands.versioning.get(command, options);
+    }
+    /** Handle a List Object Versions Command from the SDK. */
+    async listObjectVersions(command, options) {
+        return await this.commands.versioning.list(command, options);
+    }
+    /** Handle a Put Object Lock Configuration Command from the SDK. */
+    async putObjectLockConfiguration(command, options) {
+        return await this.commands.objectLock.putConfiguration(command, options);
+    }
+    /** Handle a Get Object Lock Configuration Command from the SDK. */
+    async getObjectLockConfiguration(command, options) {
+        return await this.commands.objectLock.getConfiguration(command, options);
+    }
+    /** Handle a Put Object Retention Command from the SDK. */
+    async putObjectRetention(command, options) {
+        return await this.commands.objectLock.putRetention(command, options);
+    }
+    /** Handle a Put Object Legal Hold Command from the SDK. */
+    async putObjectLegalHold(command, options) {
+        return await this.commands.objectLock.putLegalHold(command, options);
+    }
+}

package/dist/service/scheduler/command/schedule/schedule.command.d.ts

@@ -11,14 +11,21 @@ export interface SimSchedulerRequestTarget {
     readonly Arn?: string | undefined;
     readonly RoleArn?: string | undefined;
     readonly Input?: string | undefined;
-    readonly DeadLetterConfig?: unknown;
-    readonly RetryPolicy?: unknown;
+    readonly DeadLetterConfig?: SimSchedulerDeadLetterConfig | undefined;
+    readonly RetryPolicy?: SimSchedulerRetryPolicy | undefined;
     readonly EcsParameters?: SimEcsTargetParametersType | undefined;
     readonly EventBridgeParameters?: unknown;
     readonly KinesisParameters?: unknown;
     readonly SageMakerPipelineParameters?: unknown;
     readonly SqsParameters?: unknown;
 }
+export interface SimSchedulerDeadLetterConfig {
+    readonly Arn?: string | undefined;
+}
+export interface SimSchedulerRetryPolicy {
+    readonly MaximumEventAgeInSeconds?: number | undefined;
+    readonly MaximumRetryAttempts?: number | undefined;
+}
 /**
  * The time window a schedule invokes its target in.
  */

package/dist/service/scheduler/command/schedule/sim-scheduler-described-schedule.js

@@ -21,6 +21,8 @@ export function describedSchedule(schedule) {
             RoleArn: schedule.target.roleArn,
             Input: schedule.target.input,
             EcsParameters: schedule.target.task?.parameters.declared,
+            DeadLetterConfig: schedule.target.deadLetterConfig?.declared,
+            RetryPolicy: schedule.target.retryPolicy?.declared,
         },
         CreationDate: schedule.creationDate,
         LastModificationDate: schedule.lastModificationDate,

package/dist/service/scheduler/command/schedule/sim-scheduler-unsimulated-target.js

@@ -9,12 +9,6 @@ import { SimSchedulerUnsimulatedInputException } from "../../error/sim-scheduler
  */
 function unsimulatedTargetProperties(target) {
     return [
-        [
-            "DeadLetterConfig",
-            target.DeadLetterConfig,
-            "a failed invocation is recorded rather than sent on",
-        ],
-        ["RetryPolicy", target.RetryPolicy, "an invocation is attempted once"],
         [
             "EventBridgeParameters",
             target.EventBridgeParameters,

package/dist/service/scheduler/command/sim-scheduler-command.types.d.ts

@@ -1,2 +1,2 @@
-export type { SimCreateScheduleCommand, SimCreateScheduleCommandOutput, SimDeleteScheduleCommand, SimDeleteScheduleCommandInput, SimDeleteScheduleCommandOutput, SimGetScheduleCommand, SimGetScheduleCommandInput, SimGetScheduleCommandOutput, SimListSchedulesCommand, SimListSchedulesCommandInput, SimListSchedulesCommandOutput, SimSchedulerFlexibleTimeWindow, SimSchedulerListedSchedule, SimSchedulerRequestTarget, SimSchedulerScheduleInput, SimUpdateScheduleCommand, SimUpdateScheduleCommandOutput, } from "./schedule/schedule.command.js";
+export type { SimCreateScheduleCommand, SimCreateScheduleCommandOutput, SimDeleteScheduleCommand, SimDeleteScheduleCommandInput, SimDeleteScheduleCommandOutput, SimGetScheduleCommand, SimGetScheduleCommandInput, SimGetScheduleCommandOutput, SimListSchedulesCommand, SimListSchedulesCommandInput, SimListSchedulesCommandOutput, SimSchedulerFlexibleTimeWindow, SimSchedulerDeadLetterConfig, SimSchedulerListedSchedule, SimSchedulerRequestTarget, SimSchedulerRetryPolicy, SimSchedulerScheduleInput, SimUpdateScheduleCommand, SimUpdateScheduleCommandOutput, } from "./schedule/schedule.command.js";
 export type { SimCreateScheduleGroupCommand, SimCreateScheduleGroupCommandInput, SimCreateScheduleGroupCommandOutput, SimDeleteScheduleGroupCommand, SimDeleteScheduleGroupCommandInput, SimDeleteScheduleGroupCommandOutput, SimGetScheduleGroupCommand, SimGetScheduleGroupCommandInput, SimGetScheduleGroupCommandOutput, SimListScheduleGroupsCommand, SimListScheduleGroupsCommandInput, SimListScheduleGroupsCommandOutput, SimSchedulerListedScheduleGroup, SimSchedulerTag, } from "./group/group.command.js";

package/dist/service/scheduler/command/sim-scheduler-commands.js

@@ -37,6 +37,7 @@ export class SimSchedulerCommands {
         });
         this.delivery = new SimSchedulerTargetDelivery({
             endpoints: properties.deliveryTargets ?? new SimSchedulerNoDeliveryTargets(),
+            background,
         });
         this.firing = new SimSchedulerSchedules({
             schedules,

package/dist/service/scheduler/delivery/sim-aws-scheduler-dead-letters.d.ts

@@ -0,0 +1,17 @@
+import type { SimAws } from "../../aws/sim-aws.js";
+import type { SimSchedulerDeadLetterRequest } from "./sim-scheduler-delivery.js";
+interface SimAwsSchedulerDeadLettersProperties {
+    readonly simAws: SimAws;
+}
+/**
+ * Routes Scheduler dead letters to the Account and Region named by their queue ARNs.
+ */
+export declare class SimAwsSchedulerDeadLetters {
+    private readonly simAws;
+    constructor(properties: SimAwsSchedulerDeadLettersProperties);
+    /**
+     * Assume the execution role and send an abandoned input to its queue.
+     */
+    deliver(deadLetter: SimSchedulerDeadLetterRequest): Promise<void>;
+}
+export {};

package/dist/service/scheduler/delivery/sim-aws-scheduler-dead-letters.js

@@ -0,0 +1,29 @@
+import { assertDefined } from "../../../util/type-guard/defined.js";
+import { parseSqsQueueArn } from "../../sqs/queue/sim-sqs-queue-arn.js";
+import { SimSchedulerDeadLetterQueue } from "./sim-scheduler-dead-letter-queue.js";
+import { assumeSchedulerExecutionRole, schedulerExecutionRoleTarget, } from "./sim-scheduler-execution-role.js";
+/**
+ * Routes Scheduler dead letters to the Account and Region named by their queue ARNs.
+ */
+export class SimAwsSchedulerDeadLetters {
+    simAws;
+    constructor(properties) {
+        this.simAws = properties.simAws;
+    }
+    /**
+     * Assume the execution role and send an abandoned input to its queue.
+     */
+    async deliver(deadLetter) {
+        const { schedule } = deadLetter.delivery;
+        const queueArn = schedule.target.deadLetterConfig?.arn;
+        assertDefined(queueArn, "A dead-letter delivery requires a queue ARN");
+        const queue = parseSqsQueueArn(queueArn);
+        assertDefined(queue, `${queueArn} is not a standard SQS queue ARN`);
+        const role = schedulerExecutionRoleTarget(schedule.target.roleArn);
+        const regionName = queue.regionName;
+        const roleScope = this.simAws.accountRegionScope(role.accountId, regionName);
+        const caller = await assumeSchedulerExecutionRole(role, roleScope, schedule);
+        const scope = this.simAws.accountRegionScope(queue.accountId, regionName);
+        await new SimSchedulerDeadLetterQueue({ scope }).deliver({ request: deadLetter.delivery, caller }, deadLetter, queueArn, queue.name);
+    }
+}

package/dist/service/scheduler/delivery/sim-aws-scheduler-delivery-targets.d.ts

@@ -1,5 +1,5 @@
 import type { SimAws } from "../../aws/sim-aws.js";
-import type { SimSchedulerDeliveryRequest, SimSchedulerDeliveryTargets } from "./sim-scheduler-delivery.js";
+import type { SimSchedulerDeadLetterRequest, SimSchedulerDeliveryRequest, SimSchedulerDeliveryTargets } from "./sim-scheduler-delivery.js";
 interface SimAwsSchedulerDeliveryTargetsProperties {
     readonly simAws: SimAws;
 }
@@ -16,6 +16,7 @@ interface SimAwsSchedulerDeliveryTargetsProperties {
  */
 export declare class SimAwsSchedulerDeliveryTargets implements SimSchedulerDeliveryTargets {
     private readonly simAws;
+    private readonly deadLetters;
     constructor(properties: SimAwsSchedulerDeliveryTargetsProperties);
     /**
      * Assume the schedule's execution role, then invoke its target as that role.
@@ -24,6 +25,10 @@ export declare class SimAwsSchedulerDeliveryTargets implements SimSchedulerDeliv
      * target's, which are not necessarily the same one.
      */
     deliver(request: SimSchedulerDeliveryRequest): Promise<void>;
+    /**
+     * Send an exhausted or permanent failure to the configured queue.
+     */
+    deadLetter(deadLetter: SimSchedulerDeadLetterRequest): Promise<void>;
     /**
      * Hand the invocation to the one destination that knows this service.
      */

package/dist/service/scheduler/delivery/sim-aws-scheduler-delivery-targets.js

@@ -1,4 +1,5 @@
 import { SimSchedulerDeliveryFunction } from "./sim-scheduler-delivery-function.js";
+import { SimAwsSchedulerDeadLetters } from "./sim-aws-scheduler-dead-letters.js";
 import { SimSchedulerDeliveryQueue } from "./sim-scheduler-delivery-queue.js";
 import { SimSchedulerDeliveryTask } from "./sim-scheduler-delivery-task.js";
 import { SimSchedulerDeliveryTopic } from "./sim-scheduler-delivery-topic.js";
@@ -16,8 +17,10 @@ import { assumeSchedulerExecutionRole, schedulerExecutionRoleTarget, } from "./s
  */
 export class SimAwsSchedulerDeliveryTargets {
     simAws;
+    deadLetters;
     constructor(properties) {
         this.simAws = properties.simAws;
+        this.deadLetters = new SimAwsSchedulerDeadLetters(properties);
     }
     /**
      * Assume the schedule's execution role, then invoke its target as that role.
@@ -32,6 +35,12 @@ export class SimAwsSchedulerDeliveryTargets {
         const caller = await assumeSchedulerExecutionRole(role, roleScope, request.schedule);
         await this.invoke(arn.service, { request, caller });
     }
+    /**
+     * Send an exhausted or permanent failure to the configured queue.
+     */
+    async deadLetter(deadLetter) {
+        await this.deadLetters.deliver(deadLetter);
+    }
     /**
      * Hand the invocation to the one destination that knows this service.
      */

package/dist/service/scheduler/delivery/sim-scheduler-dead-letter-queue.d.ts

@@ -0,0 +1,18 @@
+import type { SimAwsAccountRegionContainer } from "../../aws/sim-aws-account-region-scope.js";
+import type { SimSchedulerAssumedDelivery, SimSchedulerDeadLetterRequest } from "./sim-scheduler-delivery.js";
+interface SimSchedulerDeadLetterQueueProperties {
+    readonly scope: SimAwsAccountRegionContainer;
+}
+/**
+ * Sends an undelivered schedule input to a standard SQS queue.
+ */
+export declare class SimSchedulerDeadLetterQueue {
+    private readonly scope;
+    constructor(properties: SimSchedulerDeadLetterQueueProperties);
+    /**
+     * Send the original input with Scheduler's diagnostic message attributes.
+     */
+    deliver(assumed: SimSchedulerAssumedDelivery, deadLetter: SimSchedulerDeadLetterRequest, queueArn: string, queueName: string): Promise<void>;
+    private attributes;
+}
+export {};

package/dist/service/scheduler/delivery/sim-scheduler-dead-letter-queue.js

@@ -0,0 +1,62 @@
+import { randomUUID } from "node:crypto";
+import { simScopeIamAuthZ } from "../../iam/authorize/sim-iam-region-auth-z.js";
+import { SimSchedulerDeliveryNotPermitted, SimSchedulerTargetNotFound, } from "../error/sim-scheduler-delivery.error.js";
+import { simSchedulerDeliveryJson } from "./sim-scheduler-delivery.js";
+const sendAction = "sqs:SendMessage";
+/**
+ * Sends an undelivered schedule input to a standard SQS queue.
+ */
+export class SimSchedulerDeadLetterQueue {
+    scope;
+    constructor(properties) {
+        this.scope = properties.scope;
+    }
+    /**
+     * Send the original input with Scheduler's diagnostic message attributes.
+     */
+    async deliver(assumed, deadLetter, queueArn, queueName) {
+        const queue = this.scope.sqs().findQueue(queueName);
+        if (queue === undefined) {
+            throw new SimSchedulerTargetNotFound(`${queueArn} is not a simulated SQS queue.`);
+        }
+        const decision = simScopeIamAuthZ(this.scope).authorize({
+            action: sendAction,
+            resource: queueArn,
+            caller: assumed.caller,
+        });
+        if (decision.isDenied) {
+            throw new SimSchedulerDeliveryNotPermitted(`${deadLetter.delivery.schedule.target.roleArn} is not allowed to ` +
+                `${sendAction} on ${queueArn}. ` +
+                `Grant it in a policy on the execution role.`);
+        }
+        await this.scope.sqs().sendMessage({
+            input: {
+                QueueUrl: queue.arn.url,
+                MessageBody: simSchedulerDeliveryJson(deadLetter.delivery),
+                MessageAttributes: this.attributes(deadLetter),
+            },
+        }, { caller: assumed.caller });
+    }
+    attributes(deadLetter) {
+        const { delivery, error, retryAttempts, exhaustedCondition } = deadLetter;
+        const errorCode = error instanceof Error ? error.name : "Error";
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        const attributes = {
+            ERROR_CODE: errorCode,
+            ERROR_MESSAGE: errorMessage,
+            EXECUTION_ID: randomUUID(),
+            IS_PAYLOAD_TRUNCATED: "false",
+            RETRY_ATTEMPTS: String(retryAttempts),
+            SCHEDULED_TIME: delivery.at.toISOString(),
+            SCHEDULE_ARN: delivery.schedule.arn,
+            TARGET_ARN: delivery.schedule.target.arn.value,
+            ...(exhaustedCondition !== undefined && {
+                EXHAUSTED_RETRY_CONDITION: exhaustedCondition,
+            }),
+        };
+        return Object.fromEntries(Object.entries(attributes).map(([name, value]) => [
+            name,
+            { DataType: "String", StringValue: value },
+        ]));
+    }
+}

package/dist/service/scheduler/delivery/sim-scheduler-delivery-attempt.d.ts

@@ -0,0 +1,29 @@
+import type { BackgroundScheduler } from "../../../util/background/background.js";
+import type { SimSchedulerDeliveryRequest, SimSchedulerDeliveryTargets } from "./sim-scheduler-delivery.js";
+interface SimSchedulerDeliveryAttemptProperties {
+    readonly request: SimSchedulerDeliveryRequest;
+    readonly endpoints: SimSchedulerDeliveryTargets;
+    readonly background: BackgroundScheduler;
+    readonly record: (error: unknown) => void;
+}
+/**
+ * One scheduled invocation across its initial attempt and any retries.
+ */
+export declare class SimSchedulerDeliveryAttempt {
+    private readonly properties;
+    private retryAttempts;
+    constructor(properties: SimSchedulerDeliveryAttemptProperties);
+    /**
+     * Make the initial attempt.
+     */
+    start(): Promise<void>;
+    private attempt;
+    private failed;
+    /**
+     * The first retry waits one second, and every following wait doubles.
+     */
+    private retryDueTime;
+    private isPermanent;
+    private abandon;
+}
+export {};

package/dist/service/scheduler/delivery/sim-scheduler-delivery-attempt.js

@@ -0,0 +1,81 @@
+import { SimSchedulerDeliveryNotPermitted, SimSchedulerTargetNotFound, } from "../error/sim-scheduler-delivery.error.js";
+const millisecondsPerSecond = 1000;
+/**
+ * One scheduled invocation across its initial attempt and any retries.
+ */
+export class SimSchedulerDeliveryAttempt {
+    properties;
+    retryAttempts = 0;
+    constructor(properties) {
+        this.properties = properties;
+    }
+    /**
+     * Make the initial attempt.
+     */
+    async start() {
+        await this.attempt();
+    }
+    async attempt() {
+        try {
+            await this.properties.endpoints.deliver(this.properties.request);
+        }
+        catch (error) {
+            await this.failed(error);
+        }
+    }
+    async failed(error) {
+        if (this.isPermanent(error)) {
+            await this.abandon(error);
+            return;
+        }
+        const policy = this.properties.request.schedule.target.retryPolicy;
+        const maximumRetries = policy?.maximumRetryAttempts ?? 0;
+        if (this.retryAttempts >= maximumRetries) {
+            await this.abandon(error, "MaximumRetryAttempts");
+            return;
+        }
+        const retryDue = this.retryDueTime();
+        const expiresAt = this.properties.request.at.getTime() +
+            (policy?.maximumEventAgeInSeconds ?? 0) * millisecondsPerSecond;
+        if (policy !== undefined && retryDue.getTime() > expiresAt) {
+            this.properties.background.scheduleAt(new Date(expiresAt), async () => {
+                await this.abandon(error, "MaximumEventAgeInSeconds");
+            });
+            return;
+        }
+        this.properties.background.scheduleAt(retryDue, async () => {
+            this.retryAttempts += 1;
+            await this.attempt();
+        });
+    }
+    /**
+     * The first retry waits one second, and every following wait doubles.
+     */
+    retryDueTime() {
+        const delaySeconds = 2 ** this.retryAttempts;
+        return new Date(this.properties.background.now().getTime() +
+            delaySeconds * millisecondsPerSecond);
+    }
+    isPermanent(error) {
+        return (error instanceof SimSchedulerDeliveryNotPermitted ||
+            error instanceof SimSchedulerTargetNotFound);
+    }
+    async abandon(error, exhaustedCondition) {
+        const { request, endpoints, record } = this.properties;
+        if (request.schedule.target.deadLetterConfig?.arn === undefined) {
+            record(error);
+            return;
+        }
+        try {
+            await endpoints.deadLetter({
+                delivery: request,
+                error,
+                retryAttempts: this.retryAttempts,
+                exhaustedCondition,
+            });
+        }
+        catch (deadLetterError) {
+            record(deadLetterError);
+        }
+    }
+}

package/dist/service/scheduler/delivery/sim-scheduler-delivery-function.js

@@ -36,10 +36,14 @@ export class SimSchedulerDeliveryFunction {
                 `${invokeAction} on ${targetArn.value}. Grant it in a policy on ` +
                 `the execution role.`);
         }
-        // Invoked directly rather than through an Invoke command, because the
-        // schedule is already inside the background task standing for the
-        // asynchronous invocation real Scheduler makes, and because a handler
-        // failure has to reach the delivery outcome rather than being swallowed.
-        await simFunction.invoke(simSchedulerDeliveryDocument(delivery.request));
+        // Scheduler waits for Lambda to accept the event. Lambda owns everything
+        // after acceptance, including handler errors, retries and destinations.
+        await this.scope.lambda().invoke({
+            input: {
+                FunctionName: targetArn.value,
+                InvocationType: "Event",
+                Payload: JSON.stringify(simSchedulerDeliveryDocument(delivery.request)),
+            },
+        }, { caller: delivery.caller });
     }
 }

package/dist/service/scheduler/delivery/sim-scheduler-delivery.d.ts

@@ -31,6 +31,17 @@ export interface SimSchedulerDeliveryTargets {
      * Invoke a schedule's target, refusing if its execution role may not.
      */
     deliver(request: SimSchedulerDeliveryRequest): Promise<void>;
+    /**
+     * Send an invocation Scheduler has stopped trying to its dead-letter queue.
+     */
+    deadLetter(request: SimSchedulerDeadLetterRequest): Promise<void>;
+}
+export type SimSchedulerExhaustedRetryCondition = "MaximumEventAgeInSeconds" | "MaximumRetryAttempts";
+export interface SimSchedulerDeadLetterRequest {
+    readonly delivery: SimSchedulerDeliveryRequest;
+    readonly error: unknown;
+    readonly retryAttempts: number;
+    readonly exhaustedCondition?: SimSchedulerExhaustedRetryCondition | undefined;
 }
 /**
  * What a target receives, as the JSON text a queue or a topic carries.

package/dist/service/scheduler/delivery/sim-scheduler-no-delivery-targets.d.ts

@@ -1,4 +1,4 @@
-import type { SimSchedulerDeliveryRequest, SimSchedulerDeliveryTargets } from "./sim-scheduler-delivery.js";
+import type { SimSchedulerDeadLetterRequest, SimSchedulerDeliveryRequest, SimSchedulerDeliveryTargets } from "./sim-scheduler-delivery.js";
 /**
  * The targets of a simulated Scheduler built on its own, which are none.
  *
@@ -13,4 +13,8 @@ export declare class SimSchedulerNoDeliveryTargets implements SimSchedulerDelive
      * Refuse the invocation, saying why there was nowhere to make it.
      */
     deliver(request: SimSchedulerDeliveryRequest): Promise<void>;
+    /**
+     * Refuse a dead-letter delivery for the same reason as a target delivery.
+     */
+    deadLetter(request: SimSchedulerDeadLetterRequest): Promise<void>;
 }

package/dist/service/scheduler/delivery/sim-scheduler-no-delivery-targets.js

@@ -17,4 +17,12 @@ export class SimSchedulerNoDeliveryTargets {
             `${request.schedule.target.arn.value} was not reached. Reach ` +
             `Scheduler through SimAws for a schedule that invokes.`));
     }
+    /**
+     * Refuse a dead-letter delivery for the same reason as a target delivery.
+     */
+    deadLetter(request) {
+        return Promise.reject(new SimSchedulerTargetNotFound(`This simulated Scheduler has no queues to dead-letter ` +
+            `${request.delivery.schedule.arn} to. Reach Scheduler through ` +
+            `SimAws for a schedule that invokes.`));
+    }
 }

package/dist/service/scheduler/delivery/sim-scheduler-target-delivery.d.ts

@@ -1,10 +1,12 @@
 import type { SimSchedulerDeliveryRequest, SimSchedulerDeliveryTargets } from "./sim-scheduler-delivery.js";
+import type { BackgroundScheduler } from "../../../util/background/background.js";
 import { type SimSchedulerDeliveryFailure } from "./sim-scheduler-delivery-failures.js";
 interface SimSchedulerTargetDeliveryProperties {
     readonly endpoints: SimSchedulerDeliveryTargets;
+    readonly background: BackgroundScheduler;
 }
 /**
- * Makes one invocation and keeps whatever went wrong.
+ * Runs one scheduled invocation through its attempts and keeps final failures.
  *
  * A failure is recorded rather than thrown, because these run as background
  * tasks and one left rejected would fail an unrelated
@@ -13,6 +15,7 @@ interface SimSchedulerTargetDeliveryProperties {
  */
 export declare class SimSchedulerTargetDelivery {
     private readonly endpoints;
+    private readonly background;
     private readonly failures;
     constructor(properties: SimSchedulerTargetDeliveryProperties);
     /**

package/dist/service/scheduler/delivery/sim-scheduler-target-delivery.js

@@ -1,6 +1,7 @@
+import { SimSchedulerDeliveryAttempt } from "./sim-scheduler-delivery-attempt.js";
 import { SimSchedulerDeliveryFailures, } from "./sim-scheduler-delivery-failures.js";
 /**
- * Makes one invocation and keeps whatever went wrong.
+ * Runs one scheduled invocation through its attempts and keeps final failures.
  *
  * A failure is recorded rather than thrown, because these run as background
  * tasks and one left rejected would fail an unrelated
@@ -9,9 +10,11 @@ import { SimSchedulerDeliveryFailures, } from "./sim-scheduler-delivery-failures
  */
 export class SimSchedulerTargetDelivery {
     endpoints;
+    background;
     failures = new SimSchedulerDeliveryFailures();
     constructor(properties) {
         this.endpoints = properties.endpoints;
+        this.background = properties.background;
     }
     /**
      * Every invocation that could not be made.
@@ -23,19 +26,21 @@ export class SimSchedulerTargetDelivery {
      * Invoke one schedule's target.
      */
     async deliver(request) {
-        try {
-            await this.endpoints.deliver(request);
-        }
-        catch (error) {
-            const schedule = request.schedule;
-            this.failures.record({
-                scheduleName: schedule.name.value,
-                scheduleArn: schedule.arn,
-                targetArn: schedule.target.arn.value,
-                roleArn: schedule.target.roleArn,
-                at: request.at,
-                error,
-            });
-        }
+        await new SimSchedulerDeliveryAttempt({
+            request,
+            endpoints: this.endpoints,
+            background: this.background,
+            record: (error) => {
+                const schedule = request.schedule;
+                this.failures.record({
+                    scheduleName: schedule.name.value,
+                    scheduleArn: schedule.arn,
+                    targetArn: schedule.target.arn.value,
+                    roleArn: schedule.target.roleArn,
+                    at: request.at,
+                    error,
+                });
+            },
+        }).start();
     }
 }

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

@@ -9,7 +9,7 @@ export { SimSchedulerScheduleState } from "./schedule/sim-scheduler-schedule-sta
 export { schedulerScheduleDialect } from "./schedule/sim-scheduler-schedule-expression.js";
 export { SimSchedulerTarget } from "./target/sim-scheduler-target.js";
 export { simSchedulerTargetServices, SimSchedulerTargetArn, type SimSchedulerTargetService, } from "./target/sim-scheduler-target-arn.js";
-export { simSchedulerServicePrincipal, type SimSchedulerDeliveryTargets, } from "./delivery/sim-scheduler-delivery.js";
+export { simSchedulerServicePrincipal, type SimSchedulerDeadLetterRequest, type SimSchedulerDeliveryRequest, type SimSchedulerDeliveryTargets, type SimSchedulerExhaustedRetryCondition, } from "./delivery/sim-scheduler-delivery.js";
 export { SimSchedulerDeliveryFailure, type SimSchedulerDeliveryFailureJson, } from "./delivery/sim-scheduler-delivery-failures.js";
 export { SimSchedulerDeliveryNotPermitted, SimSchedulerTargetNotFound, } from "./error/sim-scheduler-delivery.error.js";
 export { SimSchedulerAccessDeniedException, SimSchedulerConflictException, SimSchedulerError, SimSchedulerResourceNotFoundException, SimSchedulerUnsimulatedInputException, SimSchedulerValidationException, } from "./error/sim-scheduler.error.js";

package/dist/service/scheduler/target/sim-scheduler-dead-letter-config.d.ts

@@ -0,0 +1,15 @@
+export interface SimSchedulerDeadLetterConfigInput {
+    readonly Arn?: string | undefined;
+}
+/**
+ * The standard SQS queue a target sends undelivered input to.
+ */
+export declare class SimSchedulerDeadLetterConfig {
+    readonly declared: SimSchedulerDeadLetterConfigInput;
+    readonly arn: string | undefined;
+    private constructor();
+    /**
+     * Read a dead-letter configuration, refusing anything but a standard queue.
+     */
+    static of(config: SimSchedulerDeadLetterConfigInput): SimSchedulerDeadLetterConfig;
+}

package/dist/service/scheduler/target/sim-scheduler-dead-letter-config.js

@@ -0,0 +1,24 @@
+import { parseSqsQueueArn } from "../../sqs/queue/sim-sqs-queue-arn.js";
+import { SimSchedulerValidationException } from "../error/sim-scheduler.error.js";
+/**
+ * The standard SQS queue a target sends undelivered input to.
+ */
+export class SimSchedulerDeadLetterConfig {
+    declared;
+    arn;
+    constructor(config) {
+        this.declared = { ...config };
+        this.arn = config.Arn;
+    }
+    /**
+     * Read a dead-letter configuration, refusing anything but a standard queue.
+     */
+    static of(config) {
+        const { Arn: arn } = config;
+        if (arn !== undefined && parseSqsQueueArn(arn) === undefined) {
+            throw new SimSchedulerValidationException(`Target DeadLetterConfig Arn ${arn} is not a standard SQS queue ARN. ` +
+                `One is arn:aws:sqs:<region>:<account-id>:<queue-name>.`);
+        }
+        return new this(config);
+    }
+}