@awsless/cli 0.0.45 → 0.0.46-next.1

package/dist/build-json-schema.js

@@ -4,7 +4,7 @@ import { join as join2 } from "path";
 import { zodToJsonSchema } from "zod-to-json-schema";
 
 // src/config/app.ts
-import { z as z26 } from "zod";
+import { z as z25 } from "zod";
 
 // src/feature/alert/schema.ts
 import { kebabCase } from "change-case";
@@ -120,9 +120,9 @@ var DomainsDefaultSchema = z6.record(
 // src/feature/function/schema.ts
 import { days, minutes, seconds, toDays } from "@awsless/duration";
 import { gibibytes, mebibytes } from "@awsless/size";
-import { z as z11 } from "zod";
+import { z as z10 } from "zod";
 
-// src/config/schema/local-directory.ts
+// src/config/schema/local-file.ts
 import { stat } from "fs/promises";
 import { z as z8 } from "zod";
 
@@ -138,44 +138,25 @@ var resolvePath = (path) => {
 };
 var RelativePathSchema = z7.string().transform((path) => resolvePath(path));
 
-// src/config/schema/local-directory.ts
-var LocalDirectorySchema = z8.union([
-  RelativePathSchema.refine(async (path) => {
-    try {
-      const s = await stat(path);
-      return s.isDirectory();
-    } catch (error) {
-      return false;
-    }
-  }, `Directory doesn't exist`),
-  z8.object({
-    nocheck: RelativePathSchema.describe(
-      "Specifies a local directory without checking if the directory exists."
-    )
-  }).transform((v) => v.nocheck)
-]);
-
 // src/config/schema/local-file.ts
-import { stat as stat2 } from "fs/promises";
-import { z as z9 } from "zod";
-var LocalFileSchema = z9.union([
+var LocalFileSchema = z8.union([
   RelativePathSchema.refine(async (path) => {
     try {
-      const s = await stat2(path);
+      const s = await stat(path);
       return s.isFile();
     } catch (error) {
       return false;
     }
   }, `File doesn't exist`),
-  z9.object({
+  z8.object({
     nocheck: RelativePathSchema.describe("Specifies a local file without checking if the file exists.")
   }).transform((v) => v.nocheck)
 ]);
 
 // src/config/schema/size.ts
 import { parse as parse2 } from "@awsless/size";
-import { z as z10 } from "zod";
-var SizeSchema = z10.string().regex(/^[0-9]+ (B|KB|MB|GB|TB|PB)$/, "Invalid size").transform((v) => parse2(v));
+import { z as z9 } from "zod";
+var SizeSchema = z9.string().regex(/^[0-9]+ (B|KB|MB|GB|TB|PB)$/, "Invalid size").transform((v) => parse2(v));
 var sizeMin = (min) => {
   return (size) => {
     return size.value >= min.value;
@@ -194,33 +175,23 @@ var MemorySizeSchema = SizeSchema.refine(sizeMin(mebibytes(128)), "Minimum memor
 var TimeoutSchema = DurationSchema.refine(durationMin(seconds(10)), "Minimum timeout duration is 10 seconds").refine(durationMax(minutes(15)), "Maximum timeout duration is 15 minutes").describe(
   "The amount of time that Lambda allows a function to run before stopping it. You can specify a size value from 1 second to 15 minutes."
 );
-var EphemeralStorageSizeSchema = SizeSchema.refine(
-  sizeMin(mebibytes(512)),
-  "Minimum ephemeral storage size is 512 MB"
-).refine(sizeMax(gibibytes(10)), "Minimum ephemeral storage size is 10 GB").describe("The size of the function's /tmp directory. You can specify a size value from 512 MB to 10 GB.");
-var ReservedConcurrentExecutionsSchema = z11.number().int().min(0).describe("The number of simultaneous executions to reserve for the function. You can specify a number from 0.");
-var EnvironmentSchema = z11.record(z11.string(), z11.string()).optional().describe("Environment variable key-value pairs.");
-var ArchitectureSchema = z11.enum(["x86_64", "arm64"]).describe("The instruction set architecture that the function supports.");
-var NodeRuntimeSchema = z11.enum(["nodejs18.x", "nodejs20.x", "nodejs22.x", "nodejs24.x"]);
-var ContainerRuntimeSchema = z11.literal("container");
-var RuntimeSchema = NodeRuntimeSchema.or(ContainerRuntimeSchema).or(z11.string()).describe("The identifier of the function's runtime.");
-var ActionSchema = z11.string();
-var ActionsSchema = z11.union([ActionSchema.transform((v) => [v]), ActionSchema.array()]);
-var ArnSchema = z11.string().startsWith("arn:");
-var WildcardSchema = z11.literal("*");
-var ResourceSchema = z11.union([ArnSchema, WildcardSchema]);
-var ResourcesSchema = z11.union([ResourceSchema.transform((v) => [v]), ResourceSchema.array()]);
-var PermissionSchema = z11.object({
-  effect: z11.enum(["allow", "deny"]).default("allow"),
+var EnvironmentSchema = z10.record(z10.string(), z10.string()).optional().describe("Environment variable key-value pairs.");
+var ArchitectureSchema = z10.enum(["x86_64", "arm64"]).describe("The instruction set architecture that the function supports.");
+var RuntimeSchema = z10.enum(["nodejs18.x", "nodejs20.x", "nodejs22.x", "nodejs24.x"]).or(z10.literal("container")).or(z10.string()).describe("The identifier of the function's runtime.");
+var ActionSchema = z10.string();
+var ActionsSchema = z10.union([ActionSchema.transform((v) => [v]), ActionSchema.array()]);
+var ArnSchema = z10.string().startsWith("arn:");
+var WildcardSchema = z10.literal("*");
+var ResourceSchema = z10.union([ArnSchema, WildcardSchema]);
+var ResourcesSchema = z10.union([ResourceSchema.transform((v) => [v]), ResourceSchema.array()]);
+var PermissionSchema = z10.object({
+  effect: z10.enum(["allow", "deny"]).default("allow"),
   actions: ActionsSchema,
   resources: ResourcesSchema
 });
-var PermissionsSchema = z11.union([PermissionSchema.transform((v) => [v]), PermissionSchema.array()]).describe("Add IAM permissions to your function.");
-var WarmSchema = z11.number().int().min(0).max(10).describe("Specify how many functions you want to warm up each 5 minutes. You can specify a number from 0 to 10.");
-var VPCSchema = z11.boolean().describe("Put the function inside your global VPC.");
-var MinifySchema = z11.boolean().describe("Minify the function code.");
-var HandlerSchema = z11.string().describe("The name of the exported method within your code that Lambda calls to run your function.");
-var DescriptionSchema = z11.string().describe("A description of the function.");
+var PermissionsSchema = z10.union([PermissionSchema.transform((v) => [v]), PermissionSchema.array()]).describe("Add IAM permissions to your function.");
+var MinifySchema = z10.boolean().describe("Minify the function code.");
+var HandlerSchema = z10.string().describe("The name of the exported method within your code that Lambda calls to run your function.");
 var validLogRetentionDays = [
   ...[1, 3, 5, 7, 14, 30, 60, 90, 120, 150],
   ...[180, 365, 400, 545, 731, 1096, 1827, 2192],
@@ -235,128 +206,84 @@ var LogRetentionSchema = DurationSchema.refine(
   },
   `Invalid log retention. Valid days are: ${validLogRetentionDays.map((days8) => `${days8}`).join(", ")}`
 ).describe("The log retention duration.");
-var LogSchema = z11.union([
-  z11.boolean().transform((enabled) => ({ retention: enabled ? days(7) : days(0) })),
+var LogSchema = z10.union([
+  z10.boolean().transform((enabled) => ({ retention: enabled ? days(7) : days(0) })),
   LogRetentionSchema.transform((retention) => ({ retention })),
-  z11.object({
-    // subscription: LogSubscriptionSchema.optional(),
+  z10.object({
     retention: LogRetentionSchema.optional(),
-    format: z11.enum(["text", "json"]).describe(
+    format: z10.enum(["text", "json"]).describe(
       `The format in which Lambda sends your function's application and system logs to CloudWatch. Select between plain text and structured JSON.`
     ).optional(),
-    system: z11.enum(["debug", "info", "warn"]).describe(
+    system: z10.enum(["debug", "info", "warn"]).describe(
       "Set this property to filter the system logs for your function that Lambda sends to CloudWatch. Lambda only sends system logs at the selected level of detail and lower, where DEBUG is the highest level and WARN is the lowest."
     ).optional(),
-    level: z11.enum(["trace", "debug", "info", "warn", "error", "fatal"]).describe(
+    level: z10.enum(["trace", "debug", "info", "warn", "error", "fatal"]).describe(
       "Set this property to filter the application logs for your function that Lambda sends to CloudWatch. Lambda only sends application logs at the selected level of detail and lower, where TRACE is the highest level and FATAL is the lowest."
     ).optional()
   })
 ]).describe("Enable logging to a CloudWatch log group. Providing a duration value will set the log retention time.");
-var LayersSchema = z11.string().array().describe(
-  // `A list of function layers to add to the function's execution environment..`
-  `A list of function layers to add to the function's execution environment. Specify each layer by its ARN, including the version.`
-);
-var FileCodeSchema = z11.object({
+var FileCodeSchema = z10.object({
   file: LocalFileSchema.describe("The file path of the function code."),
   minify: MinifySchema.optional().default(true),
-  moduleSideEffects: RelativePathSchema.array().default([]).describe(
-    `A list of glob patterns for modules that should be flagged as having potential side effects. For example "./.svelte-kit/**" will flag every file inside the .svelte-kit folder.`
-  ),
-  external: z11.string().array().optional().describe(`A list of external packages that won't be included in the bundle.`),
-  importAsString: z11.string().array().optional().describe(`A list of glob patterns, which specifies the files that should be imported as string.`)
-});
-var BundleCodeSchema = z11.object({
-  bundle: LocalDirectorySchema.describe("The directory that needs to be bundled.")
-  // dir: z.string(),
-  // build: z.string(),
-  // run: z.string(),
-  // cacheKey:
+  external: z10.string().array().optional().describe(`A list of external packages that won't be included in the bundle.`),
+  importAsString: z10.string().array().optional().describe(`A list of glob patterns, which specifies the files that should be imported as string.`)
 });
-var CodeSchema = z11.union([
+var CodeSchema = z10.union([
   LocalFileSchema.transform((file) => ({
     file
   })).pipe(FileCodeSchema),
-  FileCodeSchema,
-  BundleCodeSchema
+  FileCodeSchema
 ]).describe("Specify the code of your function.");
-var FnSchema = z11.object({
+var FnSchema = z10.object({
   code: CodeSchema,
-  // node
-  handler: HandlerSchema.optional(),
-  // build: BuildSchema.optional(),
-  // bundle: BundleSchema.optional(),
-  // container
-  // ...
-  runtime: RuntimeSchema.optional(),
-  description: DescriptionSchema.optional(),
-  warm: WarmSchema.optional(),
-  vpc: VPCSchema.optional(),
-  log: LogSchema.optional(),
-  timeout: TimeoutSchema.optional(),
-  memorySize: MemorySizeSchema.optional(),
-  architecture: ArchitectureSchema.optional(),
-  ephemeralStorageSize: EphemeralStorageSizeSchema.optional(),
-  // retryAttempts: RetryAttemptsSchema.optional(),
-  reserved: ReservedConcurrentExecutionsSchema.optional(),
-  layers: LayersSchema.optional(),
-  environment: EnvironmentSchema.optional(),
-  permissions: PermissionsSchema.optional()
+  handler: HandlerSchema.optional()
 });
-var FunctionSchema = z11.union([
+var FunctionSchema = z10.union([
   LocalFileSchema.transform((code) => ({
     code
   })).pipe(FnSchema),
   FnSchema
 ]);
-var FunctionsSchema = z11.record(ResourceIdSchema, FunctionSchema).optional().describe("Define the functions in your stack.");
-var FunctionDefaultSchema = z11.object({
+var FunctionsSchema = z10.record(ResourceIdSchema, FunctionSchema).optional().describe("Define the functions in your stack.");
+var FunctionDefaultSchema = z10.object({
   runtime: RuntimeSchema.default("nodejs24.x"),
-  // node
   handler: HandlerSchema.default("index.default"),
-  // build: BuildSchema.default({
-  // 	type: 'simple',
-  // 	minify: true,
-  // }),
-  // container
-  warm: WarmSchema.default(0),
-  vpc: VPCSchema.default(false),
+  minify: MinifySchema.default(true),
+  external: z10.string().array().optional().describe(`A list of external packages that won't be included in the bundle.`),
   log: LogSchema.default(true).transform((log) => ({
     retention: log.retention ?? days(7),
     level: "level" in log ? log.level : "error",
     system: "system" in log ? log.system : "warn",
     format: "format" in log ? log.format : "json"
   })),
-  timeout: TimeoutSchema.default("10 seconds"),
-  memorySize: MemorySizeSchema.default("128 MB"),
+  // The defaults size the shared bundle lambda, which also serves queues, crons & tasks.
+  timeout: TimeoutSchema.default("15 minutes"),
+  memorySize: MemorySizeSchema.default("1024 MB"),
   architecture: ArchitectureSchema.default("arm64"),
-  ephemeralStorageSize: EphemeralStorageSizeSchema.default("512 MB"),
-  // retryAttempts: RetryAttemptsSchema.default(2),
-  reserved: ReservedConcurrentExecutionsSchema.optional(),
-  layers: LayersSchema.optional(),
   environment: EnvironmentSchema.optional(),
   permissions: PermissionsSchema.optional()
 }).default({});
 
 // src/feature/layer/schema.ts
-import { z as z13 } from "zod";
+import { z as z12 } from "zod";
 
 // src/config/schema/lambda.ts
-import { z as z12 } from "zod";
-var ArchitectureSchema2 = z12.enum(["x86_64", "arm64"]).describe("The instruction set architecture that the function supports.");
-var NodeRuntimeSchema2 = z12.enum(["nodejs18.x", "nodejs20.x", "nodejs22.x"]).describe("The identifier of the function's runtime.");
+import { z as z11 } from "zod";
+var ArchitectureSchema2 = z11.enum(["x86_64", "arm64"]).describe("The instruction set architecture that the function supports.");
+var NodeRuntimeSchema = z11.enum(["nodejs18.x", "nodejs20.x", "nodejs22.x"]).describe("The identifier of the function's runtime.");
 
 // src/feature/layer/schema.ts
-var Schema = z13.object({
+var Schema = z12.object({
   file: LocalFileSchema,
-  runtimes: NodeRuntimeSchema2.array().optional(),
+  runtimes: NodeRuntimeSchema.array().optional(),
   architecture: ArchitectureSchema2.optional(),
-  packages: z13.string().array().optional().describe(
+  packages: z12.string().array().optional().describe(
     "Define the package names that are available bundled in the layer. Those packages are not bundled while bundling the lambda."
   )
 });
-var LayerSchema = z13.record(
-  z13.string(),
-  z13.union([
+var LayerSchema = z12.record(
+  z12.string(),
+  z12.union([
     LocalFileSchema.transform((file) => ({
       file,
       description: void 0
@@ -366,21 +293,16 @@ var LayerSchema = z13.record(
 ).optional().describe("Define the lambda layers in your stack.");
 
 // src/feature/task/schema.ts
-import { z as z14 } from "zod";
-var RetryAttemptsSchema = z14.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 = z14.union([
+import { z as z13 } from "zod";
+var TaskSchema = z13.union([
   FunctionSchema.transform((consumer) => ({
-    consumer,
-    retryAttempts: 2
+    consumer
   })),
-  z14.object({
-    consumer: FunctionSchema,
-    retryAttempts: RetryAttemptsSchema.default(2)
+  z13.object({
+    consumer: FunctionSchema
   })
 ]);
-var TasksSchema = z14.record(ResourceIdSchema, TaskSchema).optional().describe("Define the tasks in your stack.");
+var TasksSchema = z13.record(ResourceIdSchema, TaskSchema).optional().describe("Define the tasks in your stack.");
 
 // src/feature/on-error-log/schema.ts
 var OnErrorLogDefaultSchema = TaskSchema.optional().describe(
@@ -388,18 +310,18 @@ var OnErrorLogDefaultSchema = TaskSchema.optional().describe(
 );
 
 // src/feature/on-failure/schema.ts
-import { z as z15 } from "zod";
-var NotifySchema = z15.union([
+import { z as z14 } from "zod";
+var NotifySchema = z14.union([
   //
   EmailSchema.transform((v) => [v]),
   EmailSchema.array()
 ]).describe("Receive an email notification when consuming failure entries goes wrong.");
-var OnFailureDefaultSchema = z15.union([
+var OnFailureDefaultSchema = z14.union([
   FunctionSchema.transform((consumer) => ({
     consumer,
     notify: []
   })),
-  z15.object({
+  z14.object({
     consumer: FunctionSchema,
     notify: NotifySchema.optional()
   })
@@ -417,13 +339,13 @@ var OnFailureDefaultSchema = z15.union([
 
 // src/feature/pubsub/schema.ts
 import { days as days4 } from "@awsless/duration";
-import { z as z18 } from "zod";
+import { z as z17 } from "zod";
 
 // src/feature/instance/schema.ts
 import { days as days2, toDays as toDays2 } from "@awsless/duration";
 import { toMebibytes } from "@awsless/size";
-import { z as z16 } from "zod";
-var CpuSchema = z16.union([z16.literal(0.25), z16.literal(0.5), z16.literal(1), z16.literal(2), z16.literal(4), z16.literal(8), z16.literal(16)]).transform((v) => `${v} vCPU`).describe(
+import { z as z15 } from "zod";
+var CpuSchema = z15.union([z15.literal(0.25), z15.literal(0.5), z15.literal(1), z15.literal(2), z15.literal(4), z15.literal(8), z15.literal(16)]).transform((v) => `${v} vCPU`).describe(
   "The number of virtual CPU units (vCPU) used by the instance. Valid values: 0.25, 0.5, 1, 2, 4, 8, 16 vCPU."
 );
 var validMemorySize = [
@@ -463,10 +385,10 @@ var MemorySizeSchema2 = SizeSchema.refine(
   (s) => validMemorySize.includes(toMebibytes(s)),
   `Invalid memory size. Allowed sizes: ${validMemorySize.join(", ")} MiB`
 ).describe("The amount of memory (in MiB) used by the instance. Valid memory values depend on the CPU configuration.");
-var HealthCheckSchema = z16.object({
-  path: z16.string().describe("The path that the container runs to determine if it is healthy."),
+var HealthCheckSchema = z15.object({
+  path: z15.string().describe("The path that the container runs to determine if it is healthy."),
   interval: DurationSchema.describe("The time period in seconds between each health check execution."),
-  retries: z16.number().int().min(1).max(10).describe(
+  retries: z15.number().int().min(1).max(10).describe(
     "The number of times to retry a failed health check before the container is considered unhealthy."
   ),
   startPeriod: DurationSchema.describe(
@@ -476,22 +398,22 @@ var HealthCheckSchema = z16.object({
     "The time period in seconds to wait for a health check to succeed before it is considered a failure."
   )
 }).describe("The health check command and associated configuration parameters for the container.");
-var EnvironmentSchema2 = z16.record(z16.string(), z16.string()).optional().describe("Environment variable key-value pairs.");
-var ArchitectureSchema3 = z16.enum(["x86_64", "arm64"]).describe("The instruction set architecture that the instance supports.");
-var ActionSchema2 = z16.string();
-var ActionsSchema2 = z16.union([ActionSchema2.transform((v) => [v]), ActionSchema2.array()]);
-var ArnSchema2 = z16.string().startsWith("arn:");
-var WildcardSchema2 = z16.literal("*");
-var ResourceSchema2 = z16.union([ArnSchema2, WildcardSchema2]);
-var ResourcesSchema2 = z16.union([ResourceSchema2.transform((v) => [v]), ResourceSchema2.array()]);
-var PermissionSchema2 = z16.object({
-  effect: z16.enum(["allow", "deny"]).default("allow"),
+var EnvironmentSchema2 = z15.record(z15.string(), z15.string()).optional().describe("Environment variable key-value pairs.");
+var ArchitectureSchema3 = z15.enum(["x86_64", "arm64"]).describe("The instruction set architecture that the instance supports.");
+var ActionSchema2 = z15.string();
+var ActionsSchema2 = z15.union([ActionSchema2.transform((v) => [v]), ActionSchema2.array()]);
+var ArnSchema2 = z15.string().startsWith("arn:");
+var WildcardSchema2 = z15.literal("*");
+var ResourceSchema2 = z15.union([ArnSchema2, WildcardSchema2]);
+var ResourcesSchema2 = z15.union([ResourceSchema2.transform((v) => [v]), ResourceSchema2.array()]);
+var PermissionSchema2 = z15.object({
+  effect: z15.enum(["allow", "deny"]).default("allow"),
   actions: ActionsSchema2,
   resources: ResourcesSchema2
 });
-var PermissionsSchema2 = z16.union([PermissionSchema2.transform((v) => [v]), PermissionSchema2.array()]).describe("Add IAM permissions to your instance.");
-var DescriptionSchema2 = z16.string().describe("A description of the instance.");
-var ImageSchema = z16.string().optional().describe("The URL of the container image to use. Default: public.ecr.aws/aws-cli/aws-cli:{architecture}");
+var PermissionsSchema2 = z15.union([PermissionSchema2.transform((v) => [v]), PermissionSchema2.array()]).describe("Add IAM permissions to your instance.");
+var DescriptionSchema = z15.string().describe("A description of the instance.");
+var ImageSchema = z15.string().optional().describe("The URL of the container image to use. Default: public.ecr.aws/aws-cli/aws-cli:{architecture}");
 var validLogRetentionDays2 = [
   ...[1, 3, 5, 7, 14, 30, 60, 90, 120, 150],
   ...[180, 365, 400, 545, 731, 1096, 1827, 2192],
@@ -506,26 +428,26 @@ var LogRetentionSchema2 = DurationSchema.refine(
   },
   `Invalid log retention. Valid days are: ${validLogRetentionDays2.map((days8) => `${days8}`).join(", ")}`
 ).describe("The log retention duration.");
-var LogSchema2 = z16.union([
-  z16.boolean().transform((enabled) => ({ retention: enabled ? days2(7) : days2(0) })),
+var LogSchema2 = z15.union([
+  z15.boolean().transform((enabled) => ({ retention: enabled ? days2(7) : days2(0) })),
   LogRetentionSchema2.transform((retention) => ({ retention })),
-  z16.object({
+  z15.object({
     retention: LogRetentionSchema2.optional()
   })
 ]).describe("Enable logging to a CloudWatch log group. Providing a duration value will set the log retention time.");
-var FileCodeSchema2 = z16.object({
+var FileCodeSchema2 = z15.object({
   file: LocalFileSchema.describe("The file path of the instance code.")
 });
-var CodeSchema2 = z16.union([
+var CodeSchema2 = z15.union([
   LocalFileSchema.transform((file) => ({
     file
   })).pipe(FileCodeSchema2),
   FileCodeSchema2
 ]).describe("Specify the code of your instance.");
-var StartupCommandSchema = z16.union([z16.string().transform((v) => [v]), z16.string().array()]).describe("Optional shell commands to run before the instance program starts.");
-var ISchema = z16.object({
+var StartupCommandSchema = z15.union([z15.string().transform((v) => [v]), z15.string().array()]).describe("Optional shell commands to run before the instance program starts.");
+var ISchema = z15.object({
   code: CodeSchema2,
-  description: DescriptionSchema2.optional(),
+  description: DescriptionSchema.optional(),
   image: ImageSchema.optional(),
   startupCommand: StartupCommandSchema.optional(),
   log: LogSchema2.optional(),
@@ -537,14 +459,14 @@ var ISchema = z16.object({
   healthCheck: HealthCheckSchema.optional()
   // restartPolicy: RestartPolicySchema.optional(),
 });
-var InstanceSchema = z16.union([
+var InstanceSchema = z15.union([
   LocalFileSchema.transform((code) => ({
     code
   })).pipe(ISchema),
   ISchema
 ]);
-var InstancesSchema = z16.record(ResourceIdSchema, InstanceSchema).optional().describe("Define the instances in your stack.");
-var InstanceDefaultSchema = z16.object({
+var InstancesSchema = z15.record(ResourceIdSchema, InstanceSchema).optional().describe("Define the instances in your stack.");
+var InstanceDefaultSchema = z15.object({
   image: ImageSchema.optional(),
   cpu: CpuSchema.default(0.25),
   memorySize: MemorySizeSchema2.default("512 MB"),
@@ -560,79 +482,15 @@ var InstanceDefaultSchema = z16.object({
 
 // src/feature/router/schema.ts
 import { days as days3, minutes as minutes2, parse as parse3 } from "@awsless/duration";
-import { z as z17 } from "zod";
-
-// src/error.ts
-var ExpectedError = class extends Error {
-};
-
-// src/feature/router/pattern.ts
-var PARAM_TOKEN = /\{([a-zA-Z_][a-zA-Z0-9_]*)\}|\*/g;
-var escapeRegex = (value) => {
-  return value.replace(/[|\\{}()[\]^$+*?.\-]/g, "\\$&");
-};
-var compileRoutePattern = (pattern) => {
-  if (!pattern.startsWith("/")) {
-    throw new ExpectedError(`Route pattern "${pattern}" must start with a slash (/)`);
-  }
-  if (pattern === "/*") {
-    return { key: pattern };
-  }
-  const params = [];
-  let regex = "";
-  let stars = 0;
-  let last = 0;
-  let token;
-  PARAM_TOKEN.lastIndex = 0;
-  while (token = PARAM_TOKEN.exec(pattern)) {
-    regex += escapeRegex(pattern.slice(last, token.index));
-    const param = token[1];
-    if (param) {
-      if (params.includes(param)) {
-        throw new ExpectedError(`Duplicate param "${param}" in route pattern "${pattern}"`);
-      }
-      params.push(param);
-      regex += "([^/]+)";
-    } else {
-      stars++;
-      regex += ".*";
-    }
-    last = PARAM_TOKEN.lastIndex;
-  }
-  if (params.length === 0 && stars === 0) {
-    return { key: pattern };
-  }
-  regex += escapeRegex(pattern.slice(last));
-  const root = pattern.split("/")[1] ?? "";
-  if (root === "" || root.includes("*") || root.includes("{")) {
-    throw new ExpectedError(
-      `The first path segment of route pattern "${pattern}" must be static when the pattern contains params or wildcards.`
-    );
-  }
-  if (root.includes(".")) {
-    throw new ExpectedError(
-      `The first path segment of route pattern "${pattern}" can't contain a dot when the pattern contains params or wildcards.`
-    );
-  }
-  if (params.length === 0 && pattern === `/${root}/*`) {
-    return { key: pattern };
-  }
-  return {
-    key: `/${root}/*`,
-    match: `^${regex}$`,
-    params: params.length > 0 ? params : void 0
-  };
-};
-
-// src/feature/router/schema.ts
-var ErrorResponsePathSchema = z17.string().describe(
+import { z as z16 } from "zod";
+var ErrorResponsePathSchema = z16.string().describe(
   [
     "The path to the custom error page that you want to return to the viewer when your origin returns the HTTP status code specified.",
     "- We recommend that you store custom error pages in an Amazon S3 bucket.",
     "If you store custom error pages on an HTTP server and the server starts to return 5xx errors, CloudFront can't get the files that you want to return to viewers because the origin server is unavailable."
   ].join("\n")
 );
-var StatusCodeSchema = z17.number().int().positive().optional().describe(
+var StatusCodeSchema = z16.number().int().positive().optional().describe(
   [
     "The HTTP status code that you want CloudFront to return to the viewer along with the custom error page.",
     "There are a variety of reasons that you might want CloudFront to return a status code different from the status code that your origin returned to CloudFront, for example:",
@@ -645,48 +503,26 @@ var StatusCodeSchema = z17.number().int().positive().optional().describe(
 var MinTTLSchema = DurationSchema.describe(
   "The minimum amount of time, that you want to cache the error response. When this time period has elapsed, CloudFront queries your origin to see whether the problem that caused the error has been resolved and the requested object is now available."
 );
-var ErrorResponseSchema = z17.union([
+var ErrorResponseSchema = z16.union([
   ErrorResponsePathSchema,
-  z17.object({
+  z16.object({
     path: ErrorResponsePathSchema,
     statusCode: StatusCodeSchema.optional(),
     minTTL: MinTTLSchema.optional()
   })
 ]).optional();
-var RouteSchema = z17.string().regex(/^\//, "Route must start with a slash (/)");
-var RoutesSchema = z17.record(
-  ResourceIdSchema.describe("The router id to add your routes to."),
-  z17.record(RouteSchema, FunctionSchema).superRefine((routes, ctx) => {
-    for (const pattern of Object.keys(routes)) {
-      try {
-        compileRoutePattern(pattern);
-      } catch (error) {
-        ctx.addIssue({
-          code: z17.ZodIssueCode.custom,
-          path: [pattern],
-          message: error instanceof Error ? error.message : `Invalid route pattern: ${pattern}`
-        });
-      }
-    }
-  }).describe(
-    [
-      "Define the routes and the lambda function that should handle them.",
-      'Routes can be an exact path like "/sitemap.xml", a wildcard like "/sitemap/*", or contain params like "/sitemap/{locale}/{page}.xml".',
-      'Param values are passed to the function as "x-param-[NAME]" request headers.'
-    ].join("\n")
-  )
-).optional().describe("Add routes to your global Router that link a path pattern to a lambda function.");
-var VisibilitySchema = z17.boolean().default(false).describe("Whether to enable CloudWatch metrics for the WAF rule.");
-var WafSettingsSchema = z17.object({
-  rateLimiter: z17.object({
-    limit: z17.number().min(10).max(2e9).default(10).describe(
+var RouteSchema = z16.string().regex(/^\//, "Route must start with a slash (/)");
+var VisibilitySchema = z16.boolean().default(false).describe("Whether to enable CloudWatch metrics for the WAF rule.");
+var WafSettingsSchema = z16.object({
+  rateLimiter: z16.object({
+    limit: z16.number().min(10).max(2e9).default(10).describe(
       "The limit on requests during the specified evaluation window for a single aggregation instance for the rate-based rule."
     ),
-    window: z17.union([
-      z17.literal("1 minute"),
-      z17.literal("2 minutes"),
-      z17.literal("5 minutes"),
-      z17.literal("10 minutes")
+    window: z16.union([
+      z16.literal("1 minute"),
+      z16.literal("2 minutes"),
+      z16.literal("5 minutes"),
+      z16.literal("10 minutes")
     ]).default("5 minutes").transform((v) => parse3(v)).describe(
       "The amount of time, in seconds, that AWS WAF should include in its request counts, looking back from the current time."
     ),
@@ -694,18 +530,18 @@ var WafSettingsSchema = z17.object({
   }).optional().describe(
     "A rate-based rule counts incoming requests and rate limits requests when they are coming at too fast a rate."
   ),
-  ddosProtection: z17.object({
-    sensitivity: z17.object({
-      challenge: z17.enum(["low", "medium", "high"]).default("low").transform((v) => v.toUpperCase()).describe("The sensitivity level for challenge requests."),
-      block: z17.enum(["low", "medium", "high"]).default("low").transform((v) => v.toUpperCase()).describe("The sensitivity level for block requests.")
+  ddosProtection: z16.object({
+    sensitivity: z16.object({
+      challenge: z16.enum(["low", "medium", "high"]).default("low").transform((v) => v.toUpperCase()).describe("The sensitivity level for challenge requests."),
+      block: z16.enum(["low", "medium", "high"]).default("low").transform((v) => v.toUpperCase()).describe("The sensitivity level for block requests.")
     }),
-    exemptUriRegex: z17.string().default("^$"),
+    exemptUriRegex: z16.string().default("^$"),
     visibility: VisibilitySchema
   }).optional().describe(
     "Provides protection against DDoS attacks targeting the application layer, also known as Layer 7 attacks. Uses 50 WCU."
   ),
-  botProtection: z17.object({
-    inspectionLevel: z17.enum(["common", "targeted"]).default("common").transform((v) => v.toUpperCase()),
+  botProtection: z16.object({
+    inspectionLevel: z16.enum(["common", "targeted"]).default("common").transform((v) => v.toUpperCase()),
     visibility: VisibilitySchema
   }).optional().describe(
     "Provides protection against automated bots that can consume excess resources, skew business metrics, cause downtime, or perform malicious activities. Bot Control provides additional visibility through Amazon CloudWatch and generates labels that you can use to control bot traffic to your applications. Uses 50 WCU."
@@ -719,15 +555,15 @@ var WafSettingsSchema = z17.object({
 }).describe(
   "WAF settings for the router. Each rule consumes Web ACL capacity units (WCUs). The total WCUs for a web ACL can't exceed 5000. Using over 1500 WCUs affects your costs."
 );
-var RouterDefaultSchema = z17.record(
+var RouterDefaultSchema = z16.record(
   ResourceIdSchema,
-  z17.object({
+  z16.object({
     domain: ResourceIdSchema.describe("The domain id to link your Router.").optional(),
-    subDomain: z17.string().optional(),
-    redirectWww: z17.boolean().default(false).describe("Redirect all www subdomain requests to your root domain."),
+    subDomain: z16.string().optional(),
+    redirectWww: z16.boolean().default(false).describe("Redirect all www subdomain requests to your root domain."),
     waf: WafSettingsSchema.optional(),
-    geoRestrictions: z17.array(z17.string().length(2).toUpperCase()).default([]).describe("Specifies a blacklist of countries that should be blocked."),
-    errors: z17.object({
+    geoRestrictions: z16.array(z16.string().length(2).toUpperCase()).default([]).describe("Specifies a blacklist of countries that should be blocked."),
+    errors: z16.object({
       400: ErrorResponseSchema.describe("Customize a `400 Bad Request` response."),
       403: ErrorResponseSchema.describe("Customize a `403 Forbidden` response."),
       404: ErrorResponseSchema.describe("Customize a `404 Not Found` response."),
@@ -740,26 +576,26 @@ var RouterDefaultSchema = z17.record(
       503: ErrorResponseSchema.describe("Customize a `503 Service Unavailable` response."),
       504: ErrorResponseSchema.describe("Customize a `504 Gateway Timeout` response.")
     }).optional().describe("Customize the error responses for specific HTTP status codes."),
-    cors: z17.object({
-      override: z17.boolean().default(false),
+    cors: z16.object({
+      override: z16.boolean().default(false),
       maxAge: DurationSchema.default("365 days"),
-      exposeHeaders: z17.string().array().optional(),
-      credentials: z17.boolean().default(false),
-      headers: z17.string().array().default(["*"]),
-      origins: z17.string().array().default(["*"]),
-      methods: z17.enum(["GET", "DELETE", "HEAD", "OPTIONS", "PATCH", "POST", "PUT", "ALL"]).array().default(["ALL"])
+      exposeHeaders: z16.string().array().optional(),
+      credentials: z16.boolean().default(false),
+      headers: z16.string().array().default(["*"]),
+      origins: z16.string().array().default(["*"]),
+      methods: z16.enum(["GET", "DELETE", "HEAD", "OPTIONS", "PATCH", "POST", "PUT", "ALL"]).array().default(["ALL"])
     }).optional().describe("Specify the cors headers."),
-    passwordAuth: z17.object({
-      password: z17.string().describe("Password.")
+    passwordAuth: z16.object({
+      password: z16.string().describe("Password.")
     }).optional().describe(
       [
         "Enable password authentication for the router.",
         'You can authenicate by adding a "authorization" header with the value "Password [YOUR_PASSWORD]".'
       ].join("\n")
     ),
-    basicAuth: z17.object({
-      username: z17.string().describe("Basic auth username."),
-      password: z17.string().describe("Basic auth password.")
+    basicAuth: z16.object({
+      username: z16.string().describe("Basic auth username."),
+      password: z16.string().describe("Basic auth password.")
     }).optional().describe("Enable basic authentication for the router."),
     // security: z
     // 	.object({
@@ -806,24 +642,24 @@ var RouterDefaultSchema = z17.record(
     // 	})
     // 	.optional()
     // 	.describe('Specify the security policy.'),
-    cache: z17.object({
-      cookies: z17.string().array().optional().describe("Specifies the cookies that CloudFront includes in the cache key."),
-      headers: z17.string().array().optional().describe("Specifies the headers that CloudFront includes in the cache key."),
-      queries: z17.string().array().optional().describe("Specifies the query values that CloudFront includes in the cache key.")
+    cache: z16.object({
+      cookies: z16.string().array().optional().describe("Specifies the cookies that CloudFront includes in the cache key."),
+      headers: z16.string().array().optional().describe("Specifies the headers that CloudFront includes in the cache key."),
+      queries: z16.string().array().optional().describe("Specifies the query values that CloudFront includes in the cache key.")
     }).optional().describe(
       "Specifies the cookies, headers, and query values that CloudFront includes in the cache key."
     )
   }).superRefine((props, ctx) => {
     if (props.redirectWww && !props.domain) {
       ctx.addIssue({
-        code: z17.ZodIssueCode.custom,
+        code: z16.ZodIssueCode.custom,
         path: ["redirectWww"],
         message: "The redirectWww option requires a domain to be set."
       });
     }
     if (props.redirectWww && props.subDomain) {
       ctx.addIssue({
-        code: z17.ZodIssueCode.custom,
+        code: z16.ZodIssueCode.custom,
         path: ["redirectWww"],
         message: `The redirectWww option can't be combined with a subDomain, because the domain certificate only covers single level subdomains.`
       });
@@ -832,9 +668,9 @@ var RouterDefaultSchema = z17.record(
 ).optional().describe(`Define the global Router. Backed by AWS CloudFront.`);
 
 // src/feature/pubsub/schema.ts
-var PubSubDefaultSchema = z18.record(
+var PubSubDefaultSchema = z17.record(
   ResourceIdSchema,
-  z18.object({
+  z17.object({
     auth: FunctionSchema.describe(
       "The authorizer that validates the client auth token and returns the allowed topics."
     ),
@@ -845,9 +681,9 @@ var PubSubDefaultSchema = z18.record(
     }))
   })
 ).optional().describe("Define the pubsub API for your app. Backed by a websocket server on AWS Fargate.");
-var PubSubSchema = z18.record(
+var PubSubSchema = z17.record(
   ResourceIdSchema,
-  z18.object({
+  z17.object({
     connected: FunctionSchema.optional().describe("Subscribe to the event when a client connects."),
     disconnected: FunctionSchema.optional().describe("Subscribe to the event when a client disconnects."),
     subscribed: FunctionSchema.optional().describe(
@@ -860,47 +696,35 @@ var PubSubSchema = z18.record(
 ).optional().describe("Define the pubsub event listeners in your stack.");
 
 // src/feature/queue/schema.ts
-import { days as days5, hours, minutes as minutes3, seconds as seconds2 } from "@awsless/duration";
+import { days as days5, minutes as minutes3, seconds as seconds2 } from "@awsless/duration";
 import { kibibytes } from "@awsless/size";
-import { z as z19 } from "zod";
+import { z as z18 } from "zod";
 var RetentionPeriodSchema = DurationSchema.refine(durationMin(minutes3(1)), "Minimum retention period is 1 minute").refine(durationMax(days5(14)), "Maximum retention period is 14 days").describe(
   "The number of seconds that Amazon SQS retains a message. You can specify a duration from 1 minute to 14 days."
 );
-var VisibilityTimeoutSchema = DurationSchema.refine(
-  durationMax(hours(12)),
-  "Maximum visibility timeout is 12 hours"
-).describe(
-  "The length of time during which a message will be unavailable after a message is delivered from the queue. You can specify a duration from 0 to 12 hours."
-);
 var ReceiveMessageWaitTimeSchema = DurationSchema.refine(
   durationMin(seconds2(1)),
   "Minimum receive message wait time is 1 second"
 ).refine(durationMax(seconds2(20)), "Maximum receive message wait time is 20 seconds").describe("Long-polling wait time. You can specify a duration from 1 to 20 seconds.");
 var MaxMessageSizeSchema = SizeSchema.refine(sizeMin(kibibytes(1)), "Minimum max message size is 1 KB").refine(sizeMax(kibibytes(256)), "Maximum max message size is 256 KB").describe("Message size limit. You can specify a size from 1 KB to 256 KB.");
-var BatchSizeSchema = z19.number().int().min(1, "Minimum batch size is 1").max(10, "FIFO queues support a maximum batch size of 10").describe("The maximum number of records per batch. FIFO queues are capped at 10.");
-var RetryAttemptsSchema2 = z19.number().int().min(0).max(999).describe(
-  "The maximum number of times to retry when the function returns an error. You can specify a number from 0 to 999."
-);
-var QueueDefaultSchema = z19.object({
+var BatchSizeSchema = z18.number().int().min(1, "Minimum batch size is 1").max(10, "FIFO queues support a maximum batch size of 10").describe("The maximum number of records per batch. FIFO queues are capped at 10.");
+var QueueDefaultSchema = z18.object({
   retentionPeriod: RetentionPeriodSchema.default("7 days"),
-  visibilityTimeout: VisibilityTimeoutSchema.default("2 minutes"),
+  // The visibility timeout is derived from the bundle timeout.
   receiveMessageWaitTime: ReceiveMessageWaitTimeSchema.optional(),
   maxMessageSize: MaxMessageSizeSchema.default("256 KB"),
-  batchSize: BatchSizeSchema.default(10),
-  retryAttempts: RetryAttemptsSchema2.default(2)
+  batchSize: BatchSizeSchema.default(10)
 }).default({});
-var QueueSchema = z19.object({
+var QueueSchema = z18.object({
   consumer: FunctionSchema.optional().describe("The consuming lambda function properties."),
   retentionPeriod: RetentionPeriodSchema.optional(),
-  visibilityTimeout: VisibilityTimeoutSchema.optional(),
   receiveMessageWaitTime: ReceiveMessageWaitTimeSchema.optional(),
   maxMessageSize: MaxMessageSizeSchema.optional(),
-  batchSize: BatchSizeSchema.optional(),
-  retryAttempts: RetryAttemptsSchema2.optional()
+  batchSize: BatchSizeSchema.optional()
 });
-var QueuesSchema = z19.record(
+var QueuesSchema = z18.record(
   ResourceIdSchema,
-  z19.union([
+  z18.union([
     LocalFileSchema.transform((consumer) => ({
       consumer
     })).pipe(QueueSchema),
@@ -911,26 +735,26 @@ var QueuesSchema = z19.record(
 );
 
 // src/feature/rest/schema.ts
-import { z as z21 } from "zod";
+import { z as z20 } from "zod";
 
 // src/config/schema/route.ts
-import { z as z20 } from "zod";
-var RouteSchema2 = z20.union([
-  z20.string().regex(/^(POST|GET|PUT|DELETE|HEAD|OPTIONS|ANY)(\s\/[a-z0-9\+\_\-\/\{\}]*)$/gi, "Invalid route"),
-  z20.literal("$default")
+import { z as z19 } from "zod";
+var RouteSchema2 = z19.union([
+  z19.string().regex(/^(POST|GET|PUT|DELETE|HEAD|OPTIONS|ANY)(\s\/[a-z0-9\+\_\-\/\{\}]*)$/gi, "Invalid route"),
+  z19.literal("$default")
 ]);
 
 // src/feature/rest/schema.ts
-var RestDefaultSchema = z21.record(
+var RestDefaultSchema = z20.record(
   ResourceIdSchema,
-  z21.object({
+  z20.object({
     domain: ResourceIdSchema.describe("The domain id to link your API with.").optional(),
-    subDomain: z21.string().optional()
+    subDomain: z20.string().optional()
   })
 ).optional().describe("Define your global REST API's.");
-var RestSchema = z21.record(
+var RestSchema = z20.record(
   ResourceIdSchema,
-  z21.record(
+  z20.record(
     RouteSchema2.describe(
       [
         "The REST API route that is comprised by the http method and http path.",
@@ -943,40 +767,31 @@ var RestSchema = z21.record(
 ).optional().describe("Define routes in your stack for your global REST API.");
 
 // src/feature/rpc/schema.ts
-import { minutes as minutes4, seconds as seconds3 } from "@awsless/duration";
-import { z as z22 } from "zod";
-var TimeoutSchema2 = DurationSchema.refine(durationMin(seconds3(10)), "Minimum timeout duration is 10 seconds").refine(durationMax(minutes4(5)), "Maximum timeout duration is 5 minutes").describe(
-  [
-    "The amount of time that the RPC lambda is allowed run before stopping it.",
-    "You can specify a timeout from 10 second to 5 minutes.",
-    "The timeouts of all inner RPC functions will be capped at 80% of this timeout."
-  ].join(" ")
-);
-var RpcDefaultSchema = z22.record(
+import { z as z21 } from "zod";
+var RpcDefaultSchema = z21.record(
   ResourceIdSchema,
-  z22.object({
+  z21.object({
     // domain: ResourceIdSchema.describe('The domain id to link your RPC API with.').optional(),
     // subDomain: z.string().optional(),
     //
     router: ResourceIdSchema.describe("The router id to link your RPC API with."),
     path: RouteSchema.describe("The path inside the router to link your RPC API to."),
-    auth: FunctionSchema.optional().describe("The authentication handler for your RPC API."),
-    log: LogSchema.optional(),
-    timeout: TimeoutSchema2.default("1 minutes")
+    auth: FunctionSchema.optional().describe("The authentication handler for your RPC API.")
+    // timeout: TimeoutSchema.default('1 minutes'),
   })
 ).describe(`Define the global RPC API's.`).optional();
-var RpcSchema = z22.record(
+var RpcSchema = z21.record(
   ResourceIdSchema,
-  z22.record(
-    z22.string(),
-    z22.union([
+  z21.record(
+    z21.string(),
+    z21.union([
       FunctionSchema.transform((f) => ({
         function: f,
         lock: false
       })),
-      z22.object({
+      z21.object({
         function: FunctionSchema.describe("The RPC function to execute."),
-        lock: z22.boolean().describe(
+        lock: z21.boolean().describe(
           [
             "Specify if the function should be locked on the `lockKey` returned from the auth function.",
             "An example would be returning the user ID as `lockKey`."
@@ -990,8 +805,8 @@ var RpcSchema = z22.record(
 // src/feature/job/schema.ts
 import { days as days6, toDays as toDays3 } from "@awsless/duration";
 import { toMebibytes as toMebibytes2 } from "@awsless/size";
-import { z as z23 } from "zod";
-var CpuSchema2 = z23.union([z23.literal(0.25), z23.literal(0.5), z23.literal(1), z23.literal(2), z23.literal(4), z23.literal(8), z23.literal(16)]).transform((v) => `${v} vCPU`).describe("The number of virtual CPU units (vCPU) used by the job. Valid values: 0.25, 0.5, 1, 2, 4, 8, 16 vCPU.");
+import { z as z22 } from "zod";
+var CpuSchema2 = z22.union([z22.literal(0.25), z22.literal(0.5), z22.literal(1), z22.literal(2), z22.literal(4), z22.literal(8), z22.literal(16)]).transform((v) => `${v} vCPU`).describe("The number of virtual CPU units (vCPU) used by the job. Valid values: 0.25, 0.5, 1, 2, 4, 8, 16 vCPU.");
 var validMemorySize2 = [
   // 0.25 vCPU
   512,
@@ -1029,20 +844,20 @@ var MemorySizeSchema3 = SizeSchema.refine(
   (s) => validMemorySize2.includes(toMebibytes2(s)),
   `Invalid memory size. Allowed sizes: ${validMemorySize2.join(", ")} MiB`
 ).describe("The amount of memory (in MiB) used by the job. Valid memory values depend on the CPU configuration.");
-var EnvironmentSchema3 = z23.record(z23.string(), z23.string()).optional().describe("Environment variable key-value pairs.");
-var ArchitectureSchema4 = z23.enum(["x86_64", "arm64"]).describe("The instruction set architecture that the job supports.");
-var ActionSchema3 = z23.string();
-var ActionsSchema3 = z23.union([ActionSchema3.transform((v) => [v]), ActionSchema3.array()]);
-var ArnSchema3 = z23.string().startsWith("arn:");
-var WildcardSchema3 = z23.literal("*");
-var ResourceSchema3 = z23.union([ArnSchema3, WildcardSchema3]);
-var ResourcesSchema3 = z23.union([ResourceSchema3.transform((v) => [v]), ResourceSchema3.array()]);
-var PermissionSchema3 = z23.object({
-  effect: z23.enum(["allow", "deny"]).default("allow"),
+var EnvironmentSchema3 = z22.record(z22.string(), z22.string()).optional().describe("Environment variable key-value pairs.");
+var ArchitectureSchema4 = z22.enum(["x86_64", "arm64"]).describe("The instruction set architecture that the job supports.");
+var ActionSchema3 = z22.string();
+var ActionsSchema3 = z22.union([ActionSchema3.transform((v) => [v]), ActionSchema3.array()]);
+var ArnSchema3 = z22.string().startsWith("arn:");
+var WildcardSchema3 = z22.literal("*");
+var ResourceSchema3 = z22.union([ArnSchema3, WildcardSchema3]);
+var ResourcesSchema3 = z22.union([ResourceSchema3.transform((v) => [v]), ResourceSchema3.array()]);
+var PermissionSchema3 = z22.object({
+  effect: z22.enum(["allow", "deny"]).default("allow"),
   actions: ActionsSchema3,
   resources: ResourcesSchema3
 });
-var PermissionsSchema3 = z23.union([PermissionSchema3.transform((v) => [v]), PermissionSchema3.array()]).describe("Add IAM permissions to your job.");
+var PermissionsSchema3 = z22.union([PermissionSchema3.transform((v) => [v]), PermissionSchema3.array()]).describe("Add IAM permissions to your job.");
 var validLogRetentionDays3 = [
   ...[1, 3, 5, 7, 14, 30, 60, 90, 120, 150],
   ...[180, 365, 400, 545, 731, 1096, 1827, 2192],
@@ -1057,27 +872,27 @@ var LogRetentionSchema3 = DurationSchema.refine(
   },
   `Invalid log retention. Valid days are: ${validLogRetentionDays3.map((days8) => `${days8}`).join(", ")}`
 ).describe("The log retention duration.");
-var LogSchema3 = z23.union([
-  z23.boolean().transform((enabled) => ({ retention: enabled ? days6(7) : days6(0) })),
+var LogSchema3 = z22.union([
+  z22.boolean().transform((enabled) => ({ retention: enabled ? days6(7) : days6(0) })),
   LogRetentionSchema3.transform((retention) => ({ retention })),
-  z23.object({
+  z22.object({
     retention: LogRetentionSchema3.optional()
   })
 ]).describe("Enable logging to a CloudWatch log group. Providing a duration value will set the log retention time.");
-var FileCodeSchema3 = z23.object({
+var FileCodeSchema3 = z22.object({
   file: LocalFileSchema.describe("The file path of the job code.")
 });
-var CodeSchema3 = z23.union([
+var CodeSchema3 = z22.union([
   LocalFileSchema.transform((file) => ({
     file
   })).pipe(FileCodeSchema3),
   FileCodeSchema3
 ]).describe("Specify the code of your job.");
-var TimeoutSchema3 = DurationSchema.describe("The maximum time the job is allowed to run before being stopped.");
-var ImageSchema2 = z23.string().describe("The URL of the container image to use. Default: public.ecr.aws/aws-cli/aws-cli:{architecture}");
-var PersistentStorageSchema = z23.boolean().describe("Mount persistent storage for the job at a fixed internal path.");
-var StartupCommandSchema2 = z23.union([z23.string().transform((v) => [v]), z23.string().array()]).describe("Optional shell commands to run before the job executable is downloaded and started.");
-var ASchema = z23.object({
+var TimeoutSchema2 = DurationSchema.describe("The maximum time the job is allowed to run before being stopped.");
+var ImageSchema2 = z22.string().describe("The URL of the container image to use. Default: public.ecr.aws/aws-cli/aws-cli:{architecture}");
+var PersistentStorageSchema = z22.boolean().describe("Mount persistent storage for the job at a fixed internal path.");
+var StartupCommandSchema2 = z22.union([z22.string().transform((v) => [v]), z22.string().array()]).describe("Optional shell commands to run before the job executable is downloaded and started.");
+var ASchema = z22.object({
   code: CodeSchema3,
   image: ImageSchema2.optional(),
   persistentStorage: PersistentStorageSchema.optional(),
@@ -1088,16 +903,16 @@ var ASchema = z23.object({
   architecture: ArchitectureSchema4.optional(),
   environment: EnvironmentSchema3.optional(),
   permissions: PermissionsSchema3.optional(),
-  timeout: TimeoutSchema3.default("30 minutes").describe("The maximum time the job is allowed to run before being stopped. Default: 30 minutes.")
+  timeout: TimeoutSchema2.default("30 minutes").describe("The maximum time the job is allowed to run before being stopped. Default: 30 minutes.")
 });
-var JobSchema = z23.union([
+var JobSchema = z22.union([
   LocalFileSchema.transform((code) => ({
     code
   })).pipe(ASchema),
   ASchema
 ]);
-var JobsSchema = z23.record(ResourceIdSchema, JobSchema).optional().describe("Define the jobs in your stack.");
-var JobDefaultSchema = z23.object({
+var JobsSchema = z22.record(ResourceIdSchema, JobSchema).optional().describe("Define the jobs in your stack.");
+var JobDefaultSchema = z22.object({
   image: ImageSchema2.optional(),
   persistentStorage: PersistentStorageSchema.optional(),
   cpu: CpuSchema2.default(0.25),
@@ -1105,7 +920,7 @@ var JobDefaultSchema = z23.object({
   architecture: ArchitectureSchema4.default("arm64"),
   environment: EnvironmentSchema3.optional(),
   permissions: PermissionsSchema3.optional(),
-  timeout: TimeoutSchema3.optional(),
+  timeout: TimeoutSchema2.optional(),
   log: LogSchema3.default(true).transform((log) => ({
     retention: log.retention ?? days6(7)
   }))
@@ -1113,15 +928,15 @@ var JobDefaultSchema = z23.object({
 
 // src/feature/topic/schema.ts
 import { kebabCase as kebabCase3 } from "change-case";
-import { z as z24 } from "zod";
-var TopicNameSchema = z24.string().min(3).max(256).regex(/^[a-z0-9\-]+$/i, "Invalid topic name").transform((value) => kebabCase3(value)).describe("Define event topic name.");
-var TopicsDefaultSchema = z24.array(TopicNameSchema).refine((topics) => {
+import { z as z23 } from "zod";
+var TopicNameSchema = z23.string().min(3).max(256).regex(/^[a-z0-9\-]+$/i, "Invalid topic name").transform((value) => kebabCase3(value)).describe("Define event topic name.");
+var TopicsDefaultSchema = z23.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 for your app.");
-var SubscribersSchema = z24.record(TopicNameSchema, TaskSchema).optional().describe("Define the event topics to subscribe too in your stack.");
+var SubscribersSchema = z23.record(TopicNameSchema, TaskSchema).optional().describe("Define the event topics to subscribe too in your stack.");
 
 // src/config/schema/region.ts
-import { z as z25 } from "zod";
+import { z as z24 } from "zod";
 var US = ["us-east-2", "us-east-1", "us-west-1", "us-west-2"];
 var AF = ["af-south-1"];
 var AP = [
@@ -1150,16 +965,16 @@ var EU = [
 var ME = ["me-south-1", "me-central-1"];
 var SA = ["sa-east-1"];
 var regions = [...US, ...AF, ...AP, ...CA, ...EU, ...ME, ...SA];
-var RegionSchema = z25.enum(regions);
+var RegionSchema = z24.enum(regions);
 
 // src/config/app.ts
-var AppSchema = z26.object({
-  $schema: z26.string().optional(),
+var AppSchema = z25.object({
+  $schema: z25.string().optional(),
   name: ResourceIdSchema.describe("App name."),
   region: RegionSchema.describe("The AWS region to deploy to."),
-  profile: z26.string().describe("The AWS profile to deploy to."),
-  protect: z26.boolean().default(false).describe("Protect your app & stacks from being deleted."),
-  removal: z26.enum(["remove", "retain"]).default("remove").describe(
+  profile: z25.string().describe("The AWS profile to deploy to."),
+  protect: z25.boolean().default(false).describe("Protect your app & stacks from being deleted."),
+  removal: z25.enum(["remove", "retain"]).default("remove").describe(
     [
       "Configure how your resources are handled when they have to be removed.",
       "",
@@ -1173,7 +988,7 @@ var AppSchema = z26.object({
   // 	.default('prod')
   // 	.describe('The deployment stage.'),
   // onFailure: OnFailureSchema,
-  defaults: z26.object({
+  defaults: z25.object({
     onFailure: OnFailureDefaultSchema,
     onErrorLog: OnErrorLogDefaultSchema,
     auth: AuthDefaultSchema,
@@ -1202,7 +1017,7 @@ import { z as z41 } from "zod";
 
 // src/feature/cache/schema.ts
 import { gibibytes as gibibytes2 } from "@awsless/size";
-import { z as z27 } from "zod";
+import { z as z26 } from "zod";
 var StorageSchema = SizeSchema.refine(sizeMin(gibibytes2(1)), "Minimum storage size is 1 GB").refine(
   sizeMax(gibibytes2(5e3)),
   "Maximum storage size is 5000 GB"
@@ -1213,31 +1028,31 @@ var MinimumStorageSchema = StorageSchema.describe(
 var MaximumStorageSchema = StorageSchema.describe(
   "The upper limit for data storage the cache is set to use. You can specify a size value from 1 GB to 5000 GB."
 );
-var EcpuSchema = z27.number().int().min(1e3).max(15e6);
+var EcpuSchema = z26.number().int().min(1e3).max(15e6);
 var MinimumEcpuSchema = EcpuSchema.describe(
   "The minimum number of ECPUs the cache can consume per second. You can specify a integer from 1,000 to 15,000,000."
 );
 var MaximumEcpuSchema = EcpuSchema.describe(
   "The maximum number of ECPUs the cache can consume per second. You can specify a integer from 1,000 to 15,000,000."
 );
-var CachesSchema = z27.record(
+var CachesSchema = z26.record(
   ResourceIdSchema,
-  z27.object({
+  z26.object({
     minStorage: MinimumStorageSchema.optional(),
     maxStorage: MaximumStorageSchema.optional(),
     minECPU: MinimumEcpuSchema.optional(),
     maxECPU: MaximumEcpuSchema.optional(),
-    snapshotRetentionLimit: z27.number().int().positive().default(1)
+    snapshotRetentionLimit: z26.number().int().positive().default(1)
   })
 ).optional().describe("Define the caches in your stack. For access to the cache put your functions inside the global VPC.");
 
 // src/feature/command/schema.ts
-import { z as z28 } from "zod";
-var CommandSchema = z28.union([
-  z28.object({
+import { z as z27 } from "zod";
+var CommandSchema = z27.union([
+  z27.object({
     file: LocalFileSchema,
-    handler: z28.string().default("default").describe("The name of the handler that needs to run"),
-    description: z28.string().optional().describe("A description of the command")
+    handler: z27.string().default("default").describe("The name of the handler that needs to run"),
+    description: z27.string().optional().describe("A description of the command")
     // options: z.record(ResourceIdSchema, OptionSchema).optional(),
     // arguments: z.record(ResourceIdSchema, ArgumentSchema).optional(),
   }),
@@ -1247,22 +1062,22 @@ var CommandSchema = z28.union([
     description: void 0
   }))
 ]);
-var CommandsSchema = z28.record(ResourceIdSchema, CommandSchema).optional().describe("Define the custom commands for your stack.");
+var CommandsSchema = z27.record(ResourceIdSchema, CommandSchema).optional().describe("Define the custom commands for your stack.");
 
 // src/feature/config/schema.ts
-import { z as z29 } from "zod";
-var ConfigNameSchema = z29.string().regex(/[a-z0-9\-]/g, "Invalid config name");
-var ConfigsSchema = z29.array(ConfigNameSchema).optional().describe("Define the config values for your stack.");
+import { z as z28 } from "zod";
+var ConfigNameSchema = z28.string().regex(/[a-z0-9\-]/g, "Invalid config name");
+var ConfigsSchema = z28.array(ConfigNameSchema).optional().describe("Define the config values for your stack.");
 
 // src/feature/cron/schema/index.ts
-import { z as z31 } from "zod";
+import { z as z30 } from "zod";
 
 // src/feature/cron/schema/schedule.ts
-import { z as z30 } from "zod";
+import { z as z29 } from "zod";
 import { awsCronExpressionValidator } from "aws-cron-expression-validator";
-var RateExpressionSchema = z30.custom(
+var RateExpressionSchema = z29.custom(
   (value) => {
-    return z30.string().regex(/^[0-9]+ (seconds?|minutes?|hours?|days?)$/).refine((rate) => {
+    return z29.string().regex(/^[0-9]+ (seconds?|minutes?|hours?|days?)$/).refine((rate) => {
       const [str] = rate.split(" ");
       const number = parseInt(str);
       return number > 0;
@@ -1278,9 +1093,9 @@ var RateExpressionSchema = z30.custom(
   }
   return `rate(${rate})`;
 });
-var CronExpressionSchema = z30.custom(
+var CronExpressionSchema = z29.custom(
   (value) => {
-    return z30.string().safeParse(value).success;
+    return z29.string().safeParse(value).success;
   },
   { message: "Invalid cron expression" }
 ).superRefine((value, ctx) => {
@@ -1289,12 +1104,12 @@ var CronExpressionSchema = z30.custom(
   } catch (error) {
     if (error instanceof Error) {
       ctx.addIssue({
-        code: z30.ZodIssueCode.custom,
+        code: z29.ZodIssueCode.custom,
         message: `Invalid cron expression: ${error.message}`
       });
     } else {
       ctx.addIssue({
-        code: z30.ZodIssueCode.custom,
+        code: z29.ZodIssueCode.custom,
         message: "Invalid cron expression"
       });
     }
@@ -1305,32 +1120,28 @@ var CronExpressionSchema = z30.custom(
 var ScheduleExpressionSchema = RateExpressionSchema.or(CronExpressionSchema);
 
 // src/feature/cron/schema/index.ts
-var RetryAttemptsSchema3 = z31.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 CronsSchema = z31.record(
+var CronsSchema = z30.record(
   ResourceIdSchema,
-  z31.object({
-    enabled: z31.boolean().default(true).describe("If the cron is enabled."),
+  z30.object({
+    enabled: z30.boolean().default(true).describe("If the cron is enabled."),
     consumer: FunctionSchema.describe("The consuming lambda function properties."),
     schedule: ScheduleExpressionSchema.describe(
       'The scheduling expression.\n\nexample: "0 20 * * ? *"\nexample: "5 minutes"'
     ),
-    payload: z31.unknown().optional().describe("The JSON payload that will be passed to the consumer."),
-    retryAttempts: RetryAttemptsSchema3.default(2)
+    payload: z30.unknown().optional().describe("The JSON payload that will be passed to the consumer.")
   })
 ).optional().describe(`Define the cron jobs in your stack.`);
 
 // src/feature/search/schema.ts
 import { gibibytes as gibibytes3 } from "@awsless/size";
-import { z as z32 } from "zod";
-var VersionSchema = z32.union([
+import { z as z31 } from "zod";
+var VersionSchema = z31.union([
   //
-  z32.enum(["2.13", "2.11", "2.9", "2.7", "2.5", "2.3", "1.3"]),
-  z32.string()
+  z31.enum(["2.13", "2.11", "2.9", "2.7", "2.5", "2.3", "1.3"]),
+  z31.string()
 ]).describe("Specify the OpenSearch engine version.");
-var TypeSchema = z32.union([
-  z32.enum([
+var TypeSchema = z31.union([
+  z31.enum([
     "t3.small",
     "t3.medium",
     "m3.medium",
@@ -1404,13 +1215,13 @@ var TypeSchema = z32.union([
     "r6gd.12xlarge",
     "r6gd.16xlarge"
   ]),
-  z32.string()
+  z31.string()
 ]).describe("Instance type of data nodes in the cluster.");
-var CountSchema = z32.number().int().min(1).describe("Number of instances in the cluster.");
+var CountSchema = z31.number().int().min(1).describe("Number of instances in the cluster.");
 var StorageSizeSchema = SizeSchema.refine(sizeMin(gibibytes3(10)), "Minimum storage size is 10 GB").refine(sizeMax(gibibytes3(100)), "Maximum storage size is 100 GB").describe("The size of the function's /tmp directory. You can specify a size value from 512 MB to 10 GiB.");
-var SearchsSchema = z32.record(
+var SearchsSchema = z31.record(
   ResourceIdSchema,
-  z32.object({
+  z31.object({
     type: TypeSchema.default("t3.small"),
     count: CountSchema.default(1),
     version: VersionSchema.default("2.13"),
@@ -1423,6 +1234,25 @@ var SearchsSchema = z32.record(
 // src/feature/site/schema.ts
 import { z as z34 } from "zod";
 
+// src/config/schema/local-directory.ts
+import { stat as stat2 } from "fs/promises";
+import { z as z32 } from "zod";
+var LocalDirectorySchema = z32.union([
+  RelativePathSchema.refine(async (path) => {
+    try {
+      const s = await stat2(path);
+      return s.isDirectory();
+    } catch (error) {
+      return false;
+    }
+  }, `Directory doesn't exist`),
+  z32.object({
+    nocheck: RelativePathSchema.describe(
+      "Specifies a local directory without checking if the directory exists."
+    )
+  }).transform((v) => v.nocheck)
+]);
+
 // src/config/schema/local-entry.ts
 import { stat as stat3 } from "fs/promises";
 import { z as z33 } from "zod";
@@ -1485,7 +1315,6 @@ var StoresSchema = z35.union([
     ResourceIdSchema,
     z35.object({
       static: LocalDirectorySchema.optional().describe("Specifies the path to the static files directory."),
-      versioning: z35.boolean().default(false).describe("Enable versioning of your store."),
       lifecycle: z35.array(LifecycleRuleSchema).optional().describe("S3 lifecycle rules for this store. Each rule expires objects matching an optional prefix."),
       events: z35.object({
         // create
@@ -1534,7 +1363,6 @@ var IconsSchema = z36.record(
     // subDomain: z.string().optional(),
     router: ResourceIdSchema.describe("The router id to link your icon proxy."),
     path: RouteSchema.describe("The path inside the router to link your icon proxy to."),
-    log: LogSchema.optional(),
     cacheDuration: DurationSchema.optional().describe("The cache duration of the cached icons."),
     preserveIds: z36.boolean().optional().default(false).describe("Preserve the IDs of the icons."),
     symbols: z36.boolean().optional().default(false).describe(`Convert the SVG's to SVG symbols.`),
@@ -1591,7 +1419,6 @@ var ImagesSchema = z37.record(
     // subDomain: z.string().optional(),
     router: ResourceIdSchema.describe("The router id to link your image proxy."),
     path: RouteSchema.describe("The path inside the router to link your image proxy to."),
-    log: LogSchema.optional(),
     cacheDuration: DurationSchema.optional().describe("Cache duration of the cached images."),
     presets: z37.record(z37.string(), transformationOptionsSchema).describe("Named presets for image transformations"),
     extensions: z37.object({
@@ -1677,7 +1504,7 @@ var MetricsSchema = z38.record(
 ).optional().describe("Define the metrics in your stack.");
 
 // src/feature/table/schema.ts
-import { minutes as minutes5, seconds as seconds4 } from "@awsless/duration";
+import { minutes as minutes4, seconds as seconds3 } from "@awsless/duration";
 import { z as z39 } from "zod";
 var KeySchema = z39.string().min(1).max(255);
 var TablesSchema = z39.record(
@@ -1720,9 +1547,9 @@ var TablesSchema = z39.record(
         ].join("\n")
       ),
       batchWindow: DurationSchema.refine(
-        durationMin(seconds4(1)),
+        durationMin(seconds3(1)),
         "Minimum batch window duration is 1 second"
-      ).refine(durationMax(minutes5(5)), "Maximum batch window duration is 5 minutes").optional().describe(
+      ).refine(durationMax(minutes4(5)), "Maximum batch window duration is 5 minutes").optional().describe(
         [
           "The maximum amount of time that is spend gathering records before invoking the function.",
           "You can specify a duration from 1 seconds to 5 minutes."
@@ -1804,7 +1631,6 @@ var StackSchema = z41.object({
   // auth: AuthSchema,
   // http: HttpSchema,
   rest: RestSchema,
-  routes: RoutesSchema,
   rpc: RpcSchema,
   configs: ConfigsSchema,
   crons: CronsSchema,
@@ -2099,7 +1925,6 @@ var generateJsonSchema = (props) => {
 var appendDefaults = (object) => {
   if (Array.isArray(object)) {
     object.forEach(appendDefaults);
-    return;
   }
   if (typeof object === "object" && object !== null) {
     if ("default" in object && "type" in object) {