@kensio/yulin 1.20.15 → 1.20.17

package/dist/service/cloudformation/stack/deploy/sim-cfn-stack-resource-batch-creator.d.ts

@@ -3,12 +3,14 @@ import type { SimAwsCaller } from "../../../aws/caller/sim-aws-caller.js";
 import type { SimCfnBinding } from "../../bind/sim-cfn-binding.js";
 import type { SimCdkOutContext } from "../../cdk/sim-cdk-out-context.js";
 import type { SimCfnResource } from "../../resource/sim-cfn-resource.js";
+import { type SimCfnResourceOrder } from "./sim-cfn-resource-order.js";
 interface SimCfnStackResourceBatchCreatorProperties {
     readonly simAws: SimAws;
     readonly resources: ReadonlyMap<string, SimCfnResource>;
     readonly cdkOutContext?: SimCdkOutContext | undefined;
     readonly bindings?: readonly SimCfnBinding[] | undefined;
     readonly caller?: SimAwsCaller | undefined;
+    readonly resourceOrder?: SimCfnResourceOrder | undefined;
 }
 /**
  * Creates one dependency-ready batch of Stack Resources.
@@ -17,6 +19,7 @@ interface SimCfnStackResourceBatchCreatorProperties {
  * class owns only the batch execution details:
  *
  * - create all Resources in the batch in parallel
+ * - start them in the order the deployment asked for
  * - pass the shared Stack creation context to each Resource
  *
  * It does not choose which Resources are ready, retry incomplete Resources, or
@@ -30,12 +33,16 @@ export declare class SimCfnStackResourceBatchCreator {
     private readonly cdkOutContext;
     private readonly bindings;
     private readonly caller;
+    private readonly resourceOrder;
     constructor(properties: SimCfnStackResourceBatchCreatorProperties);
     /**
      * Create the supplied Resources concurrently.
      *
      * Each Resource still owns its own create lifecycle and status transitions.
      * This method only waits for the batch to settle.
+     *
+     * Nothing in the batch depends on anything else in it, so the order they
+     * start in is the deployment's to choose.
      */
     create(resources: readonly SimCfnResource[]): Promise<void>;
 }

package/dist/service/cloudformation/stack/deploy/sim-cfn-stack-resource-batch-creator.js

@@ -1,3 +1,4 @@
+import { simCfnOrderedResources, } from "./sim-cfn-resource-order.js";
 /**
  * Creates one dependency-ready batch of Stack Resources.
  *
@@ -5,6 +6,7 @@
  * class owns only the batch execution details:
  *
  * - create all Resources in the batch in parallel
+ * - start them in the order the deployment asked for
  * - pass the shared Stack creation context to each Resource
  *
  * It does not choose which Resources are ready, retry incomplete Resources, or
@@ -18,22 +20,27 @@ export class SimCfnStackResourceBatchCreator {
     cdkOutContext;
     bindings;
     caller;
+    resourceOrder;
     constructor(properties) {
-        const { simAws, resources, cdkOutContext, bindings, caller } = properties;
+        const { simAws, resources, cdkOutContext, bindings, caller, resourceOrder, } = properties;
         this.simAws = simAws;
         this.resources = resources;
         this.cdkOutContext = cdkOutContext;
         this.bindings = bindings;
         this.caller = caller;
+        this.resourceOrder = resourceOrder;
     }
     /**
      * Create the supplied Resources concurrently.
      *
      * Each Resource still owns its own create lifecycle and status transitions.
      * This method only waits for the batch to settle.
+     *
+     * Nothing in the batch depends on anything else in it, so the order they
+     * start in is the deployment's to choose.
      */
     async create(resources) {
-        await Promise.all(resources.map(async (resource) => {
+        await Promise.all(simCfnOrderedResources(resources, this.resourceOrder).map(async (resource) => {
             await resource.create({
                 simAws: this.simAws,
                 resources: this.resources,

package/dist/service/cloudformation/stack/deploy/sim-cfn-stack-resource-creator.d.ts

@@ -3,6 +3,7 @@ import type { SimAwsCaller } from "../../../aws/caller/sim-aws-caller.js";
 import type { SimCfnResource } from "../../resource/sim-cfn-resource.js";
 import type { SimCdkOutContext } from "../../cdk/sim-cdk-out-context.js";
 import type { SimCfnBinding } from "../../bind/sim-cfn-binding.js";
+import type { SimCfnResourceOrder } from "./sim-cfn-resource-order.js";
 interface SimCfnStackResourceCreatorProperties {
     readonly simAws: SimAws;
     readonly resources: ReadonlyMap<string, SimCfnResource>;
@@ -10,6 +11,7 @@ interface SimCfnStackResourceCreatorProperties {
     readonly cdkOutContext?: SimCdkOutContext | undefined;
     readonly bindings?: readonly SimCfnBinding[] | undefined;
     readonly caller?: SimAwsCaller | undefined;
+    readonly resourceOrder?: SimCfnResourceOrder | undefined;
 }
 /**
  * Orchestrates dependency-ordered creation of a Stack's simulated Resources.

package/dist/service/cloudformation/stack/deploy/sim-cfn-stack-resource-creator.js

@@ -21,7 +21,7 @@ export class SimCfnStackResourceCreator {
     stackName;
     batchCreator;
     constructor(properties) {
-        const { simAws, resources, stackName, cdkOutContext, bindings, caller } = properties;
+        const { simAws, resources, stackName, cdkOutContext, bindings, caller, resourceOrder, } = properties;
         this.resources = resources;
         this.stackName = stackName;
         this.batchCreator = new SimCfnStackResourceBatchCreator({
@@ -30,6 +30,7 @@ export class SimCfnStackResourceCreator {
             cdkOutContext,
             bindings,
             caller,
+            resourceOrder,
         });
     }
     /**

package/dist/service/cloudformation/stack/sim-cfn-stack-resource-operations.d.ts

@@ -6,6 +6,7 @@ import type { SimCfnBinding } from "../bind/sim-cfn-binding.js";
 import type { SimCdkOutContext } from "../cdk/sim-cdk-out-context.js";
 import type { SimCfnResource } from "../resource/sim-cfn-resource.js";
 import type { SimCfnTemplate } from "../template/sim-cfn-template.js";
+import type { SimCfnResourceOrder } from "./deploy/sim-cfn-resource-order.js";
 import { SimCfnStackUpdater } from "./update/sim-cfn-stack-updater.js";
 import type { SimCloudFormationStackName } from "./sim-cfn-stack.js";
 interface SimCfnStackUpdateProperties {
@@ -25,6 +26,10 @@ interface SimCfnStackResourceOperationsProperties {
      * caller leaves each service to decide the request as the Account root.
      */
     readonly caller?: SimAwsCaller | undefined;
+    /**
+     * The order Resources with no dependency between them are started in.
+     */
+    readonly resourceOrder?: SimCfnResourceOrder | undefined;
 }
 /**
  * What a Stack can ask simulated AWS to do with its Resources.
@@ -44,6 +49,7 @@ export declare class SimCfnStackResourceOperations {
     private readonly accountRegionScope;
     private readonly stackName;
     private readonly bindings;
+    private readonly resourceOrder;
     private cdkOutContext;
     private caller;
     constructor(properties: SimCfnStackResourceOperationsProperties);

package/dist/service/cloudformation/stack/sim-cfn-stack-resource-operations.js

@@ -20,16 +20,18 @@ export class SimCfnStackResourceOperations {
     accountRegionScope;
     stackName;
     bindings;
+    resourceOrder;
     cdkOutContext;
     caller;
     constructor(properties) {
-        const { simAws, accountRegionScope, stackName, cdkOutContext, bindings, caller, } = properties;
+        const { simAws, accountRegionScope, stackName, cdkOutContext, bindings, caller, resourceOrder, } = properties;
         this.simAws = simAws;
         this.accountRegionScope = accountRegionScope;
         this.stackName = stackName;
         this.cdkOutContext = cdkOutContext;
         this.bindings = bindings;
         this.caller = caller;
+        this.resourceOrder = resourceOrder;
     }
     /**
      * Take on what an update brings with it, for this and every later operation.
@@ -106,6 +108,7 @@ export class SimCfnStackResourceOperations {
             cdkOutContext: this.cdkOutContext,
             bindings: this.bindings,
             caller: this.caller,
+            resourceOrder: this.resourceOrder,
         });
     }
     deleter(resources) {

package/dist/service/cloudformation/stack/sim-cfn-stack.js

@@ -38,7 +38,7 @@ export class SimCfnStack {
     stackOutputs;
     cfnTemplate;
     constructor(properties) {
-        const { simAws, accountRegionScope, background, stackName, template, cdkOutContext, bindings, caller, exports, } = properties;
+        const { simAws, accountRegionScope, background, stackName, template, cdkOutContext, bindings, caller, resourceOrder, exports, } = properties;
         this.background = background;
         this.stackName = stackName;
         this.stackOutputs = new SimCfnStackOutputs({ stackName, exports });
@@ -61,6 +61,7 @@ export class SimCfnStack {
             cdkOutContext,
             bindings,
             caller,
+            resourceOrder,
         });
         this.lifecycle = new SimCfnStackDeploymentLifecycle({
             background,

package/dist/service/cloudformation/stack/sim-cfn-stack.type.d.ts

@@ -7,6 +7,7 @@ import type { SimCfnTemplate } from "../template/sim-cfn-template.js";
 import type { SimCdkOutContext } from "../cdk/sim-cdk-out-context.js";
 import type { SimCfnBinding } from "../bind/sim-cfn-binding.js";
 import type { SimCfnExports } from "../export/sim-cfn-exports.js";
+import type { SimCfnResourceOrder } from "./deploy/sim-cfn-resource-order.js";
 export type SimCloudFormationStackName = Brand<string, "SimCloudFormationStackName">;
 export type SimCloudFormationStackStatus = "REVIEW_IN_PROGRESS" | "CREATE_IN_PROGRESS" | "CREATE_COMPLETE" | "CREATE_FAILED" | "UPDATE_IN_PROGRESS" | "UPDATE_COMPLETE" | "UPDATE_FAILED" | "DELETE_IN_PROGRESS" | "DELETE_COMPLETE" | "DELETE_FAILED";
 export interface SimCfnStackUpdateProperties {
@@ -37,6 +38,11 @@ export interface SimCloudFormationStackProperties {
      * simulation.
      */
     readonly caller?: SimAwsCaller | undefined;
+    /**
+     * The order this Stack starts Resources with no dependency between them in.
+     * The template's own order unless the deployment asked for another one.
+     */
+    readonly resourceOrder?: SimCfnResourceOrder | undefined;
     /**
      * The export names published in the Account and Region this Stack deploys
      * into. This Stack publishes its own Outputs here and reads the ones its

package/dist/service/cloudfront/behaviour/sim-cloud-front-behavior.d.ts

@@ -12,6 +12,11 @@ export interface SimCloudFrontBehavior {
      * The response headers policy applied to every response this Behavior serves.
      */
     responseHeadersPolicyId?: string | undefined;
+    /**
+     * The cache policy this Behavior was given, whether a template created it or
+     * AWS manages it. The simulated cache does not read it yet.
+     */
+    cachePolicyId?: string | undefined;
     functionAssociations?: undefined | {
         viewerRequest?: SimArn;
         viewerResponse?: SimArn;

package/dist/service/cloudfront/cache-policy/sim-cf-cache-policy-registry.d.ts

@@ -0,0 +1,37 @@
+import type { SimCloudFrontCachePolicy, SimCloudFrontCachePolicyId } from "./sim-cf-cache-policy.js";
+/**
+ * The cache policies one simulated CloudFront holds.
+ *
+ * Policies are found by ID, which is what a cache Behavior's `cachePolicyId`
+ * names, and by name, which is what decides whether a new one may be stored.
+ *
+ * AWS's seven managed policies are held apart from the ones a template
+ * creates. CloudFront keeps them in its own namespace, so a template may
+ * create a policy called `CachingDisabled` of its own, and deleting the stack
+ * that created it leaves the managed one where it was.
+ */
+export declare class SimCloudFrontCachePolicyRegistry {
+    private readonly policies;
+    private readonly managedPolicies;
+    /**
+     * Store a policy a template created, refusing a name another such policy
+     * already holds as CloudFront does.
+     */
+    add(policy: SimCloudFrontCachePolicy): void;
+    /**
+     * Forget a policy.
+     */
+    remove(policyId: SimCloudFrontCachePolicyId): void;
+    /**
+     * Get a policy by ID, whether a template created it or AWS manages it.
+     */
+    byId(policyId: SimCloudFrontCachePolicyId | string): SimCloudFrontCachePolicy | undefined;
+    /**
+     * Get a policy a template created, by name.
+     *
+     * A managed policy is left out. Its name belongs to CloudFront's own
+     * namespace, and this is what decides whether a template may store a policy
+     * under a name.
+     */
+    byName(policyName: string): SimCloudFrontCachePolicy | undefined;
+}

package/dist/service/cloudfront/cache-policy/sim-cf-cache-policy-registry.js

@@ -0,0 +1,50 @@
+import { SimCloudFrontCachePolicyAlreadyExists } from "../error/sim-cloudfront.error.js";
+import { simCfManagedCachePolicies } from "./sim-cf-managed-cache-policies.js";
+/**
+ * The cache policies one simulated CloudFront holds.
+ *
+ * Policies are found by ID, which is what a cache Behavior's `cachePolicyId`
+ * names, and by name, which is what decides whether a new one may be stored.
+ *
+ * AWS's seven managed policies are held apart from the ones a template
+ * creates. CloudFront keeps them in its own namespace, so a template may
+ * create a policy called `CachingDisabled` of its own, and deleting the stack
+ * that created it leaves the managed one where it was.
+ */
+export class SimCloudFrontCachePolicyRegistry {
+    policies = new Map();
+    managedPolicies = simCfManagedCachePolicies();
+    /**
+     * Store a policy a template created, refusing a name another such policy
+     * already holds as CloudFront does.
+     */
+    add(policy) {
+        if (this.byName(policy.name) !== undefined) {
+            throw new SimCloudFrontCachePolicyAlreadyExists(`Sim CloudFront cache policy ${policy.name} already exists`);
+        }
+        this.policies.set(policy.id, policy);
+    }
+    /**
+     * Forget a policy.
+     */
+    remove(policyId) {
+        this.policies.delete(policyId);
+    }
+    /**
+     * Get a policy by ID, whether a template created it or AWS manages it.
+     */
+    byId(policyId) {
+        const id = policyId;
+        return this.policies.get(id) ?? this.managedPolicies.get(id);
+    }
+    /**
+     * Get a policy a template created, by name.
+     *
+     * A managed policy is left out. Its name belongs to CloudFront's own
+     * namespace, and this is what decides whether a template may store a policy
+     * under a name.
+     */
+    byName(policyName) {
+        return this.policies.values().find((policy) => policy.name === policyName);
+    }
+}

package/dist/service/cloudfront/cache-policy/sim-cf-cache-policy.d.ts

@@ -0,0 +1,25 @@
+import type { Brand } from "../../../util/brand.type.js";
+export type SimCloudFrontCachePolicyId = Brand<string, "SimCloudFrontCachePolicyId">;
+interface SimCloudFrontCachePolicyProperties {
+    readonly id?: SimCloudFrontCachePolicyId;
+    readonly name: string;
+    readonly comment?: string | undefined;
+}
+/**
+ * Simulated CloudFront cache policy.
+ *
+ * A cache policy decides what a cache Behavior keys its cache on and how long
+ * an object stays there. This simulation holds the policy under its ID and
+ * hands it back. The cache key, the TTLs and the compression settings belong
+ * to a simulated cache, which CloudFront here has yet to grow.
+ *
+ * https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/controlling-the-cache-key.html
+ */
+export declare class SimCloudFrontCachePolicy {
+    readonly id: SimCloudFrontCachePolicyId;
+    readonly name: string;
+    readonly comment: string | undefined;
+    constructor(properties: SimCloudFrontCachePolicyProperties);
+}
+export type SimCloudFrontCachePolicyMap = Map<SimCloudFrontCachePolicyId, SimCloudFrontCachePolicy>;
+export {};

package/dist/service/cloudfront/cache-policy/sim-cf-cache-policy.js

@@ -0,0 +1,21 @@
+import { randomUUID } from "node:crypto";
+/**
+ * Simulated CloudFront cache policy.
+ *
+ * A cache policy decides what a cache Behavior keys its cache on and how long
+ * an object stays there. This simulation holds the policy under its ID and
+ * hands it back. The cache key, the TTLs and the compression settings belong
+ * to a simulated cache, which CloudFront here has yet to grow.
+ *
+ * https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/controlling-the-cache-key.html
+ */
+export class SimCloudFrontCachePolicy {
+    id;
+    name;
+    comment;
+    constructor(properties) {
+        this.id = properties.id ?? randomUUID();
+        this.name = properties.name;
+        this.comment = properties.comment;
+    }
+}

package/dist/service/cloudfront/cache-policy/sim-cf-managed-cache-policies.d.ts

@@ -0,0 +1,28 @@
+import { type SimCloudFrontCachePolicyMap } from "./sim-cf-cache-policy.js";
+/**
+ * The IDs AWS publishes for its managed cache policies.
+ *
+ * A template names one of these directly. CDK's `CachePolicy` statics carry
+ * the same seven, and synthesize the ID into a Behavior's `CachePolicyId` with
+ * no Resource behind it.
+ */
+export declare const simCfManagedCachePolicyIds: {
+    readonly amplify: "2e54312d-136d-493c-8eb9-b001f22f67d2";
+    readonly cachingOptimized: "658327ea-f89d-4fab-a63d-7e88639e58f6";
+    readonly cachingOptimizedForUncompressedObjects: "b2884449-e4de-46a7-ac36-70bc7f1ddd6d";
+    readonly cachingDisabled: "4135ea2d-6df8-44a3-9df3-4b5a84be39ad";
+    readonly elementalMediaPackage: "08627262-05a9-4f76-9ded-b50ca2e3a84f";
+    readonly useOriginCacheControlHeaders: "83da9c7e-98b4-4e11-a168-04f0df8e2c65";
+    readonly useOriginCacheControlHeadersQueryStrings: "4cc15a8a-d715-48a4-82b8-cc0b614638fe";
+};
+/**
+ * The seven managed cache policies, built fresh for one simulated CloudFront.
+ *
+ * CloudFront owns these and every account has them, so a Behavior can name one
+ * without a template creating anything. Each carries the ID and the name AWS
+ * publishes for it. The cache key and the TTLs behind each one are left out,
+ * along with those of a policy a template creates.
+ *
+ * https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/using-managed-cache-policies.html
+ */
+export declare function simCfManagedCachePolicies(): SimCloudFrontCachePolicyMap;

package/dist/service/cloudfront/cache-policy/sim-cf-managed-cache-policies.js

@@ -0,0 +1,48 @@
+import { SimCloudFrontCachePolicy, } from "./sim-cf-cache-policy.js";
+/**
+ * The IDs AWS publishes for its managed cache policies.
+ *
+ * A template names one of these directly. CDK's `CachePolicy` statics carry
+ * the same seven, and synthesize the ID into a Behavior's `CachePolicyId` with
+ * no Resource behind it.
+ */
+export const simCfManagedCachePolicyIds = {
+    amplify: "2e54312d-136d-493c-8eb9-b001f22f67d2",
+    cachingOptimized: "658327ea-f89d-4fab-a63d-7e88639e58f6",
+    cachingOptimizedForUncompressedObjects: "b2884449-e4de-46a7-ac36-70bc7f1ddd6d",
+    cachingDisabled: "4135ea2d-6df8-44a3-9df3-4b5a84be39ad",
+    elementalMediaPackage: "08627262-05a9-4f76-9ded-b50ca2e3a84f",
+    useOriginCacheControlHeaders: "83da9c7e-98b4-4e11-a168-04f0df8e2c65",
+    useOriginCacheControlHeadersQueryStrings: "4cc15a8a-d715-48a4-82b8-cc0b614638fe",
+};
+/**
+ * The seven managed cache policies, built fresh for one simulated CloudFront.
+ *
+ * CloudFront owns these and every account has them, so a Behavior can name one
+ * without a template creating anything. Each carries the ID and the name AWS
+ * publishes for it. The cache key and the TTLs behind each one are left out,
+ * along with those of a policy a template creates.
+ *
+ * https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/using-managed-cache-policies.html
+ */
+export function simCfManagedCachePolicies() {
+    const policies = [
+        managedCachePolicy(simCfManagedCachePolicyIds.amplify, "Amplify"),
+        managedCachePolicy(simCfManagedCachePolicyIds.cachingOptimized, "CachingOptimized"),
+        managedCachePolicy(simCfManagedCachePolicyIds.cachingOptimizedForUncompressedObjects, "CachingOptimizedForUncompressedObjects"),
+        managedCachePolicy(simCfManagedCachePolicyIds.cachingDisabled, "CachingDisabled"),
+        managedCachePolicy(simCfManagedCachePolicyIds.elementalMediaPackage, "Elemental-MediaPackage"),
+        managedCachePolicy(simCfManagedCachePolicyIds.useOriginCacheControlHeaders, "UseOriginCacheControlHeaders"),
+        managedCachePolicy(simCfManagedCachePolicyIds.useOriginCacheControlHeadersQueryStrings, "UseOriginCacheControlHeaders-QueryStrings"),
+    ];
+    return new Map(policies.map((policy) => [policy.id, policy]));
+}
+/**
+ * One managed policy, under the ID and the name AWS gives it.
+ */
+function managedCachePolicy(id, name) {
+    return new SimCloudFrontCachePolicy({
+        id: id,
+        name,
+    });
+}

package/dist/service/cloudfront/cff/function-code-input/cff-function-code-input.d.ts

@@ -7,6 +7,14 @@ type FunctionCodeInput = SimCreateFunctionCommand["input"]["FunctionCode"];
  * CloudFront CreateFunction Command input FunctionCode.
  */
 export declare function makeCffFunctionCodeInput(handlerFunction: CloudFrontFunction.Handler): FunctionCodeInput;
+/**
+ * The source a Function reports as the code it was created with.
+ *
+ * A Function created from source keeps the bytes it was given. One created
+ * from a handler function reference was never given any source, so what it
+ * keeps is that handler's own source text, which is the code it runs.
+ */
+export declare function cffFunctionCodeSource(functionCodeInput: FunctionCodeInput): Uint8Array;
 /**
  * A little trick to allow passing a handler function into CreateFunctionCommand
  * input as if it were a Uint8Array without TypeScript complaining.

package/dist/service/cloudfront/cff/function-code-input/cff-function-code-input.js

@@ -9,6 +9,19 @@ export function makeCffFunctionCodeInput(handlerFunction) {
     stowaway.stowawayHandlerFunction(handlerFunction);
     return stowaway;
 }
+/**
+ * The source a Function reports as the code it was created with.
+ *
+ * A Function created from source keeps the bytes it was given. One created
+ * from a handler function reference was never given any source, so what it
+ * keeps is that handler's own source text, which is the code it runs.
+ */
+export function cffFunctionCodeSource(functionCodeInput) {
+    if (functionCodeInput instanceof CffUint8ArrayStowaway) {
+        return Buffer.from(functionCodeInput.handlerFunction.toString());
+    }
+    return functionCodeInput ?? new Uint8Array();
+}
 /**
  * A little trick to allow passing a handler function into CreateFunctionCommand
  * input as if it were a Uint8Array without TypeScript complaining.

package/dist/service/cloudfront/cff/sim-cf-function-commands.d.ts

@@ -0,0 +1,52 @@
+import type { BackgroundScheduler } from "../../../util/background/background.js";
+import type { SimAwsCaller } from "../../aws/caller/sim-aws-caller.js";
+import type { SimAwsAccountId } from "../../aws/sim-aws-account.js";
+import type { SimIamInterServiceAuthZ } from "../../iam/authorize/sim-iam-inter-service-auth-z.js";
+import type { SimCreateFunctionCommand, SimCreateFunctionCommandOutput } from "../command/create-function/create-function.command.js";
+import { type SimCloudFrontFunctionMap } from "../command/create-function/create-function.handler.js";
+import type { SimDeleteFunctionCommand, SimDeleteFunctionCommandOutput } from "../command/delete-function/delete-function.command.js";
+import type { SimDescribeFunctionCommand, SimDescribeFunctionCommandOutput, SimGetFunctionCommand, SimGetFunctionCommandOutput, SimListFunctionsCommand, SimListFunctionsCommandOutput } from "../command/function/sim-cf-function-command.types.js";
+import type { SimCloudFrontKeyValueStoreRegistry } from "../key-value-store/sim-cf-key-value-store-registry.js";
+interface SimCfFunctionCommandsProperties {
+    readonly accountId: SimAwsAccountId;
+    readonly cloudFrontFunctions: SimCloudFrontFunctionMap;
+    readonly iam: SimIamInterServiceAuthZ;
+    readonly background: BackgroundScheduler;
+    readonly keyValueStores: SimCloudFrontKeyValueStoreRegistry;
+}
+interface FunctionRequestOptions {
+    readonly caller?: SimAwsCaller;
+}
+/**
+ * The CloudFront Function commands on the CloudFront client.
+ *
+ * They are grouped here rather than beside the Distribution commands on
+ * SimCloudFrontCommands because they work on their own state, the Account's
+ * Functions, and because there are enough of them to be their own thing.
+ */
+export declare class SimCfFunctionCommands {
+    private readonly writeState;
+    private readonly access;
+    constructor(properties: SimCfFunctionCommandsProperties);
+    /**
+     * Handle a Create Function Command from the SDK.
+     */
+    createFunction(command: SimCreateFunctionCommand, options?: FunctionRequestOptions): Promise<SimCreateFunctionCommandOutput>;
+    /**
+     * Handle a Delete Function Command from the SDK.
+     */
+    deleteFunction(command: SimDeleteFunctionCommand, options?: FunctionRequestOptions): Promise<SimDeleteFunctionCommandOutput>;
+    /**
+     * Handle a List Functions Command from the SDK.
+     */
+    listFunctions(command: SimListFunctionsCommand, options?: FunctionRequestOptions): Promise<SimListFunctionsCommandOutput>;
+    /**
+     * Handle a Describe Function Command from the SDK.
+     */
+    describeFunction(command: SimDescribeFunctionCommand, options?: FunctionRequestOptions): Promise<SimDescribeFunctionCommandOutput>;
+    /**
+     * Handle a Get Function Command from the SDK.
+     */
+    getFunction(command: SimGetFunctionCommand, options?: FunctionRequestOptions): Promise<SimGetFunctionCommandOutput>;
+}
+export {};

package/dist/service/cloudfront/cff/sim-cf-function-commands.js

@@ -0,0 +1,51 @@
+import { CreateFunctionCommandHandler, } from "../command/create-function/create-function.handler.js";
+import { DeleteFunctionCommandHandler } from "../command/delete-function/delete-function.handler.js";
+import { SimCfDescribeFunction } from "../command/function/sim-cf-describe-function.js";
+import { SimCfFunctionAccess } from "../command/function/sim-cf-function-access.js";
+import { SimCfGetFunction } from "../command/function/sim-cf-get-function.js";
+import { SimCfListFunctions } from "../command/function/sim-cf-list-functions.js";
+/**
+ * The CloudFront Function commands on the CloudFront client.
+ *
+ * They are grouped here rather than beside the Distribution commands on
+ * SimCloudFrontCommands because they work on their own state, the Account's
+ * Functions, and because there are enough of them to be their own thing.
+ */
+export class SimCfFunctionCommands {
+    writeState;
+    access;
+    constructor(properties) {
+        this.writeState = properties;
+        this.access = new SimCfFunctionAccess(properties);
+    }
+    /**
+     * Handle a Create Function Command from the SDK.
+     */
+    async createFunction(command, options) {
+        return await new CreateFunctionCommandHandler(this.writeState).handle(command, options);
+    }
+    /**
+     * Handle a Delete Function Command from the SDK.
+     */
+    async deleteFunction(command, options) {
+        return await new DeleteFunctionCommandHandler(this.writeState).handle(command, options);
+    }
+    /**
+     * Handle a List Functions Command from the SDK.
+     */
+    async listFunctions(command, options) {
+        return await new SimCfListFunctions(this.access).handle(command, options);
+    }
+    /**
+     * Handle a Describe Function Command from the SDK.
+     */
+    async describeFunction(command, options) {
+        return await new SimCfDescribeFunction(this.access).handle(command, options);
+    }
+    /**
+     * Handle a Get Function Command from the SDK.
+     */
+    async getFunction(command, options) {
+        return await new SimCfGetFunction(this.access).handle(command, options);
+    }
+}

package/dist/service/cloudfront/cff/sim-cff-configuration.d.ts

@@ -0,0 +1,41 @@
+/**
+ * The JavaScript runtime a CloudFront Function is written against.
+ */
+export type SimCloudFrontFunctionRuntime = "cloudfront-js-1.0" | "cloudfront-js-2.0";
+export interface SimCffConfigurationProperties {
+    /** The `FunctionConfig` comment, which CloudFront requires and reports. */
+    readonly comment?: string | undefined;
+    /** The `FunctionConfig` runtime this Function is written against. */
+    readonly runtime?: SimCloudFrontFunctionRuntime | undefined;
+    /** The source this Function was created with, which GetFunction reports. */
+    readonly functionCode?: Uint8Array | undefined;
+    /** When this Function was created, off the simulation's clock. */
+    readonly createdTime?: Date | undefined;
+}
+/**
+ * What a CloudFront Function was created with, which every read of it reports.
+ *
+ * This is the `FunctionConfig` and `FunctionMetadata` pair the API answers
+ * with, held together because they are written once at creation and read
+ * together afterwards. The Function itself is what runs; this is what it says
+ * about itself.
+ */
+export declare class SimCffConfiguration {
+    readonly comment: string;
+    readonly runtime: SimCloudFrontFunctionRuntime;
+    readonly functionCode: Uint8Array;
+    /**
+     * When this Function was created, and when it was last changed.
+     *
+     * They are the same instant here. What moves the modified time apart from
+     * the created time in CloudFront is UpdateFunction and PublishFunction, and
+     * neither is simulated yet.
+     */
+    readonly createdTime: Date;
+    readonly lastModifiedTime: Date;
+    /**
+     * The version of this Function a write has to carry to be accepted.
+     */
+    readonly etag: string;
+    constructor(properties?: SimCffConfigurationProperties);
+}

package/dist/service/cloudfront/cff/sim-cff-configuration.js

@@ -0,0 +1,34 @@
+import { makeSimCloudFrontETag } from "../sim-cf-etag.js";
+/**
+ * What a CloudFront Function was created with, which every read of it reports.
+ *
+ * This is the `FunctionConfig` and `FunctionMetadata` pair the API answers
+ * with, held together because they are written once at creation and read
+ * together afterwards. The Function itself is what runs; this is what it says
+ * about itself.
+ */
+export class SimCffConfiguration {
+    comment;
+    runtime;
+    functionCode;
+    /**
+     * When this Function was created, and when it was last changed.
+     *
+     * They are the same instant here. What moves the modified time apart from
+     * the created time in CloudFront is UpdateFunction and PublishFunction, and
+     * neither is simulated yet.
+     */
+    createdTime;
+    lastModifiedTime;
+    /**
+     * The version of this Function a write has to carry to be accepted.
+     */
+    etag = makeSimCloudFrontETag();
+    constructor(properties = {}) {
+        this.comment = properties.comment ?? "";
+        this.runtime = properties.runtime ?? "cloudfront-js-2.0";
+        this.functionCode = properties.functionCode ?? new Uint8Array();
+        this.createdTime = properties.createdTime ?? new Date();
+        this.lastModifiedTime = this.createdTime;
+    }
+}