@kensio/yulin 1.20.15 → 1.20.17

package/docs/terraform/README.md

@@ -0,0 +1,248 @@
+# Terraform
+
+A team whose infrastructure is written in Terraform can deploy it into simulated AWS without
+hand-writing a second CloudFormation template describing the same infrastructure. `TerraformAdapter`
+reads the JSON `terraform show -json` writes for a saved plan file and creates the resources the
+plan declares.
+
+```bash
+npm i -D @kensio/yulin
+```
+
+## Deploying a plan
+
+Write the JSON first. `terraform plan` produces the saved plan in Terraform's own binary format, and
+`terraform show -json` turns that into the document the adapter reads.
+
+```bash
+terraform plan -out=orders.tfplan
+terraform show -json orders.tfplan > orders.tfplan.json
+```
+
+A plan carries no code for its functions. It points at a zip on disk, an S3 object or a container
+image, and none of the three is a handler Yulin can run. A binding matched on the function name the
+plan declares is where the behaviour comes from.
+
+```typescript terraform-deploy-plan
+/**
+ * Deploying a Terraform plan into simulated AWS.
+ */
+
+import { SimAws } from "@kensio/yulin";
+import { TerraformAdapter } from "@kensio/yulin/terraform";
+
+const simAws = new SimAws();
+
+const { stack } = await new TerraformAdapter(simAws).deployPlan({
+  planPath: "terraform/orders.tfplan.json",
+  bindings: [
+    {
+      functionName: "orders-processor",
+      handler: (event: { orderId: string }): string => `took ${event.orderId}`,
+    },
+  ],
+});
+
+// The bucket, the table and the queue the configuration declared.
+console.log(simAws.s3().getSimBucketByName("orders-uploads")?.bucketName);
+console.log(simAws.dynamoDb().findTable("orders-orders")?.tableName);
+
+console.log(stack.status);
+```
+
+The Stack is named after the plan file when the deployment does not name one, so
+`orders.tfplan.json` deploys as `orders`. Pass `stackName` to name it yourself, and pass the path on
+its own where nothing else needs saying.
+
+```typescript terraform-deploy-plan-path
+/**
+ * Deploying a Terraform plan named by path alone.
+ */
+
+import { SimAws } from "@kensio/yulin";
+import { TerraformAdapter } from "@kensio/yulin/terraform";
+
+const simAws = new SimAws();
+
+const { stack } = await new TerraformAdapter(simAws).deployPlan(
+  "terraform/orders.tfplan.json",
+);
+
+console.log(stack.stackName);
+```
+
+## What comes back
+
+`deployPlan` answers with the Stack and a report of what reading the plan made of it.
+
+The Stack is an ordinary simulated CloudFormation Stack, and everything the [CloudFormation
+docs](https://yulinsim.dev/services/cloudformation/ "Simulated CloudFormation usage docs") describe applies to it.
+Resources are read with `stack.getResource(...)`, Outputs with `stack.output(...)`, and the whole
+thing is torn down with `stack.delete()`.
+
+## What the adapter reads
+
+A resource declared with `count` or `for_each` arrives in the plan already expanded, and each
+instance becomes a resource of its own. Resources declared inside a module are reached through the
+module path they were declared under, however many modules deep.
+
+An attribute Terraform could not resolve at plan time is absent from the plan's values. The plan
+keeps the reference behind it, and that reference becomes the link a hand-written template would
+have carried.
+
+Ordering is rebuilt. Terraform resolves what it can before writing the plan, so a Lambda permission
+naming a function the same plan creates carries the function's name as a plain string. The value is
+right and the edge CloudFormation orders from has gone with it. Every reference a resource declares
+becomes an ordering edge, whether or not the value resolved.
+
+## Supplying environment variables and role policies
+
+Terraform resolves nothing inside a value it could not build. A Lambda `environment.variables` map
+holding one reference to a queue of the same plan arrives unknown in its entirety, and the variable
+names go with it. An `aws_iam_role_policy` written with `jsonencode` around an ARN of the same plan
+arrives without its statements.
+
+Those two cost more than their count suggests (four attributes out of 154 on a hand-written
+application configuration). A handler reads its configuration out of environment variables, and
+simulated IAM evaluates authorization.
+
+`overrides` supplies them, matched on the name the plan carries, the way a binding is matched on a
+function name. An environment is matched on the function's name and an inline policy on the role's.
+
+```typescript terraform-plan-overrides
+/**
+ * Supplying the values a Terraform plan could not carry.
+ */
+
+import { SimAws } from "@kensio/yulin";
+import { TerraformAdapter } from "@kensio/yulin/terraform";
+
+const simAws = new SimAws();
+
+const { report } = await new TerraformAdapter(simAws).deployPlan({
+  planPath: "terraform/orders.tfplan.json",
+  bindings: [
+    {
+      functionName: "orders-processor",
+      handler: (): string => process.env["QUEUE_URL"] ?? "",
+    },
+  ],
+  overrides: [
+    {
+      functionName: "orders-processor",
+      environment: {
+        TABLE_NAME: "orders-orders",
+        QUEUE_URL:
+          "https://sqs.eu-west-1.amazonaws.com/123456789012/orders-processing",
+      },
+    },
+    {
+      roleName: "orders-processor",
+      policy: {
+        Version: "2012-10-17",
+        Statement: [
+          {
+            Effect: "Allow",
+            Action: [
+              "sqs:ReceiveMessage",
+              "sqs:DeleteMessage",
+              "sqs:GetQueueAttributes",
+            ],
+            Resource: "*",
+          },
+        ],
+      },
+    },
+  ],
+});
+
+// The attributes the plan lost that no override covered.
+console.log(report.lost);
+```
+
+An override fills a gap. Where Terraform resolved the value, the plan wins, and environment
+variables are merged one variable at a time. A configuration that stops collapsing a value stops
+needing the override written for it.
+
+A role whose policy no override supplies is created allowing everything, and `policy` is named on
+the report's `lost`. Simulated IAM evaluates authorization, and a role holding no policy would deny
+what the configuration allowed and fail the resources using it (an event source mapping is refused
+outright when its execution role cannot poll the queue). Supplying the policy takes that default
+off. The document is evaluated as it stands, and one omitting `sqs:ReceiveMessage` fails the mapping
+the way AWS fails it.
+
+## What it maps
+
+The adapter maps 24 Terraform resource types and folds 11 more into the resource they configure. The
+set covers API Gateway, CloudWatch (log groups, metric alarms and EventBridge rules), Cognito,
+DynamoDB, ECR, IAM, KMS, Lambda, S3, Secrets Manager, SNS, SQS and SSM Parameter Store.
+
+A hand-written application configuration of 46 resources deploys whole. A configuration built out of
+published `terraform-aws-modules` modules reaches 21 of its 25. Of the four it leaves, the Lambda
+module uses `null_resource` and `local_file` to package a zip, and an integration and a route read
+their values through a `for_each` hop the adapter steps over.
+
+## What the report says
+
+A type with no mapping, and a resource from a provider other than AWS, are recorded and stepped over
+rather than failing the deployment.
+
+```typescript terraform-plan-report
+/**
+ * Reading what a Terraform plan import made of the plan.
+ */
+
+import { SimAws } from "@kensio/yulin";
+import { TerraformAdapter } from "@kensio/yulin/terraform";
+
+const simAws = new SimAws();
+
+const { report } = await new TerraformAdapter(simAws).deployPlan(
+  "terraform/orders.tfplan.json",
+);
+
+// [ { address: 'aws_s3_bucket.uploads', type: 'aws_s3_bucket',
+//     cfnType: 'AWS::S3::Bucket', logicalId: 'AwsS3BucketUploads' } ]
+console.log(report.mapped);
+
+// [ { address: 'aws_route53_zone.public', type: 'aws_route53_zone',
+//     reason: 'no mapping for resource type' } ]
+console.log(report.skipped);
+
+// The aws_s3_bucket_versioning and friends that became bucket properties.
+console.log(report.folded);
+
+// Attributes a mapping could not carry and no override supplied, such as a
+// Lambda's environment variables, which Terraform collapses whole when one of
+// them is unknown.
+console.log(report.lost);
+```
+
+`mapped`, `folded` and `skipped` add up to the plan's managed resource count. `lost` names the
+attributes that did not survive the plan and that no override covered, per resource. A Terraform
+value that names a resource of the same plan and sits inside something Terraform builds in one go,
+such as a `jsonencode` document or a `for_each` map, is unknown in its entirety and its contents go
+with it.
+
+## What a reference cannot reach
+
+A value a plan resolved arrives as a value. A value the plan could not resolve arrives as a
+reference, and the import follows that reference to the resource that will produce it, through
+module outputs, module variables, `each.value` and `each.key`. That covers what a community module
+such as `terraform-aws-modules/apigateway-v2/aws` does with a `routes` map.
+
+Two shapes stop it, and both are recorded as `unresolved required attribute` on `report.skipped`.
+
+A plan records the references of a whole collection in one list, and the list says what the
+collection was built from without saying which entry holds which. A `routes` map naming one function
+is unambiguous. A `routes` map naming two functions leaves `each.value.uri` able to mean either, and
+the import declines. Setting the value with a resource of its own, or with one module call per
+function, gives each reference a collection to itself.
+
+A value reaching a resource through a `local` is out of range whatever it holds. A plan carries the
+locals' effects and none of their definitions, so there is nothing to follow.
+
+## The scope of what it reads
+
+One plan JSON file, already produced. Reading HCL, reading `terraform.tfstate`, and running
+`terraform` as a subprocess are all outside it.

package/docs/time/README.md

@@ -0,0 +1,284 @@
+# Simulated time
+
+Every timestamp a simulated AWS service produces comes from that simulation's own clock, and that
+clock can be moved. Time can be frozen, set to an instant, or advanced by a duration. Behaviour that
+depends on time passing, such as a temporary session expiring, can be tested without waiting for it.
+
+Time belongs to a `SimAws` instance. Moving it affects that instance only. The host clock, another
+simulation running in the same test file, and any other code in the process all carry on unchanged.
+
+## Reading the time
+
+`simAws.now()` is what the simulation means by "now". The host clock may say something different. It
+also stamps simulated resources, such as an IAM User's `CreateDate` and an `AssumeRole` session's
+`Expiration`.
+
+By default a new `SimAws` runs in step with the real system clock.
+
+## Starting at a known instant
+
+Pass a clock to start somewhere specific. `SimFixedClock` is the usual choice, since it reports one
+instant and stays there:
+
+```typescript sim-clock-freeze-and-advance
+/**
+ * Starting a simulation at a known instant, then moving its clock on.
+ */
+
+import { CreateUserCommand } from "@aws-sdk/client-iam";
+import { SimAws, SimFixedClock } from "@kensio/yulin";
+
+const simAws = new SimAws({
+  clock: new SimFixedClock(new Date("2026-07-26T09:00:00.000Z")),
+});
+
+const output = await simAws
+  .iam()
+  .createUser(new CreateUserCommand({ UserName: "Clockwatcher" }));
+
+console.log(output.User.CreateDate); // 2026-07-26T09:00:00.000Z
+
+await simAws.clock().advanceBy({ hours: 2, minutes: 30 });
+
+console.log(simAws.now()); // 2026-07-26T11:30:00.000Z
+
+// Still two and a half hours ahead of the clock it was given. That clock is a
+// fixed one, so simulated time stays at 11:30 rather than running on.
+simAws.clock().resume();
+```
+
+Simulated time is layered over whatever clock is supplied. A simulation started at a fixed instant
+is still free to move from there, and it stays measured against that clock. Resuming a simulation
+built on a `SimFixedClock` puts it back in running mode, and its time then moves whenever the clock
+underneath moves. A fixed clock stays where it is. Leave the default real clock in place for a
+simulation whose time should pass by itself.
+
+## Frozen and running
+
+There are two modes:
+
+- **Frozen**: simulated time only moves when something moves it. A frozen clock reports the same
+  instant however long the host takes, and a slow test holds the state it set up. This is what a
+  deterministic assertion wants.
+- **Running**: simulated time tracks the clock underneath, offset from it. On the default real clock
+  time passes by itself. Use it to jump forward an hour and carry on.
+
+Moving time deliberately freezes it. `setTo(...)` and `advanceBy(...)` both leave the clock stopped
+where they put it. A test that asked for a specific instant then asserts on that instant, however
+long the assertion takes. `resume()` is the way back to running, and it carries on from where the
+clock stopped.
+
+`simAws.clock().isFrozen` reports which mode the clock is in.
+
+## Advancing time
+
+`advanceBy(...)` takes a duration written as any combination of `days`, `hours`, `minutes`,
+`seconds` and `milliseconds`, which add together. A bare number counts milliseconds, as it does for
+`setTimeout`, and `advanceBy(3_600_000)` moves an hour. Durations are never negative, since time
+passing only runs forwards. `setTo(...)` is the explicit way to move a clock back.
+
+Advancing moves the clock, and it runs whatever the passage of time should have caused. Work
+scheduled for an instant inside the interval is dispatched in due order, each task running with the
+clock reading its own due time. Further work it schedules settles before `advanceBy` returns where
+that work is itself due by the new time, and stays queued where it falls later. So a test can
+advance and then assert, with no additional waiting:
+
+```typescript sim-clock-session-expiry
+/**
+ * Advancing simulated time past a temporary session's expiry.
+ */
+
+import { CreateRoleCommand } from "@aws-sdk/client-iam";
+import { AssumeRoleCommand } from "@aws-sdk/client-sts";
+import { SimAws } from "@kensio/yulin";
+
+const simAws = new SimAws();
+const simIam = simAws.iam();
+
+await simIam.createRole(
+  new CreateRoleCommand({
+    RoleName: "ReportingRole",
+    AssumeRolePolicyDocument: JSON.stringify({
+      Version: "2012-10-17",
+      Statement: {
+        Effect: "Allow",
+        Principal: { AWS: `arn:aws:iam::${simAws.defaultAccountId}:root` },
+        Action: "sts:AssumeRole",
+      },
+    }),
+  }),
+);
+
+// A fifteen minute session.
+const assumeRoleOutput = await simAws.sts().assumeRole(
+  new AssumeRoleCommand({
+    RoleArn: `arn:aws:iam::${simAws.defaultAccountId}:role/ReportingRole`,
+    RoleSessionName: "reporting-session",
+    DurationSeconds: 900,
+  }),
+);
+
+const issued = assumeRoleOutput.Credentials!;
+const credentials = {
+  accessKeyId: issued.AccessKeyId!,
+  secretAccessKey: issued.SecretAccessKey!,
+  sessionToken: issued.SessionToken!,
+};
+
+// The session authenticates while it is current.
+console.log(simIam.credentials.resolveCredentials(credentials).principal);
+
+await simAws.clock().advanceBy({ minutes: 20 });
+
+try {
+  simIam.credentials.resolveCredentials(credentials);
+} catch (error) {
+  // Rejected as an expired session, twenty simulated minutes later.
+  console.log((error as Error).message);
+}
+```
+
+Work triggered by advancing that fails throws from `advanceBy(...)`, where the caller can see it.
+The clock is left at the point it failed, and anything still queued stays queued.
+
+Delivery to a target is the exception, and deliberately so. An EventBridge rule or a Scheduler
+schedule that cannot reach its target records the failure instead of throwing. Real AWS reports a
+failed delivery to nobody, and one rejected delivery would otherwise fail an unrelated
+`advanceBy(...)` elsewhere in the same test. Read the failures from `eventBridge().deliveryFailures`
+and `scheduler().deliveryFailures`.
+
+A Step Functions execution works the same way. A state that fails while the clock is being advanced
+is recorded on the execution, and `DescribeExecution` reports it once the advance has returned.
+
+Several parts of the simulator schedule work on the clock. Advancing time does more than change what
+timestamps and expiry checks see. A scheduled EventBridge rule fires, an EventBridge Scheduler
+schedule invokes its target, a DynamoDB item passes its time to live, a Secrets Manager deletion
+falls due, a Step Functions execution moves on from a `Wait` state, and a Lambda event source
+mapping polls again. Each of those runs at its own due instant inside the interval, in the order
+they fall due.
+
+## Time inside a simulated Lambda handler
+
+A simulated Lambda function runs on its simulation's clock, and that reaches the JavaScript clock
+the function code itself reads. `Date.now()` and `new Date()` inside a handler report simulated
+time. Code stamping an expiry or building a date-partitioned key can be tested against a clock the
+test controls:
+
+```typescript sim-clock-lambda-handler
+/**
+ * A simulated Lambda handler reading the simulation's clock.
+ */
+
+import { CreateFunctionCommand, InvokeCommand } from "@aws-sdk/client-lambda";
+
+import { SimAws, SimFixedClock } from "@kensio/yulin";
+import { makeLambdaZipFileInput } from "@kensio/yulin/lambda";
+
+const simAws = new SimAws({
+  clock: new SimFixedClock(new Date("2026-07-26T09:00:00.000Z")),
+});
+const lambda = simAws.lambda();
+
+await lambda.createFunction(
+  new CreateFunctionCommand({
+    FunctionName: "stamper",
+    Role: "arn:aws:iam::111111111111:role/StamperRole",
+    Code: {
+      // The handler asks JavaScript for the time, not the simulator.
+      ZipFile: makeLambdaZipFileInput(() => ({ at: new Date().toISOString() })),
+    },
+  }),
+);
+
+const first = await lambda.invoke(
+  new InvokeCommand({ FunctionName: "stamper" }),
+);
+console.log(Buffer.from(first.Payload!).toString()); // {"at":"2026-07-26T09:00:00.000Z"}
+
+await simAws.clock().advanceBy({ hours: 2 });
+
+const second = await lambda.invoke(
+  new InvokeCommand({ FunctionName: "stamper" }),
+);
+console.log(Buffer.from(second.Payload!).toString()); // {"at":"2026-07-26T11:00:00.000Z"}
+```
+
+How that is arranged depends on where the function code runs. One of the two touches a process
+global:
+
+- **Zip code** runs in a vm sandbox owning its own globals, and is handed a `Date` bound to the
+  simulation's clock. The globals outside the sandbox are left alone.
+- **A real in-process handler function** is a closure over the module scope it was written in, and
+  reads the global `Date` like everything else in the test run. So the global is substituted for one
+  reporting the invocation's clock while an invocation is running, and the host clock otherwise,
+  tracked with `AsyncLocalStorage` so concurrent invocations of different simulations stay apart. It
+  is installed on the first in-process invocation and never removed, and with no invocation running
+  it behaves exactly as the host's own `Date` does.
+
+Only the current time comes from the clock. `new Date("2020-03-12")`, `Date.parse(...)`,
+`Date.UTC(...)` and `instanceof Date` all behave as they always did.
+
+Under a frozen clock `Date.now()` returns the same number for the whole invocation, and handler code
+that waits for it to change never finishes. Call `resume()` before invoking if the code under test
+polls the clock.
+
+### Where real AWS gets the time
+
+Real Lambda has no current-time API. The context object carries no timestamp, only
+`getRemainingTimeInMillis()`, and no environment variable holds one. Handler code reading `new
+Date()` is reading the machine clock. AWS does provide the time on the event:
+
+| Event source              | Field                                             |
+| ------------------------- | ------------------------------------------------- |
+| EventBridge               | `time`                                            |
+| Function URL, API Gateway | `requestContext.timeEpoch`, `requestContext.time` |
+| S3 notification           | `Records[].eventTime`                             |
+| SNS                       | `Records[].Sns.Timestamp`                         |
+| SQS                       | `Records[].attributes.SentTimestamp`              |
+
+For a scheduled invocation AWS advises reading the event's `time` in preference to the system clock,
+because a retry or a delayed delivery runs later than the time the work was for. Simulated Lambda
+follows the same rule where it builds events. A Function URL request carries simulated time in
+`requestContext.time` and `requestContext.timeEpoch`.
+
+An SQS event source mapping does the same. The `SentTimestamp` and
+`ApproximateFirstReceiveTimestamp` attributes on a delivered record are simulated time, and a
+handler reading the event's time reads the clock the test controls. See
+[simulated Lambda](https://yulinsim.dev/services/lambda/#triggering-a-function-from-an-sqs-queue "Simulated Lambda event source mapping docs").
+
+Handler code that takes a clock as a dependency stays the most testable option, on real AWS and
+here, and needs none of the machinery above.
+
+## Time over HTTP
+
+A simulation served over HTTP, through `serveSimAws` or `SimAwsHttp.fetch(...)`, stamps every
+response with simulated time in its `Date` header, as real AWS stamps every API response with server
+time. Advancing the clock changes what that header reports. A client talking to the simulation sees
+the same "now" the simulation does, with no need to know it is talking to a simulator.
+
+## Time and SDK interception
+
+A `SimSdk` owns a simulated AWS environment, available as `simSdk.simAws`. Intercepted SDK code runs
+on a clock a test can control with `await simSdk.simAws.clock().advanceBy({ hours: 1 })`.
+
+## Limitations
+
+- Advancing the clock is the only thing that fires a scheduled
+  [EventBridge rule](https://yulinsim.dev/services/eventbridge/#rules-that-fire-on-a-schedule). Nothing runs on the
+  host's clock. A simulation left alone in real time fires nothing however long it is left.
+- Advancing the clock is also the only thing that fires an
+  [EventBridge Scheduler schedule](https://yulinsim.dev/services/scheduler/#firing-a-schedule), including a one-time
+  `at(...)` one.
+- Only `SimAws` exposes time control. Services constructed standalone, such as `new SimS3()`, get
+  their own real clock and no way to move it.
+- A `SimAws` constructed with a `background` scheduler of its own cannot control time, because that
+  scheduler brings its own clock. `simAws.clock()` throws a diagnostic error saying so.
+- Simulated time reaches JavaScript's own clock inside a simulated Lambda invocation, and nowhere
+  else. `Date.now()` and `new Date()` in code under test that is not running as a simulated Lambda
+  function still report real time.
+- Timers are not simulated. `setTimeout` inside a handler is a host timer. A sleeping handler waits
+  in real time, and advancing the clock leaves it asleep.
+- A time already read cannot be reached. A handler module doing `const startedAt = Date.now()` at
+  module scope read it when the test file imported the module, long before any invocation.
+- Advancing time does not re-evaluate simulated state that was already computed, such as an ACM
+  certificate that has finished validating. It changes what is read from the clock next.

package/llms.txt

@@ -0,0 +1,59 @@
+# Yulin
+
+> AWS system behaviour simulation for isolated unit testing.
+
+The pages below ship with the package as markdown, and they document the version
+installed. Paths are relative to the package root, which an installed project
+has at `node_modules/@kensio/yulin/`.
+
+The same pages are on the web at https://yulinsim.dev/ for whichever release is current.
+
+## Service documentation
+
+- [ACM](docs/services/acm/README.md): Simulated ACM usage docs
+- [API Gateway HTTP APIs](docs/services/apigatewayv2/README.md): Simulated API Gateway HTTP API usage docs
+- [API Gateway REST APIs](docs/services/apigateway/README.md): Simulated API Gateway REST API usage docs
+- [Athena](docs/services/athena/README.md): Simulated Amazon Athena usage docs
+- [Bedrock](docs/services/bedrock/README.md): Simulated Amazon Bedrock usage docs
+- [CloudFormation](docs/services/cloudformation/README.md): Simulated CloudFormation usage docs
+- [CloudFront](docs/services/cloudfront/README.md): Simulated CloudFront usage docs
+- [CloudWatch metrics](docs/services/cloudwatch/README.md): Simulated CloudWatch metrics usage docs
+- [Cognito user pools](docs/services/cognito/README.md): Simulated Cognito user pools usage docs
+- [DynamoDB](docs/services/dynamodb/README.md): Simulated DynamoDB usage docs
+- [ECR](docs/services/ecr/README.md): Simulated ECR usage docs
+- [ECS](docs/services/ecs/README.md): Simulated ECS usage docs
+- [Elastic Load Balancing](docs/services/elbv2/README.md): Simulated Application Load Balancer usage docs
+- [EventBridge](docs/services/eventbridge/README.md): Simulated EventBridge usage docs
+- [Glue](docs/services/glue/README.md): Simulated Glue Data Catalog usage docs
+- [IAM](docs/services/iam/README.md): Simulated IAM usage docs
+- [Kinesis Data Firehose](docs/services/firehose/README.md): Simulated Kinesis Data Firehose usage docs
+- [Kinesis Data Streams](docs/services/kinesis/README.md): Simulated Kinesis Data Streams usage docs
+- [KMS](docs/services/kms/README.md): Simulated KMS usage docs
+- [Lambda](docs/services/lambda/README.md): Simulated Lambda usage docs
+- [CloudWatch Logs](docs/services/logs/README.md): Simulated CloudWatch Logs usage docs
+- [Organizations](docs/services/organizations/README.md): Simulated Organizations service control policies usage docs
+- [Personalize](docs/services/personalize/README.md): Simulated Amazon Personalize usage docs
+- [Rekognition](docs/services/rekognition/README.md): Simulated Rekognition usage docs
+- [Route53](docs/services/route53/README.md): Simulated Route53 usage docs
+- [S3](docs/services/s3/README.md): Simulated S3 usage docs
+- [Scheduler](docs/services/scheduler/README.md): Simulated EventBridge Scheduler usage docs
+- [Secrets Manager](docs/services/secretsmanager/README.md): Simulated Secrets Manager usage docs
+- [SES](docs/services/ses/README.md): Simulated SES usage docs
+- [SNS](docs/services/sns/README.md): Simulated SNS usage docs
+- [SQS](docs/services/sqs/README.md): Simulated SQS usage docs
+- [SSM Parameter Store](docs/services/ssm/README.md): Simulated SSM Parameter Store usage docs
+- [Step Functions](docs/services/stepfunctions/README.md): Simulated Step Functions usage docs
+- [STS](docs/services/sts/README.md): Simulated STS usage docs
+- [WAFv2](docs/services/wafv2/README.md): Simulated WAFv2 usage docs
+
+## Feature documentation
+
+- [AI skill](docs/ai-skill/README.md): Yulin AI skill usage docs
+- [The AWS CLI](docs/cli/README.md): The AWS CLI against simulated AWS usage docs
+- [AWS SDK interception](docs/sdk/README.md): Simulated AWS SDK usage docs
+- [Event factories](docs/factories/README.md): Test factories for AWS event shapes usage docs
+- [Linting CloudFront Functions JS2](docs/lint/README.md): CloudFront Functions JS2 lint config usage docs
+- [Non-AWS dependencies](docs/non-aws-dependencies/README.md): Dependencies Yulin does not simulate usage docs
+- [Serving on localhost](docs/serve/README.md): Serving simulated AWS on localhost usage docs
+- [Simulated time](docs/time/README.md): Simulated time usage docs
+- [Terraform](docs/terraform/README.md): Deploying Terraform into simulated AWS usage docs

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kensio/yulin",
-  "version": "1.20.15",
+  "version": "1.20.17",
   "description": "AWS system behaviour simulation for isolated unit testing",
   "repository": "https://github.com/KensioSoftware/yulin",
   "homepage": "https://yulinsim.dev/",
@@ -11,9 +11,10 @@
     "yulin": "./dist/cli/yulin.js"
   },
   "scripts": {
-    "clean": "rm -rf ./dist/ ./*.tsbuildinfo ./cffjs2.oxlintrc.json",
-    "build": "pnpm clean && tsc -p tsconfig.build.json && pnpm oxlint:config",
+    "clean": "rm -rf ./dist/ ./*.tsbuildinfo ./cffjs2.oxlintrc.json ./llms.txt",
+    "build": "pnpm clean && tsc -p tsconfig.build.json && pnpm oxlint:config && pnpm docs:index",
     "oxlint:config": "pnpm tsx scripts/mts/write-oxlint-config.mts",
+    "docs:index": "pnpm tsx scripts/mts/write-llms-index.mts",
     "build:check": "tsc -p tsconfig.json --noEmit",
     "prepack": "pnpm build",
     "verify:pack": "pnpm tsx scripts/mts/verify-pack.mts",
@@ -27,7 +28,7 @@
     "examples:tsc": "tsc -p docs/tsconfig.json",
     "examples:tsc:cdk": "tsc -p docs/tsconfig.cdk.json",
     "examples:lint": "oxlint --type-aware --max-warnings=0 docs",
-    "examples:check": "pnpm examples:extract && pnpm examples:tsc && pnpm examples:tsc:cdk && pnpm examples:lint",
+    "examples:check": "pnpm docs:index && pnpm examples:extract && pnpm examples:tsc && pnpm examples:tsc:cdk && pnpm examples:lint",
     "fta": "./scripts/sh/fta.sh",
     "check": "pnpm fmt && pnpm fta && pnpm build:check && pnpm examples:check && pnpm test:coverage",
     "tf:init": "./scripts/sh/tf-init.sh"
@@ -213,7 +214,9 @@
   },
   "files": [
     "dist",
+    "docs/**/README.md",
     "cffjs2.oxlintrc.json",
+    "llms.txt",
     "README.md",
     "LICENSE"
   ],

package/dist/service/stepfunctions/command/machine/sim-state-machine-writes.d.ts

@@ -1,25 +0,0 @@
-import type { BackgroundScheduler } from "../../../../util/background/background.js";
-import type { SimStatesExecutionStore } from "../../execution/sim-states-execution-store.js";
-import type { SimStateMachineStore } from "../../machine/sim-state-machine-store.js";
-import type { SimDeleteStateMachineCommand, SimDeleteStateMachineCommandOutput, SimUpdateStateMachineCommand, SimUpdateStateMachineCommandOutput } from "./machine.command.js";
-interface SimStateMachineWritesProperties {
-    readonly stateMachines: SimStateMachineStore;
-    readonly executions: SimStatesExecutionStore;
-    readonly background: BackgroundScheduler;
-}
-/**
- * The commands that change and delete state machines.
- */
-export declare class SimStateMachineWrites {
-    #private;
-    constructor(properties: SimStateMachineWritesProperties);
-    /**
-     * Change a state machine's definition or role.
-     */
-    update(command: SimUpdateStateMachineCommand): SimUpdateStateMachineCommandOutput;
-    /**
-     * Delete a state machine and forget its executions.
-     */
-    delete(command: SimDeleteStateMachineCommand): SimDeleteStateMachineCommandOutput;
-}
-export {};