@kensio/yulin 1.21.26 → 1.21.28

package/dist/service/eventbridge/target/sim-event-target-retry-policy.d.ts

@@ -0,0 +1,28 @@
+/**
+ * A target's `RetryPolicy`, as a request or a template carries it.
+ */
+export interface SimEventTargetRetryPolicyInput {
+    readonly MaximumEventAgeInSeconds?: number | undefined;
+    readonly MaximumRetryAttempts?: number | undefined;
+}
+/**
+ * The retry limits one target declares, and the values they come to.
+ *
+ * A limit the policy leaves out takes EventBridge's own default, which is 185
+ * retries over at most 24 hours.
+ */
+export declare class SimEventTargetRetryPolicy {
+    readonly declared: SimEventTargetRetryPolicyInput;
+    readonly maximumEventAgeInSeconds: number;
+    readonly maximumRetryAttempts: number;
+    private constructor();
+    /**
+     * Read the retry policy a target may leave out.
+     */
+    static optional(policy: SimEventTargetRetryPolicyInput | undefined): SimEventTargetRetryPolicy | undefined;
+    /**
+     * Read a retry policy, refusing values outside EventBridge's ranges.
+     */
+    static of(policy: SimEventTargetRetryPolicyInput): SimEventTargetRetryPolicy;
+    private static requireWholeNumber;
+}

package/dist/service/eventbridge/target/sim-event-target-retry-policy.js

@@ -0,0 +1,53 @@
+import { SimEventBridgeValidationException } from "../error/sim-event-bridge.error.js";
+/**
+ * The longest EventBridge keeps retrying an event, and the most retries it
+ * makes, when a target's retry policy leaves either out.
+ */
+const defaultMaximumEventAgeInSeconds = 86_400;
+const defaultMaximumRetryAttempts = 185;
+const minimumEventAgeInSeconds = 60;
+/**
+ * The retry limits one target declares, and the values they come to.
+ *
+ * A limit the policy leaves out takes EventBridge's own default, which is 185
+ * retries over at most 24 hours.
+ */
+export class SimEventTargetRetryPolicy {
+    declared;
+    maximumEventAgeInSeconds;
+    maximumRetryAttempts;
+    constructor(policy) {
+        this.declared = { ...policy };
+        this.maximumEventAgeInSeconds =
+            policy.MaximumEventAgeInSeconds ?? defaultMaximumEventAgeInSeconds;
+        this.maximumRetryAttempts =
+            policy.MaximumRetryAttempts ?? defaultMaximumRetryAttempts;
+    }
+    /**
+     * Read the retry policy a target may leave out.
+     */
+    static optional(policy) {
+        if (policy === undefined) {
+            return undefined;
+        }
+        return this.of(policy);
+    }
+    /**
+     * Read a retry policy, refusing values outside EventBridge's ranges.
+     */
+    static of(policy) {
+        this.requireWholeNumber("MaximumEventAgeInSeconds", policy.MaximumEventAgeInSeconds, minimumEventAgeInSeconds, defaultMaximumEventAgeInSeconds);
+        this.requireWholeNumber("MaximumRetryAttempts", policy.MaximumRetryAttempts, 0, defaultMaximumRetryAttempts);
+        return new this(policy);
+    }
+    static requireWholeNumber(name, value, minimum, maximum) {
+        if (value === undefined) {
+            return;
+        }
+        if (!Number.isSafeInteger(value) || value < minimum || value > maximum) {
+            throw new SimEventBridgeValidationException(`Invalid parameter: Target RetryPolicy ${name} Reason: it is a whole ` +
+                `number between ${String(minimum)} and ${String(maximum)}, and ` +
+                `${String(value)} is not.`);
+        }
+    }
+}

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

@@ -1,4 +1,6 @@
 import { SimEventTargetArn } from "./sim-event-target-arn.js";
+import { SimEventTargetDeadLetterConfig, type SimEventTargetDeadLetterConfigInput } from "./sim-event-target-dead-letter-config.js";
+import { SimEventTargetRetryPolicy, type SimEventTargetRetryPolicyInput } from "./sim-event-target-retry-policy.js";
 import { SimEventTargetEcs, type SimEventTargetTaskProperties } from "./sim-event-target-ecs.js";
 /**
  * One place a rule sends the events it matches.
@@ -29,6 +31,19 @@ export declare class SimEventTarget {
      * is what the task overrides instead.
      */
     readonly ecs: SimEventTargetEcs | undefined;
+    /**
+     * How long and how often a failed delivery is retried, where the target
+     * says.
+     *
+     * A target without one is delivered once. Real EventBridge retries such a
+     * target for up to 24 hours by default, and that divergence is documented.
+     */
+    readonly retryPolicy: SimEventTargetRetryPolicy | undefined;
+    /**
+     * The queue an event goes to once delivery is given up, where the target
+     * names one.
+     */
+    readonly deadLetterConfig: SimEventTargetDeadLetterConfig | undefined;
     private constructor();
     /**
      * Read a target from request input.
@@ -36,6 +51,8 @@ export declare class SimEventTarget {
     static of(properties: SimEventTargetTaskProperties & {
         readonly Id?: string | undefined;
         readonly Arn?: string | undefined;
+        readonly RetryPolicy?: SimEventTargetRetryPolicyInput | undefined;
+        readonly DeadLetterConfig?: SimEventTargetDeadLetterConfigInput | undefined;
     }): SimEventTarget;
     /**
      * Read a target's fixed input, which has to be JSON.

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

@@ -1,5 +1,7 @@
 import { SimEventBridgeValidationException } from "../error/sim-event-bridge.error.js";
 import { SimEventTargetArn } from "./sim-event-target-arn.js";
+import { SimEventTargetDeadLetterConfig, } from "./sim-event-target-dead-letter-config.js";
+import { SimEventTargetRetryPolicy, } from "./sim-event-target-retry-policy.js";
 import { SimEventTargetEcs, } from "./sim-event-target-ecs.js";
 /**
  * Real EventBridge allows alphanumerics, full stops, hyphens and underscores,
@@ -35,11 +37,26 @@ export class SimEventTarget {
      * is what the task overrides instead.
      */
     ecs;
+    /**
+     * How long and how often a failed delivery is retried, where the target
+     * says.
+     *
+     * A target without one is delivered once. Real EventBridge retries such a
+     * target for up to 24 hours by default, and that divergence is documented.
+     */
+    retryPolicy;
+    /**
+     * The queue an event goes to once delivery is given up, where the target
+     * names one.
+     */
+    deadLetterConfig;
     constructor(properties) {
         this.id = properties.id;
         this.arn = properties.arn;
         this.input = properties.input;
         this.ecs = properties.ecs;
+        this.retryPolicy = properties.retryPolicy;
+        this.deadLetterConfig = properties.deadLetterConfig;
     }
     /**
      * Read a target from request input.
@@ -51,6 +68,8 @@ export class SimEventTarget {
             arn,
             input: this.readInput(properties.Input),
             ecs: SimEventTargetEcs.of(arn, properties),
+            retryPolicy: SimEventTargetRetryPolicy.optional(properties.RetryPolicy),
+            deadLetterConfig: SimEventTargetDeadLetterConfig.optional(properties.DeadLetterConfig),
         });
     }
     /**

package/docs/serve/README.md

@@ -415,6 +415,6 @@ service guide lists its supported commands.
 - `yulin watch` does not preserve simulated state across a restart or reload changed Lambda and
   CloudFront Function code inside the current process.
 - The shared AWS API endpoint refuses unsupported protocols and operations with `501 Not
-Implemented`.
+  Implemented`.
 - Some service functionality is available only through `SimAws` or SDK interception. Check the
   relevant service guide before depending on access through the local endpoint.

package/docs/services/cloudformation/README.md

@@ -948,8 +948,20 @@ console.log(
 
 A parameter with no supplied value takes the template default, when the template has one.
 
-A parameter's `Type` is read for the `AWS::SSM::Parameter::Value<...>` types, which hold a Parameter
-Store name and resolve to the value stored under it. See
+A `CommaDelimitedList` or `List<...>` parameter (`List<String>`, `List<Number>`,
+`List<AWS::EC2::Subnet::Id>` and the rest) is given one comma-separated string. A `Ref` to it
+resolves to the list of members, each trimmed of the spaces around it. `Fn::Join` and `Fn::Select`
+read that list as they read any other:
+
+```json
+{ "Fn::Join": ["-", { "Ref": "Names" }] }
+```
+
+With `Names` declared as a `CommaDelimitedList` and given `a, b, c`, this resolves to `a-b-c`. The
+members of a `List<Number>` are strings, as CloudFormation gives them.
+
+The `AWS::SSM::Parameter::Value<...>` types hold a Parameter Store name and resolve to the value
+stored under it. See
 [reading a parameter through a template Parameter](https://yulinsim.dev/services/ssm/#reading-a-parameter-through-a-template-parameter).
 Every other type is accepted and its value used as written, with no validation of the value against
 the type.
@@ -1217,6 +1229,17 @@ await simAws.cloudFormation().deployTemplate({
 });
 ```
 
+The second argument may also be a function that returns the whole list. CDK writes this for
+`Fn.join(",", zone.hostedZoneNameServers)`:
+
+```json
+{ "Fn::Join": [",", { "Fn::GetAtt": ["Zone", "NameServers"] }] }
+```
+
+`Fn::Split`, an `Fn::FindInMap` of a list value, `Fn::If` and a `Ref` to a list parameter can supply
+the list the same way. A list that resolves to anything but strings fails the deployment. That
+includes a number, and a list nested inside the list (CloudFormation joins one level only).
+
 ### `Fn::Sub`
 
 ```typescript sim-cloudformation-fn-sub
@@ -4545,9 +4568,9 @@ Each service's own docs describe what its resource types support.
   would reject as well. The simulator just rejects them later rather than up front.
 - `Fn::If` is a condition function inside the `Conditions` section, and is not a value an
   `Fn::Equals` can compare. Real CloudFormation allows only `Ref` and `Fn::FindInMap` there.
-- `Fn::Split` and `Fn::Select` accept any argument that resolves to the type they need. Real
-  CloudFormation allows only a named set of functions inside each of them. A template the simulator
-  resolves may still be one CloudFormation rejects.
+- `Fn::Join`, `Fn::Split` and `Fn::Select` accept any argument that resolves to the type they
+  need. Real CloudFormation allows only a named set of functions inside each of them. A template the
+  simulator resolves may still be one CloudFormation rejects.
 - The SAM transform is expanded for `AWS::Serverless::Function`, `AWS::Serverless::SimpleTable`,
   `AWS::Serverless::HttpApi` and `AWS::Serverless::Api`. Every other `AWS::Serverless::*` resource
   type is recorded as unsupported. `Api`, `HttpApi`, `SQS`, `DynamoDB`, `SNS`, `S3`, `Cognito`,

package/docs/services/dynamodb/README.md

@@ -3940,7 +3940,7 @@ is written.
   `AWS::DynamoDB::Table` path does, with the replica's `TableClass`, `DeletionProtectionEnabled` and
   `Tags` read off it, the table's writes and the replica's reads put back together into one
   provisioned capacity for the table and for each global secondary index, and `Ref`, `Fn::GetAtt …
-Arn`, `Fn::GetAtt … StreamArn` and `Fn::GetAtt … TableId` answering. A CDK `TableV2` stack deploys
+  Arn`, `Fn::GetAtt … StreamArn` and `Fn::GetAtt … TableId` answering. A CDK `TableV2` stack deploys
   through it without hand-editing.
 - SDK interception, and an intercepted `DynamoDBClient` or `DynamoDBStreamsClient` reaches the
   simulation.
@@ -4035,7 +4035,7 @@ Arn`, `Fn::GetAtt … StreamArn` and `Fn::GetAtt … TableId` answering. A CDK `
 - Time to live expiry is dispatched by moving the clock through `simAws.clock()`, not by real time
   elapsing. An item whose window goes by while a running-mode clock tracks the host stays where it
   is until something moves the clock. A simulated DynamoDB constructed standalone as `new
-SimDynamoDb()` has no clock control at all. No item there ever expires.
+  SimDynamoDb()` has no clock control at all. No item there ever expires.
 - A Lambda event source mapping is the only simulated service integration that consumes a stream.
   Anything else reads one through the Streams API itself. A Kinesis Data Streams destination is
   absent.

package/docs/services/eventbridge/README.md

@@ -921,6 +921,91 @@ and a rule routes the same events whether it carries them or not. They are recor
 property and the deploy stands. Nothing reads them back. A rule or a bus deployed with tags behaves
 as though the template had never named them.
 
+## Receiving events from a SaaS partner
+
+A SaaS partner such as Stripe sends events to an account through a partner event source, named like
+`aws.partner/stripe.com/ed_...`. The partner creates the source from its own account, so a test
+shares one with `addPartnerEventSource(...)`. The account then creates a partner event bus with the
+same `Name` and `EventSourceName`, and `putPartnerEvents(...)` sends events onto it as the partner
+would.
+
+```typescript sim-event-bridge-partner-events
+/**
+ * Receiving Stripe's events on a partner event bus.
+ */
+
+import {
+  CreateEventBusCommand,
+  PutPartnerEventsCommand,
+  PutRuleCommand,
+} from "@aws-sdk/client-eventbridge";
+
+import { SimAws } from "@kensio/yulin";
+
+const simAws = new SimAws();
+const events = simAws.eventBridge();
+const source = "aws.partner/stripe.com/ed_test_billing";
+
+// What Stripe does when an event destination is set up for the account.
+events.addPartnerEventSource(source);
+
+// What the account does to receive from it.
+await events.createEventBus(
+  new CreateEventBusCommand({ Name: source, EventSourceName: source }),
+);
+await events.putRule(
+  new PutRuleCommand({
+    Name: "subscriptions",
+    EventBusName: source,
+    EventPattern: JSON.stringify({
+      source: [{ prefix: "aws.partner/stripe.com" }],
+      "detail-type": ["customer.subscription.created"],
+    }),
+  }),
+);
+
+// What Stripe sends when a subscription starts.
+await events.putPartnerEvents(
+  new PutPartnerEventsCommand({
+    Entries: [
+      {
+        Source: source,
+        DetailType: "customer.subscription.created",
+        Detail: JSON.stringify({
+          id: "evt_test_subscription",
+          type: "customer.subscription.created",
+          data: { object: { id: "sub_test" } },
+        }),
+      },
+    ],
+  }),
+);
+
+console.log(events.receiptsOn(source)[0]?.matchedRuleNames); // ["subscriptions"]
+```
+
+`putPartnerEvents(...)` takes the entries of the partner's `PutPartnerEvents` request. Each entry's
+`Source` names a shared source, and the event goes to the bus of the same name. Rules match it on
+`source`, `detail-type` and `detail` like any other event. A target receives the usual envelope, with
+`account` set to the receiving account. Stripe puts its event type in `DetailType` and the whole
+Stripe event object, as JSON, in `Detail`. An entry whose `Source` names no shared source fails the
+whole request with `ResourceNotFoundException`.
+
+An `AWS::Events::EventBus` with `Name` and `EventSourceName` both set to the source name creates the
+same bus from a template, and a rule names it with a `Ref` to the bus.
+
+The source has to be shared before the bus is created. `CreateEventBus` fails with
+`ResourceNotFoundException` when it is missing, and a template creating the bus fails its stack, as
+both do on AWS. A `Name` that differs from the `EventSourceName` is a `ValidationException`, as is a
+`/` in the name of a bus created without one.
+
+`DescribeEventSource` reports the source as `PENDING` until its bus exists, and `ACTIVE` after.
+Deleting the bus puts it back to `PENDING`. An event sent while the source is pending is dropped,
+as AWS documents.
+
+Only the partner sends events to a partner event bus. `PutEvents` naming one is refused with a
+`ValidationException` (its `EventBusName` takes no `/`).
+
 ## Reading back a failed delivery
 
 Real EventBridge tells the caller nothing about a failed delivery. A `PutEvents` that matched a rule
@@ -981,6 +1066,125 @@ no is a modelled outcome a test may be asking for on purpose.
 `JSON.stringify` on a failure carries the message alongside the rule, the target and the event it
 names.
 
+## Retrying and dead-lettering a delivery
+
+A target can carry a `RetryPolicy` and a `DeadLetterConfig`, from `PutTargets` or from a target in an
+`AWS::Events::Rule`. The dead-letter queue receives an event once EventBridge gives up delivering it.
+
+```typescript sim-event-bridge-dead-letter
+/**
+ * Sending an event a target refused to its dead-letter queue.
+ */
+
+import {
+  PutEventsCommand,
+  PutRuleCommand,
+  PutTargetsCommand,
+} from "@aws-sdk/client-eventbridge";
+import {
+  CreateQueueCommand,
+  ReceiveMessageCommand,
+  SetQueueAttributesCommand,
+} from "@aws-sdk/client-sqs";
+
+import { SimAws } from "@kensio/yulin";
+
+const simAws = new SimAws();
+const dlqArn = "arn:aws:sqs:us-east-1:888888888888:undelivered-orders";
+
+// A dead-letter queue admitting EventBridge for the rule.
+const { QueueUrl } = await simAws
+  .sqs()
+  .createQueue(new CreateQueueCommand({ QueueName: "undelivered-orders" }));
+await simAws.sqs().setQueueAttributes(
+  new SetQueueAttributesCommand({
+    QueueUrl,
+    Attributes: {
+      Policy: JSON.stringify({
+        Version: "2012-10-17",
+        Statement: [
+          {
+            Effect: "Allow",
+            Principal: { Service: "events.amazonaws.com" },
+            Action: "sqs:SendMessage",
+            Resource: dlqArn,
+            Condition: {
+              ArnEquals: {
+                "aws:SourceArn":
+                  "arn:aws:events:us-east-1:888888888888:rule/orders",
+              },
+            },
+          },
+        ],
+      }),
+    },
+  }),
+);
+
+// A target queue that was never created, so every delivery fails.
+await simAws.eventBridge().putRule(
+  new PutRuleCommand({
+    Name: "orders",
+    EventPattern: JSON.stringify({ source: ["orders.service"] }),
+  }),
+);
+await simAws.eventBridge().putTargets(
+  new PutTargetsCommand({
+    Rule: "orders",
+    Targets: [
+      {
+        Id: "fulfilment",
+        Arn: "arn:aws:sqs:us-east-1:888888888888:fulfilment",
+        RetryPolicy: { MaximumRetryAttempts: 2 },
+        DeadLetterConfig: { Arn: dlqArn },
+      },
+    ],
+  }),
+);
+
+await simAws.eventBridge().putEvents(
+  new PutEventsCommand({
+    Entries: [
+      { Source: "orders.service", DetailType: "OrderPlaced", Detail: "{}" },
+    ],
+  }),
+);
+await simAws.backgroundTasksComplete();
+
+const { Messages } = await simAws
+  .sqs()
+  .receiveMessage(
+    new ReceiveMessageCommand({ QueueUrl, MessageAttributeNames: ["All"] }),
+  );
+
+console.log(Messages?.[0]?.MessageAttributes?.["ERROR_CODE"]?.StringValue);
+// "NO_RESOURCE"
+```
+
+The message body is the event, as JSON. Its attributes are the ones EventBridge documents.
+`RULE_ARN` and `TARGET_ARN` name where the event was going. `ERROR_CODE` and `ERROR_MESSAGE` say why
+it failed, and `RETRY_ATTEMPTS` counts the retries made. `EXHAUSTED_RETRY_CONDITION` is
+`MaximumRetryAttempts` or `MaximumEventAgeInSeconds` when a retry limit ran out.
+
+`ERROR_CODE` is `NO_PERMISSIONS` for a target that refused EventBridge and `NO_RESOURCE` for one
+that is not there. Every other failure is `ERROR_FROM_TARGET`. EventBridge lists these codes
+without saying which failure gets which.
+
+A missing target and a refusal are never retried, because the same request gets the same answer.
+EventBridge sends both straight to the dead-letter queue, and so does Yulin. Any other failure is
+retried on the simulation's clock. The first retry is due one second after the failed attempt, and
+each following wait doubles to 2, 4, 8 seconds and so on. Retries stop at `MaximumRetryAttempts`, or
+once the event is `MaximumEventAgeInSeconds` old. A retry only runs as `advanceBy(...)` moves the
+clock past it.
+
+EventBridge sends to the dead-letter queue as `events.amazonaws.com`, with the rule ARN as
+`aws:SourceArn`, so the queue policy has to admit it. A dead-letter queue that is missing or refuses
+EventBridge leaves the failure in `deliveryFailures`. An event that reached its dead-letter queue
+leaves nothing there.
+
+A Lambda target is invoked asynchronously. Once Lambda accepts the invocation the delivery is done,
+and a handler error is left to the function's own retries and destinations.
+
 ## Permissions
 
 Most operations are authorized by simulated IAM against the bus ARN. The two that name no bus
@@ -1048,6 +1252,8 @@ no permission for.
 ## Supported operations
 
 - `CreateEventBus`, `DeleteEventBus`, `DescribeEventBus`, `ListEventBuses` and `PutEvents`.
+- Partner event buses created with `EventSourceName`, and `DescribeEventSource`. A test acts as the
+  partner through `addPartnerEventSource(...)` and `putPartnerEvents(...)`.
 - `PutRule`, `DeleteRule`, `DescribeRule`, `ListRules`, `EnableRule`, `DisableRule` and
   `TestEventPattern`.
 - Scheduled rules, with a `rate(...)` or six-field `cron(...)` `ScheduleExpression`, fired by
@@ -1061,6 +1267,8 @@ no permission for.
 - Targets in another account or region of the same simulation, admitted by the target's own resource
   policy on `aws:SourceArn` or `aws:SourceAccount`, as real EventBridge does.
 - A target's fixed `Input`, and `deliveryFailures` for a delivery that failed.
+- A target's `RetryPolicy`, retried on the simulation's clock, and its `DeadLetterConfig`, with the
+  dead-letter message attributes EventBridge documents.
 - The `default` bus in every account and region, without one being created.
 - Bus descriptions, creation timestamps from the simulation's clock, and prefix-narrowed paged
   listings.
@@ -1073,9 +1281,13 @@ no permission for.
 
 - Targets deliver to Lambda, SQS and SNS, and run a task in ECS. A target ARN naming any other
   service is refused as the target is added, ahead of any matching event.
-- Target `InputPath` and `InputTransformer` are refused, as are dead letter queues and retry
-  policies. A delivery is attempted once. A target `RoleArn` is refused except on an ECS target.
-  That is the one target type that runs as a role, where the others run as the service principal.
+- Target `InputPath` and `InputTransformer` are refused. A target `RoleArn` is refused except on an
+  ECS target. That is the one target type that runs as a role, where the others run as the service
+  principal.
+- A target with no `RetryPolicy` is delivered once. Real EventBridge retries such a target for up to
+  24 hours and 185 times. Retry waits are deterministic powers of two seconds, where real
+  EventBridge uses exponential backoff with jitter. The fixed sequence lets a test move the clock to
+  a known retry.
 - An ECS target's `EcsParameters` takes `TaskDefinitionArn` and `TaskCount`, and takes and ignores
   `LaunchType`, `PlatformVersion`, `NetworkConfiguration` and `CapacityProviderStrategy`, since
   there is no placement and no network here for them to apply to. Anything else it can carry, such
@@ -1115,8 +1327,13 @@ no permission for.
   attribute are all missing, and a caller from another account cannot be admitted to a bus. That is
   stricter than real AWS.
 - Putting an event onto another account's or region's bus is refused.
-- Partner event buses and partner event sources are refused, as are event bus tags, encryption with
-  a customer managed key, dead letter queues, logging configuration and global endpoints. An
-  `AWS::Events::EventBus` carrying `Tags` deploys with the tags dropped and the property recorded.
+- Event bus tags, encryption with a customer managed key, dead letter queues, logging configuration
+  and global endpoints are refused. An `AWS::Events::EventBus` carrying `Tags` deploys with the tags
+  dropped and the property recorded.
+- A pending partner event source never expires, and `DescribeEventSource` leaves out
+  `ExpirationTime`. Its `CreatedBy` is the segment after `aws.partner/`, such as `stripe.com`.
+  `ListEventSources`, `ActivateEventSource` and `DeactivateEventSource` are absent, as are the
+  partner's own commands. A partner is a test calling `addPartnerEventSource(...)` and
+  `putPartnerEvents(...)`.
 - Archives, replay, schema registry and discovery, API destinations and connections are not
   simulated.

package/docs/services/s3/README.md

@@ -1079,7 +1079,7 @@ A delete on a versioned Bucket raises `s3:ObjectRemoved:DeleteMarkerCreated` rat
 
 - MFA delete is refused with `NotImplemented` rather than stored. Nothing here could enforce it, and
   a Bucket reporting a protection it does not apply is worse than one that says so. `MFADelete:
-"Disabled"` is taken, and any other value is refused with `InvalidArgument`.
+  "Disabled"` is taken, and any other value is refused with `InvalidArgument`.
 - A `versionId` in a `CopySource` is still refused with `NotImplemented`. A copy reads the current
   version.
 - `NoncurrentVersionTransitions` is stored and unread, because storage classes are left out. An

package/docs/services/sqs/README.md

@@ -1214,7 +1214,7 @@ Current documented limitations:
 - A Lambda event source mapping polls one batch at a time. Real Lambda runs several pollers at once
   and scales them with the queue, and what that concurrency does to ordering is invisible here. See
   [simulated Lambda](https://yulinsim.dev/services/lambda/#triggering-a-function-from-an-sqs-queue "Simulated Lambda event
-source mapping docs") for the rest of the mapping limitations.
+  source mapping docs") for the rest of the mapping limitations.
 - `AWS::SQS::Queue` and `AWS::SQS::QueuePolicy` are the SQS resource types CloudFormation creates.
   Any other is reported as unsupported and skipped. A queue attribute outside the range real SQS
   accepts fails the resource, and a property it has no behaviour for is recorded and the queue

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kensio/yulin",
-  "version": "1.21.26",
+  "version": "1.21.28",
   "description": "AWS system behaviour simulation for isolated unit testing",
   "repository": "https://github.com/KensioSoftware/yulin",
   "homepage": "https://yulinsim.dev/",
@@ -299,7 +299,7 @@
     "hyparquet": "^1.29.2",
     "hyparquet-writer": "^0.16.9",
     "node-sql-parser": "^5.4.0",
-    "oxfmt": "^0.71.0",
+    "oxfmt": "^0.72.0",
     "oxlint": "^1.77.0",
     "oxlint-tsgolint": "^7.0.2001",
     "semantic-release": "25.0.9",