@kensio/yulin 1.21.6 → 1.21.7

package/dist/service/eventbridge/cfn/bus/sim-cfn-event-bus-creator.js

@@ -24,6 +24,7 @@ export class SimCfnEventBusCreator {
             properties,
         });
         busProperties.refuseUnsimulated();
+        busProperties.recordIgnoredProperties();
         const name = busProperties.name();
         const description = busProperties.description();
         return await simCfnEventBridgeResourceCreation(eventBusResourceType, resource.logicalId, async () => {

package/dist/service/eventbridge/cfn/bus/sim-cfn-event-bus-properties.d.ts

@@ -27,6 +27,10 @@ export declare class SimCfnEventBusProperties {
      * Refuse what this simulation does not model, naming the property.
      */
     refuseUnsimulated(): void;
+    /**
+     * Record the properties the bus is created without acting on.
+     */
+    recordIgnoredProperties(): void;
     private propertyError;
 }
 export {};

package/dist/service/eventbridge/cfn/bus/sim-cfn-event-bus-properties.js

@@ -19,8 +19,23 @@ const unsimulatedProperties = [
     ["EventSourceName", "partner event buses are not simulated"],
     ["KmsKeyIdentifier", "events are not encrypted with a customer managed key"],
     ["LogConfig", "event bus logging is not simulated"],
-    ["Tags", "event bus tags are not simulated"],
 ];
+/**
+ * What a template can say about an event bus that this simulation has nothing
+ * to act on, and why.
+ *
+ * `Tags` is the whole list, and it is recorded rather than refused. A bus
+ * behaves the same way with a tag and without one, and a CDK app calling
+ * `Tags.of(app).add(...)` tags every bus in it.
+ */
+const ignoredPropertyReasons = new Map([
+    [
+        "Tags",
+        `${eventBusResourceType} property Tags is not simulated, so the bus is ` +
+            "created without them. Nothing reads them back and nothing is grouped " +
+            "or billed by them.",
+    ],
+]);
 /**
  * Reads AWS::Events::EventBus properties into the shape CreateEventBus takes.
  */
@@ -71,6 +86,16 @@ export class SimCfnEventBusProperties {
             }
         }
     }
+    /**
+     * Record the properties the bus is created without acting on.
+     */
+    recordIgnoredProperties() {
+        for (const [property, reason] of ignoredPropertyReasons) {
+            if (this.properties.has(property)) {
+                this.resource.ignoreProperty(property, reason);
+            }
+        }
+    }
     propertyError(reason) {
         return simCfnEventBridgeResourceError(eventBusResourceType, this.resource.logicalId, reason);
     }

package/dist/service/eventbridge/cfn/rule/sim-cfn-event-rule-creator.js

@@ -2,6 +2,7 @@ import { assertDefined } from "../../../../util/type-guard/defined.js";
 import { simCfnEventBridgeResourceCreation } from "../sim-cfn-event-bridge-resource-error.js";
 import { eventRuleResourceType } from "../sim-cfn-event-bridge-resource-types.js";
 import { SimCfnEventRuleProperties } from "./sim-cfn-event-rule-properties.js";
+import { recordIgnoredEventRuleProperties, refuseUnsimulatedEventRuleProperties, } from "./sim-cfn-event-rule-unsimulated-properties.js";
 /**
  * Creates simulated rules from AWS::Events::Rule Resources.
  *
@@ -27,7 +28,8 @@ export class SimCfnEventRuleCreator {
             resource,
             properties,
         });
-        ruleProperties.refuseUnsimulated();
+        refuseUnsimulatedEventRuleProperties(resource, properties);
+        recordIgnoredEventRuleProperties(resource, properties);
         const name = ruleProperties.name();
         const busName = ruleProperties.busName();
         const targets = ruleProperties.targets();

package/dist/service/eventbridge/cfn/rule/sim-cfn-event-rule-properties.d.ts

@@ -48,13 +48,6 @@ export declare class SimCfnEventRuleProperties {
      * The rule's inline targets.
      */
     targets(): readonly SimCfnEventRuleTarget[];
-    /**
-     * Refuse what this simulation does not model, naming the property.
-     *
-     * Both are asked by key rather than by value, so a template writing `null`
-     * for one is refused rather than read as having left it out.
-     */
-    refuseUnsimulated(): void;
     private stringProperty;
     private propertyError;
 }

package/dist/service/eventbridge/cfn/rule/sim-cfn-event-rule-properties.js

@@ -89,26 +89,6 @@ export class SimCfnEventRuleProperties {
     targets() {
         return simCfnEventRuleTargets(this.properties.get("Targets"), (reason) => this.propertyError(reason));
     }
-    /**
-     * Refuse what this simulation does not model, naming the property.
-     *
-     * Both are asked by key rather than by value, so a template writing `null`
-     * for one is refused rather than read as having left it out.
-     */
-    refuseUnsimulated() {
-        if (this.properties.has("RoleArn")) {
-            throw this.propertyError("RoleArn is not simulated, so the Resource is refused rather than " +
-                "deployed without it: a rule reaches its target as the EventBridge " +
-                "service principal, admitted by the target's own resource policy");
-        }
-        // Rule tags never reach PutRule, which is the one place that would
-        // otherwise refuse them, so a tagged rule would deploy and quietly lose
-        // its tags.
-        if (this.properties.has("Tags")) {
-            throw this.propertyError("Tags are not simulated, so the Resource is refused rather than " +
-                "deployed without them");
-        }
-    }
     stringProperty(name) {
         const value = this.properties.get(name);
         if (value === undefined) {

package/dist/service/eventbridge/cfn/rule/sim-cfn-event-rule-unsimulated-properties.d.ts

@@ -0,0 +1,13 @@
+import type { SimCfnResource } from "../../../cloudformation/resource/sim-cfn-resource.js";
+import type { SimCfnTemplateValueRecord } from "../../../cloudformation/template/value/sim-cfn-template-value.js";
+/**
+ * Refuse what this simulation does not model, naming the property.
+ *
+ * Asked by key rather than by value, so a template writing `null` for one of
+ * these is refused rather than read as having left it out.
+ */
+export declare function refuseUnsimulatedEventRuleProperties(resource: SimCfnResource, properties: SimCfnTemplateValueRecord): void;
+/**
+ * Record the properties the rule is created without acting on.
+ */
+export declare function recordIgnoredEventRuleProperties(resource: SimCfnResource, properties: SimCfnTemplateValueRecord): void;

package/dist/service/eventbridge/cfn/rule/sim-cfn-event-rule-unsimulated-properties.js

@@ -0,0 +1,59 @@
+import { simCfnEventBridgeResourceError } from "../sim-cfn-event-bridge-resource-error.js";
+import { eventRuleResourceType } from "../sim-cfn-event-bridge-resource-types.js";
+/**
+ * What a template can say about a rule that this simulation does not model,
+ * and why each one fails the Resource.
+ *
+ * `RoleArn` is the whole list. A rule reaches its target as the EventBridge
+ * service principal, admitted by the target's own resource policy, so a rule
+ * deployed with a role would sit in a test looking as though the role decided
+ * something.
+ */
+const refusedPropertyReasons = new Map([
+    [
+        "RoleArn",
+        "RoleArn is not simulated, so the Resource is refused rather than " +
+            "deployed without it: a rule reaches its target as the EventBridge " +
+            "service principal, admitted by the target's own resource policy",
+    ],
+]);
+/**
+ * What a template can say about a rule that this simulation has nothing to act
+ * on, and why each one is recorded rather than refused.
+ *
+ * `Tags` is the whole list. Rule tags never reach `PutRule`, so the record is
+ * the only place a tagged rule says it lost them. A rule routes the same
+ * events with a tag and without one, and a CDK app calling
+ * `Tags.of(app).add(...)` tags every rule in it.
+ */
+const ignoredPropertyReasons = new Map([
+    [
+        "Tags",
+        `${eventRuleResourceType} property Tags is not simulated, so the rule is ` +
+            "created without them. Nothing reads them back and nothing is grouped " +
+            "or billed by them.",
+    ],
+]);
+/**
+ * Refuse what this simulation does not model, naming the property.
+ *
+ * Asked by key rather than by value, so a template writing `null` for one of
+ * these is refused rather than read as having left it out.
+ */
+export function refuseUnsimulatedEventRuleProperties(resource, properties) {
+    for (const [property, reason] of refusedPropertyReasons) {
+        if (Object.hasOwn(properties, property)) {
+            throw simCfnEventBridgeResourceError(eventRuleResourceType, resource.logicalId, reason);
+        }
+    }
+}
+/**
+ * Record the properties the rule is created without acting on.
+ */
+export function recordIgnoredEventRuleProperties(resource, properties) {
+    for (const [property, reason] of ignoredPropertyReasons) {
+        if (Object.hasOwn(properties, property)) {
+            resource.ignoreProperty(property, reason);
+        }
+    }
+}

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

@@ -15,7 +15,7 @@ export declare function simCfnEventBridgeResourceError(resourceType: string, log
  * Every Resource type here goes through the ordinary EventBridge commands, so
  * what a template may ask for is decided once, by simulated EventBridge, rather
  * than again in the CloudFormation layer. What that leaves out is where the
- * request came from: a deployment failing with `Rule tags are not simulated`
+ * request came from: a deployment failing with `Rule pattern is not valid`
  * says nothing about which Resource asked for it. Only EventBridge's own errors
  * are renamed, so a refusal the CloudFormation layer decided keeps the wording
  * it was written with.

package/dist/service/eventbridge/cfn/sim-cfn-event-bridge-resource-error.js

@@ -20,7 +20,7 @@ export function simCfnEventBridgeResourceError(resourceType, logicalId, reason,
  * Every Resource type here goes through the ordinary EventBridge commands, so
  * what a template may ask for is decided once, by simulated EventBridge, rather
  * than again in the CloudFormation layer. What that leaves out is where the
- * request came from: a deployment failing with `Rule tags are not simulated`
+ * request came from: a deployment failing with `Rule pattern is not valid`
  * says nothing about which Resource asked for it. Only EventBridge's own errors
  * are renamed, so a refusal the CloudFormation layer decided keeps the wording
  * it was written with.

package/dist/service/lambda/cfn/event-source-mapping/sim-cfn-lambda-event-source-mapping-properties.js

@@ -31,7 +31,7 @@ export class SimCfnLambdaEventSourceMappingProperties {
      */
     createInput() {
         const eventSourceArn = this.parser.requiredString(this.resource, this.properties["EventSourceArn"], "EventSourceArn");
-        assertSimulatedEventSourceMappingProperties(this.resource.logicalId, this.properties);
+        assertSimulatedEventSourceMappingProperties(this.resource, this.properties);
         return {
             EventSourceArn: eventSourceArn,
             FunctionName: simCfnLambdaTargetFunctionName(this.parser.requiredString(this.resource, this.properties["FunctionName"], "FunctionName")),

package/dist/service/lambda/cfn/event-source-mapping/sim-cfn-lambda-event-source-mapping-property-rules.d.ts

@@ -1,3 +1,4 @@
+import type { SimCfnResource } from "../../../cloudformation/resource/sim-cfn-resource.js";
 import type { SimCfnTemplateValueRecord } from "../../../cloudformation/template/value/sim-cfn-template-value.js";
 /**
  * Build the error a property of an AWS::Lambda::EventSourceMapping Resource is
@@ -11,6 +12,6 @@ import type { SimCfnTemplateValueRecord } from "../../../cloudformation/template
 export declare function eventSourceMappingPropertyError(logicalId: string, reason: string): Error;
 /**
  * Refuse everything about an AWS::Lambda::EventSourceMapping Resource that is
- * not simulated.
+ * not simulated, and record what the mapping is created without.
  */
-export declare function assertSimulatedEventSourceMappingProperties(logicalId: string, properties: SimCfnTemplateValueRecord): void;
+export declare function assertSimulatedEventSourceMappingProperties(resource: SimCfnResource, properties: SimCfnTemplateValueRecord): void;

package/dist/service/lambda/cfn/event-source-mapping/sim-cfn-lambda-event-source-mapping-property-rules.js

@@ -44,10 +44,26 @@ const unsimulatedPropertyNames = new Set([
     "SelfManagedEventSource",
     "SelfManagedKafkaEventSourceConfig",
     "SourceAccessConfigurations",
-    "Tags",
     "Topics",
     "TumblingWindowInSeconds",
 ]);
+/**
+ * Real AWS::Lambda::EventSourceMapping properties this simulation has nothing
+ * to act on and no reason to fail a stack over.
+ *
+ * `Tags` is the whole list. The mapping is created without them and the
+ * omission is recorded against the Resource. A mapping delivers the same
+ * records with a tag and without one, and a CDK app calling
+ * `Tags.of(app).add(...)` tags every mapping in it.
+ */
+const ignoredPropertyReasons = new Map([
+    [
+        "Tags",
+        "AWS::Lambda::EventSourceMapping property Tags is not simulated, so the " +
+            "mapping is created without them. Nothing reads them back and nothing " +
+            "is grouped or billed by them.",
+    ],
+]);
 /**
  * Build the error a property of an AWS::Lambda::EventSourceMapping Resource is
  * refused with.
@@ -62,10 +78,16 @@ export function eventSourceMappingPropertyError(logicalId, reason) {
 }
 /**
  * Refuse everything about an AWS::Lambda::EventSourceMapping Resource that is
- * not simulated.
+ * not simulated, and record what the mapping is created without.
  */
-export function assertSimulatedEventSourceMappingProperties(logicalId, properties) {
+export function assertSimulatedEventSourceMappingProperties(resource, properties) {
+    const logicalId = resource.logicalId;
     for (const name of Object.keys(properties)) {
+        const ignoredReason = ignoredPropertyReasons.get(name);
+        if (ignoredReason !== undefined) {
+            resource.ignoreProperty(name, ignoredReason);
+            continue;
+        }
         if (unsimulatedPropertyNames.has(name)) {
             throw eventSourceMappingPropertyError(logicalId, `${name} is a real AWS::Lambda::EventSourceMapping property that ` +
                 "this simulation does not simulate, so it is refused rather than " +

package/dist/service/sns/cfn/topic/sim-cfn-sns-topic-creator.js

@@ -23,6 +23,7 @@ export class SimCfnSnsTopicCreator {
             resource,
             properties,
         });
+        topicProperties.recordIgnoredProperties();
         const name = topicProperties.name();
         const attributes = topicProperties.attributes();
         const inline = topicProperties.inlineSubscriptions();

package/dist/service/sns/cfn/topic/sim-cfn-sns-topic-properties.d.ts

@@ -43,13 +43,18 @@ export declare class SimCfnSnsTopicProperties {
      * The subscriptions the topic declares inside itself.
      */
     inlineSubscriptions(): readonly SimCfnSnsInlineSubscription[];
+    /**
+     * Record the properties the topic is created without acting on.
+     */
+    recordIgnoredProperties(): void;
     /**
      * Whether a property is handed to CreateTopic as an attribute.
      *
-     * The two properties the CloudFormation layer reads itself are not. The rest
-     * are refused as they are reached: the ones with a reason of their own with
-     * that reason, and anything else as a property AWS::SNS::Topic does not have,
-     * which is how real CloudFormation answers one too.
+     * The two properties the CloudFormation layer reads itself are not, and
+     * neither are the ones recorded as ignored. The rest are refused as they are
+     * reached: the ones with a reason of their own with that reason, and
+     * anything else as a property AWS::SNS::Topic does not have, which is how
+     * real CloudFormation answers one too.
      */
     private isAttributeProperty;
     private propertyError;

package/dist/service/sns/cfn/topic/sim-cfn-sns-topic-properties.js

@@ -3,7 +3,7 @@ import { simCfnSnsResourceError } from "../sim-cfn-sns-resource-error.js";
 import { snsTopicResourceType } from "../sim-cfn-sns-resource-types.js";
 import { simCfnSnsInlineSubscriptions, } from "./sim-cfn-sns-inline-subscriptions.js";
 import { SimCfnSnsTopicName } from "./sim-cfn-sns-topic-name.js";
-import { attributePropertyNames, topicNamePropertyName, topicSubscriptionPropertyName, unsimulatedPropertyReasons, } from "./sim-cfn-sns-topic-property-names.js";
+import { attributePropertyNames, ignoredPropertyReasons, topicNamePropertyName, topicSubscriptionPropertyName, unsimulatedPropertyReasons, } from "./sim-cfn-sns-topic-property-names.js";
 /**
  * Reads AWS::SNS::Topic CloudFormation properties into the shape CreateTopic
  * takes.
@@ -63,17 +63,29 @@ export class SimCfnSnsTopicProperties {
     inlineSubscriptions() {
         return simCfnSnsInlineSubscriptions(this.resource.logicalId, this.properties.get(topicSubscriptionPropertyName));
     }
+    /**
+     * Record the properties the topic is created without acting on.
+     */
+    recordIgnoredProperties() {
+        for (const [property, reason] of ignoredPropertyReasons) {
+            if (this.properties.has(property)) {
+                this.resource.ignoreProperty(property, reason);
+            }
+        }
+    }
     /**
      * Whether a property is handed to CreateTopic as an attribute.
      *
-     * The two properties the CloudFormation layer reads itself are not. The rest
-     * are refused as they are reached: the ones with a reason of their own with
-     * that reason, and anything else as a property AWS::SNS::Topic does not have,
-     * which is how real CloudFormation answers one too.
+     * The two properties the CloudFormation layer reads itself are not, and
+     * neither are the ones recorded as ignored. The rest are refused as they are
+     * reached: the ones with a reason of their own with that reason, and
+     * anything else as a property AWS::SNS::Topic does not have, which is how
+     * real CloudFormation answers one too.
      */
     isAttributeProperty(name) {
         if (name === topicNamePropertyName ||
-            name === topicSubscriptionPropertyName) {
+            name === topicSubscriptionPropertyName ||
+            ignoredPropertyReasons.has(name)) {
             return false;
         }
         if (attributePropertyNames.has(name)) {

package/dist/service/sns/cfn/topic/sim-cfn-sns-topic-property-names.d.ts

@@ -28,3 +28,13 @@ export declare const attributePropertyNames: ReadonlySet<string>;
  * become fifteen separate attributes.
  */
 export declare const unsimulatedPropertyReasons: ReadonlyMap<string, string>;
+/**
+ * The real AWS::SNS::Topic properties this simulation has nothing to act on
+ * and no reason to fail a stack over.
+ *
+ * `Tags` is the whole list. The topic is created without them and the omission
+ * is recorded against the Resource. A topic behaves the same way with a tag
+ * and without one, and a CDK app calling `Tags.of(app).add(...)` tags every
+ * topic in it.
+ */
+export declare const ignoredPropertyReasons: ReadonlyMap<string, string>;

package/dist/service/sns/cfn/topic/sim-cfn-sns-topic-property-names.js

@@ -47,5 +47,20 @@ export const unsimulatedPropertyReasons = new Map([
         "DeliveryStatusLogging",
         "delivery status logging writes to CloudWatch Logs, which is not simulated",
     ],
-    ["Tags", "no simulated service reads a topic tag"],
+]);
+/**
+ * The real AWS::SNS::Topic properties this simulation has nothing to act on
+ * and no reason to fail a stack over.
+ *
+ * `Tags` is the whole list. The topic is created without them and the omission
+ * is recorded against the Resource. A topic behaves the same way with a tag
+ * and without one, and a CDK app calling `Tags.of(app).add(...)` tags every
+ * topic in it.
+ */
+export const ignoredPropertyReasons = new Map([
+    [
+        "Tags",
+        "AWS::SNS::Topic property Tags is not simulated, so the topic is created " +
+            "without them. No simulated service reads a topic tag.",
+    ],
 ]);

package/dist/service/ssm/cfn/parameter/sim-cfn-ssm-parameter-creator.js

@@ -28,6 +28,7 @@ export class SimCfnSsmParameterCreator {
             properties,
         });
         const name = parameterProperties.name();
+        parameterProperties.recordIgnoredTags();
         await this.ssm.putParameter({
             input: {
                 Name: name,
@@ -38,7 +39,6 @@ export class SimCfnSsmParameterCreator {
                 AllowedPattern: parameterProperties.allowedPattern(),
                 DataType: parameterProperties.dataType(),
                 Policies: parameterProperties.policies(),
-                Tags: parameterProperties.tags(),
             },
         }, options);
         const parameter = this.ssm.findParameter(name);

package/dist/service/ssm/cfn/parameter/sim-cfn-ssm-parameter-properties.d.ts

@@ -1,6 +1,5 @@
 import type { SimCfnResource } from "../../../cloudformation/resource/sim-cfn-resource.js";
 import type { SimCfnTemplateValueRecord } from "../../../cloudformation/template/value/sim-cfn-template-value.js";
-import type { SimSsmTag } from "../../command/parameter/parameter.command.js";
 interface SimCfnSsmParameterPropertiesProperties {
     readonly resource: SimCfnResource;
     readonly properties: SimCfnTemplateValueRecord;
@@ -60,13 +59,19 @@ export declare class SimCfnSsmParameterProperties {
      */
     policies(): string | undefined;
     /**
-     * The parameter Tags, which PutParameter refuses.
+     * Record the tags the parameter is written without.
      *
-     * CloudFormation carries these as a map of names to values for this
-     * Resource type, rather than the list of Key/Value pairs most Resource
-     * types use, so they are turned into the list shape PutParameter takes.
+     * `Tags` is the one difference from `PutParameter`, which refuses it
+     * outright. A template's tags are usually the whole stack's, and a CDK app
+     * calling `Tags.of(app).add(...)` tags every parameter in it. The parameter
+     * holds the same value either way, so the deploy stands and the omission is
+     * recorded.
+     *
+     * The shape is still read, because CloudFormation carries these as a map of
+     * names to values for this Resource type and a template AWS refuses should
+     * not deploy here.
      */
-    tags(): readonly SimSsmTag[] | undefined;
+    recordIgnoredTags(): void;
     private string;
     private stringValue;
     private propertyError;

package/dist/service/ssm/cfn/parameter/sim-cfn-ssm-parameter-properties.js

@@ -88,23 +88,32 @@ export class SimCfnSsmParameterProperties {
         return this.string(this.properties["Policies"], "Policies");
     }
     /**
-     * The parameter Tags, which PutParameter refuses.
+     * Record the tags the parameter is written without.
      *
-     * CloudFormation carries these as a map of names to values for this
-     * Resource type, rather than the list of Key/Value pairs most Resource
-     * types use, so they are turned into the list shape PutParameter takes.
+     * `Tags` is the one difference from `PutParameter`, which refuses it
+     * outright. A template's tags are usually the whole stack's, and a CDK app
+     * calling `Tags.of(app).add(...)` tags every parameter in it. The parameter
+     * holds the same value either way, so the deploy stands and the omission is
+     * recorded.
+     *
+     * The shape is still read, because CloudFormation carries these as a map of
+     * names to values for this Resource type and a template AWS refuses should
+     * not deploy here.
      */
-    tags() {
+    recordIgnoredTags() {
         const tags = this.properties["Tags"];
         if (tags === undefined) {
-            return undefined;
+            return;
         }
         if (typeof tags !== "object" || tags === null || Array.isArray(tags)) {
             throw this.propertyError("Tags must be an object");
         }
-        return Object.entries(tags).map(([key, value]) => {
-            return { Key: key, Value: this.stringValue(value, `Tags.${key}`) };
-        });
+        for (const [key, value] of Object.entries(tags)) {
+            this.stringValue(value, `Tags.${key}`);
+        }
+        this.resource.ignoreProperty("Tags", "AWS::SSM::Parameter property Tags is not simulated, so the parameter " +
+            "is written without them. Nothing reads them back and no " +
+            "aws:ResourceTag condition key matches them.");
     }
     string(value, name) {
         if (value === undefined) {

package/docs/README.md

@@ -1,7 +1,36 @@
-# Simulated AWS usage documentation
+# Yulin documentation
 
-This directory contains area-specific documentation for Yulin. Each page explains the simulated
-behaviour and includes example code that can be copied into tests or local development scripts.
+Yulin runs simulated AWS services inside a Node.js process. Tests can use AWS SDK clients,
+CloudFormation templates, or direct service calls without connecting to AWS. Each `SimAws` instance
+holds its own state in memory.
+
+Yulin implements selected AWS behaviour. The service pages describe what each simulation supports
+and where it differs from AWS.
+
+## Install Yulin
+
+```bash
+npm install --save-dev @kensio/yulin
+```
+
+## Choose how to use Yulin
+
+Start with [AWS SDK interception](https://yulinsim.dev/sdk/) when the code under test already uses an
+AWS SDK client. Yulin intercepts the client's `send` calls and returns responses from a simulated
+service. The application code continues to use the AWS SDK normally.
+
+Use [event factories](https://yulinsim.dev/factories/) when a test calls a handler directly and only
+needs an AWS event object. The factories fill in fields that the test does not care about.
+
+Use [CloudFormation](https://yulinsim.dev/services/cloudformation/) to build a simulation from a
+template. This also works with templates synthesized by AWS CDK and AWS SAM.
+
+Use the [localhost server](https://yulinsim.dev/serve/) when the code runs in another process or
+sends HTTP requests. The [AWS CLI guide](https://yulinsim.dev/cli/) explains how to point AWS CLI
+commands at the same endpoint.
+
+Read [simulated time](https://yulinsim.dev/time/) when a test needs to advance a schedule, expire a
+credential, or run other work that depends on time passing.
 
 ## Service documentation
 
@@ -42,7 +71,7 @@ behaviour and includes example code that can be copied into tests or local devel
 - [STS](https://yulinsim.dev/services/sts/ "Simulated STS usage docs")
 - [WAFv2](https://yulinsim.dev/services/wafv2/ "Simulated WAFv2 usage docs")
 
-## Feature documentation
+## Feature guides
 
 - [AI skill](https://yulinsim.dev/ai-skill/ "Yulin AI skill usage docs")
 - [The AWS CLI](https://yulinsim.dev/cli/ "The AWS CLI against simulated AWS usage docs")