@awsless/awsless 0.0.488 → 0.0.490

package/dist/bin.js

@@ -861,7 +861,7 @@ var LogRetentionSchema = DurationSchema.refine(
   (duration) => {
     return validLogRetentionDays.includes(toDays(duration));
   },
-  `Invalid log retention. Valid days are: ${validLogRetentionDays.map((days6) => `${days6}`).join(", ")}`
+  `Invalid log retention. Valid days are: ${validLogRetentionDays.map((days7) => `${days7}`).join(", ")}`
 ).describe("The log retention duration.");
 var LogSchema = z14.union([
   z14.boolean().transform((enabled) => ({ retention: enabled ? days(7) : days(0) })),
@@ -1241,7 +1241,7 @@ var AppSchema = z24.object({
 });
 
 // src/config/stack.ts
-import { z as z38 } from "zod";
+import { z as z39 } from "zod";
 
 // src/feature/cache/schema.ts
 import { gibibytes as gibibytes2 } from "@awsless/size";
@@ -1676,24 +1676,96 @@ var StoresSchema = z33.union([
   )
 ]).optional().describe("Define the stores in your stack.");
 
-// src/feature/table/schema.ts
-import { minutes as minutes4, seconds as seconds4 } from "@awsless/duration";
+// src/feature/images/schema.ts
 import { z as z34 } from "zod";
-var KeySchema = z34.string().min(1).max(255);
-var TablesSchema = z34.record(
+var transformationOptionsSchema = z34.object({
+  // Resize options
+  width: z34.number().int().positive().optional(),
+  height: z34.number().int().positive().optional(),
+  fit: z34.enum(["cover", "contain", "fill", "inside", "outside"]).optional(),
+  position: z34.enum(["top", "right top", "right", "right bottom", "bottom", "left bottom", "left", "left top", "center"]).optional(),
+  // Format options
+  quality: z34.number().int().min(1).max(100).optional(),
+  progressive: z34.boolean().optional(),
+  // Processing options
+  rotate: z34.number().optional(),
+  flip: z34.boolean().optional(),
+  flop: z34.boolean().optional(),
+  blur: z34.number().min(0.3).max(1e3).optional(),
+  sharpen: z34.boolean().optional(),
+  grayscale: z34.boolean().optional(),
+  normalize: z34.boolean().optional()
+});
+var extensionOptionsSchema = z34.object({
+  // WebP specific
+  effort: z34.number().int().min(0).max(6).optional(),
+  lossless: z34.boolean().optional(),
+  nearLossless: z34.boolean().optional(),
+  // smartSubsample: z.boolean().optional(),
+  // JPEG specific
+  mozjpeg: z34.boolean().optional(),
+  // trellisQuantisation: z.boolean().optional(),
+  // overshootDeringing: z.boolean().optional(),
+  // optimiseScans: z.boolean().optional(),
+  // PNG specific
+  compressionLevel: z34.number().int().min(0).max(9).optional(),
+  adaptiveFiltering: z34.boolean().optional(),
+  // palette: z.boolean().optional(),
+  // AVIF specific
+  speed: z34.number().int().min(0).max(9).optional()
+  // chromaSubsampling: z.string().optional(),
+});
+var staticOriginSchema = LocalDirectorySchema.describe(
+  "Specifies the path to a image directory that will be uploaded in S3."
+);
+var functionOriginSchema = FunctionSchema.describe(
+  "Specifies the file that will be called when an image isn't found in the S3 bucket."
+);
+var ImagesSchema = z34.record(
   ResourceIdSchema,
   z34.object({
+    domain: ResourceIdSchema.describe("The domain id to link your site with.").optional(),
+    subDomain: z34.string().optional(),
+    presets: z34.record(z34.string(), transformationOptionsSchema).describe("Named presets for image transformations"),
+    extensions: z34.record(z34.enum(["jpeg", "jpg", "png", "webp"]), extensionOptionsSchema).describe("Format-specific optimization options"),
+    origin: z34.union([
+      z34.object({
+        static: staticOriginSchema,
+        function: functionOriginSchema.optional()
+      }),
+      z34.object({
+        static: staticOriginSchema.optional(),
+        function: functionOriginSchema
+      }),
+      z34.object({
+        static: staticOriginSchema,
+        function: functionOriginSchema
+      })
+    ]).describe(
+      "Image transformation will be applied from a base image. Base images orginates from a local directory that will be uploaded to S3 or from a lambda function."
+    )
+    // postprocess: FunctionSchema.optional()
+  })
+).optional().describe("Define image CDN & transformations in your stack.");
+
+// src/feature/table/schema.ts
+import { minutes as minutes4, seconds as seconds4 } from "@awsless/duration";
+import { z as z35 } from "zod";
+var KeySchema = z35.string().min(1).max(255);
+var TablesSchema = z35.record(
+  ResourceIdSchema,
+  z35.object({
     hash: KeySchema.describe(
       "Specifies the name of the partition / hash key that makes up the primary key for the table."
     ),
     sort: KeySchema.optional().describe(
       "Specifies the name of the range / sort key that makes up the primary key for the table."
     ),
-    fields: z34.record(z34.string(), z34.enum(["string", "number", "binary"])).optional().describe(
+    fields: z35.record(z35.string(), z35.enum(["string", "number", "binary"])).optional().describe(
       'A list of attributes that describe the key schema for the table and indexes. If no attribute field is defined we default to "string".'
     ),
-    class: z34.enum(["standard", "standard-infrequent-access"]).default("standard").describe("The table class of the table."),
-    pointInTimeRecovery: z34.boolean().default(false).describe("Indicates whether point in time recovery is enabled on the table."),
+    class: z35.enum(["standard", "standard-infrequent-access"]).default("standard").describe("The table class of the table."),
+    pointInTimeRecovery: z35.boolean().default(false).describe("Indicates whether point in time recovery is enabled on the table."),
     ttl: KeySchema.optional().describe(
       [
         "The name of the TTL attribute used to store the expiration time for items in the table.",
@@ -1701,8 +1773,8 @@ var TablesSchema = z34.record(
       ].join("\n")
     ),
     // deletionProtection: DeletionProtectionSchema.optional(),
-    stream: z34.object({
-      type: z34.enum(["keys-only", "new-image", "old-image", "new-and-old-images"]).describe(
+    stream: z35.object({
+      type: z35.enum(["keys-only", "new-image", "old-image", "new-and-old-images"]).describe(
         [
           "When an item in the table is modified, you can determines what information is written to the stream for this table.",
           "Valid values are:",
@@ -1712,7 +1784,7 @@ var TablesSchema = z34.record(
           "- new-and-old-images - Both the new and the old item images of the item are written to the stream."
         ].join("\n")
       ),
-      batchSize: z34.number().min(1).max(1e4).default(1).describe(
+      batchSize: z35.number().min(1).max(1e4).default(1).describe(
         [
           "The maximum number of records in each batch that Lambda pulls from your stream and sends to your function.",
           "Lambda passes all of the records in the batch to the function in a single call, up to the payload limit for synchronous invocation (6 MB).",
@@ -1742,7 +1814,7 @@ var TablesSchema = z34.record(
       // 			'You can specify a number from -1 to 10000.',
       // 		].join('\n')
       // 	),
-      retryAttempts: z34.number().min(-1).max(1e4).default(-1).describe(
+      retryAttempts: z35.number().min(-1).max(1e4).default(-1).describe(
         [
           "Discard records after the specified number of retries.",
           "The default value is -1, which sets the maximum number of retries to infinite.",
@@ -1750,7 +1822,7 @@ var TablesSchema = z34.record(
           "You can specify a number from -1 to 10000."
         ].join("\n")
       ),
-      concurrencyPerShard: z34.number().min(1).max(10).default(1).describe(
+      concurrencyPerShard: z35.number().min(1).max(10).default(1).describe(
         [
           "The number of batches to process concurrently from each shard.",
           "You can specify a number from 1 to 10."
@@ -1760,16 +1832,16 @@ var TablesSchema = z34.record(
     }).optional().describe(
       "The settings for the DynamoDB table stream, which capture changes to items stored in the table."
     ),
-    indexes: z34.record(
-      z34.string(),
-      z34.object({
+    indexes: z35.record(
+      z35.string(),
+      z35.object({
         hash: KeySchema.describe(
           "Specifies the name of the partition / hash key that makes up the primary key for the global secondary index."
         ),
         sort: KeySchema.optional().describe(
           "Specifies the name of the range / sort key that makes up the primary key for the global secondary index."
         ),
-        projection: z34.enum(["all", "keys-only"]).default("all").describe(
+        projection: z35.enum(["all", "keys-only"]).default("all").describe(
           [
             "The set of attributes that are projected into the index:",
             "- all - All of the table attributes are projected into the index.",
@@ -1783,11 +1855,11 @@ var TablesSchema = z34.record(
 ).optional().describe("Define the tables in your stack.");
 
 // src/feature/task/schema.ts
-import { z as z35 } from "zod";
-var RetryAttemptsSchema2 = z35.number().int().min(0).max(2).describe(
+import { z as z36 } from "zod";
+var RetryAttemptsSchema2 = z36.number().int().min(0).max(2).describe(
   "The maximum number of times to retry when the function returns an error. You can specify a number from 0 to 2."
 );
-var TaskSchema = z35.union([
+var TaskSchema = z36.union([
   LocalFileSchema.transform((file) => ({
     consumer: {
       code: {
@@ -1798,33 +1870,33 @@ var TaskSchema = z35.union([
     },
     retryAttempts: void 0
   })),
-  z35.object({
+  z36.object({
     consumer: FunctionSchema,
     retryAttempts: RetryAttemptsSchema2.optional()
   })
 ]);
-var TasksSchema = z35.record(ResourceIdSchema, TaskSchema).optional().describe("Define the tasks in your stack.");
+var TasksSchema = z36.record(ResourceIdSchema, TaskSchema).optional().describe("Define the tasks in your stack.");
 
 // src/feature/test/schema.ts
-import { z as z36 } from "zod";
-var TestsSchema = z36.union([LocalDirectorySchema.transform((v) => [v]), LocalDirectorySchema.array()]).describe("Define the location of your tests for your stack.").optional();
+import { z as z37 } from "zod";
+var TestsSchema = z37.union([LocalDirectorySchema.transform((v) => [v]), LocalDirectorySchema.array()]).describe("Define the location of your tests for your stack.").optional();
 
 // src/feature/topic/schema.ts
 import { kebabCase as kebabCase3 } from "change-case";
-import { z as z37 } from "zod";
-var TopicNameSchema = z37.string().min(3).max(256).regex(/^[a-z0-9\-]+$/i, "Invalid topic name").transform((value) => kebabCase3(value)).describe("Define event topic name.");
-var TopicsSchema = z37.array(TopicNameSchema).refine((topics) => {
+import { z as z38 } from "zod";
+var TopicNameSchema = z38.string().min(3).max(256).regex(/^[a-z0-9\-]+$/i, "Invalid topic name").transform((value) => kebabCase3(value)).describe("Define event topic name.");
+var TopicsSchema = z38.array(TopicNameSchema).refine((topics) => {
   return topics.length === new Set(topics).size;
 }, "Must be a list of unique topic names").optional().describe("Define the event topics to publish too in your stack.");
-var SubscribersSchema = z37.record(TopicNameSchema, FunctionSchema).optional().describe("Define the event topics to subscribe too in your stack.");
+var SubscribersSchema = z38.record(TopicNameSchema, FunctionSchema).optional().describe("Define the event topics to subscribe too in your stack.");
 
 // src/config/stack.ts
 var DependsSchema = ResourceIdSchema.array().optional().describe("Define the stacks that this stack is depended on.");
 var NameSchema = ResourceIdSchema.refine((name) => !["base", "hostedzones"].includes(name), {
   message: `Stack name can't be a reserved name.`
 }).describe("Stack name.");
-var StackSchema = z38.object({
-  $schema: z38.string().optional(),
+var StackSchema = z39.object({
+  $schema: z39.string().optional(),
   name: NameSchema,
   depends: DependsSchema,
   commands: CommandsSchema,
@@ -1849,7 +1921,8 @@ var StackSchema = z38.object({
   pubsub: PubSubSchema,
   searchs: SearchsSchema,
   sites: SitesSchema,
-  tests: TestsSchema
+  tests: TestsSchema,
+  images: ImagesSchema
 });
 
 // src/config/load/read.ts
@@ -1891,13 +1964,13 @@ var readConfigWithStage = async (file, stage) => {
 };
 
 // src/config/load/validate.ts
-import { z as z39 } from "zod";
+import { z as z40 } from "zod";
 var validateConfig = async (schema, file, data) => {
   try {
     const result = await schema.parseAsync(data);
     return result;
   } catch (error) {
-    if (error instanceof z39.ZodError) {
+    if (error instanceof z40.ZodError) {
       throw new ConfigError(file, error, data);
     }
     throw error;
@@ -4076,19 +4149,23 @@ var createPrebuildLambdaFunction = (group, ctx, ns, id, props) => {
   }
   if (props.log?.retention && props.log?.retention?.value > 0n) {
     const logGroup = new $12.aws.cloudwatch.LogGroup(group, "log", {
-      name: lambda.functionName.pipe((name2) => `/aws/lambda/${name2}`),
+      name: `/aws/lambda/${name}`,
       retentionInDays: toDays4(props.log.retention ?? days3(7))
     });
-    addPermission(
-      {
-        actions: ["logs:CreateLogStream"],
-        resources: [logGroup.arn]
-      },
-      {
-        actions: ["logs:PutLogEvents"],
-        resources: [logGroup.arn.pipe((arn) => `${arn}:*`)]
-      }
-    );
+    addPermission({
+      actions: ["logs:PutLogEvents", "logs:CreateLogStream"],
+      resources: [logGroup.arn.pipe((arn) => `${arn}:*`)]
+    });
+    const onLogArn = getGlobalOnLog(ctx);
+    if (onLogArn && ctx.appConfig.defaults.onLog) {
+      const logFilter = ctx.appConfig.defaults.onLog.filter;
+      new $12.aws.cloudwatch.LogSubscriptionFilter(group, `on-log`, {
+        name: "log-subscription",
+        destinationArn: onLogArn,
+        logGroupName: logGroup.name,
+        filterPattern: formatFilterPattern(logFilter)
+      });
+    }
   }
   if (props.warm) {
     const rule = new $12.aws.cloudwatch.EventRule(group, "warm", {
@@ -4322,10 +4399,11 @@ var rpcFeature = defineFeature({
         }
       });
       const cdn = new $13.aws.cloudfront.Distribution(group, "cdn", {
-        tags: {
-          Name: name
-          // Feature: ''
-        },
+        // tags: {
+        // 	Name: name,
+        // 	// Feature: ''
+        // },
+        comment: name,
         enabled: true,
         aliases: domainName ? [domainName] : void 0,
         priceClass: "PriceClass_All",
@@ -4733,6 +4811,11 @@ var siteFeature = defineFeature({
         functionUrl = new $15.aws.lambda.FunctionUrl(group, "url", {
           functionName: result.lambda.functionName,
           authorizationType: "AWS_IAM"
+          // cors: {
+          // 	allowOrigins: ['*'],
+          // 	allowMethods: ['*'],
+          // 	allowHeaders: ['*'],
+          // },
         });
       }
       let bucket;
@@ -5690,10 +5773,6 @@ import { $ as $21, Group as Group22 } from "@awsless/formation";
 var layerFeature = defineFeature({
   name: "layer",
   onBefore(ctx) {
-    const layers = Object.entries(ctx.appConfig.defaults.layers ?? {});
-    if (layers.length === 0) {
-      return;
-    }
     const group = new Group22(ctx.base, "layer", "asset");
     const bucket = new $21.aws.s3.Bucket(group, "bucket", {
       bucket: formatGlobalResourceName({
@@ -5725,7 +5804,7 @@ var layerFeature = defineFeature({
     for (const [id, _props] of layers) {
       const props = _props;
       const group = new Group22(ctx.base, "layer", id);
-      const code = new $21.aws.s3.BucketObject(group, "code", {
+      const zip = new $21.aws.s3.BucketObject(group, "zip", {
         bucket: ctx.shared.get("layer", "bucket-name"),
         key: `/layer/${id}.zip`,
         contentType: "application/zip",
@@ -5744,9 +5823,9 @@ var layerFeature = defineFeature({
           description: id,
           compatibleArchitectures: props.architecture ? [props.architecture] : void 0,
           compatibleRuntimes: props.runtimes,
-          s3Bucket: code.bucket,
-          s3ObjectVersion: code.versionId,
-          s3Key: code.key.pipe((name) => {
+          s3Bucket: zip.bucket,
+          s3ObjectVersion: zip.versionId,
+          s3Key: zip.key.pipe((name) => {
             if (name.startsWith("/")) {
               return name.substring(1);
             }
@@ -5755,7 +5834,7 @@ var layerFeature = defineFeature({
           sourceCodeHash: $hash(props.file)
         },
         {
-          dependsOn: [code]
+          dependsOn: [zip]
         }
       );
       ctx.shared.add("layer", "arn", id, layer.arn);
@@ -5764,6 +5843,248 @@ var layerFeature = defineFeature({
   }
 });
 
+// src/feature/images/index.ts
+import { $ as $22, Group as Group23 } from "@awsless/formation";
+import { glob as glob3 } from "glob";
+import { join as join12, extname as extname3, dirname as dirname8 } from "path";
+import { contentType as contentType2 } from "mime-types";
+import { Future as Future4 } from "@awsless/formation";
+import { createHash as createHash5 } from "crypto";
+import { mebibytes as mebibytes4 } from "@awsless/size";
+import { days as days6, seconds as seconds9, toSeconds as toSeconds8, weeks } from "@awsless/duration";
+import { constantCase as constantCase11 } from "change-case";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var __dirname2 = dirname8(fileURLToPath2(import.meta.url));
+var imagesFeature = defineFeature({
+  name: "images",
+  onStack(ctx) {
+    for (const [id, props] of Object.entries(ctx.stackConfig.images ?? {})) {
+      const group = new Group23(ctx.stack, "images", id);
+      const name = formatLocalResourceName({
+        appName: ctx.app.name,
+        stackName: ctx.stack.name,
+        resourceType: "images",
+        resourceName: id
+      });
+      const originGroup = new Group23(ctx.stack, "images-origins", id);
+      let lambdaOrigin = void 0;
+      if (props.origin.function) {
+        lambdaOrigin = createLambdaFunction(originGroup, ctx, `images-lambda-origin`, id, props.origin.function);
+      }
+      let s3Origin;
+      if (props.origin.static) {
+        s3Origin = new $22.aws.s3.Bucket(originGroup, "bucket", {
+          bucket: formatLocalResourceName({
+            appName: ctx.app.name,
+            stackName: ctx.stack.name,
+            resourceType: "images",
+            resourceName: id,
+            postfix: ctx.appId
+          }),
+          forceDestroy: true
+        });
+      }
+      const path = join12(__dirname2, "/layers/sharp-arm.zip");
+      const layerId = formatLocalResourceName({
+        appName: ctx.appConfig.name,
+        stackName: ctx.stack.name,
+        resourceType: "layer",
+        resourceName: shortId(id)
+      });
+      const zipFile = new $22.aws.s3.BucketObject(group, "layer-zip", {
+        bucket: ctx.shared.get("layer", "bucket-name"),
+        key: `/layer/${layerId}.zip`,
+        contentType: "application/zip",
+        source: path,
+        sourceHash: $hash(path)
+      });
+      const layer = new $22.aws.lambda.LayerVersion(
+        group,
+        "layer",
+        {
+          layerName: layerId,
+          description: "sharp-arm.zip for the awsless images feature.",
+          compatibleArchitectures: ["arm64"],
+          compatibleRuntimes: ["nodejs22.x"],
+          s3Bucket: zipFile.bucket,
+          s3ObjectVersion: zipFile.versionId,
+          s3Key: zipFile.key.pipe((name2) => {
+            if (name2.startsWith("/")) {
+              return name2.substring(1);
+            }
+            return name2;
+          }),
+          sourceCodeHash: $hash(path)
+        },
+        {
+          dependsOn: [zipFile]
+        }
+      );
+      ctx.shared.add("layer", "arn", layerId, layer.arn);
+      const transformFn = createPrebuildLambdaFunction(group, ctx, "images", id, {
+        bundleFile: join12(__dirname2, "/prebuild/images/bundle.zip"),
+        bundleHash: join12(__dirname2, "/prebuild/images/HASH"),
+        memorySize: mebibytes4(512),
+        timeout: seconds9(10),
+        handler: "index.default",
+        runtime: "nodejs22.x",
+        log: { retention: weeks(2) },
+        layers: [layerId]
+      });
+      new UpdateFunctionCode(group, "update", {
+        version: transformFn.code.sourceHash,
+        functionName: transformFn.lambda.functionName,
+        architectures: transformFn.lambda.architectures,
+        s3Bucket: transformFn.lambda.s3Bucket,
+        s3Key: transformFn.lambda.s3Key,
+        s3ObjectVersion: transformFn.lambda.s3ObjectVersion,
+        imageUri: transformFn.lambda.imageUri
+      });
+      const permission = new $22.aws.lambda.Permission(group, "permission", {
+        principal: "cloudfront.amazonaws.com",
+        action: "lambda:InvokeFunctionUrl",
+        functionName: transformFn.lambda.functionName,
+        functionUrlAuthType: "AWS_IAM",
+        sourceArn: `arn:aws:cloudfront::${ctx.accountId}:distribution/*`
+      });
+      const transformFnUrl = new $22.aws.lambda.FunctionUrl(
+        group,
+        "url",
+        {
+          functionName: transformFn.lambda.functionName,
+          authorizationType: "AWS_IAM"
+        },
+        { dependsOn: [permission] }
+      );
+      transformFn.setEnvironment(
+        "IMAGES_CONFIG",
+        JSON.stringify({
+          presets: props.presets,
+          extensions: props.extensions
+        })
+      );
+      if (lambdaOrigin) {
+        transformFn.setEnvironment("IMAGES_ORIGIN_LAMBDA", lambdaOrigin.name);
+      }
+      if (s3Origin) {
+        transformFn.setEnvironment("IMAGES_ORIGIN_S3", s3Origin.bucket);
+        transformFn.addPermission({
+          actions: [
+            "s3:ListBucket",
+            "s3:ListBucketV2",
+            "s3:HeadObject",
+            "s3:GetObject",
+            "s3:PutObject",
+            "s3:DeleteObject",
+            // 's3:CopyObject',
+            "s3:GetObjectAttributes"
+          ],
+          resources: [
+            //
+            s3Origin.arn,
+            s3Origin.arn.pipe((arn) => `${arn}/*`)
+          ]
+        });
+      }
+      const versions = [];
+      ctx.onReady(() => {
+        if (props.origin.static && s3Origin) {
+          const files = glob3.sync("**", {
+            cwd: props.origin.static,
+            nodir: true
+          });
+          for (const file of files) {
+            const object = new $22.aws.s3.BucketObject(group, `static-${file}`, {
+              bucket: s3Origin.bucket,
+              key: file,
+              cacheControl: "public, max-age=31536000, immutable",
+              contentType: contentType2(extname3(file)) || `image/${extname3(file).slice(1)}`,
+              source: join12(props.origin.static, file),
+              sourceHash: $hash(join12(props.origin.static, file))
+            });
+            versions.push(object.key);
+            versions.push(object.sourceHash);
+          }
+        }
+      });
+      const domainName = props.domain ? formatFullDomainName(ctx.appConfig, props.domain, props.subDomain) : void 0;
+      const certificateArn = props.domain ? ctx.shared.entry("domain", `global-certificate-arn`, props.domain) : void 0;
+      const accessControl = new $22.aws.cloudfront.OriginAccessControl(group, "access", {
+        name,
+        description: "Policy for Images Lambda Transformation Function URL",
+        originAccessControlOriginType: "lambda",
+        signingBehavior: "always",
+        signingProtocol: "sigv4"
+      });
+      const cache = new $22.aws.cloudfront.CachePolicy(group, "cache", {
+        name,
+        defaultTtl: toSeconds8(days6(365))
+      });
+      const distribution = new $22.aws.cloudfront.Distribution(group, "distribution", {
+        comment: name,
+        enabled: true,
+        aliases: domainName ? [domainName] : void 0,
+        priceClass: "PriceClass_All",
+        httpVersion: "http2and3",
+        viewerCertificate: certificateArn ? {
+          sslSupportMethod: "sni-only",
+          minimumProtocolVersion: "TLSv1.2_2021",
+          acmCertificateArn: certificateArn
+        } : {
+          cloudfrontDefaultCertificate: true
+        },
+        origin: [
+          {
+            originId: "default",
+            domainName: transformFnUrl.functionUrl.pipe((url) => url.split("/")[2]),
+            originAccessControlId: accessControl.id,
+            customOriginConfig: {
+              originProtocolPolicy: "https-only",
+              httpPort: 80,
+              httpsPort: 443,
+              originSslProtocols: ["TLSv1.2"]
+            }
+          }
+        ],
+        defaultCacheBehavior: {
+          compress: true,
+          targetOriginId: "default",
+          cachePolicyId: cache.id,
+          viewerProtocolPolicy: "redirect-to-https",
+          allowedMethods: ["GET", "HEAD"],
+          cachedMethods: ["GET", "HEAD"]
+        }
+      });
+      new Invalidation(group, "invalidate", {
+        distributionId: distribution.id,
+        paths: ["/*"],
+        version: new Future4((resolve) => {
+          $combine(...versions).then((versions2) => {
+            const combined = versions2.filter((v) => !!v).sort().join(",");
+            const version = createHash5("sha1").update(combined).digest("hex");
+            resolve(version);
+          });
+        })
+      });
+      if (domainName) {
+        new $22.aws.route53.Record(group, `record`, {
+          zoneId: ctx.shared.entry("domain", "zone-id", props.domain),
+          type: "A",
+          name: domainName,
+          alias: {
+            name: distribution.domainName,
+            zoneId: distribution.hostedZoneId,
+            evaluateTargetHealth: false
+          }
+        });
+        ctx.bind(`IMAGES_${ctx.stack.name}_${constantCase11(id)}_ENDPOINT`, domainName);
+      } else {
+        ctx.bind(`IMAGES_${ctx.stack.name}_${constantCase11(id)}_ENDPOINT`, distribution.domainName);
+      }
+    }
+  }
+});
+
 // src/feature/index.ts
 var features = [
   // 1
@@ -5796,6 +6117,7 @@ var features = [
   // httpFeature,
   restFeature,
   siteFeature,
+  imagesFeature,
   // 4
   rpcFeature
 ];
@@ -6657,13 +6979,13 @@ import wildstring4 from "wildstring";
 import { log as log9 } from "@clack/prompts";
 import chalk5 from "chalk";
 import { mkdir as mkdir4, readFile as readFile5, writeFile as writeFile3 } from "fs/promises";
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 import wildstring3 from "wildstring";
 
 // src/build/__fingerprint.ts
-import { createHash as createHash5 } from "crypto";
+import { createHash as createHash6 } from "crypto";
 import { readdir as readdir4, readFile as readFile4, stat as stat4 } from "fs/promises";
-import { basename as basename4, dirname as dirname8, extname as extname3, join as join12 } from "path";
+import { basename as basename4, dirname as dirname9, extname as extname4, join as join13 } from "path";
 import parseStaticImports from "parse-static-imports";
 var extensions = ["js", "mjs", "jsx", "ts", "mts", "tsx"];
 var generateFileHashes = async (file, hashes) => {
@@ -6672,7 +6994,7 @@ var generateFileHashes = async (file, hashes) => {
   }
   const code = await readModuleFile(file);
   const deps = await findDependencies(file, code);
-  const hash = createHash5("sha1").update(code).digest();
+  const hash = createHash6("sha1").update(code).digest();
   hashes.set(file, hash);
   for (const dep of deps) {
     if (dep.startsWith("/")) {
@@ -6684,12 +7006,12 @@ var fingerprintFromDirectory = async (dir) => {
   const hashes = /* @__PURE__ */ new Map();
   const files = await readdir4(dir, { recursive: true });
   for (const file of files) {
-    if (extensions.includes(extname3(file).substring(1)) && file.at(0) !== "_") {
-      await generateFileHashes(join12(dir, file), hashes);
+    if (extensions.includes(extname4(file).substring(1)) && file.at(0) !== "_") {
+      await generateFileHashes(join13(dir, file), hashes);
     }
   }
   const merge2 = Buffer.concat(Array.from(hashes.values()).sort());
-  return createHash5("sha1").update(merge2).digest("hex");
+  return createHash6("sha1").update(merge2).digest("hex");
 };
 var readModuleFile = (file) => {
   if (file.endsWith(".js")) {
@@ -6699,7 +7021,7 @@ var readModuleFile = (file) => {
     return readFiles([
       file,
       ...extensions.map((exp) => `${file}.${exp}`),
-      ...extensions.map((exp) => join12(file, `/index.${exp}`))
+      ...extensions.map((exp) => join13(file, `/index.${exp}`))
     ]);
   }
   return readFile4(file, "utf8");
@@ -6719,7 +7041,7 @@ var readFiles = async (files) => {
 };
 var findDependencies = async (file, code) => {
   const imports = await parseStaticImports(code);
-  return imports.map((entry) => entry.moduleName).filter(Boolean).map((value) => value?.startsWith(".") ? join12(dirname8(file), value) : value);
+  return imports.map((entry) => entry.moduleName).filter(Boolean).map((value) => value?.startsWith(".") ? join13(dirname9(file), value) : value);
 };
 
 // src/test/reporter.ts
@@ -6799,13 +7121,13 @@ var CustomReporter = class {
 import commonjs2 from "@rollup/plugin-commonjs";
 import json2 from "@rollup/plugin-json";
 import nodeResolve2 from "@rollup/plugin-node-resolve";
-import { dirname as dirname9, join as join13 } from "path";
+import { dirname as dirname10, join as join14 } from "path";
 import { swc as swc2 } from "rollup-plugin-swc3";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { fileURLToPath as fileURLToPath3 } from "url";
 import { configDefaults } from "vitest/config";
 import { startVitest } from "vitest/node";
 var startTest = async (props) => {
-  const __dirname2 = dirname9(fileURLToPath2(import.meta.url));
+  const __dirname3 = dirname10(fileURLToPath3(import.meta.url));
   const result = await startVitest(
     "test",
     props.filters,
@@ -6821,7 +7143,7 @@ var startTest = async (props) => {
       reporters: props.reporter,
       setupFiles: [
         //
-        join13(__dirname2, "test-global-setup.js")
+        join14(__dirname3, "test-global-setup.js")
       ]
       // globalSetup: [
       // 	//
@@ -6920,7 +7242,7 @@ var logTestErrors = (event) => {
 var runTest = async (stack, dir, filters) => {
   await mkdir4(directories.test, { recursive: true });
   const fingerprint = await fingerprintFromDirectory(dir);
-  const file = join14(directories.test, `${stack}.json`);
+  const file = join15(directories.test, `${stack}.json`);
   const exists = await fileExist(file);
   if (exists && !process.env.NO_CACHE) {
     const raw = await readFile5(file, { encoding: "utf8" });
@@ -7159,7 +7481,7 @@ var auth = (program2) => {
 
 // src/cli/command/bind.ts
 import { log as log10, note as note3 } from "@clack/prompts";
-import { constantCase as constantCase11 } from "change-case";
+import { constantCase as constantCase12 } from "change-case";
 import { spawn } from "child_process";
 var bind = (program2) => {
   program2.command("bind").argument("[command...]", "The command to execute").option("--config <string...>", "List of config values that will be accessable", (v) => v.split(",")).description(`Bind your site environment variables to a command`).action(async (commands7 = [], opts) => {
@@ -7188,10 +7510,10 @@ var bind = (program2) => {
       const configList = opts.config ?? [];
       const configs = {};
       for (const name of configList) {
-        configs[`CONFIG_${constantCase11(name)}`] = name;
+        configs[`CONFIG_${constantCase12(name)}`] = name;
       }
       if (configList.length ?? 0 > 0) {
-        note3(wrap(configList.map((v) => color.label(constantCase11(v)))), "Bind Config");
+        note3(wrap(configList.map((v) => color.label(constantCase12(v)))), "Bind Config");
       }
       if (commands7.length === 0) {
         return "No command to execute.";
@@ -7254,7 +7576,7 @@ import { log as log11 } from "@clack/prompts";
 
 // src/type-gen/generate.ts
 import { mkdir as mkdir5, writeFile as writeFile4 } from "fs/promises";
-import { dirname as dirname10, join as join15, relative as relative7 } from "path";
+import { dirname as dirname11, join as join16, relative as relative7 } from "path";
 var generateTypes = async (props) => {
   const files = [];
   await Promise.all(
@@ -7263,12 +7585,12 @@ var generateTypes = async (props) => {
         ...props,
         async write(file, data, include = false) {
           const code = data?.toString("utf8");
-          const path = join15(directories.types, file);
+          const path = join16(directories.types, file);
           if (code) {
             if (include) {
               files.push(relative7(directories.root, path));
             }
-            await mkdir5(dirname10(path), { recursive: true });
+            await mkdir5(dirname11(path), { recursive: true });
             await writeFile4(path, code);
           }
         }
@@ -7277,7 +7599,7 @@ var generateTypes = async (props) => {
   );
   if (files.length) {
     const code = files.map((file) => `/// <reference path='${file}' />`).join("\n");
-    await writeFile4(join15(directories.root, `awsless.d.ts`), code);
+    await writeFile4(join16(directories.root, `awsless.d.ts`), code);
   }
 };