@kensio/yulin 1.20.17 → 1.21.1

package/dist/service/s3/sdk/sim-s3-sdk-object-routes.js

@@ -0,0 +1,80 @@
+import { simSdkCallerOptions, simSdkStreamBody } from "../../../sdk/index.js";
+/**
+ * The SDK Commands that act on the Objects in a Bucket, the multipart uploads
+ * that build one, and the versions a Bucket keeps of them.
+ */
+export function simS3SdkObjectRoutes(simS3) {
+    return [
+        [
+            "PutObjectCommand",
+            async (command, context) => await simS3.putObject(command, simSdkCallerOptions(context)),
+        ],
+        [
+            "GetObjectCommand",
+            async (command, context) => await getObjectWithSdkStreamBody(simS3, command, simSdkCallerOptions(context)),
+        ],
+        [
+            "HeadObjectCommand",
+            async (command, context) => await simS3.headObject(command, simSdkCallerOptions(context)),
+        ],
+        [
+            "CopyObjectCommand",
+            async (command, context) => await simS3.copyObject(command, simSdkCallerOptions(context)),
+        ],
+        [
+            "DeleteObjectCommand",
+            async (command, context) => await simS3.deleteObject(command, simSdkCallerOptions(context)),
+        ],
+        [
+            "DeleteObjectsCommand",
+            async (command, context) => await simS3.deleteObjects(command, simSdkCallerOptions(context)),
+        ],
+        [
+            "ListObjectsCommand",
+            async (command, context) => await simS3.listObjects(command, simSdkCallerOptions(context)),
+        ],
+        [
+            "ListObjectsV2Command",
+            async (command, context) => await simS3.listObjectsV2(command, simSdkCallerOptions(context)),
+        ],
+        [
+            "ListObjectVersionsCommand",
+            async (command, context) => await simS3.listObjectVersions(command, simSdkCallerOptions(context)),
+        ],
+        [
+            "CreateMultipartUploadCommand",
+            async (command, context) => await simS3.createMultipartUpload(command, simSdkCallerOptions(context)),
+        ],
+        [
+            "UploadPartCommand",
+            async (command, context) => await simS3.uploadPart(command, simSdkCallerOptions(context)),
+        ],
+        [
+            "CompleteMultipartUploadCommand",
+            async (command, context) => await simS3.completeMultipartUpload(command, simSdkCallerOptions(context)),
+        ],
+        [
+            "AbortMultipartUploadCommand",
+            async (command, context) => await simS3.abortMultipartUpload(command, simSdkCallerOptions(context)),
+        ],
+        [
+            "ListMultipartUploadsCommand",
+            async (command, context) => await simS3.listMultipartUploads(command, simSdkCallerOptions(context)),
+        ],
+        [
+            "ListPartsCommand",
+            async (command, context) => await simS3.listParts(command, simSdkCallerOptions(context)),
+        ],
+    ];
+}
+/**
+ * Get an Object and mix the SDK stream transform methods into its Body, so
+ * SDK callers can use e.g. Body.transformToString() as with real S3.
+ */
+async function getObjectWithSdkStreamBody(simS3, command, options) {
+    const output = await simS3.getObject(command, options);
+    if (output.Body === undefined) {
+        return output;
+    }
+    return { ...output, Body: simSdkStreamBody(output.Body) };
+}

package/dist/service/s3/sim-s3-commands.d.ts

@@ -8,7 +8,9 @@ import { SimS3LifecycleCommands } from "./command/lifecycle/sim-s3-lifecycle-com
 import { SimS3MultipartCommands } from "./command/multipart/sim-s3-multipart-commands.js";
 import { SimS3NotificationCommands } from "./command/notification/sim-s3-notification-commands.js";
 import { SimS3ObjectCommands } from "./command/object/sim-s3-object-commands.js";
+import { SimS3ObjectLockCommands } from "./command/object-lock/sim-s3-object-lock-commands.js";
 import { SimS3PublicAccessBlockCommands } from "./command/public-access-block/sim-s3-public-access-block-commands.js";
+import { SimS3VersioningCommands } from "./command/versioning/sim-s3-versioning-commands.js";
 import type { SimS3NotificationDestinations } from "./notification/destination/sim-s3-notification-destination.js";
 import { SimS3ObjectNotifier } from "./notification/sim-s3-object-notifier.js";
 import type { SimS3GlobalRegistry } from "./sim-s3-global-registry.js";
@@ -52,6 +54,8 @@ export declare class SimS3Commands {
     readonly publicAccessBlocks: SimS3PublicAccessBlockCommands;
     readonly notifications: SimS3NotificationCommands;
     readonly lifecycles: SimS3LifecycleCommands;
+    readonly versioning: SimS3VersioningCommands;
+    readonly objectLock: SimS3ObjectLockCommands;
     readonly objects: SimS3ObjectCommands;
     readonly multipartUploads: SimS3MultipartCommands;
     readonly objectNotifier: SimS3ObjectNotifier;

package/dist/service/s3/sim-s3-commands.js

@@ -6,7 +6,9 @@ import { SimS3LifecycleCommands } from "./command/lifecycle/sim-s3-lifecycle-com
 import { SimS3MultipartCommands } from "./command/multipart/sim-s3-multipart-commands.js";
 import { SimS3NotificationCommands } from "./command/notification/sim-s3-notification-commands.js";
 import { SimS3ObjectCommands } from "./command/object/sim-s3-object-commands.js";
+import { SimS3ObjectLockCommands } from "./command/object-lock/sim-s3-object-lock-commands.js";
 import { SimS3PublicAccessBlockCommands } from "./command/public-access-block/sim-s3-public-access-block-commands.js";
+import { SimS3VersioningCommands } from "./command/versioning/sim-s3-versioning-commands.js";
 import { SimS3NoNotificationDestinations } from "./notification/destination/sim-s3-service-notification-destinations.js";
 import { SimS3ObjectNotifier } from "./notification/sim-s3-object-notifier.js";
 import { SimS3ObjectListingLimits } from "./object/s3-object-listing-limits.js";
@@ -24,6 +26,8 @@ export class SimS3Commands {
     publicAccessBlocks;
     notifications;
     lifecycles;
+    versioning;
+    objectLock;
     objects;
     multipartUploads;
     objectNotifier;
@@ -51,6 +55,8 @@ export class SimS3Commands {
         this.publicAccessBlocks = new SimS3PublicAccessBlockCommands(state);
         this.notifications = new SimS3NotificationCommands(state);
         this.lifecycles = new SimS3LifecycleCommands(state);
+        this.versioning = new SimS3VersioningCommands(state);
+        this.objectLock = new SimS3ObjectLockCommands(state);
         this.objects = new SimS3ObjectCommands(state);
         this.multipartUploads = new SimS3MultipartCommands(state);
     }

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

@@ -1,16 +1,16 @@
 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";
+import { SimS3VersionOperations } from "./sim-s3-version-operations.js";
 /**
  * The AWS operations simulated S3 answers. One delegation per SDK Command,
  * onto the handler in `SimS3Commands` that runs it.
  *
  * `SimS3` extends this. A caller reaches every operation on the one service
- * object, alongside the simulator-only controls `SimS3` holds itself.
+ * object, alongside the simulator-only controls `SimS3` holds itself. The
+ * operations that make a Bucket keep what it held are on
+ * `SimS3VersionOperations`, which this extends.
  */
-export declare abstract class SimS3Operations {
-    protected readonly commands: SimS3Commands;
-    protected constructor(commands: SimS3Commands);
+export declare abstract class SimS3Operations extends SimS3VersionOperations {
     /** Handle a Create Bucket Command from the SDK. */
     createBucket(command: simS3Commands.SimCreateBucketCommand, options?: SimS3RequestOptions): Promise<simS3Commands.SimCreateBucketCommandOutput>;
     /** Handle a Head Bucket Command from the SDK. */

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

@@ -1,15 +1,14 @@
+import { SimS3VersionOperations } from "./sim-s3-version-operations.js";
 /**
  * The AWS operations simulated S3 answers. One delegation per SDK Command,
  * onto the handler in `SimS3Commands` that runs it.
  *
  * `SimS3` extends this. A caller reaches every operation on the one service
- * object, alongside the simulator-only controls `SimS3` holds itself.
+ * object, alongside the simulator-only controls `SimS3` holds itself. The
+ * operations that make a Bucket keep what it held are on
+ * `SimS3VersionOperations`, which this extends.
  */
-export class SimS3Operations {
-    commands;
-    constructor(commands) {
-        this.commands = commands;
-    }
+export class SimS3Operations extends SimS3VersionOperations {
     /** Handle a Create Bucket Command from the SDK. */
     async createBucket(command, options) {
         return await this.commands.buckets.create(command, options);

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 });
     }
 }