@awsless/awsless 0.0.509 → 0.0.510

package/dist/bin.js

@@ -833,7 +833,7 @@ var LogRetentionSchema = DurationSchema.refine(
   (duration) => {
     return validLogRetentionDays.includes(toDays(duration));
   },
-  `Invalid log retention. Valid days are: ${validLogRetentionDays.map((days7) => `${days7}`).join(", ")}`
+  `Invalid log retention. Valid days are: ${validLogRetentionDays.map((days8) => `${days8}`).join(", ")}`
 ).describe("The log retention duration.");
 var LogSchema = z14.union([
   z14.boolean().transform((enabled) => ({ retention: enabled ? days(7) : days(0) })),
@@ -912,11 +912,11 @@ var FunctionDefaultSchema = z14.object({
   // container
   warm: WarmSchema.default(0),
   vpc: VPCSchema.default(false),
-  log: LogSchema.default(true).transform((log23) => ({
-    retention: log23.retention ?? days(7),
-    level: "level" in log23 ? log23.level : "error",
-    system: "system" in log23 ? log23.system : "warn",
-    format: "format" in log23 ? log23.format : "json"
+  log: LogSchema.default(true).transform((log25) => ({
+    retention: log25.retention ?? days(7),
+    level: "level" in log25 ? log25.level : "error",
+    system: "system" in log25 ? log25.system : "warn",
+    format: "format" in log25 ? log25.format : "json"
   })),
   timeout: TimeoutSchema.default("10 seconds"),
   memorySize: MemorySizeSchema.default("128 MB"),
@@ -1213,7 +1213,7 @@ var AppSchema = z24.object({
 });
 
 // src/config/stack.ts
-import { z as z39 } from "zod";
+import { z as z40 } from "zod";
 
 // src/feature/cache/schema.ts
 import { gibibytes as gibibytes2 } from "@awsless/size";
@@ -1657,44 +1657,22 @@ var StoresSchema = z33.union([
   )
 ]).optional().describe("Define the stores in your stack.");
 
-// src/feature/images/schema.ts
+// src/feature/icon/schema.ts
 import { z as z34 } from "zod";
-var transformationOptionsSchema = z34.object({
-  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(),
-  quality: z34.number().int().min(1).max(100).optional()
-});
 var staticOriginSchema = LocalDirectorySchema.describe(
-  "Specifies the path to a image directory that will be uploaded in S3."
+  "Specifies the path to a local 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."
+  "Specifies the file that will be called when an image isn't found in the (cache) bucket."
 );
-var ImagesSchema = z34.record(
+var IconsSchema = z34.record(
   ResourceIdSchema,
   z34.object({
     domain: ResourceIdSchema.describe("The domain id to link your site with.").optional(),
     subDomain: z34.string().optional(),
     log: LogSchema.optional(),
-    presets: z34.record(z34.string(), transformationOptionsSchema).describe("Named presets for image transformations"),
-    extensions: z34.object({
-      jpeg: z34.object({
-        mozjpeg: z34.boolean().optional(),
-        progressive: z34.boolean().optional()
-      }).optional(),
-      webp: z34.object({
-        effort: z34.number().int().min(0).max(6).optional(),
-        lossless: z34.boolean().optional(),
-        nearLossless: z34.boolean().optional()
-      }).optional(),
-      png: z34.object({
-        compressionLevel: z34.number().int().min(0).max(9).optional()
-      }).optional()
-    }).refine((data) => {
-      return Object.keys(data).length > 0;
-    }, "At least one extension must be defined.").describe("Image format-specific options for transformations"),
+    preserveId: z34.boolean().optional().default(false).describe("Preserve the IDs of the icons."),
+    symbols: z34.boolean().optional().default(false).describe("Use SVG symbols for icons."),
     origin: z34.union([
       z34.object({
         static: staticOriginSchema,
@@ -1711,29 +1689,86 @@ var ImagesSchema = z34.record(
     ]).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."
     ),
-    version: z34.number().int().min(1).optional().describe("Version of the image configuration.")
-    // postprocess: FunctionSchema.optional()
+    version: z34.number().int().min(1).optional().describe("Version of the icon configuration.")
   })
-).optional().describe("Define image CDN & transformations in your stack.");
+).optional().describe("Define an icon proxy in your stack. Store, optimize, and deliver icons at scale.");
 
-// src/feature/table/schema.ts
-import { minutes as minutes4, seconds as seconds4 } from "@awsless/duration";
+// src/feature/image/schema.ts
 import { z as z35 } from "zod";
-var KeySchema = z35.string().min(1).max(255);
-var TablesSchema = z35.record(
+var transformationOptionsSchema = z35.object({
+  width: z35.number().int().positive().optional(),
+  height: z35.number().int().positive().optional(),
+  fit: z35.enum(["cover", "contain", "fill", "inside", "outside"]).optional(),
+  position: z35.enum(["top", "right top", "right", "right bottom", "bottom", "left bottom", "left", "left top", "center"]).optional(),
+  quality: z35.number().int().min(1).max(100).optional()
+});
+var staticOriginSchema2 = LocalDirectorySchema.describe(
+  "Specifies the path to a local image directory that will be uploaded in S3."
+);
+var functionOriginSchema2 = FunctionSchema.describe(
+  "Specifies the file that will be called when an image isn't found in the (cache) bucket."
+);
+var ImagesSchema = z35.record(
   ResourceIdSchema,
   z35.object({
+    domain: ResourceIdSchema.describe("The domain id to link your site with.").optional(),
+    subDomain: z35.string().optional(),
+    log: LogSchema.optional(),
+    presets: z35.record(z35.string(), transformationOptionsSchema).describe("Named presets for image transformations"),
+    extensions: z35.object({
+      jpeg: z35.object({
+        mozjpeg: z35.boolean().optional(),
+        progressive: z35.boolean().optional()
+      }).optional(),
+      webp: z35.object({
+        effort: z35.number().int().min(1).max(10).default(7).optional(),
+        lossless: z35.boolean().optional(),
+        nearLossless: z35.boolean().optional()
+      }).optional(),
+      png: z35.object({
+        compressionLevel: z35.number().int().min(0).max(9).default(6).optional()
+      }).optional()
+    }).refine((data) => {
+      return Object.keys(data).length > 0;
+    }, "At least one extension must be defined.").describe("Specify the allowed extensions."),
+    origin: z35.union([
+      z35.object({
+        static: staticOriginSchema2,
+        function: functionOriginSchema2.optional()
+      }),
+      z35.object({
+        static: staticOriginSchema2.optional(),
+        function: functionOriginSchema2
+      }),
+      z35.object({
+        static: staticOriginSchema2,
+        function: functionOriginSchema2
+      })
+    ]).describe(
+      "Specify the origin of your images. Image transformation will be applied from a base image. Base images can be loaded from a S3 bucket (that is synced from a local directory) or dynamicly from a lambda function."
+    ),
+    version: z35.number().int().min(1).optional().describe("Version of the image configuration.")
+  })
+).optional().describe("Define an image proxy in your stack. Store, transform, optimize, and deliver images at scale.");
+
+// src/feature/table/schema.ts
+import { minutes as minutes4, seconds as seconds4 } from "@awsless/duration";
+import { z as z36 } from "zod";
+var KeySchema = z36.string().min(1).max(255);
+var TablesSchema = z36.record(
+  ResourceIdSchema,
+  z36.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: z35.record(z35.string(), z35.enum(["string", "number", "binary"])).optional().describe(
+    fields: z36.record(z36.string(), z36.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: 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."),
+    class: z36.enum(["standard", "standard-infrequent-access"]).default("standard").describe("The table class of the table."),
+    pointInTimeRecovery: z36.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.",
@@ -1741,8 +1776,8 @@ var TablesSchema = z35.record(
       ].join("\n")
     ),
     // deletionProtection: DeletionProtectionSchema.optional(),
-    stream: z35.object({
-      type: z35.enum(["keys-only", "new-image", "old-image", "new-and-old-images"]).describe(
+    stream: z36.object({
+      type: z36.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:",
@@ -1752,7 +1787,7 @@ var TablesSchema = z35.record(
           "- new-and-old-images - Both the new and the old item images of the item are written to the stream."
         ].join("\n")
       ),
-      batchSize: z35.number().min(1).max(1e4).default(1).describe(
+      batchSize: z36.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).",
@@ -1782,7 +1817,7 @@ var TablesSchema = z35.record(
       // 			'You can specify a number from -1 to 10000.',
       // 		].join('\n')
       // 	),
-      retryAttempts: z35.number().min(-1).max(1e4).default(-1).describe(
+      retryAttempts: z36.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.",
@@ -1790,7 +1825,7 @@ var TablesSchema = z35.record(
           "You can specify a number from -1 to 10000."
         ].join("\n")
       ),
-      concurrencyPerShard: z35.number().min(1).max(10).default(1).describe(
+      concurrencyPerShard: z36.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."
@@ -1800,16 +1835,16 @@ var TablesSchema = z35.record(
     }).optional().describe(
       "The settings for the DynamoDB table stream, which capture changes to items stored in the table."
     ),
-    indexes: z35.record(
-      z35.string(),
-      z35.object({
+    indexes: z36.record(
+      z36.string(),
+      z36.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: z35.enum(["all", "keys-only"]).default("all").describe(
+        projection: z36.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.",
@@ -1823,11 +1858,11 @@ var TablesSchema = z35.record(
 ).optional().describe("Define the tables in your stack.");
 
 // src/feature/task/schema.ts
-import { z as z36 } from "zod";
-var RetryAttemptsSchema2 = z36.number().int().min(0).max(2).describe(
+import { z as z37 } from "zod";
+var RetryAttemptsSchema2 = z37.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 = z36.union([
+var TaskSchema = z37.union([
   LocalFileSchema.transform((file) => ({
     consumer: {
       code: {
@@ -1838,33 +1873,33 @@ var TaskSchema = z36.union([
     },
     retryAttempts: void 0
   })),
-  z36.object({
+  z37.object({
     consumer: FunctionSchema,
     retryAttempts: RetryAttemptsSchema2.optional()
   })
 ]);
-var TasksSchema = z36.record(ResourceIdSchema, TaskSchema).optional().describe("Define the tasks in your stack.");
+var TasksSchema = z37.record(ResourceIdSchema, TaskSchema).optional().describe("Define the tasks in your stack.");
 
 // src/feature/test/schema.ts
-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();
+import { z as z38 } from "zod";
+var TestsSchema = z38.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 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) => {
+import { z as z39 } from "zod";
+var TopicNameSchema = z39.string().min(3).max(256).regex(/^[a-z0-9\-]+$/i, "Invalid topic name").transform((value) => kebabCase3(value)).describe("Define event topic name.");
+var TopicsSchema = z39.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 = z38.record(TopicNameSchema, FunctionSchema).optional().describe("Define the event topics to subscribe too in your stack.");
+var SubscribersSchema = z39.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 = z39.object({
-  $schema: z39.string().optional(),
+var StackSchema = z40.object({
+  $schema: z40.string().optional(),
   name: NameSchema,
   depends: DependsSchema,
   commands: CommandsSchema,
@@ -1890,7 +1925,8 @@ var StackSchema = z39.object({
   searchs: SearchsSchema,
   sites: SitesSchema,
   tests: TestsSchema,
-  images: ImagesSchema
+  images: ImagesSchema,
+  icons: IconsSchema
 });
 
 // src/config/load/read.ts
@@ -1932,13 +1968,13 @@ var readConfigWithStage = async (file, stage) => {
 };
 
 // src/config/load/validate.ts
-import { z as z40 } from "zod";
+import { z as z41 } from "zod";
 var validateConfig = async (schema, file, data) => {
   try {
     const result = await schema.parseAsync(data);
     return result;
   } catch (error) {
-    if (error instanceof z40.ZodError) {
+    if (error instanceof z41.ZodError) {
       throw new ConfigError(file, error, data);
     }
     throw error;
@@ -5944,7 +5980,7 @@ var layerFeature = defineFeature({
   }
 });
 
-// src/feature/images/index.ts
+// src/feature/image/index.ts
 import { $ as $22, Group as Group23 } from "@awsless/formation";
 import { join as join12, dirname as dirname8 } from "path";
 import { mebibytes as mebibytes4 } from "@awsless/size";
@@ -5953,8 +5989,8 @@ import { constantCase as constantCase11 } from "change-case";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { glob as glob3 } from "glob";
 var __dirname2 = dirname8(fileURLToPath2(import.meta.url));
-var imagesFeature = defineFeature({
-  name: "images",
+var imageFeature = defineFeature({
+  name: "image",
   onApp(ctx) {
     const found = ctx.stackConfigs.filter((stack) => {
       return Object.keys(stack.images ?? {}).length > 0;
@@ -5978,7 +6014,7 @@ var imagesFeature = defineFeature({
     });
     const layer = new $22.aws.lambda.LayerVersion(group, "layer", {
       layerName: layerId,
-      description: "sharp-arm.zip for the awsless images feature.",
+      description: "sharp-arm.zip for the awsless image feature.",
       compatibleArchitectures: ["arm64"],
       s3Bucket: zipFile.bucket,
       s3ObjectVersion: zipFile.versionId,
@@ -5994,11 +6030,11 @@ var imagesFeature = defineFeature({
   },
   onStack(ctx) {
     for (const [id, props] of Object.entries(ctx.stackConfig.images ?? {})) {
-      const group = new Group23(ctx.stack, "images", id);
+      const group = new Group23(ctx.stack, "image", id);
       const name = formatLocalResourceName({
         appName: ctx.app.name,
         stackName: ctx.stack.name,
-        resourceType: "images",
+        resourceType: "image",
         resourceName: id
       });
       let lambdaOrigin = void 0;
@@ -6011,7 +6047,7 @@ var imagesFeature = defineFeature({
           bucket: formatLocalResourceName({
             appName: ctx.app.name,
             stackName: ctx.stack.name,
-            resourceType: "images",
+            resourceType: "image",
             resourceName: id,
             postfix: ctx.appId
           }),
@@ -6022,7 +6058,7 @@ var imagesFeature = defineFeature({
         bucket: formatLocalResourceName({
           appName: ctx.app.name,
           stackName: ctx.stack.name,
-          resourceType: "images",
+          resourceType: "image",
           resourceName: `cache-${id}`,
           postfix: ctx.appId
         }),
@@ -6033,9 +6069,9 @@ var imagesFeature = defineFeature({
         resourceType: "layer",
         resourceName: "sharp"
       });
-      const transformFn = createPrebuildLambdaFunction(group, ctx, "images", id, {
-        bundleFile: join12(__dirname2, "/prebuild/images/bundle.zip"),
-        bundleHash: join12(__dirname2, "/prebuild/images/HASH"),
+      const serverLambda = createPrebuildLambdaFunction(group, ctx, "image", id, {
+        bundleFile: join12(__dirname2, "/prebuild/image/bundle.zip"),
+        bundleHash: join12(__dirname2, "/prebuild/image/HASH"),
         memorySize: mebibytes4(512),
         timeout: seconds9(10),
         handler: "index.default",
@@ -6046,20 +6082,20 @@ var imagesFeature = defineFeature({
       const permission = new $22.aws.lambda.Permission(group, "permission", {
         principal: "cloudfront.amazonaws.com",
         action: "lambda:InvokeFunctionUrl",
-        functionName: transformFn.lambda.functionName,
+        functionName: serverLambda.lambda.functionName,
         functionUrlAuthType: "AWS_IAM",
         sourceArn: `arn:aws:cloudfront::${ctx.accountId}:distribution/*`
       });
-      const transformFnUrl = new $22.aws.lambda.FunctionUrl(
+      const serverLambdaUrl = new $22.aws.lambda.FunctionUrl(
         group,
         "url",
         {
-          functionName: transformFn.lambda.functionName,
+          functionName: serverLambda.lambda.functionName,
           authorizationType: "AWS_IAM"
         },
         { dependsOn: [permission] }
       );
-      transformFn.addPermission({
+      serverLambda.addPermission({
         actions: [
           "s3:ListBucket",
           "s3:ListBucketV2",
@@ -6076,20 +6112,20 @@ var imagesFeature = defineFeature({
           ...s3Origin ? [s3Origin.arn, s3Origin.arn.pipe((arn) => `${arn}/*`)] : []
         ]
       });
-      transformFn.setEnvironment(
-        "IMAGES_CONFIG",
+      serverLambda.setEnvironment(
+        "IMAGE_CONFIG",
         JSON.stringify({
           presets: props.presets,
           extensions: props.extensions,
           version: props.version
         })
       );
-      transformFn.setEnvironment("IMAGES_CACHE_BUCKET", cacheBucket.bucket);
+      serverLambda.setEnvironment("IMAGE_CACHE_BUCKET", cacheBucket.bucket);
       if (lambdaOrigin) {
-        transformFn.setEnvironment("IMAGES_ORIGIN_LAMBDA", lambdaOrigin.name);
+        serverLambda.setEnvironment("IMAGE_ORIGIN_LAMBDA", lambdaOrigin.name);
       }
       if (s3Origin) {
-        transformFn.setEnvironment("IMAGES_ORIGIN_S3", s3Origin.bucket);
+        serverLambda.setEnvironment("IMAGE_ORIGIN_S3", s3Origin.bucket);
       }
       ctx.onReady(() => {
         if (props.origin.static && s3Origin) {
@@ -6111,14 +6147,14 @@ var imagesFeature = defineFeature({
       const certificateArn = props.domain ? ctx.shared.entry("domain", `global-certificate-arn`, props.domain) : void 0;
       const s3AccessControl = new $22.aws.cloudfront.OriginAccessControl(group, `s3`, {
         name: `${name}-s3`,
-        description: "Policy for Images cache in S3",
+        description: `Policy for the ${id} image cache in S3`,
         originAccessControlOriginType: "s3",
         signingBehavior: "always",
         signingProtocol: "sigv4"
       });
       const lambdaAccessControl = new $22.aws.cloudfront.OriginAccessControl(group, "lambda", {
         name: `${name}-lambda`,
-        description: "Policy for Images Lambda Transformation Function URL",
+        description: `Policy for the ${id} image lambda server function URL`,
         originAccessControlOriginType: "lambda",
         signingBehavior: "always",
         signingProtocol: "sigv4"
@@ -6151,8 +6187,8 @@ var imagesFeature = defineFeature({
             }
           },
           {
-            originId: "transform",
-            domainName: transformFnUrl.functionUrl.pipe((url) => url.split("/")[2]),
+            originId: "server",
+            domainName: serverLambdaUrl.functionUrl.pipe((url) => url.split("/")[2]),
             originAccessControlId: lambdaAccessControl.id,
             customOriginConfig: {
               originProtocolPolicy: "https-only",
@@ -6165,7 +6201,7 @@ var imagesFeature = defineFeature({
         originGroup: [
           {
             originId: "group",
-            member: [{ originId: "cache" }, { originId: "transform" }],
+            member: [{ originId: "cache" }, { originId: "server" }],
             failoverCriteria: {
               statusCodes: [403, 404]
             }
@@ -6223,9 +6259,260 @@ var imagesFeature = defineFeature({
         });
       }
       ctx.bind(
-        `IMAGES_${constantCase11(ctx.stack.name)}_${constantCase11(id)}_ENDPOINT`,
+        `IMAGE_${constantCase11(ctx.stack.name)}_${constantCase11(id)}_ENDPOINT`,
         domainName ?? distribution.domainName
       );
+      ctx.shared.add("image", "distribution-id", id, distribution.id);
+      ctx.shared.add("image", "cache-bucket", id, cacheBucket.bucket);
+    }
+  }
+});
+
+// src/feature/icon/index.ts
+import { $ as $23, Group as Group24 } from "@awsless/formation";
+import { join as join13, dirname as dirname9 } from "path";
+import { mebibytes as mebibytes5 } from "@awsless/size";
+import { days as days7, seconds as seconds10, toSeconds as toSeconds9 } from "@awsless/duration";
+import { constantCase as constantCase12 } from "change-case";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import { glob as glob4 } from "glob";
+var __dirname3 = dirname9(fileURLToPath3(import.meta.url));
+var iconFeature = defineFeature({
+  name: "icon",
+  onStack(ctx) {
+    for (const [id, props] of Object.entries(ctx.stackConfig.icons ?? {})) {
+      const group = new Group24(ctx.stack, "icon", id);
+      const name = formatLocalResourceName({
+        appName: ctx.app.name,
+        stackName: ctx.stack.name,
+        resourceType: "icon",
+        resourceName: id
+      });
+      let lambdaOrigin = void 0;
+      if (props.origin.function) {
+        lambdaOrigin = createLambdaFunction(group, ctx, "origin", id, props.origin.function);
+      }
+      let s3Origin;
+      if (props.origin.static) {
+        s3Origin = new $23.aws.s3.Bucket(group, "origin", {
+          bucket: formatLocalResourceName({
+            appName: ctx.app.name,
+            stackName: ctx.stack.name,
+            resourceType: "icon",
+            resourceName: id,
+            postfix: ctx.appId
+          }),
+          forceDestroy: true
+        });
+      }
+      const cacheBucket = new $23.aws.s3.Bucket(group, "cache", {
+        bucket: formatLocalResourceName({
+          appName: ctx.app.name,
+          stackName: ctx.stack.name,
+          resourceType: "icon",
+          resourceName: `cache-${id}`,
+          postfix: ctx.appId
+        }),
+        forceDestroy: true
+      });
+      const serverLambda = createPrebuildLambdaFunction(group, ctx, "icon", id, {
+        bundleFile: join13(__dirname3, "/prebuild/icon/bundle.zip"),
+        bundleHash: join13(__dirname3, "/prebuild/icon/HASH"),
+        memorySize: mebibytes5(1024),
+        timeout: seconds10(60),
+        architecture: "x86_64",
+        handler: "index.default",
+        runtime: "nodejs22.x",
+        log: props.log
+      });
+      const permission = new $23.aws.lambda.Permission(group, "permission", {
+        principal: "cloudfront.amazonaws.com",
+        action: "lambda:InvokeFunctionUrl",
+        functionName: serverLambda.lambda.functionName,
+        functionUrlAuthType: "AWS_IAM",
+        sourceArn: `arn:aws:cloudfront::${ctx.accountId}:distribution/*`
+      });
+      const serverLambdaUrl = new $23.aws.lambda.FunctionUrl(
+        group,
+        "url",
+        {
+          functionName: serverLambda.lambda.functionName,
+          authorizationType: "AWS_IAM"
+        },
+        { dependsOn: [permission] }
+      );
+      serverLambda.addPermission({
+        actions: [
+          "s3:ListBucket",
+          "s3:ListBucketV2",
+          "s3:HeadObject",
+          "s3:GetObject",
+          "s3:PutObject",
+          "s3:DeleteObject",
+          "s3:GetObjectAttributes"
+        ],
+        resources: [
+          //
+          cacheBucket.arn,
+          cacheBucket.arn.pipe((arn) => `${arn}/*`),
+          ...s3Origin ? [s3Origin.arn, s3Origin.arn.pipe((arn) => `${arn}/*`)] : []
+        ]
+      });
+      serverLambda.setEnvironment(
+        "ICON_CONFIG",
+        JSON.stringify({
+          preserveId: props.preserveId,
+          symbols: props.symbols,
+          version: props.version
+        })
+      );
+      serverLambda.setEnvironment("ICON_CACHE_BUCKET", cacheBucket.bucket);
+      if (lambdaOrigin) {
+        serverLambda.setEnvironment("ICON_ORIGIN_LAMBDA", lambdaOrigin.name);
+      }
+      if (s3Origin) {
+        serverLambda.setEnvironment("ICON_ORIGIN_S3", s3Origin.bucket);
+      }
+      ctx.onReady(() => {
+        if (props.origin.static && s3Origin) {
+          const files = glob4.sync("**", {
+            cwd: props.origin.static,
+            nodir: true
+          });
+          for (const file of files) {
+            if (!file.endsWith(".svg")) {
+              throw new Error(`Icon file "${file}" in "${props.origin.static}" is not an SVG file.`);
+            }
+            new $23.aws.s3.BucketObject(group, `static-${file}`, {
+              bucket: s3Origin.bucket,
+              key: file,
+              source: join13(props.origin.static, file),
+              sourceHash: $hash(join13(props.origin.static, file))
+            });
+          }
+        }
+      });
+      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 s3AccessControl = new $23.aws.cloudfront.OriginAccessControl(group, `s3`, {
+        name: `${name}-s3`,
+        description: `Policy for the ${id} icon cache in S3`,
+        originAccessControlOriginType: "s3",
+        signingBehavior: "always",
+        signingProtocol: "sigv4"
+      });
+      const lambdaAccessControl = new $23.aws.cloudfront.OriginAccessControl(group, "lambda", {
+        name: `${name}-lambda`,
+        description: `Policy for the ${id} icon lambda server function URL`,
+        originAccessControlOriginType: "lambda",
+        signingBehavior: "always",
+        signingProtocol: "sigv4"
+      });
+      const cache = new $23.aws.cloudfront.CachePolicy(group, "cache", {
+        name,
+        defaultTtl: toSeconds9(days7(365))
+      });
+      const distribution = new $23.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: "cache",
+            domainName: cacheBucket.bucketRegionalDomainName,
+            originAccessControlId: s3AccessControl.id,
+            s3OriginConfig: {
+              // is required to have an value for s3 origins when using origin access control
+              originAccessIdentity: ""
+            }
+          },
+          {
+            originId: "server",
+            domainName: serverLambdaUrl.functionUrl.pipe((url) => url.split("/")[2]),
+            originAccessControlId: lambdaAccessControl.id,
+            customOriginConfig: {
+              originProtocolPolicy: "https-only",
+              httpPort: 80,
+              httpsPort: 443,
+              originSslProtocols: ["TLSv1.2"]
+            }
+          }
+        ],
+        originGroup: [
+          {
+            originId: "group",
+            member: [{ originId: "cache" }, { originId: "server" }],
+            failoverCriteria: {
+              statusCodes: [403, 404]
+            }
+          }
+        ],
+        defaultCacheBehavior: {
+          compress: true,
+          targetOriginId: "group",
+          cachePolicyId: cache.id,
+          viewerProtocolPolicy: "redirect-to-https",
+          allowedMethods: ["GET", "HEAD"],
+          cachedMethods: ["GET", "HEAD"]
+        }
+      });
+      new $23.aws.s3.BucketPolicy(
+        group,
+        `policy`,
+        {
+          bucket: cacheBucket.bucket,
+          policy: $resolve([cacheBucket.arn, distribution.id], (arn, id2) => {
+            return JSON.stringify({
+              Version: "2012-10-17",
+              Statement: [
+                {
+                  Effect: "Allow",
+                  Action: "s3:GetObject",
+                  Resource: `${arn}/*`,
+                  Principal: {
+                    Service: "cloudfront.amazonaws.com"
+                  },
+                  Condition: {
+                    StringEquals: {
+                      "AWS:SourceArn": `arn:aws:cloudfront::${ctx.accountId}:distribution/${id2}`
+                    }
+                  }
+                }
+              ]
+            });
+          })
+        },
+        {
+          dependsOn: [cacheBucket, distribution]
+        }
+      );
+      if (domainName) {
+        new $23.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(
+        `ICON_${constantCase12(ctx.stack.name)}_${constantCase12(id)}_ENDPOINT`,
+        domainName ?? distribution.domainName
+      );
+      ctx.shared.add("icon", "distribution-id", id, distribution.id);
+      ctx.shared.add("icon", "cache-bucket", id, cacheBucket.bucket);
     }
   }
 });
@@ -6262,7 +6549,8 @@ var features = [
   // httpFeature,
   restFeature,
   siteFeature,
-  imagesFeature,
+  imageFeature,
+  iconFeature,
   // 4
   rpcFeature
 ];
@@ -6608,7 +6896,7 @@ var createApp = (props) => {
     region: props.appConfig.region,
     appName: props.appConfig.name
   });
-  const commands7 = [];
+  const commands9 = [];
   const configs = /* @__PURE__ */ new Set();
   const tests = [];
   const builders = [];
@@ -6668,7 +6956,7 @@ var createApp = (props) => {
         });
       },
       registerCommand(command) {
-        commands7.push(command);
+        commands9.push(command);
       },
       registerDomainZone(zone) {
         domainZones.push(zone);
@@ -6760,7 +7048,7 @@ var createApp = (props) => {
           configs.add(name);
         },
         registerCommand(command) {
-          commands7.push(command);
+          commands9.push(command);
         },
         registerDomainZone(zone) {
           domainZones.push(zone);
@@ -6853,7 +7141,7 @@ var createApp = (props) => {
     shared,
     configs,
     builders,
-    commands: commands7
+    commands: commands9
     // deploymentLine,
   };
 };
@@ -7127,13 +7415,13 @@ import wildstring4 from "wildstring";
 import { log as log15 } from "@awsless/clui";
 import chalk4 from "chalk";
 import { mkdir as mkdir4, readFile as readFile5, writeFile as writeFile3 } from "fs/promises";
-import { join as join15 } from "path";
+import { join as join16 } from "path";
 import wildstring3 from "wildstring";
 
 // src/build/__fingerprint.ts
 import { createHash as createHash5 } from "crypto";
 import { readdir as readdir4, readFile as readFile4, stat as stat4 } from "fs/promises";
-import { basename as basename4, dirname as dirname9, extname as extname3, join as join13 } from "path";
+import { basename as basename4, dirname as dirname10, extname as extname3, join as join14 } from "path";
 import parseStaticImports from "parse-static-imports";
 var extensions = ["js", "mjs", "jsx", "ts", "mts", "tsx"];
 var generateFileHashes = async (file, hashes) => {
@@ -7155,7 +7443,7 @@ var fingerprintFromDirectory = async (dir) => {
   const files = await readdir4(dir, { recursive: true });
   for (const file of files) {
     if (extensions.includes(extname3(file).substring(1)) && file.at(0) !== "_") {
-      await generateFileHashes(join13(dir, file), hashes);
+      await generateFileHashes(join14(dir, file), hashes);
     }
   }
   const merge2 = Buffer.concat(Array.from(hashes.values()).sort());
@@ -7169,7 +7457,7 @@ var readModuleFile = (file) => {
     return readFiles([
       file,
       ...extensions.map((exp) => `${file}.${exp}`),
-      ...extensions.map((exp) => join13(file, `/index.${exp}`))
+      ...extensions.map((exp) => join14(file, `/index.${exp}`))
     ]);
   }
   return readFile4(file, "utf8");
@@ -7189,7 +7477,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(".") ? join13(dirname9(file), value) : value);
+  return imports.map((entry) => entry.moduleName).filter(Boolean).map((value) => value?.startsWith(".") ? join14(dirname10(file), value) : value);
 };
 
 // src/test/reporter.ts
@@ -7247,8 +7535,8 @@ var CustomReporter = class {
       this.cache = cache;
     }
   }
-  onUserConsoleLog(log23) {
-    this.logs.push(log23.content.trimEnd());
+  onUserConsoleLog(log25) {
+    this.logs.push(log25.content.trimEnd());
   }
   runningTask(tasks) {
     return tasks.find((t) => t.result?.state === "run");
@@ -7269,13 +7557,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 dirname10, join as join14 } from "path";
+import { dirname as dirname11, join as join15 } from "path";
 import { swc as swc2 } from "rollup-plugin-swc3";
-import { fileURLToPath as fileURLToPath3 } from "url";
+import { fileURLToPath as fileURLToPath4 } from "url";
 import { configDefaults } from "vitest/config";
 import { startVitest } from "vitest/node";
 var startTest = async (props) => {
-  const __dirname3 = dirname10(fileURLToPath3(import.meta.url));
+  const __dirname4 = dirname11(fileURLToPath4(import.meta.url));
   const result = await startVitest(
     "test",
     props.filters,
@@ -7291,7 +7579,7 @@ var startTest = async (props) => {
       reporters: props.reporter,
       setupFiles: [
         //
-        join14(__dirname3, "test-global-setup.js")
+        join15(__dirname4, "test-global-setup.js")
       ]
       // globalSetup: [
       // 	//
@@ -7350,7 +7638,7 @@ var formatResult = (props) => {
 var logTestLogs = (event) => {
   if (event.logs.length > 0) {
     log15.message(color.info.bold.inverse(" LOGS "), color.dim(icon.dot));
-    log15.message(event.logs.map((log23) => wrap(log23, { hard: true })).join("\n"));
+    log15.message(event.logs.map((log25) => wrap(log25, { hard: true })).join("\n"));
   }
 };
 var logTestErrors = (event) => {
@@ -7381,7 +7669,7 @@ var logTestErrors = (event) => {
 var runTest = async (stack, dir, filters) => {
   await mkdir4(directories.test, { recursive: true });
   const fingerprint = await fingerprintFromDirectory(dir);
-  const file = join15(directories.test, `${stack}.json`);
+  const file = join16(directories.test, `${stack}.json`);
   const exists = await fileExist(file);
   if (exists && !process.env.NO_CACHE) {
     const raw = await readFile5(file, { encoding: "utf8" });
@@ -7618,10 +7906,10 @@ var auth = (program2) => {
 
 // src/cli/command/bind.ts
 import { log as log17 } from "@awsless/clui";
-import { constantCase as constantCase12 } from "change-case";
+import { constantCase as constantCase13 } 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) => {
+  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 (commands9 = [], opts) => {
     await layout("bind", async ({ appConfig, stackConfigs }) => {
       const region = appConfig.region;
       const profile = appConfig.profile;
@@ -7647,15 +7935,15 @@ var bind = (program2) => {
       const configList = opts.config ?? [];
       const configs = {};
       for (const name of configList) {
-        configs[`CONFIG_${constantCase12(name)}`] = name;
+        configs[`CONFIG_${constantCase13(name)}`] = name;
       }
       if (configList.length ?? 0 > 0) {
-        log17.note("Bind Config", configList.map((v) => color.label(constantCase12(v))).join("\n"));
+        log17.note("Bind Config", configList.map((v) => color.label(constantCase13(v))).join("\n"));
       }
-      if (commands7.length === 0) {
+      if (commands9.length === 0) {
         return "No command to execute.";
       }
-      const command = commands7.join(" ");
+      const command = commands9.join(" ");
       const freshCred = await credentials();
       spawn(command, {
         env: {
@@ -7713,7 +8001,7 @@ import { log as log18 } from "@awsless/clui";
 
 // src/type-gen/generate.ts
 import { mkdir as mkdir5, writeFile as writeFile4 } from "fs/promises";
-import { dirname as dirname11, join as join16, relative as relative7 } from "path";
+import { dirname as dirname12, join as join17, relative as relative7 } from "path";
 var generateTypes = async (props) => {
   const files = [];
   await Promise.all(
@@ -7722,12 +8010,12 @@ var generateTypes = async (props) => {
         ...props,
         async write(file, data, include = false) {
           const code = data?.toString("utf8");
-          const path = join16(directories.types, file);
+          const path = join17(directories.types, file);
           if (code) {
             if (include) {
               files.push(relative7(directories.root, path));
             }
-            await mkdir5(dirname11(path), { recursive: true });
+            await mkdir5(dirname12(path), { recursive: true });
             await writeFile4(path, code);
           }
         }
@@ -7736,7 +8024,7 @@ var generateTypes = async (props) => {
   );
   if (files.length) {
     const code = files.map((file) => `/// <reference path='${file}' />`).join("\n");
-    await writeFile4(join16(directories.root, `awsless.d.ts`), code);
+    await writeFile4(join17(directories.root, `awsless.d.ts`), code);
   }
 };
 
@@ -7811,17 +8099,17 @@ var run = (program2) => {
       const region = appConfig.region;
       const credentials = getCredentials(appConfig.profile);
       const accountId = await getAccountId(credentials, region);
-      const { commands: commands7 } = createApp({ appConfig, stackConfigs, accountId });
+      const { commands: commands9 } = createApp({ appConfig, stackConfigs, accountId });
       let command;
       if (selected) {
-        command = commands7.find((cmd) => {
+        command = commands9.find((cmd) => {
           return cmd.name === selected;
         });
       } else {
         command = await prompt7.select({
           message: "Pick the command you want to run:",
-          initialValue: commands7[0],
-          options: commands7.map((cmd) => ({
+          initialValue: commands9[0],
+          options: commands9.map((cmd) => ({
             value: cmd,
             label: cmd.name,
             hint: cmd.description
@@ -8191,8 +8479,262 @@ var parseJsonLog = (message) => {
   };
 };
 
+// src/cli/command/image/clear-cache.ts
+import { CloudFrontClient as CloudFrontClient2, CreateInvalidationCommand as CreateInvalidationCommand2 } from "@aws-sdk/client-cloudfront";
+import { DeleteObjectsCommand, ListObjectsV2Command, S3Client as S3Client3 } from "@aws-sdk/client-s3";
+import { Cancelled as Cancelled2, log as log23, prompt as prompt10 } from "@awsless/clui";
+var clearCache = (program2) => {
+  program2.command("cache-clear").argument("[stack]", "The stack name of the image proxy").argument("[name]", "The name of the image proxy").description("Clears the cache of the image proxy").action(async (stack, name) => {
+    await layout("image cache-clear", async ({ appConfig, stackConfigs }) => {
+      const region = appConfig.region;
+      const profile = appConfig.profile;
+      const credentials = getCredentials(profile);
+      const accountId = await getAccountId(credentials, region);
+      if (!stack) {
+        const imageStacks = stackConfigs.filter((stack2) => {
+          if (Object.keys(stack2.images ?? {}).length > 0) {
+            return stack2;
+          }
+          return;
+        });
+        stack = await prompt10.select({
+          message: "Select the image proxy:",
+          options: imageStacks.map((stack2) => ({
+            label: stack2.name,
+            value: stack2.name
+          }))
+        });
+      }
+      if (!name) {
+        const stackConfig = stackConfigs.find((s) => s.name === stack);
+        if (!stackConfig) {
+          throw new ExpectedError(`The stack "${stack}" doesn't exist.`);
+        }
+        const names = Object.keys(stackConfig.images ?? {});
+        if (!names) {
+          throw new ExpectedError(`No images are defined in stack "${stack}".`);
+        }
+        name = await prompt10.select({
+          message: "Select the image:",
+          options: names.map((name2) => ({
+            label: name2,
+            value: name2
+          }))
+        });
+      }
+      const ok = await prompt10.confirm({
+        message: `Are you sure you want to clear the cache`
+      });
+      if (!ok) {
+        throw new Cancelled2();
+      }
+      const { shared, app } = createApp({ appConfig, stackConfigs, accountId });
+      const { workspace } = await createWorkSpace({
+        credentials,
+        accountId,
+        profile,
+        region
+      });
+      await workspace.hydrate(app);
+      let distributionId;
+      let cacheBucket;
+      try {
+        distributionId = await shared.entry("image", "distribution-id", name);
+        cacheBucket = await shared.entry("image", "cache-bucket", name);
+      } catch (_) {
+        throw new ExpectedError(`The image proxy hasn't been deployed yet.`);
+      }
+      const s3Client2 = new S3Client3({
+        credentials,
+        region
+      });
+      let continuationToken;
+      let totalDeleted = 0;
+      let hasMore = true;
+      while (hasMore) {
+        const result = await s3Client2.send(
+          new ListObjectsV2Command({
+            Bucket: cacheBucket,
+            ContinuationToken: continuationToken,
+            MaxKeys: 1e3
+            // Maximum allowed per request
+          })
+        );
+        if (result.Contents && result.Contents.length > 0) {
+          await s3Client2.send(
+            new DeleteObjectsCommand({
+              Bucket: cacheBucket,
+              Delete: {
+                Objects: result.Contents.map((obj) => ({
+                  Key: obj.Key
+                })),
+                Quiet: true
+              }
+            })
+          );
+          totalDeleted += result.Contents.length;
+          log23.info(`${result.Contents.length} objects deleted from cache.`);
+        }
+        continuationToken = result.NextContinuationToken;
+        hasMore = !!continuationToken;
+      }
+      const cloudFrontClient = new CloudFrontClient2({
+        credentials,
+        region: "us-east-1"
+      });
+      await cloudFrontClient.send(
+        new CreateInvalidationCommand2({
+          DistributionId: distributionId,
+          InvalidationBatch: {
+            CallerReference: `image-cache-clear-${Date.now()}`,
+            Paths: {
+              Quantity: 1,
+              Items: ["/*"]
+            }
+          }
+        })
+      );
+      return "Cache has been cleared";
+    });
+  });
+};
+
+// src/cli/command/image/index.ts
+var commands6 = [clearCache];
+var image = (program2) => {
+  const command = program2.command("image").description(`Manage image proxies`);
+  commands6.forEach((cb) => cb(command));
+};
+
+// src/cli/command/icon/clear-cache.ts
+import { CloudFrontClient as CloudFrontClient3, CreateInvalidationCommand as CreateInvalidationCommand3 } from "@aws-sdk/client-cloudfront";
+import { DeleteObjectsCommand as DeleteObjectsCommand2, ListObjectsV2Command as ListObjectsV2Command2, S3Client as S3Client4 } from "@aws-sdk/client-s3";
+import { Cancelled as Cancelled3, log as log24, prompt as prompt11 } from "@awsless/clui";
+var clearCache2 = (program2) => {
+  program2.command("cache-clear").argument("[stack]", "The stack name of the icon proxy").argument("[name]", "The name of the icon proxy").description("Clears the cache of the icon proxy").action(async (stack, name) => {
+    await layout("icon cache-clear", async ({ appConfig, stackConfigs }) => {
+      const region = appConfig.region;
+      const profile = appConfig.profile;
+      const credentials = getCredentials(profile);
+      const accountId = await getAccountId(credentials, region);
+      if (!stack) {
+        const iconStacks = stackConfigs.filter((stack2) => {
+          if (Object.keys(stack2.icons ?? {}).length > 0) {
+            return stack2;
+          }
+          return;
+        });
+        stack = await prompt11.select({
+          message: "Select the icon proxy:",
+          options: iconStacks.map((stack2) => ({
+            label: stack2.name,
+            value: stack2.name
+          }))
+        });
+      }
+      if (!name) {
+        const stackConfig = stackConfigs.find((s) => s.name === stack);
+        if (!stackConfig) {
+          throw new ExpectedError(`The stack "${stack}" doesn't exist.`);
+        }
+        const names = Object.keys(stackConfig.icons ?? {});
+        if (!names) {
+          throw new ExpectedError(`No icons are defined in stack "${stack}".`);
+        }
+        name = await prompt11.select({
+          message: "Select the icon:",
+          options: names.map((name2) => ({
+            label: name2,
+            value: name2
+          }))
+        });
+      }
+      const ok = await prompt11.confirm({
+        message: `Are you sure you want to clear the cache`
+      });
+      if (!ok) {
+        throw new Cancelled3();
+      }
+      const { shared, app } = createApp({ appConfig, stackConfigs, accountId });
+      const { workspace } = await createWorkSpace({
+        credentials,
+        accountId,
+        profile,
+        region
+      });
+      await workspace.hydrate(app);
+      let distributionId;
+      let cacheBucket;
+      try {
+        distributionId = await shared.entry("icon", "distribution-id", name);
+        cacheBucket = await shared.entry("icon", "cache-bucket", name);
+      } catch (_) {
+        throw new ExpectedError(`The icon proxy hasn't been deployed yet.`);
+      }
+      const s3Client2 = new S3Client4({
+        credentials,
+        region
+      });
+      let continuationToken;
+      let totalDeleted = 0;
+      let hasMore = true;
+      while (hasMore) {
+        const result = await s3Client2.send(
+          new ListObjectsV2Command2({
+            Bucket: cacheBucket,
+            ContinuationToken: continuationToken,
+            MaxKeys: 1e3
+            // Maximum allowed per request
+          })
+        );
+        if (result.Contents && result.Contents.length > 0) {
+          await s3Client2.send(
+            new DeleteObjectsCommand2({
+              Bucket: cacheBucket,
+              Delete: {
+                Objects: result.Contents.map((obj) => ({
+                  Key: obj.Key
+                })),
+                Quiet: true
+              }
+            })
+          );
+          totalDeleted += result.Contents.length;
+          log24.info(`${result.Contents.length} objects deleted from cache.`);
+        }
+        continuationToken = result.NextContinuationToken;
+        hasMore = !!continuationToken;
+      }
+      const cloudFrontClient = new CloudFrontClient3({
+        credentials,
+        region: "us-east-1"
+      });
+      await cloudFrontClient.send(
+        new CreateInvalidationCommand3({
+          DistributionId: distributionId,
+          InvalidationBatch: {
+            CallerReference: `icon-cache-clear-${Date.now()}`,
+            Paths: {
+              Quantity: 1,
+              Items: ["/*"]
+            }
+          }
+        })
+      );
+      return "Cache has been cleared";
+    });
+  });
+};
+
+// src/cli/command/icon/index.ts
+var commands7 = [clearCache2];
+var icon2 = (program2) => {
+  const command = program2.command("icon").description(`Manage icon proxies`);
+  commands7.forEach((cb) => cb(command));
+};
+
 // src/cli/command/index.ts
-var commands6 = [
+var commands8 = [
   bootstrap,
   types,
   build2,
@@ -8208,7 +8750,9 @@ var commands6 = [
   state,
   resources,
   config,
-  test
+  test,
+  image,
+  icon2
 ];
 
 // src/cli/program.ts
@@ -8231,7 +8775,7 @@ program.on("option:skip-prompt", () => {
 program.on("option:no-cache", () => {
   process.env.NO_CACHE = program.opts().noCache ? "1" : void 0;
 });
-commands6.forEach((fn) => fn(program));
+commands8.forEach((fn) => fn(program));
 
 // src/bin.ts
 program.parse(process.argv);