@awsless/awsless 0.0.471 → 0.0.473

package/dist/bin.js

@@ -414,7 +414,7 @@ var debug = (...parts) => {
 };
 
 // src/config/app.ts
-import { z as z19 } from "zod";
+import { z as z21 } from "zod";
 
 // src/feature/alert/schema.ts
 import { kebabCase } from "change-case";
@@ -529,10 +529,11 @@ 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 z9 } from "zod";
+import { z as z11 } from "zod";
 
 // src/config/schema/local-directory.ts
 import { stat } from "fs/promises";
+import { z as z8 } from "zod";
 
 // src/config/schema/relative-path.ts
 import { join as join3 } from "path";
@@ -550,30 +551,41 @@ var resolvePath = (path) => {
 var RelativePathSchema = z7.string().transform((path) => resolvePath(path));
 
 // src/config/schema/local-directory.ts
-var LocalDirectorySchema = RelativePathSchema.refine(async (path) => {
-  try {
-    const s = await stat(path);
-    return s.isDirectory();
-  } catch (error) {
-    return false;
-  }
-}, `Directory doesn't exist`);
+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: z8.string().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";
-var LocalFileSchema = RelativePathSchema.refine(async (path) => {
-  try {
-    const s = await stat2(path);
-    return s.isFile();
-  } catch (error) {
-    return false;
-  }
-}, `File doesn't exist`);
+import { z as z9 } from "zod";
+var LocalFileSchema = z9.union([
+  RelativePathSchema.refine(async (path) => {
+    try {
+      const s = await stat2(path);
+      return s.isFile();
+    } catch (error) {
+      return false;
+    }
+  }, `File doesn't exist`),
+  z9.object({
+    nocheck: z9.string().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 z8 } from "zod";
-var SizeSchema = z8.string().regex(/^[0-9]+ (B|KB|MB|GB|TB|PB)$/, "Invalid size").transform((v) => parse2(v));
+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));
 var sizeMin = (min) => {
   return (size) => {
     return size.value >= min.value;
@@ -596,32 +608,32 @@ 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 = z9.number().int().min(0).describe("The number of simultaneous executions to reserve for the function. You can specify a number from 0.");
-var EnvironmentSchema = z9.record(z9.string(), z9.string()).optional().describe("Environment variable key-value pairs.");
-var ArchitectureSchema = z9.enum(["x86_64", "arm64"]).describe("The instruction set architecture that the function supports.");
-var RetryAttemptsSchema = z9.number().int().min(0).max(2).describe(
+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 RetryAttemptsSchema = z11.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 NodeRuntimeSchema = z9.enum(["nodejs18.x", "nodejs20.x", "nodejs22.x"]);
-var ContainerRuntimeSchema = z9.literal("container");
+var NodeRuntimeSchema = z11.enum(["nodejs18.x", "nodejs20.x", "nodejs22.x"]);
+var ContainerRuntimeSchema = z11.literal("container");
 var RuntimeSchema = NodeRuntimeSchema.or(ContainerRuntimeSchema).describe("The identifier of the function's runtime.");
-var ActionSchema = z9.string();
-var ActionsSchema = z9.union([ActionSchema.transform((v) => [v]), ActionSchema.array()]);
-var ArnSchema = z9.string().startsWith("arn:");
-var WildcardSchema = z9.literal("*");
-var ResourceSchema = z9.union([ArnSchema, WildcardSchema]);
-var ResourcesSchema = z9.union([ResourceSchema.transform((v) => [v]), ResourceSchema.array()]);
-var PermissionSchema = z9.object({
-  effect: z9.enum(["allow", "deny"]).default("allow"),
+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"),
   actions: ActionsSchema,
   resources: ResourcesSchema
 });
-var PermissionsSchema = z9.union([PermissionSchema.transform((v) => [v]), PermissionSchema.array()]).describe("Add IAM permissions to your function.");
-var WarmSchema = z9.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 = z9.boolean().describe("Put the function inside your global VPC.");
-var MinifySchema = z9.boolean().describe("Minify the function code.");
-var HandlerSchema = z9.string().describe("The name of the exported method within your code that Lambda calls to run your function.");
-var DescriptionSchema = z9.string().describe("A description of the function.");
+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 validLogRetentionDays = [
   ...[1, 3, 5, 7, 14, 30, 60, 90, 120, 150],
   ...[180, 365, 400, 545, 731, 1096, 1827, 2192],
@@ -636,43 +648,43 @@ var LogRetentionSchema = DurationSchema.refine(
   },
   `Invalid log retention. Valid days are: ${validLogRetentionDays.map((days6) => `${days6}`).join(", ")}`
 ).describe("The log retention duration.");
-var LogSchema = z9.union([
-  z9.boolean().transform((enabled) => ({ retention: enabled ? days(7) : days(0) })),
+var LogSchema = z11.union([
+  z11.boolean().transform((enabled) => ({ retention: enabled ? days(7) : days(0) })),
   LogRetentionSchema.transform((retention) => ({ retention })),
-  z9.object({
+  z11.object({
     // subscription: LogSubscriptionSchema.optional(),
     retention: LogRetentionSchema.optional(),
-    format: z9.enum(["text", "json"]).describe(
+    format: z11.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: z9.enum(["debug", "info", "warn"]).describe(
+    system: z11.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: z9.enum(["trace", "debug", "info", "warn", "error", "fatal"]).describe(
+    level: z11.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 = z9.string().array().describe(
+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 = z9.object({
+var FileCodeSchema = z11.object({
   file: LocalFileSchema.describe("The file path of the function code."),
   minify: MinifySchema.optional().default(true),
-  external: z9.string().array().optional().describe(`A list of external packages that won't be included in the bundle.`)
+  external: z11.string().array().optional().describe(`A list of external packages that won't be included in the bundle.`)
 });
-var BundleCodeSchema = z9.object({
+var BundleCodeSchema = z11.object({
   bundle: LocalDirectorySchema.describe("The directory that needs to be bundled.")
 });
-var CodeSchema = z9.union([
+var CodeSchema = z11.union([
   LocalFileSchema.transform((file) => ({
     file
   })).pipe(FileCodeSchema),
   FileCodeSchema,
   BundleCodeSchema
 ]).describe("Specify the code of your function.");
-var FnSchema = z9.object({
+var FnSchema = z11.object({
   code: CodeSchema,
   // node
   handler: HandlerSchema.optional(),
@@ -695,14 +707,14 @@ var FnSchema = z9.object({
   environment: EnvironmentSchema.optional(),
   permissions: PermissionsSchema.optional()
 });
-var FunctionSchema = z9.union([
+var FunctionSchema = z11.union([
   LocalFileSchema.transform((code) => ({
     code
   })).pipe(FnSchema),
   FnSchema
 ]);
-var FunctionsSchema = z9.record(ResourceIdSchema, FunctionSchema).optional().describe("Define the functions in your stack.");
-var FunctionDefaultSchema = z9.object({
+var FunctionsSchema = z11.record(ResourceIdSchema, FunctionSchema).optional().describe("Define the functions in your stack.");
+var FunctionDefaultSchema = z11.object({
   runtime: RuntimeSchema.default("nodejs20.x"),
   // node
   handler: HandlerSchema.default("index.default"),
@@ -731,25 +743,25 @@ var FunctionDefaultSchema = z9.object({
 }).default({});
 
 // src/feature/layer/schema.ts
-import { z as z11 } from "zod";
+import { z as z13 } from "zod";
 
 // src/config/schema/lambda.ts
-import { z as z10 } from "zod";
-var ArchitectureSchema2 = z10.enum(["x86_64", "arm64"]).describe("The instruction set architecture that the function supports.");
-var NodeRuntimeSchema2 = z10.enum(["nodejs18.x", "nodejs20.x", "nodejs22.x"]).describe("The identifier of the function's runtime.");
+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.");
 
 // src/feature/layer/schema.ts
-var Schema = z11.object({
+var Schema = z13.object({
   file: LocalFileSchema,
   runtimes: NodeRuntimeSchema2.array().optional(),
   architecture: ArchitectureSchema2.optional(),
-  packages: z11.string().array().optional().describe(
+  packages: z13.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 = z11.record(
-  z11.string(),
-  z11.union([
+var LayerSchema = z13.record(
+  z13.string(),
+  z13.union([
     LocalFileSchema.transform((file) => ({
       file,
       description: void 0
@@ -764,28 +776,28 @@ var OnFailureDefaultSchema = FunctionSchema.optional().describe(
 );
 
 // src/feature/on-log/schema.ts
-import { z as z12 } from "zod";
-var FilterSchema = z12.enum(["trace", "debug", "info", "warn", "error", "fatal"]).array().describe("The log level that will gets delivered to the consumer.");
-var OnLogDefaultSchema = z12.union([
+import { z as z14 } from "zod";
+var FilterSchema = z14.enum(["trace", "debug", "info", "warn", "error", "fatal"]).array().describe("The log level that will gets delivered to the consumer.");
+var OnLogDefaultSchema = z14.union([
   FunctionSchema.transform((consumer) => ({
     consumer,
     filter: ["error", "fatal"]
   })),
-  z12.object({
+  z14.object({
     consumer: FunctionSchema,
     filter: FilterSchema
   })
 ]).optional().describe("Define a subscription on all Lambda functions logs.");
 
 // src/feature/pubsub/schema.ts
-import { z as z13 } from "zod";
+import { z as z15 } from "zod";
 var DomainSchema = ResourceIdSchema.describe("The domain id to link your Pubsub API with.");
-var PubSubDefaultSchema = z13.record(
+var PubSubDefaultSchema = z15.record(
   ResourceIdSchema,
-  z13.object({
+  z15.object({
     auth: FunctionSchema,
     domain: DomainSchema.optional(),
-    subDomain: z13.string().optional()
+    subDomain: z15.string().optional()
     // auth: z.union([
     // 	ResourceIdSchema,
     // 	z.object({
@@ -801,11 +813,11 @@ var PubSubDefaultSchema = z13.record(
     // 	.optional(),
   })
 ).optional().describe("Define the pubsub subscriber in your stack.");
-var PubSubSchema = z13.record(
+var PubSubSchema = z15.record(
   ResourceIdSchema,
-  z13.object({
-    sql: z13.string().describe("The SQL statement used to query the IOT topic."),
-    sqlVersion: z13.enum(["2015-10-08", "2016-03-23", "beta"]).default("2016-03-23").describe("The version of the SQL rules engine to use when evaluating the rule."),
+  z15.object({
+    sql: z15.string().describe("The SQL statement used to query the IOT topic."),
+    sqlVersion: z15.enum(["2015-10-08", "2016-03-23", "beta"]).default("2016-03-23").describe("The version of the SQL rules engine to use when evaluating the rule."),
     consumer: FunctionSchema.describe("The consuming lambda function properties.")
   })
 ).optional().describe("Define the pubsub subscriber in your stack.");
@@ -813,7 +825,7 @@ var PubSubSchema = z13.record(
 // src/feature/queue/schema.ts
 import { days as days2, hours, minutes as minutes2, seconds as seconds2 } from "@awsless/duration";
 import { kibibytes } from "@awsless/size";
-import { z as z14 } from "zod";
+import { z as z16 } from "zod";
 var RetentionPeriodSchema = DurationSchema.refine(
   durationMin(minutes2(1)),
   "Minimum retention period is 1 minute"
@@ -841,10 +853,10 @@ var ReceiveMessageWaitTimeSchema = DurationSchema.refine(
 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(
   "The limit of how many bytes that a message can contain before Amazon SQS rejects it. You can specify an size from 1 KB to 256 KB."
 );
-var BatchSizeSchema = z14.number().int().min(1, "Minimum batch size is 1").max(1e4, "Maximum batch size is 10000").describe(
+var BatchSizeSchema = z16.number().int().min(1, "Minimum batch size is 1").max(1e4, "Maximum batch size is 10000").describe(
   "The maximum number of records in each batch that Lambda pulls from your queue 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). You can specify an integer from 1 to 10000."
 );
-var MaxConcurrencySchema = z14.number().int().min(2, "Minimum max concurrency is 2").max(1e3, "Maximum max concurrency is 1000").describe(
+var MaxConcurrencySchema = z16.number().int().min(2, "Minimum max concurrency is 2").max(1e3, "Maximum max concurrency is 1000").describe(
   "Limits the number of concurrent instances that the queue worker can invoke. You can specify an integer from 2 to 1000."
 );
 var MaxBatchingWindow = DurationSchema.refine(
@@ -853,7 +865,7 @@ var MaxBatchingWindow = DurationSchema.refine(
 ).describe(
   "The maximum amount of time, that Lambda spends gathering records before invoking the function. You can specify an duration from 0 seconds to 5 minutes."
 );
-var QueueDefaultSchema = z14.object({
+var QueueDefaultSchema = z16.object({
   retentionPeriod: RetentionPeriodSchema.default("7 days"),
   visibilityTimeout: VisibilityTimeoutSchema.default("30 seconds"),
   deliveryDelay: DeliveryDelaySchema.default("0 seconds"),
@@ -863,7 +875,7 @@ var QueueDefaultSchema = z14.object({
   maxConcurrency: MaxConcurrencySchema.optional(),
   maxBatchingWindow: MaxBatchingWindow.optional()
 }).default({});
-var QueueSchema = z14.object({
+var QueueSchema = z16.object({
   consumer: FunctionSchema.describe("The consuming lambda function properties."),
   retentionPeriod: RetentionPeriodSchema.optional(),
   visibilityTimeout: VisibilityTimeoutSchema.optional(),
@@ -874,9 +886,9 @@ var QueueSchema = z14.object({
   maxConcurrency: MaxConcurrencySchema.optional(),
   maxBatchingWindow: MaxBatchingWindow.optional()
 });
-var QueuesSchema = z14.record(
+var QueuesSchema = z16.record(
   ResourceIdSchema,
-  z14.union([
+  z16.union([
     LocalFileSchema.transform((consumer) => ({
       consumer
     })).pipe(QueueSchema),
@@ -885,41 +897,50 @@ var QueuesSchema = z14.record(
 ).optional().describe("Define the queues in your stack.");
 
 // src/feature/rest/schema.ts
-import { z as z16 } from "zod";
+import { z as z18 } from "zod";
 
 // src/config/schema/route.ts
-import { z as z15 } from "zod";
-var RouteSchema = z15.union([
-  z15.string().regex(/^(POST|GET|PUT|DELETE|HEAD|OPTIONS)(\s\/[a-z0-9\+\_\-\/\{\}]*)$/gi, "Invalid route"),
-  z15.literal("$default")
+import { z as z17 } from "zod";
+var RouteSchema = z17.union([
+  z17.string().regex(/^(POST|GET|PUT|DELETE|HEAD|OPTIONS)(\s\/[a-z0-9\+\_\-\/\{\}]*)$/gi, "Invalid route"),
+  z17.literal("$default")
 ]);
 
 // src/feature/rest/schema.ts
-var RestDefaultSchema = z16.record(
+var RestDefaultSchema = z18.record(
   ResourceIdSchema,
-  z16.object({
+  z18.object({
     domain: ResourceIdSchema.describe("The domain id to link your API with.").optional(),
-    subDomain: z16.string().optional()
+    subDomain: z18.string().optional()
   })
 ).optional().describe("Define your global REST API's.");
-var RestSchema = z16.record(ResourceIdSchema, z16.record(RouteSchema, FunctionSchema)).optional().describe("Define routes in your stack for your global REST API.");
+var RestSchema = z18.record(ResourceIdSchema, z18.record(RouteSchema, FunctionSchema)).optional().describe("Define routes in your stack for your global REST API.");
 
 // src/feature/rpc/schema.ts
-import { z as z17 } from "zod";
-var RpcDefaultSchema = z17.record(
+import { z as z19 } from "zod";
+import { minutes as minutes3, seconds as seconds3 } from "@awsless/duration";
+var TimeoutSchema2 = DurationSchema.refine(durationMin(seconds3(10)), "Minimum timeout duration is 10 seconds").refine(durationMax(minutes3(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 size value from 1 second to 5 minutes.",
+    "The timeouts of all inner RPC functions will be capped at 80% of this timeout."
+  ].join(" ")
+);
+var RpcDefaultSchema = z19.record(
   ResourceIdSchema,
-  z17.object({
+  z19.object({
     domain: ResourceIdSchema.describe("The domain id to link your RPC API with.").optional(),
-    subDomain: z17.string().optional(),
+    subDomain: z19.string().optional(),
     auth: FunctionSchema.optional(),
     log: LogSchema.optional(),
-    geoRestrictions: z17.array(z17.string().length(2).toUpperCase()).default([]).describe("Specifies a blacklist of countries that should be blocked.")
+    timeout: TimeoutSchema2.default("1 minutes"),
+    geoRestrictions: z19.array(z19.string().length(2).toUpperCase()).default([]).describe("Specifies a blacklist of countries that should be blocked.")
   })
 ).describe(`Define the global RPC API's.`).optional();
-var RpcSchema = z17.record(ResourceIdSchema, z17.record(z17.string(), FunctionSchema).describe("The queries for your global RPC API.")).describe("Define the schema in your stack for your global RPC API.").optional();
+var RpcSchema = z19.record(ResourceIdSchema, z19.record(z19.string(), FunctionSchema).describe("The queries for your global RPC API.")).describe("Define the schema in your stack for your global RPC API.").optional();
 
 // src/config/schema/region.ts
-import { z as z18 } from "zod";
+import { z as z20 } from "zod";
 var US = ["us-east-2", "us-east-1", "us-west-1", "us-west-2"];
 var AF = ["af-south-1"];
 var AP = [
@@ -948,16 +969,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 = z18.enum(regions);
+var RegionSchema = z20.enum(regions);
 
 // src/config/app.ts
-var AppSchema = z19.object({
-  $schema: z19.string().optional(),
+var AppSchema = z21.object({
+  $schema: z21.string().optional(),
   name: ResourceIdSchema.describe("App name."),
   region: RegionSchema.describe("The AWS region to deploy to."),
-  profile: z19.string().describe("The AWS profile to deploy to."),
-  protect: z19.boolean().default(false).describe("Protect your app & stacks from being deleted."),
-  removal: z19.enum(["remove", "retain"]).default("remove").describe(
+  profile: z21.string().describe("The AWS profile to deploy to."),
+  protect: z21.boolean().default(false).describe("Protect your app & stacks from being deleted."),
+  removal: z21.enum(["remove", "retain"]).default("remove").describe(
     [
       "Configure how your resources are handled when they have to be removed.",
       "",
@@ -971,7 +992,7 @@ var AppSchema = z19.object({
   // 	.default('prod')
   // 	.describe('The deployment stage.'),
   // onFailure: OnFailureSchema,
-  defaults: z19.object({
+  defaults: z21.object({
     onFailure: OnFailureDefaultSchema,
     onLog: OnLogDefaultSchema,
     auth: AuthDefaultSchema,
@@ -993,11 +1014,11 @@ var AppSchema = z19.object({
 });
 
 // src/config/stack.ts
-import { z as z32 } from "zod";
+import { z as z34 } from "zod";
 
 // src/feature/cache/schema.ts
 import { gibibytes as gibibytes2 } from "@awsless/size";
-import { z as z20 } from "zod";
+import { z as z22 } 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"
@@ -1008,31 +1029,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 = z20.number().int().min(1e3).max(15e6);
+var EcpuSchema = z22.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 = z20.record(
+var CachesSchema = z22.record(
   ResourceIdSchema,
-  z20.object({
+  z22.object({
     minStorage: MinimumStorageSchema.optional(),
     maxStorage: MaximumStorageSchema.optional(),
     minECPU: MinimumEcpuSchema.optional(),
     maxECPU: MaximumEcpuSchema.optional(),
-    snapshotRetentionLimit: z20.number().int().positive().default(1)
+    snapshotRetentionLimit: z22.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 z21 } from "zod";
-var CommandSchema = z21.union([
-  z21.object({
+import { z as z23 } from "zod";
+var CommandSchema = z23.union([
+  z23.object({
     file: LocalFileSchema,
-    handler: z21.string().default("default").describe("The name of the handler that needs to run"),
-    description: z21.string().optional().describe("A description of the command")
+    handler: z23.string().default("default").describe("The name of the handler that needs to run"),
+    description: z23.string().optional().describe("A description of the command")
     // options: z.record(ResourceIdSchema, OptionSchema).optional(),
     // arguments: z.record(ResourceIdSchema, ArgumentSchema).optional(),
   }),
@@ -1042,22 +1063,22 @@ var CommandSchema = z21.union([
     description: void 0
   }))
 ]);
-var CommandsSchema = z21.record(ResourceIdSchema, CommandSchema).optional().describe("Define the custom commands for your stack.");
+var CommandsSchema = z23.record(ResourceIdSchema, CommandSchema).optional().describe("Define the custom commands for your stack.");
 
 // src/feature/config/schema.ts
-import { z as z22 } from "zod";
-var ConfigNameSchema = z22.string().regex(/[a-z0-9\-]/g, "Invalid config name");
-var ConfigsSchema = z22.array(ConfigNameSchema).optional().describe("Define the config values for your stack.");
+import { z as z24 } from "zod";
+var ConfigNameSchema = z24.string().regex(/[a-z0-9\-]/g, "Invalid config name");
+var ConfigsSchema = z24.array(ConfigNameSchema).optional().describe("Define the config values for your stack.");
 
 // src/feature/cron/schema/index.ts
-import { z as z24 } from "zod";
+import { z as z26 } from "zod";
 
 // src/feature/cron/schema/schedule.ts
-import { z as z23 } from "zod";
+import { z as z25 } from "zod";
 import { awsCronExpressionValidator } from "aws-cron-expression-validator";
-var RateExpressionSchema = z23.custom(
+var RateExpressionSchema = z25.custom(
   (value) => {
-    return z23.string().regex(/^[0-9]+ (seconds?|minutes?|hours?|days?)$/).refine((rate) => {
+    return z25.string().regex(/^[0-9]+ (seconds?|minutes?|hours?|days?)$/).refine((rate) => {
       const [str] = rate.split(" ");
       const number = parseInt(str);
       return number > 0;
@@ -1073,9 +1094,9 @@ var RateExpressionSchema = z23.custom(
   }
   return `rate(${rate})`;
 });
-var CronExpressionSchema = z23.custom(
+var CronExpressionSchema = z25.custom(
   (value) => {
-    return z23.string().safeParse(value).success;
+    return z25.string().safeParse(value).success;
   },
   { message: "Invalid cron expression" }
 ).superRefine((value, ctx) => {
@@ -1084,12 +1105,12 @@ var CronExpressionSchema = z23.custom(
   } catch (error) {
     if (error instanceof Error) {
       ctx.addIssue({
-        code: z23.ZodIssueCode.custom,
+        code: z25.ZodIssueCode.custom,
         message: `Invalid cron expression: ${error.message}`
       });
     } else {
       ctx.addIssue({
-        code: z23.ZodIssueCode.custom,
+        code: z25.ZodIssueCode.custom,
         message: "Invalid cron expression"
       });
     }
@@ -1100,23 +1121,23 @@ var CronExpressionSchema = z23.custom(
 var ScheduleExpressionSchema = RateExpressionSchema.or(CronExpressionSchema);
 
 // src/feature/cron/schema/index.ts
-var CronsSchema = z24.record(
+var CronsSchema = z26.record(
   ResourceIdSchema,
-  z24.object({
-    enabled: z24.boolean().default(true).describe("If the cron is enabled."),
+  z26.object({
+    enabled: z26.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: z24.unknown().optional().describe("The JSON payload that will be passed to the consumer.")
+    payload: z26.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 z25 } from "zod";
-var VersionSchema = z25.enum(["2.13", "2.11", "2.9", "2.7", "2.5", "2.3", "1.3"]);
-var TypeSchema = z25.enum([
+import { z as z27 } from "zod";
+var VersionSchema = z27.enum(["2.13", "2.11", "2.9", "2.7", "2.5", "2.3", "1.3"]);
+var TypeSchema = z27.enum([
   "t3.small",
   "t3.medium",
   "m3.medium",
@@ -1191,11 +1212,11 @@ var TypeSchema = z25.enum([
   "r6gd.16xlarge"
 ]);
 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 = z25.record(
+var SearchsSchema = z27.record(
   ResourceIdSchema,
-  z25.object({
+  z27.object({
     type: TypeSchema.default("t3.small"),
-    count: z25.number().int().min(1).default(1),
+    count: z27.number().int().min(1).default(1),
     version: VersionSchema.default("2.13"),
     storage: StorageSizeSchema.default("10 GB")
     // vpc: z.boolean().default(false),
@@ -1203,29 +1224,29 @@ var SearchsSchema = z25.record(
 ).optional().describe("Define the search instances in your stack. Backed by OpenSearch.");
 
 // src/feature/site/schema.ts
-import { z as z26 } from "zod";
-var ErrorResponsePathSchema = z26.string().describe(
+import { z as z28 } from "zod";
+var ErrorResponsePathSchema = z28.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.\n - 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."
 );
-var StatusCodeSchema = z26.number().int().positive().optional().describe(
+var StatusCodeSchema = z28.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:\n- Some Internet devices (some firewalls and corporate proxies, for example) intercept HTTP 4xx and 5xx and prevent the response from being returned to the viewer. If you substitute 200, the response typically won't be intercepted.\n- If you don't care about distinguishing among different client errors or server errors, you can specify 400 or 500 as the ResponseCode for all 4xx or 5xx errors.\n- You might want to return a 200 status code (OK) and static website so your customers don't know that your website is down."
 );
 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 = z26.union([
+var ErrorResponseSchema = z28.union([
   ErrorResponsePathSchema,
-  z26.object({
+  z28.object({
     path: ErrorResponsePathSchema,
     statusCode: StatusCodeSchema.optional(),
     minTTL: MinTTLSchema.optional()
   })
 ]).optional();
-var SitesSchema = z26.record(
+var SitesSchema = z28.record(
   ResourceIdSchema,
-  z26.object({
+  z28.object({
     domain: ResourceIdSchema.describe("The domain id to link your site with.").optional(),
-    subDomain: z26.string().optional(),
+    subDomain: z28.string().optional(),
     // bind: z
     // 	.object({
     // 		auth: z.array(ResourceIdSchema),
@@ -1234,11 +1255,25 @@ var SitesSchema = z26.record(
     // 		// rest: z.array(ResourceIdSchema),
     // 	})
     // 	.optional(),
-    static: z26.union([LocalDirectorySchema, z26.boolean()]).optional().describe(
+    build: z28.object({
+      command: z28.string().describe(
+        `Specifies the files and directories to generate the cache key for your custom build command.`
+      ),
+      cacheKey: z28.union([
+        LocalFileSchema.transform((v) => [v]),
+        LocalFileSchema.array(),
+        LocalDirectorySchema.transform((v) => [v]),
+        LocalDirectorySchema.array()
+      ]).describe(
+        `Specifies the files and directories to generate the cache key for your custom build command.`
+      )
+    }).optional().describe(`Specifies the build process for sites that need a build step.`),
+    static: z28.union([LocalDirectorySchema, z28.boolean()]).optional().describe(
       "Specifies the path to the static files directory. Additionally you can also pass `true` when you don't have local static files, but still want to make an S3 bucket."
     ),
-    ssr: FunctionSchema.optional().describe("Specifies the ssr file."),
-    origin: z26.enum(["ssr-first", "static-first"]).default("static-first").describe("Specifies the origin fallback ordering."),
+    ssr: FunctionSchema.optional().describe("Specifies the file that will render the site on the server."),
+    // envPrefix: z.string().optional().describe('Specifies a prefix for all '),
+    origin: z28.enum(["ssr-first", "static-first"]).default("static-first").describe("Specifies the origin fallback ordering."),
     // bind: z.object({
     // 	auth:
     // 	h
@@ -1251,11 +1286,11 @@ var SitesSchema = z26.record(
     // 		build: z.string().optional(),
     // 	}),
     // ]),
-    geoRestrictions: z26.array(z26.string().length(2).toUpperCase()).default([]).describe("Specifies a blacklist of countries that should be blocked."),
-    forwardHost: z26.boolean().default(false).describe(
-      "Specify if the host header will be forwarded to the SSR function. Keep in mind that this requires an extra CloudFront Function."
+    geoRestrictions: z28.array(z28.string().length(2).toUpperCase()).default([]).describe("Specifies a blacklist of countries that should be blocked."),
+    forwardHost: z28.boolean().default(false).describe(
+      "Specify if the host header should be forwarded to the SSR function. Keep in mind that this requires an extra CloudFront Function."
     ),
-    errors: z26.object({
+    errors: z28.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."),
@@ -1268,16 +1303,16 @@ var SitesSchema = z26.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: z26.object({
-      override: z26.boolean().default(false),
+    cors: z28.object({
+      override: z28.boolean().default(false),
       maxAge: DurationSchema.default("365 days"),
-      exposeHeaders: z26.string().array().optional(),
-      credentials: z26.boolean().default(false),
-      headers: z26.string().array().default(["*"]),
-      origins: z26.string().array().default(["*"]),
-      methods: z26.enum(["GET", "DELETE", "HEAD", "OPTIONS", "PATCH", "POST", "PUT", "ALL"]).array().default(["ALL"])
+      exposeHeaders: z28.string().array().optional(),
+      credentials: z28.boolean().default(false),
+      headers: z28.string().array().default(["*"]),
+      origins: z28.string().array().default(["*"]),
+      methods: z28.enum(["GET", "DELETE", "HEAD", "OPTIONS", "PATCH", "POST", "PUT", "ALL"]).array().default(["ALL"])
     }).optional().describe("Define the cors headers."),
-    security: z26.object({
+    security: z28.object({
       // contentSecurityPolicy: z.object({
       // 	override: z.boolean().default(false),
       // 	policy: z.string(),
@@ -1319,10 +1354,10 @@ var SitesSchema = z26.record(
       // 	reportUri?: string
       // }
     }).optional().describe("Define the security policy."),
-    cache: z26.object({
-      cookies: z26.string().array().optional().describe("Specifies the cookies that CloudFront includes in the cache key."),
-      headers: z26.string().array().optional().describe("Specifies the headers that CloudFront includes in the cache key."),
-      queries: z26.string().array().optional().describe("Specifies the query values that CloudFront includes in the cache key.")
+    cache: z28.object({
+      cookies: z28.string().array().optional().describe("Specifies the cookies that CloudFront includes in the cache key."),
+      headers: z28.string().array().optional().describe("Specifies the headers that CloudFront includes in the cache key."),
+      queries: z28.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."
     )
@@ -1330,22 +1365,22 @@ var SitesSchema = z26.record(
 ).optional().describe("Define the sites in your stack.");
 
 // src/feature/store/schema.ts
-import { z as z27 } from "zod";
-var StoresSchema = z27.union([
-  z27.array(ResourceIdSchema).transform((list5) => {
+import { z as z29 } from "zod";
+var StoresSchema = z29.union([
+  z29.array(ResourceIdSchema).transform((list5) => {
     const stores = {};
     for (const key of list5) {
       stores[key] = {};
     }
     return stores;
   }),
-  z27.record(
+  z29.record(
     ResourceIdSchema,
-    z27.object({
+    z29.object({
       // cors: CorsSchema,
       // deletionProtection: DeletionProtectionSchema.optional(),
-      versioning: z27.boolean().default(false).describe("Enable versioning of your store."),
-      events: z27.object({
+      versioning: z29.boolean().default(false).describe("Enable versioning of your store."),
+      events: z29.object({
         // create
         "created:*": FunctionSchema.optional().describe(
           "Subscribe to notifications regardless of the API that was used to create an object."
@@ -1378,44 +1413,100 @@ var StoresSchema = z27.union([
 ]).optional().describe("Define the stores in your stack.");
 
 // src/feature/table/schema.ts
-import { z as z28 } from "zod";
-var KeySchema = z28.string().min(1).max(255);
-var TablesSchema = z28.record(
+import { minutes as minutes4, seconds as seconds4 } from "@awsless/duration";
+import { z as z30 } from "zod";
+var KeySchema = z30.string().min(1).max(255);
+var TablesSchema = z30.record(
   ResourceIdSchema,
-  z28.object({
+  z30.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: z28.record(z28.string(), z28.enum(["string", "number", "binary"])).optional().describe(
+    fields: z30.record(z30.string(), z30.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: z28.enum(["standard", "standard-infrequent-access"]).default("standard").describe("The table class of the table."),
-    pointInTimeRecovery: z28.boolean().default(false).describe("Indicates whether point in time recovery is enabled on the table."),
-    timeToLiveAttribute: KeySchema.optional().describe(
-      "The name of the TTL attribute used to store the expiration time for items in the table. To update this property, you must first disable TTL and then enable TTL with the new attribute name."
+    class: z30.enum(["standard", "standard-infrequent-access"]).default("standard").describe("The table class of the table."),
+    pointInTimeRecovery: z30.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.",
+        "To update this property, you must first disable TTL and then enable TTL with the new attribute name."
+      ].join("\n")
     ),
     // deletionProtection: DeletionProtectionSchema.optional(),
-    stream: z28.object({
-      type: z28.enum(["keys-only", "new-image", "old-image", "new-and-old-images"]).describe(
-        "When an item in the table is modified, stream.type determines what information is written to the stream for this table. Valid values are:\n- keys-only - Only the key attributes of the modified item are written to the stream.\n- new-image - The entire item, as it appears after it was modified, is written to the stream.\n- old-image - The entire item, as it appeared before it was modified, is written to the stream.\n- new-and-old-images - Both the new and the old item images of the item are written to the stream."
+    stream: z30.object({
+      type: z30.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:",
+          "- keys-only - Only the key attributes of the modified item are written to the stream.",
+          "- new-image - The entire item, as it appears after it was modified, is written to the stream.",
+          "- old-image - The entire item, as it appeared before it was modified, is written to the stream.",
+          "- new-and-old-images - Both the new and the old item images of the item are written to the stream."
+        ].join("\n")
+      ),
+      batchSize: z30.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).",
+          "You can specify a number from 1 to 10000."
+        ].join("\n")
+      ),
+      batchWindow: DurationSchema.refine(
+        durationMin(seconds4(1)),
+        "Minimum batch window duration is 1 second"
+      ).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."
+        ].join("\n")
+      ),
+      // maxRecordAge: DurationSchema.refine(
+      // 	durationMin(seconds(1)),
+      // 	'Minimum record age duration is 1 second'
+      // )
+      // 	.refine(durationMax(minutes(5)), 'Maximum batch window duration is 5 minutes')
+      // 	.optional()
+      // 	.describe(
+      // 		[
+      // 			'Discard records after the specified number of retries.',
+      // 			'The default value is -1, which sets the maximum number of retries to infinite.',
+      // 			'When maxRetryAttempts is infinite, Lambda retries failed records until the record expires in the event source.',
+      // 			'You can specify a number from -1 to 10000.',
+      // 		].join('\n')
+      // 	),
+      retryAttempts: z30.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.",
+          "When maxRetryAttempts is infinite, Lambda retries failed records until the record expires in the event source.",
+          "You can specify a number from -1 to 10000."
+        ].join("\n")
+      ),
+      concurrencyPerShard: z30.number().min(1).max(10).default(1).describe(
+        [
+          "The number of batches to process concurrently from each shard.",
+          "The default value is 1.",
+          "You can specify a number from 1 to 10."
+        ].join("\n")
       ),
       consumer: FunctionSchema.describe("The consuming lambda function for the stream")
     }).optional().describe(
       "The settings for the DynamoDB table stream, which capture changes to items stored in the table."
     ),
-    indexes: z28.record(
-      z28.string(),
-      z28.object({
+    indexes: z30.record(
+      z30.string(),
+      z30.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: z28.enum(["all", "keys-only"]).default("all").describe(
+        projection: z30.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.",
@@ -1429,11 +1520,11 @@ var TablesSchema = z28.record(
 ).optional().describe("Define the tables in your stack.");
 
 // src/feature/task/schema.ts
-import { z as z29 } from "zod";
-var RetryAttemptsSchema2 = z29.number().int().min(0).max(2).describe(
+import { z as z31 } from "zod";
+var RetryAttemptsSchema2 = 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 TaskSchema = z29.union([
+var TaskSchema = z31.union([
   LocalFileSchema.transform((file) => ({
     consumer: {
       code: {
@@ -1444,33 +1535,33 @@ var TaskSchema = z29.union([
     },
     retryAttempts: void 0
   })),
-  z29.object({
+  z31.object({
     consumer: FunctionSchema,
     retryAttempts: RetryAttemptsSchema2.optional()
   })
 ]);
-var TasksSchema = z29.record(ResourceIdSchema, TaskSchema).optional().describe("Define the tasks in your stack.");
+var TasksSchema = z31.record(ResourceIdSchema, TaskSchema).optional().describe("Define the tasks in your stack.");
 
 // src/feature/test/schema.ts
-import { z as z30 } from "zod";
-var TestsSchema = z30.union([LocalDirectorySchema.transform((v) => [v]), LocalDirectorySchema.array()]).describe("Define the location of your tests for your stack.").optional();
+import { z as z32 } from "zod";
+var TestsSchema = z32.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 z31 } from "zod";
-var TopicNameSchema = z31.string().min(3).max(256).regex(/^[a-z0-9\-]+$/i, "Invalid topic name").transform((value) => kebabCase3(value)).describe("Define event topic name.");
-var TopicsSchema = z31.array(TopicNameSchema).refine((topics) => {
+import { z as z33 } from "zod";
+var TopicNameSchema = z33.string().min(3).max(256).regex(/^[a-z0-9\-]+$/i, "Invalid topic name").transform((value) => kebabCase3(value)).describe("Define event topic name.");
+var TopicsSchema = z33.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 = z31.record(TopicNameSchema, FunctionSchema).optional().describe("Define the event topics to subscribe too in your stack.");
+var SubscribersSchema = z33.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 = z32.object({
-  $schema: z32.string().optional(),
+var StackSchema = z34.object({
+  $schema: z34.string().optional(),
   name: NameSchema,
   depends: DependsSchema,
   commands: CommandsSchema,
@@ -1537,13 +1628,13 @@ var readConfigWithStage = async (file, stage) => {
 };
 
 // src/config/load/validate.ts
-import { z as z33 } from "zod";
+import { z as z35 } from "zod";
 var validateConfig = async (schema, file, data) => {
   try {
     const result = await schema.parseAsync(data);
     return result;
   } catch (error) {
-    if (error instanceof z33.ZodError) {
+    if (error instanceof z35.ZodError) {
       throw new ConfigError(file, error, data);
     }
     throw error;
@@ -2294,90 +2385,6 @@ var getGlobalOnFailure = (ctx) => {
   return ctx.appConfig.defaults.onFailure ? ctx.shared.get("on-failure", "queue-arn") : void 0;
 };
 
-// src/feature/function/build/typescript/bundle.ts
-import commonjs from "@rollup/plugin-commonjs";
-import json from "@rollup/plugin-json";
-import nodeResolve from "@rollup/plugin-node-resolve";
-import { createHash } from "crypto";
-import { dirname as dirname5 } from "path";
-import { rollup } from "rollup";
-import natives from "rollup-plugin-natives";
-import { swc, minify as swcMinify } from "rollup-plugin-swc3";
-var bundleTypeScript = async ({
-  format: format2 = "esm",
-  minify = true,
-  file,
-  nativeDir,
-  external
-}) => {
-  const bundle = await rollup({
-    input: file,
-    external: (importee) => {
-      return importee.startsWith("@aws-sdk") || importee.startsWith("aws-sdk") || external?.includes(importee);
-    },
-    onwarn: (error) => {
-      debugError(error.message);
-    },
-    treeshake: {
-      preset: "smallest",
-      moduleSideEffects: (id) => file === id
-    },
-    plugins: [
-      commonjs({ sourceMap: true }),
-      nodeResolve({ preferBuiltins: true }),
-      // @ts-ignore
-      nativeDir ? natives({
-        copyTo: nativeDir,
-        targetEsm: format2 === "esm",
-        sourcemap: true
-      }) : void 0,
-      swc({
-        // minify,
-        // module: true,
-        jsc: {
-          baseUrl: dirname5(file),
-          minify: { sourceMap: true }
-        },
-        sourceMaps: true
-      }),
-      minify ? swcMinify({
-        module: format2 === "esm",
-        sourceMap: true,
-        compress: true
-      }) : void 0,
-      json()
-    ]
-  });
-  const ext = format2 === "esm" ? "mjs" : "js";
-  const result = await bundle.generate({
-    format: format2,
-    sourcemap: "hidden",
-    exports: "auto",
-    manualChunks: {},
-    entryFileNames: `index.${ext}`,
-    chunkFileNames: `[name].${ext}`
-  });
-  const hash = createHash("sha1");
-  const files = [];
-  for (const item of result.output) {
-    if (item.type !== "chunk") {
-      continue;
-    }
-    const code = Buffer.from(item.code, "utf8");
-    const map = item.map ? Buffer.from(item.map.toString(), "utf8") : void 0;
-    hash.update(code);
-    files.push({
-      name: item.fileName,
-      code,
-      map
-    });
-  }
-  return {
-    hash: hash.digest("hex"),
-    files
-  };
-};
-
 // src/feature/function/build/zip.ts
 import { createReadStream } from "fs";
 import JSZip from "jszip";
@@ -2404,6 +2411,44 @@ import { toDays as toDays3, toSeconds } from "@awsless/duration";
 import { toMebibytes } from "@awsless/size";
 import { pascalCase } from "change-case";
 
+// src/util/cache.ts
+import { createHash } from "node:crypto";
+import { createReadStream as createReadStream2 } from "node:fs";
+import { lstat as lstat2, readdir } from "node:fs/promises";
+import { join as join7 } from "node:path";
+var generateCacheKey = async (directories2) => {
+  const files = await listAllFiles(directories2);
+  const hashes = {};
+  for (const file of files) {
+    hashes[file] = await createHashFromFile(file);
+  }
+  return createHash("md5").update(JSON.stringify(hashes)).digest("hex");
+};
+var createHashFromFile = (file) => {
+  return new Promise((resolve) => {
+    const hash = createHash("md5");
+    const stream = createReadStream2(file);
+    stream.on("data", (data) => hash.update(data));
+    stream.on("end", () => resolve(hash.digest("hex")));
+  });
+};
+var listAllFiles = async (list5) => {
+  const files = [];
+  for (const entry of list5) {
+    const stat4 = await lstat2(entry);
+    if (stat4.isDirectory()) {
+      const dirents = await readdir(entry, {
+        recursive: true,
+        withFileTypes: true
+      });
+      files.push(...dirents.filter((d) => d.isFile()).map((file) => join7(file.path, file.name)));
+    } else if (stat4.isFile()) {
+      files.push(entry);
+    }
+  }
+  return files;
+};
+
 // src/util/id.ts
 import { createHash as createHash2 } from "crypto";
 var shortId = (ns) => {
@@ -2411,18 +2456,18 @@ var shortId = (ns) => {
 };
 
 // src/util/temp.ts
-import { mkdir as mkdir3, readdir, rm as rm2 } from "fs/promises";
-import { join as join7 } from "path";
+import { mkdir as mkdir3, readdir as readdir2, rm as rm2 } from "fs/promises";
+import { join as join8 } from "path";
 var createTempFolder = async (name) => {
-  const path = join7(directories.temp, name);
-  await mkdir3(join7(directories.temp, name), { recursive: true });
+  const path = join8(directories.temp, name);
+  await mkdir3(join8(directories.temp, name), { recursive: true });
   process.on("SIGTERM", async () => {
     await rm2(path, { recursive: true });
   });
   return {
     path,
     async files() {
-      return readdir(path, { recursive: true });
+      return readdir2(path, { recursive: true });
     },
     async delete() {
       await rm2(path, { recursive: true });
@@ -2443,20 +2488,20 @@ var formatFilterPattern = (filters) => {
 
 // src/feature/function/build/bundle/bundle.ts
 import JSZip2 from "jszip";
-import { createReadStream as createReadStream2 } from "node:fs";
-import { readdir as readdir2 } from "node:fs/promises";
-import { join as join8, relative as relative2 } from "node:path";
+import { createReadStream as createReadStream3 } from "node:fs";
+import { readdir as readdir3 } from "node:fs/promises";
+import { join as join9, relative as relative2 } from "node:path";
 var zipBundle = async ({ directory }) => {
   const zip = new JSZip2();
-  const list5 = await readdir2(directory, {
+  const list5 = await readdir3(directory, {
     recursive: true,
     withFileTypes: true
   });
   for (const file of list5) {
     if (file.isFile()) {
-      const path = join8(file.path, file.name);
+      const path = join9(file.path, file.name);
       const rel = relative2(directory, path);
-      zip.file(rel, createReadStream2(path));
+      zip.file(rel, createReadStream3(path));
     }
   }
   return zip.generateAsync({
@@ -2468,42 +2513,85 @@ var zipBundle = async ({ directory }) => {
   });
 };
 
-// src/feature/function/build/bundle/cache.ts
-import { createHash as createHash3 } from "node:crypto";
-import { createReadStream as createReadStream3 } from "node:fs";
-import { lstat as lstat2, readdir as readdir3 } from "node:fs/promises";
-import { join as join9 } from "node:path";
-var bundleCacheKey = async (props) => {
-  const files = await listAllFiles([props.directory]);
-  const hashes = {};
-  for (const file of files) {
-    hashes[file] = await createHashFromFile(file);
-  }
-  return createHash3("md5").update(JSON.stringify(hashes)).digest("hex");
-};
-var createHashFromFile = (file) => {
-  return new Promise((resolve) => {
-    const hash = createHash3("md5");
-    const stream = createReadStream3(file);
-    stream.on("data", (data) => hash.update(data));
-    stream.on("end", () => resolve(hash.digest("hex")));
+// src/feature/function/build/typescript/rolldown.ts
+import json from "@rollup/plugin-json";
+import nodeResolve from "@rollup/plugin-node-resolve";
+import { createHash as createHash3 } from "crypto";
+import { rolldown } from "rolldown";
+import natives from "rollup-plugin-natives";
+import { minify as swcMinify } from "rollup-plugin-swc3";
+var bundleTypeScriptWithRolldown = async ({
+  format: format2 = "esm",
+  minify = true,
+  file,
+  nativeDir,
+  external
+}) => {
+  const bundle = await rolldown({
+    input: file,
+    external: (importee) => {
+      return importee.startsWith("@aws-sdk") || importee.startsWith("aws-sdk") || external?.includes(importee);
+    },
+    onwarn: (error) => {
+      debugError(error.message);
+    },
+    treeshake: {
+      // preset: 'smallest',
+      moduleSideEffects: (id) => file === id
+    },
+    plugins: [
+      // commonjs({ sourceMap: true }),
+      nodeResolve({ preferBuiltins: true }),
+      nativeDir ? natives({
+        copyTo: nativeDir,
+        targetEsm: format2 === "esm",
+        sourcemap: true
+      }) : void 0,
+      // swc({
+      // 	// minify,
+      // 	// module: true,
+      // 	jsc: {
+      // 		baseUrl: dirname(file),
+      // 		minify: { sourceMap: true },
+      // 	},
+      // 	sourceMaps: true,
+      // }),
+      minify ? swcMinify({
+        module: format2 === "esm",
+        sourceMap: true,
+        compress: true
+      }) : void 0,
+      json()
+    ]
   });
-};
-var listAllFiles = async (list5) => {
+  const ext = format2 === "esm" ? "mjs" : "js";
+  const result = await bundle.generate({
+    format: format2,
+    sourcemap: "hidden",
+    exports: "auto",
+    // manualChunks: {},
+    entryFileNames: `index.${ext}`,
+    chunkFileNames: `[name].${ext}`
+  });
+  const hash = createHash3("sha1");
   const files = [];
-  for (const entry of list5) {
-    const stat4 = await lstat2(entry);
-    if (stat4.isDirectory()) {
-      const dirents = await readdir3(entry, {
-        recursive: true,
-        withFileTypes: true
-      });
-      files.push(...dirents.filter((d) => d.isFile()).map((file) => join9(file.path, file.name)));
-    } else if (stat4.isFile()) {
-      files.push(entry);
+  for (const item of result.output) {
+    if (item.type !== "chunk") {
+      continue;
     }
+    const code = Buffer.from(item.code, "utf8");
+    const map = item.map ? Buffer.from(item.map.toString(), "utf8") : void 0;
+    hash.update(code);
+    files.push({
+      name: item.fileName,
+      code,
+      map
+    });
   }
-  return files;
+  return {
+    hash: hash.digest("hex"),
+    files
+  };
 };
 
 // src/feature/function/util.ts
@@ -2542,10 +2630,10 @@ var createLambdaFunction = (group, ctx, ns, id, local) => {
   } else if ("file" in local.code) {
     const fileCode = local.code;
     ctx.registerBuild("function", name, async (build3, { workspace }) => {
-      const version = await generateFileHash(workspace, fileCode.file);
-      return build3(version, async (write) => {
+      const fingerprint = await generateFileHash(workspace, fileCode.file);
+      return build3(fingerprint, async (write) => {
         const temp = await createTempFolder(`function--${name}`);
-        const bundle = await bundleTypeScript({
+        const bundle = await bundleTypeScriptWithRolldown({
           file: fileCode.file,
           external: [
             ...fileCode.external ?? [],
@@ -2584,14 +2672,12 @@ var createLambdaFunction = (group, ctx, ns, id, local) => {
   } else {
     const bundleCode = local.code;
     ctx.registerBuild("function", name, async (build3) => {
-      const version = await bundleCacheKey({
-        directory: bundleCode.bundle
-      });
-      return build3(version, async (write) => {
+      const fingerprint = await generateCacheKey([bundleCode.bundle]);
+      return build3(fingerprint, async (write) => {
         const bundle = await zipBundle({
           directory: bundleCode.bundle
         });
-        await write("HASH", version);
+        await write("HASH", fingerprint);
         await write("bundle.zip", bundle);
         return {
           size: formatByteSize(bundle.byteLength)
@@ -2872,7 +2958,7 @@ var cronFeature = defineFeature({
 });
 
 // src/feature/domain/index.ts
-import { minutes as minutes3, toSeconds as toSeconds2 } from "@awsless/duration";
+import { minutes as minutes5, toSeconds as toSeconds2 } from "@awsless/duration";
 import { $ as $5, Group as Group5 } from "@awsless/formation";
 var domainFeature = defineFeature({
   name: "domain",
@@ -2910,7 +2996,7 @@ var domainFeature = defineFeature({
         zoneId: zone.id,
         name: option(certificate, 0).pipe((r) => r.resourceRecordName),
         type: option(certificate, 0).pipe((r) => r.resourceRecordType),
-        ttl: toSeconds2(minutes3(5)),
+        ttl: toSeconds2(minutes5(5)),
         records: [option(certificate, 0).pipe((r) => r.resourceRecordValue)],
         allowOverwrite: true
       });
@@ -2918,7 +3004,7 @@ var domainFeature = defineFeature({
         zoneId: zone.id,
         name: option(certificate, 1).pipe((r) => r.resourceRecordName),
         type: option(certificate, 1).pipe((r) => r.resourceRecordType),
-        ttl: toSeconds2(minutes3(5)),
+        ttl: toSeconds2(minutes5(5)),
         records: [option(certificate, 1).pipe((r) => r.resourceRecordValue)],
         allowOverwrite: true
       });
@@ -2946,7 +3032,7 @@ var domainFeature = defineFeature({
           zoneId: zone.id,
           name: option(globalCertificate, 0).pipe((r) => r.resourceRecordName),
           type: option(globalCertificate, 0).pipe((r) => r.resourceRecordType),
-          ttl: toSeconds2(minutes3(5)),
+          ttl: toSeconds2(minutes5(5)),
           records: [option(globalCertificate, 0).pipe((r) => r.resourceRecordValue)],
           allowOverwrite: true
         });
@@ -2954,7 +3040,7 @@ var domainFeature = defineFeature({
           zoneId: zone.id,
           name: option(globalCertificate, 1).pipe((r) => r.resourceRecordName),
           type: option(globalCertificate, 1).pipe((r) => r.resourceRecordType),
-          ttl: toSeconds2(minutes3(5)),
+          ttl: toSeconds2(minutes5(5)),
           records: [option(globalCertificate, 1).pipe((r) => r.resourceRecordValue)],
           allowOverwrite: true
         });
@@ -2980,7 +3066,7 @@ var domainFeature = defineFeature({
         zoneId: zone.id,
         name: `_amazonses.${props.domain}`,
         type: "TXT",
-        ttl: toSeconds2(minutes3(5)),
+        ttl: toSeconds2(minutes5(5)),
         records: [identity.verificationToken]
       });
       const dkim = new $5.aws.ses.DomainDkim(group2, "dkim", {
@@ -2991,7 +3077,7 @@ var domainFeature = defineFeature({
           zoneId: zone.id,
           type: "CNAME",
           name: dkim.dkimTokens.pipe((t) => `${t.at(i)}._domainkey`),
-          ttl: toSeconds2(minutes3(5)),
+          ttl: toSeconds2(minutes5(5)),
           records: [dkim.dkimTokens.pipe((t) => `${t.at(i)}.dkim.amazonses.com`)]
         });
       }
@@ -3004,21 +3090,21 @@ var domainFeature = defineFeature({
         zoneId: zone.id,
         name: mailFrom.mailFromDomain,
         type: "MX",
-        ttl: toSeconds2(minutes3(5)),
+        ttl: toSeconds2(minutes5(5)),
         records: [`10 feedback-smtp.${ctx.appConfig.region}.amazonses.com`]
       });
       new $5.aws.route53.Record(group2, `SPF`, {
         zoneId: zone.id,
         name: mailFrom.mailFromDomain,
         type: "TXT",
-        ttl: toSeconds2(minutes3(5)),
+        ttl: toSeconds2(minutes5(5)),
         records: ["v=spf1 include:amazonses.com -all"]
       });
       new $5.aws.route53.Record(group2, `DMARC`, {
         zoneId: zone.id,
         name: `_dmarc.${props.domain}`,
         type: "TXT",
-        ttl: toSeconds2(minutes3(5)),
+        ttl: toSeconds2(minutes5(5)),
         records: ["v=DMARC1; p=none;"]
       });
       const verification = new $5.aws.ses.DomainIdentityVerification(
@@ -3371,7 +3457,7 @@ import { $ as $10, Group as Group10 } from "@awsless/formation";
 import { camelCase as camelCase4, constantCase as constantCase6 } from "change-case";
 import deepmerge3 from "deepmerge";
 import { relative as relative4 } from "path";
-import { seconds as seconds3, toSeconds as toSeconds3 } from "@awsless/duration";
+import { seconds as seconds5, toSeconds as toSeconds3 } from "@awsless/duration";
 import { toBytes } from "@awsless/size";
 var typeGenCode3 = `
 import { SendMessageOptions, SendMessageBatchOptions, BatchItem } from '@awsless/sqs'
@@ -3442,7 +3528,7 @@ var queueFeature = defineFeature({
         name,
         delaySeconds: toSeconds3(props.deliveryDelay),
         visibilityTimeoutSeconds: toSeconds3(props.visibilityTimeout),
-        receiveWaitTimeSeconds: toSeconds3(props.receiveMessageWaitTime ?? seconds3(0)),
+        receiveWaitTimeSeconds: toSeconds3(props.receiveMessageWaitTime ?? seconds5(0)),
         messageRetentionSeconds: toSeconds3(props.retentionPeriod),
         maxMessageSize: toBytes(props.maxMessageSize),
         redrivePolicy: onFailure && onFailure.pipe(
@@ -3598,11 +3684,11 @@ var restFeature = defineFeature({
 import { camelCase as camelCase5, constantCase as constantCase8, kebabCase as kebabCase6 } from "change-case";
 import { $ as $13, Group as Group13 } from "@awsless/formation";
 import { mebibytes as mebibytes3 } from "@awsless/size";
-import { dirname as dirname6, join as join10, relative as relative5 } from "path";
+import { dirname as dirname5, join as join10, relative as relative5 } from "path";
 import { fileURLToPath } from "node:url";
 
 // src/feature/function/prebuild.ts
-import { days as days3, seconds as seconds4, toDays as toDays4, toSeconds as toSeconds4 } from "@awsless/duration";
+import { days as days3, seconds as seconds6, toDays as toDays4, toSeconds as toSeconds4 } from "@awsless/duration";
 import { $ as $12, Future as Future2, resolveInputs as resolveInputs2 } from "@awsless/formation";
 import { mebibytes as mebibytes2, toMebibytes as toMebibytes2 } from "@awsless/size";
 import { pascalCase as pascalCase2 } from "change-case";
@@ -3691,7 +3777,7 @@ var createPrebuildLambdaFunction = (group, ctx, ns, id, props) => {
     // runtime: props.runtime === 'container' ? undefined : props.runtime,
     runtime: props.runtime,
     handler: props.handler,
-    timeout: toSeconds4(props.timeout ?? seconds4(10)),
+    timeout: toSeconds4(props.timeout ?? seconds6(10)),
     memorySize: toMebibytes2(props.memorySize ?? mebibytes2(128)),
     architectures: [props.architecture ?? "arm64"],
     layers: props.layers?.map((id2) => ctx.shared.entry("layer", "arn", id2)),
@@ -3776,8 +3862,8 @@ var createPrebuildLambdaFunction = (group, ctx, ns, id, props) => {
 };
 
 // src/feature/rpc/index.ts
-import { days as days4, minutes as minutes4, seconds as seconds5, toSeconds as toSeconds5 } from "@awsless/duration";
-var __dirname = dirname6(fileURLToPath(import.meta.url));
+import { days as days4, seconds as seconds7, toSeconds as toSeconds5 } from "@awsless/duration";
+var __dirname = dirname5(fileURLToPath(import.meta.url));
 var rpcFeature = defineFeature({
   name: "rpc",
   async onTypeGen(ctx) {
@@ -3812,12 +3898,23 @@ var rpcFeature = defineFeature({
     for (const stack of ctx.stackConfigs) {
       for (const [id, queries] of Object.entries(stack.rpc ?? {})) {
         const list5 = names[id];
-        for (const name of Object.keys(queries ?? {})) {
+        if (!list5) {
+          throw new FileError(stack.file, `The RPC API for "${id}" isn't defined on app level.`);
+        }
+        for (const [name, props] of Object.entries(queries ?? {})) {
           if (list5.has(name)) {
             throw new FileError(stack.file, `Duplicate RPC API function "${id}.${name}"`);
           } else {
             list5.add(name);
           }
+          const timeout = toSeconds5(props.timeout ?? ctx.appConfig.defaults.function.timeout);
+          const maxTimeout = toSeconds5(ctx.appConfig.defaults.rpc[id].timeout) * 0.8;
+          if (timeout > maxTimeout) {
+            throw new FileError(
+              stack.file,
+              `Your RPC function "${id}.${name}" has a ${timeout} seconds timeout, the maximum is ${maxTimeout} seconds.`
+            );
+          }
         }
       }
     }
@@ -3834,12 +3931,13 @@ var rpcFeature = defineFeature({
         bundleFile: join10(__dirname, "/prebuild/rpc/bundle.zip"),
         bundleHash: join10(__dirname, "/prebuild/rpc/HASH"),
         memorySize: mebibytes3(256),
-        timeout: minutes4(3),
+        timeout: props.timeout,
         handler: "index.default",
         runtime: "nodejs22.x",
         warm: 3,
         log: props.log
       });
+      result.setEnvironment("TIMEOUT", toSeconds5(props.timeout).toString());
       const schemaTable = new $13.aws.dynamodb.Table(group, "schema", {
         name: formatGlobalResourceName({
           appName: ctx.app.name,
@@ -3929,7 +4027,7 @@ var rpcFeature = defineFeature({
       const certificateArn = props.domain ? ctx.shared.entry("domain", `global-certificate-arn`, props.domain) : void 0;
       const cache = new $13.aws.cloudfront.CachePolicy(group, "cache", {
         name,
-        minTtl: toSeconds5(seconds5(1)),
+        minTtl: toSeconds5(seconds7(1)),
         maxTtl: toSeconds5(days4(365)),
         defaultTtl: toSeconds5(days4(1))
       });
@@ -4141,10 +4239,10 @@ var searchFeature = defineFeature({
 });
 
 // src/feature/site/index.ts
-import { days as days5, seconds as seconds6, toSeconds as toSeconds6 } from "@awsless/duration";
+import { days as days5, seconds as seconds8, toSeconds as toSeconds6 } from "@awsless/duration";
 import { $ as $15, Group as Group15 } from "@awsless/formation";
 import { glob as glob2 } from "glob";
-import { join as join11 } from "path";
+import { dirname as dirname6, join as join11 } from "path";
 
 // src/feature/site/util.ts
 import { contentType, lookup } from "mime-types";
@@ -4179,6 +4277,7 @@ var getForwardHostFunctionCode = () => {
 
 // src/feature/site/index.ts
 import { camelCase as camelCase6, constantCase as constantCase10 } from "change-case";
+import { exec } from "promisify-child-process";
 var siteFeature = defineFeature({
   name: "site",
   onStack(ctx) {
@@ -4190,6 +4289,20 @@ var siteFeature = defineFeature({
         resourceType: "site",
         resourceName: id
       });
+      if (props.build) {
+        const buildProps = props.build;
+        ctx.registerBuild("site", name, async (build3) => {
+          const fingerprint = await generateCacheKey(buildProps.cacheKey);
+          return build3(fingerprint, async (write) => {
+            const cwd = join11(directories.root, dirname6(ctx.stackConfig.file));
+            await exec(buildProps.command, { cwd });
+            await write("HASH", fingerprint);
+            return {
+              size: "n/a"
+            };
+          });
+        });
+      }
       const origins = [];
       const originGroups = [];
       let bucket;
@@ -4316,7 +4429,7 @@ var siteFeature = defineFeature({
       }
       const cache = new $15.aws.cloudfront.CachePolicy(group, "cache", {
         name,
-        minTtl: toSeconds6(seconds6(1)),
+        minTtl: toSeconds6(seconds8(1)),
         maxTtl: toSeconds6(days5(365)),
         defaultTtl: toSeconds6(days5(1)),
         parametersInCacheKeyAndForwardedToOrigin: {
@@ -4671,6 +4784,7 @@ var storeFeature = defineFeature({
 // src/feature/table/index.ts
 import { $ as $17, Group as Group17 } from "@awsless/formation";
 import { constantCase as constantCase11 } from "change-case";
+import { toSeconds as toSeconds7 } from "@awsless/duration";
 var tableFeature = defineFeature({
   name: "table",
   async onTypeGen(ctx) {
@@ -4757,8 +4871,8 @@ var tableFeature = defineFeature({
           rangeKey: props.sort,
           attribute: attributeDefinitions(),
           ttl: {
-            attributeName: props.timeToLiveAttribute,
-            enabled: !!props.timeToLiveAttribute
+            attributeName: props.ttl,
+            enabled: !!props.ttl
           },
           pointInTimeRecovery: {
             enabled: props.pointInTimeRecovery
@@ -4786,11 +4900,14 @@ var tableFeature = defineFeature({
           {
             functionName: result.lambda.functionName,
             eventSourceArn: table2.streamArn,
-            batchSize: 100,
-            bisectBatchOnFunctionError: true,
-            // maximumRetryAttempts: props.stream.
-            // retryAttempts: props.stream.consumer.retryAttempts ?? -1,
-            parallelizationFactor: 1,
+            // tumblingWindowInSeconds
+            // maximumRecordAgeInSeconds: props.stream.
+            // bisectBatchOnFunctionError: true,
+            batchSize: props.stream.batchSize,
+            maximumBatchingWindowInSeconds: props.stream.batchWindow ? toSeconds7(props.stream.batchWindow) : void 0,
+            maximumRetryAttempts: props.stream.retryAttempts,
+            parallelizationFactor: props.stream.concurrencyPerShard,
+            functionResponseTypes: ["ReportBatchItemFailures"],
             startingPosition: "LATEST",
             destinationConfig: {
               onFailure: onFailure ? { destinationArn: onFailure } : void 0
@@ -5910,7 +6027,6 @@ var buildAssets = async (builders, stackFilters, showResult = false) => {
         });
         results.push({ ...builder, result });
       } catch (error) {
-        console.log(error);
         logError(new Error(`Build failed for: ${builder.type} ${builder.name}`));
         throw error;
       }
@@ -6279,10 +6395,10 @@ var CustomReporter = class {
 };
 
 // src/test/start.ts
-import { swc as swc2 } from "rollup-plugin-swc3";
+import { swc } from "rollup-plugin-swc3";
 import { configDefaults } from "vitest/config";
 import { startVitest } from "vitest/node";
-import commonjs2 from "@rollup/plugin-commonjs";
+import commonjs from "@rollup/plugin-commonjs";
 import nodeResolve2 from "@rollup/plugin-node-resolve";
 import json2 from "@rollup/plugin-json";
 import { dirname as dirname8, join as join13 } from "path";
@@ -6321,10 +6437,10 @@ var startTest = async (props) => {
     {
       plugins: [
         // @ts-ignore
-        commonjs2({ sourceMap: true }),
+        commonjs({ sourceMap: true }),
         // @ts-ignore
         nodeResolve2({ preferBuiltins: true }),
-        swc2({
+        swc({
           jsc: {
             // baseUrl: dirname(input),
             minify: { sourceMap: true }