@awsless/awsless 0.0.365 → 0.0.367

package/dist/bin.js

@@ -596,9 +596,9 @@ var require_Alias = __commonJS({
     var anchors = require_anchors();
     var visit = require_visit();
     var identity = require_identity();
-    var Node22 = require_Node();
+    var Node24 = require_Node();
     var toJS = require_toJS();
-    var Alias = class extends Node22.NodeBase {
+    var Alias = class extends Node24.NodeBase {
       constructor(source) {
         super(identity.ALIAS);
         this.source = source;
@@ -696,10 +696,10 @@ var require_Scalar = __commonJS({
   "../../node_modules/.pnpm/yaml@2.5.0/node_modules/yaml/dist/nodes/Scalar.js"(exports) {
     "use strict";
     var identity = require_identity();
-    var Node22 = require_Node();
+    var Node24 = require_Node();
     var toJS = require_toJS();
     var isScalarValue = (value) => !value || typeof value !== "function" && typeof value !== "object";
-    var Scalar = class extends Node22.NodeBase {
+    var Scalar = class extends Node24.NodeBase {
       constructor(value) {
         super(identity.SCALAR);
         this.value = value;
@@ -803,7 +803,7 @@ var require_Collection = __commonJS({
     "use strict";
     var createNode = require_createNode();
     var identity = require_identity();
-    var Node22 = require_Node();
+    var Node24 = require_Node();
     function collectionFromPath(schema, path, value) {
       let v = value;
       for (let i = path.length - 1; i >= 0; --i) {
@@ -827,7 +827,7 @@ var require_Collection = __commonJS({
       });
     }
     var isEmptyPath = (path) => path == null || typeof path === "object" && !!path[Symbol.iterator]().next().done;
-    var Collection = class extends Node22.NodeBase {
+    var Collection = class extends Node24.NodeBase {
       constructor(type, schema) {
         super(type);
         Object.defineProperty(this, "schema", {
@@ -7560,7 +7560,7 @@ var debug = (...parts) => {
 };
 
 // src/config/app.ts
-import { z as z20 } from "zod";
+import { z as z21 } from "zod";
 
 // src/feature/auth/schema.ts
 import { z as z7 } from "zod";
@@ -7678,7 +7678,7 @@ var LogRetentionSchema = DurationSchema.refine(
   (duration) => {
     return validLogRetentionDays.includes(toDays(duration));
   },
-  `Invalid log retention. Valid days are: ${validLogRetentionDays.map((days6) => `${days6}`).join(", ")}`
+  `Invalid log retention. Valid days are: ${validLogRetentionDays.map((days7) => `${days7}`).join(", ")}`
 ).describe("The log retention duration.");
 var LogSchema = z5.union([
   z5.boolean().transform((enabled) => ({ retention: enabled ? days(7) : days(0) })),
@@ -7703,32 +7703,33 @@ var BuildSchema = z5.object({
   minify: MinifySchema.default(true),
   external: z5.string().array().optional().describe(`A list of external packages that won't be included in the bundle.`)
 }).describe(`Options for the function bundler`);
+var FnSchema = z5.object({
+  file: FileSchema,
+  // node
+  handler: HandlerSchema.optional(),
+  build: BuildSchema.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()
+});
 var FunctionSchema = z5.union([
   LocalFileSchema.transform((file) => ({
     file
   })),
-  z5.object({
-    file: FileSchema,
-    // node
-    handler: HandlerSchema.optional(),
-    build: BuildSchema.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()
-  })
+  FnSchema
 ]);
 var FunctionsSchema = z5.record(ResourceIdSchema, FunctionSchema).optional().describe("Define the functions in your stack.");
 var FunctionDefaultSchema = z5.object({
@@ -8105,27 +8106,39 @@ var RestDefaultSchema = z16.record(
 ).optional().describe("Define your global REST API's.");
 var RestSchema = z16.record(ResourceIdSchema, z16.record(RouteSchema2, FunctionSchema)).optional().describe("Define routes in your stack for your global REST API.");
 
-// src/feature/store/schema.ts
+// src/feature/rpc/schema.ts
 import { z as z17 } from "zod";
-var DeletionProtectionSchema = z17.boolean().describe("Specifies if you want to protect the store from being deleted by awsless.");
-var StoreDefaultSchema = z17.object({
+var RpcDefaultSchema = z17.record(
+  ResourceIdSchema,
+  z17.object({
+    domain: ResourceIdSchema.describe("The domain id to link your RPC API with.").optional(),
+    subDomain: z17.string().optional(),
+    auth: FunctionSchema.optional()
+  })
+).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();
+
+// src/feature/store/schema.ts
+import { z as z18 } from "zod";
+var DeletionProtectionSchema = z18.boolean().describe("Specifies if you want to protect the store from being deleted by awsless.");
+var StoreDefaultSchema = z18.object({
   deletionProtection: DeletionProtectionSchema.optional()
 }).optional();
-var StoresSchema = z17.union([
-  z17.array(ResourceIdSchema).transform((list4) => {
+var StoresSchema = z18.union([
+  z18.array(ResourceIdSchema).transform((list4) => {
     const stores = {};
     for (const key of list4) {
       stores[key] = {};
     }
     return stores;
   }),
-  z17.record(
+  z18.record(
     ResourceIdSchema,
-    z17.object({
+    z18.object({
       // cors: CorsSchema,
       deletionProtection: DeletionProtectionSchema.optional(),
-      versioning: z17.boolean().default(false).describe("Enable versioning of your store."),
-      events: z17.object({
+      versioning: z18.boolean().default(false).describe("Enable versioning of your store."),
+      events: z18.object({
         // create
         "created:*": FunctionSchema.optional().describe(
           "Subscribe to notifications regardless of the API that was used to create an object."
@@ -8158,41 +8171,41 @@ var StoresSchema = z17.union([
 ]).optional().describe("Define the stores in your stack.");
 
 // src/feature/table/schema.ts
-import { z as z18 } from "zod";
-var KeySchema = z18.string().min(1).max(255);
-var DeletionProtectionSchema2 = z18.boolean().describe("Specifies if you want to protect the table from being deleted by awsless.");
-var TableDefaultSchema = z18.object({
+import { z as z19 } from "zod";
+var KeySchema = z19.string().min(1).max(255);
+var DeletionProtectionSchema2 = z19.boolean().describe("Specifies if you want to protect the table from being deleted by awsless.");
+var TableDefaultSchema = z19.object({
   deletionProtection: DeletionProtectionSchema2.optional()
 }).optional();
-var TablesSchema = z18.record(
+var TablesSchema = z19.record(
   ResourceIdSchema,
-  z18.object({
+  z19.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: z18.record(z18.string(), z18.enum(["string", "number", "binary"])).optional().describe(
+    fields: z19.record(z19.string(), z19.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: z18.enum(["standard", "standard-infrequent-access"]).default("standard").describe("The table class of the table."),
-    pointInTimeRecovery: z18.boolean().default(false).describe("Indicates whether point in time recovery is enabled on the table."),
+    class: z19.enum(["standard", "standard-infrequent-access"]).default("standard").describe("The table class of the table."),
+    pointInTimeRecovery: z19.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."
     ),
     deletionProtection: DeletionProtectionSchema2.optional(),
-    stream: z18.object({
-      type: z18.enum(["keys-only", "new-image", "old-image", "new-and-old-images"]).describe(
+    stream: z19.object({
+      type: z19.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."
       ),
       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: z18.record(
-      z18.string(),
-      z18.object({
+    indexes: z19.record(
+      z19.string(),
+      z19.object({
         /** Specifies the name of the partition / hash key that makes up the primary key for the global secondary index. */
         hash: KeySchema,
         /** Specifies the name of the range / sort key that makes up the primary key for the global secondary index. */
@@ -8202,14 +8215,14 @@ var TablesSchema = z18.record(
          * - keys-only - Only the index and primary keys are projected into the index.
          * @default 'all'
          */
-        projection: z18.enum(["all", "keys-only"]).default("all")
+        projection: z19.enum(["all", "keys-only"]).default("all")
       })
     ).optional().describe("Specifies the global secondary indexes to be created on the table.")
   })
 ).optional().describe("Define the tables in your stack.");
 
 // src/config/schema/region.ts
-import { z as z19 } 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 = [
@@ -8238,20 +8251,20 @@ 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 = z19.enum(regions);
+var RegionSchema = z20.enum(regions);
 
 // src/config/app.ts
-var AppSchema = z20.object({
-  $schema: z20.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: z20.string().describe("The AWS profile to deploy to."),
+  profile: z21.string().describe("The AWS profile to deploy to."),
   // stage: z
   // 	.string()
   // 	.regex(/^[a-z]+$/)
   // 	.default('prod')
   // 	.describe('The deployment stage.'),
-  defaults: z20.object({
+  defaults: z21.object({
     auth: AuthDefaultSchema,
     domains: DomainsDefaultSchema,
     function: FunctionDefaultSchema,
@@ -8260,6 +8273,7 @@ var AppSchema = z20.object({
     graphql: GraphQLDefaultSchema,
     http: HttpDefaultSchema,
     rest: RestDefaultSchema,
+    rpc: RpcDefaultSchema,
     pubsub: PubSubDefaultSchema,
     table: TableDefaultSchema,
     store: StoreDefaultSchema
@@ -8268,11 +8282,11 @@ var AppSchema = z20.object({
 });
 
 // src/config/stack.ts
-import { z as z32 } from "zod";
+import { z as z33 } from "zod";
 
 // src/feature/cache/schema.ts
-import { z as z21 } from "zod";
-var TypeSchema2 = z21.enum([
+import { z as z22 } from "zod";
+var TypeSchema2 = z22.enum([
   "t4g.small",
   "t4g.medium",
   "r6g.large",
@@ -8287,29 +8301,29 @@ var TypeSchema2 = z21.enum([
   "r6gd.4xlarge",
   "r6gd.8xlarge"
 ]);
-var PortSchema = z21.number().int().min(1).max(5e4);
-var ShardsSchema = z21.number().int().min(0).max(100);
-var ReplicasPerShardSchema = z21.number().int().min(0).max(5);
-var EngineSchema = z21.enum(["7.0", "6.2"]);
-var CachesSchema = z21.record(
+var PortSchema = z22.number().int().min(1).max(5e4);
+var ShardsSchema = z22.number().int().min(0).max(100);
+var ReplicasPerShardSchema = z22.number().int().min(0).max(5);
+var EngineSchema = z22.enum(["7.0", "6.2"]);
+var CachesSchema = z22.record(
   ResourceIdSchema,
-  z21.object({
+  z22.object({
     type: TypeSchema2.default("t4g.small"),
     port: PortSchema.default(6379),
     shards: ShardsSchema.default(1),
     replicasPerShard: ReplicasPerShardSchema.default(1),
     engine: EngineSchema.default("7.0"),
-    dataTiering: z21.boolean().default(false)
+    dataTiering: z22.boolean().default(false)
   })
 ).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 z22 } from "zod";
-var CommandSchema2 = z22.union([
-  z22.object({
+import { z as z23 } from "zod";
+var CommandSchema2 = z23.union([
+  z23.object({
     file: LocalFileSchema,
-    handler: z22.string().default("default").describe("The name of the handler that needs to run"),
-    description: z22.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(),
   }),
@@ -8319,22 +8333,22 @@ var CommandSchema2 = z22.union([
     description: void 0
   }))
 ]);
-var CommandsSchema = z22.record(ResourceIdSchema, CommandSchema2).optional().describe("Define the custom commands for your stack.");
+var CommandsSchema = z23.record(ResourceIdSchema, CommandSchema2).optional().describe("Define the custom commands for your stack.");
 
 // src/feature/config/schema.ts
-import { z as z23 } from "zod";
-var ConfigNameSchema = z23.string().regex(/[a-z0-9\-]/g, "Invalid config name");
-var ConfigsSchema = z23.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 z25 } from "zod";
+import { z as z26 } from "zod";
 
 // src/feature/cron/schema/schedule.ts
-import { z as z24 } from "zod";
+import { z as z25 } from "zod";
 import { awsCronExpressionValidator } from "aws-cron-expression-validator";
-var RateExpressionSchema = z24.custom(
+var RateExpressionSchema = z25.custom(
   (value) => {
-    return z24.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;
@@ -8350,9 +8364,9 @@ var RateExpressionSchema = z24.custom(
   }
   return `rate(${rate})`;
 });
-var CronExpressionSchema = z24.custom(
+var CronExpressionSchema = z25.custom(
   (value) => {
-    return z24.string().safeParse(value).success;
+    return z25.string().safeParse(value).success;
   },
   { message: "Invalid cron expression" }
 ).superRefine((value, ctx) => {
@@ -8361,12 +8375,12 @@ var CronExpressionSchema = z24.custom(
   } catch (error) {
     if (error instanceof Error) {
       ctx.addIssue({
-        code: z24.ZodIssueCode.custom,
+        code: z25.ZodIssueCode.custom,
         message: `Invalid cron expression: ${error.message}`
       });
     } else {
       ctx.addIssue({
-        code: z24.ZodIssueCode.custom,
+        code: z25.ZodIssueCode.custom,
         message: "Invalid cron expression"
       });
     }
@@ -8377,15 +8391,15 @@ var CronExpressionSchema = z24.custom(
 var ScheduleExpressionSchema = RateExpressionSchema.or(CronExpressionSchema);
 
 // src/feature/cron/schema/index.ts
-var CronsSchema = z25.record(
+var CronsSchema = z26.record(
   ResourceIdSchema,
-  z25.object({
-    enabled: z25.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: z25.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.`);
 
@@ -8396,9 +8410,9 @@ var OnFailureSchema = FunctionSchema.optional().describe(
 
 // src/feature/search/schema.ts
 import { gibibytes as gibibytes2 } from "@awsless/size";
-import { z as z26 } from "zod";
-var VersionSchema = z26.enum(["2.13", "2.11", "2.9", "2.7", "2.5", "2.3", "1.3"]);
-var TypeSchema3 = z26.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 TypeSchema3 = z27.enum([
   "t3.small",
   "t3.medium",
   "m3.medium",
@@ -8473,41 +8487,41 @@ var TypeSchema3 = z26.enum([
   "r6gd.16xlarge"
 ]);
 var StorageSizeSchema = SizeSchema.refine(sizeMin(gibibytes2(10)), "Minimum storage size is 10 GB").refine(sizeMax(gibibytes2(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 = z26.record(
+var SearchsSchema = z27.record(
   ResourceIdSchema,
-  z26.object({
+  z27.object({
     type: TypeSchema3.default("t3.small"),
-    count: z26.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: z26.boolean().default(false)
+    vpc: z27.boolean().default(false)
   })
 ).optional().describe("Define the search instances in your stack. Backed by OpenSearch.");
 
 // src/feature/site/schema.ts
-import { z as z27 } from "zod";
-var ErrorResponsePathSchema = z27.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 = z27.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 = z27.union([
+var ErrorResponseSchema = z28.union([
   ErrorResponsePathSchema,
-  z27.object({
+  z28.object({
     path: ErrorResponsePathSchema,
     statusCode: StatusCodeSchema.optional(),
     minTTL: MinTTLSchema.optional()
   })
 ]).optional();
-var SitesSchema = z27.record(
+var SitesSchema = z28.record(
   ResourceIdSchema,
-  z27.object({
+  z28.object({
     domain: ResourceIdSchema.describe("The domain id to link your site with.").optional(),
-    subDomain: z27.string().optional(),
+    subDomain: z28.string().optional(),
     // bind: z
     // 	.object({
     // 		auth: z.array(ResourceIdSchema),
@@ -8530,7 +8544,7 @@ var SitesSchema = z27.record(
     // 		build: z.string().optional(),
     // 	}),
     // ]),
-    errors: z27.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."),
@@ -8543,16 +8557,16 @@ var SitesSchema = z27.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: z27.object({
-      override: z27.boolean().default(false),
+    cors: z28.object({
+      override: z28.boolean().default(false),
       maxAge: DurationSchema.default("365 days"),
-      exposeHeaders: z27.string().array().optional(),
-      credentials: z27.boolean().default(false),
-      headers: z27.string().array().default(["*"]),
-      origins: z27.string().array().default(["*"]),
-      methods: z27.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: z27.object({
+    security: z28.object({
       // contentSecurityPolicy: z.object({
       // 	override: z.boolean().default(false),
       // 	policy: z.string(),
@@ -8594,10 +8608,10 @@ var SitesSchema = z27.record(
       // 	reportUri?: string
       // }
     }).optional().describe("Define the security policy."),
-    cache: z27.object({
-      cookies: z27.string().array().optional().describe("Specifies the cookies that CloudFront includes in the cache key."),
-      headers: z27.string().array().optional().describe("Specifies the headers that CloudFront includes in the cache key."),
-      queries: z27.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."
     )
@@ -8605,22 +8619,22 @@ var SitesSchema = z27.record(
 ).optional().describe("Define the sites in your stack.");
 
 // src/feature/stream/schema.ts
-import { z as z28 } from "zod";
-var LatencyModeSchema = z28.enum(["low", "normal"]).describe(
+import { z as z29 } from "zod";
+var LatencyModeSchema = z29.enum(["low", "normal"]).describe(
   `Channel latency mode. Valid values:
 - normal: Use "normal" to broadcast and deliver live video up to Full HD.
 - low: Use "low" for near real-time interactions with viewers.`
 );
-var TypeSchema4 = z28.enum(["standard", "basic", "advanced-sd", "advanced-hd"]).describe(`The channel type, which determines the allowable resolution and bitrate.
+var TypeSchema4 = z29.enum(["standard", "basic", "advanced-sd", "advanced-hd"]).describe(`The channel type, which determines the allowable resolution and bitrate.
 If you exceed the allowable resolution or bitrate, the stream probably will disconnect immediately. Valid values:
 - standard: Video is transcoded: multiple qualities are generated from the original input to automatically give viewers the best experience for their devices and network conditions. Transcoding allows higher playback quality across a range of download speeds. Resolution can be up to 1080p and bitrate can be up to 8.5 Mbps. Audio is transcoded only for renditions 360p and below; above that, audio is passed through.
 - basic: Video is transmuxed: Amazon IVS delivers the original input to viewers. The viewer's video-quality choice is limited to the original input. Resolution can be up to 1080p and bitrate can be up to 1.5 Mbps for 480p and up to 3.5 Mbps for resolutions between 480p and 1080p.
 - advanced-sd: Video is transcoded; multiple qualities are generated from the original input, to automatically give viewers the best experience for their devices and network conditions. Input resolution can be up to 1080p and bitrate can be up to 8.5 Mbps; output is capped at SD quality (480p). You can select an optional transcode preset (see below). Audio for all renditions is transcoded, and an audio-only rendition is available.
 - advanced-hd: Video is transcoded; multiple qualities are generated from the original input, to automatically give viewers the best experience for their devices and network conditions. Input resolution can be up to 1080p and bitrate can be up to 8.5 Mbps; output is capped at HD quality (720p). You can select an optional transcode preset (see below). Audio for all renditions is transcoded, and an audio-only rendition is available.
 `);
-var StreamsSchema = z28.record(
+var StreamsSchema = z29.record(
   ResourceIdSchema,
-  z28.object({
+  z29.object({
     type: TypeSchema4.default("standard"),
     // preset: PresetSchema.optional(),
     latencyMode: LatencyModeSchema.default("low")
@@ -8628,42 +8642,42 @@ var StreamsSchema = z28.record(
 ).optional().describe("Define the streams 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 z30 } from "zod";
+var RetryAttemptsSchema2 = z30.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 = z30.union([
   LocalFileSchema.transform((file) => ({
     consumer: { file },
     retryAttempts: void 0
   })),
-  z29.object({
+  z30.object({
     consumer: FunctionSchema,
     retryAttempts: RetryAttemptsSchema2.optional()
   })
 ]);
-var TasksSchema = z29.record(ResourceIdSchema, TaskSchema).optional().describe("Define the tasks in your stack.");
+var TasksSchema = z30.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 z31 } from "zod";
+var TestsSchema = z31.union([LocalDirectorySchema.transform((v) => [v]), LocalDirectorySchema.array()]).describe("Define the location of your tests for your stack.").optional();
 
 // src/feature/topic/schema.ts
 import { paramCase as paramCase2 } 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) => paramCase2(value)).describe("Define event topic name.");
-var TopicsSchema = z31.array(TopicNameSchema).refine((topics) => {
+import { z as z32 } from "zod";
+var TopicNameSchema = z32.string().min(3).max(256).regex(/^[a-z0-9\-]+$/i, "Invalid topic name").transform((value) => paramCase2(value)).describe("Define event topic name.");
+var TopicsSchema = z32.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, z31.union([EmailSchema, FunctionSchema])).optional().describe("Define the event topics to subscribe too in your stack.");
+var SubscribersSchema = z32.record(TopicNameSchema, z32.union([EmailSchema, 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"].includes(name), {
   message: `Stack name can't be a reserved name.`
 }).describe("Stack name.");
-var StackSchema = z32.object({
-  $schema: z32.string().optional(),
+var StackSchema = z33.object({
+  $schema: z33.string().optional(),
   name: NameSchema,
   depends: DependsSchema,
   commands: CommandsSchema,
@@ -8672,6 +8686,7 @@ var StackSchema = z32.object({
   graphql: GraphQLSchema,
   http: HttpSchema,
   rest: RestSchema,
+  rpc: RpcSchema,
   configs: ConfigsSchema,
   crons: CronsSchema,
   caches: CachesSchema,
@@ -8729,13 +8744,13 @@ var readConfigWithStage = async (file, stage) => {
 };
 
 // src/config/load/validate.ts
-import { z as z33 } from "zod";
+import { z as z34 } 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 z34.ZodError) {
       throw new ConfigError(file, error, data);
     }
     throw error;
@@ -10672,7 +10687,7 @@ import nodeResolve from "@rollup/plugin-node-resolve";
 import { createHash as createHash2 } from "crypto";
 import { dirname as dirname6 } from "path";
 import { rollup } from "rollup";
-import { minify as swcMinify, swc } from "rollup-plugin-swc3";
+import { swc, minify as swcMinify } from "rollup-plugin-swc3";
 var bundleTypeScript = async ({ format: format2 = "esm", minify = true, file, external }) => {
   const bundle = await rollup({
     input: file,
@@ -10802,7 +10817,7 @@ var createLambdaFunction = (group, ctx, ns, id, local2) => {
   let code;
   if (props.runtime === "container") {
     ctx.registerBuild("function", name, async (build3) => {
-      const cwd = dirname7(props.file);
+      const cwd = dirname7(local2.file);
       const version = await hashElement(cwd, {
         files: {
           exclude: ["stack.json"]
@@ -10831,10 +10846,10 @@ var createLambdaFunction = (group, ctx, ns, id, local2) => {
     };
   } else {
     ctx.registerBuild("function", name, async (build3, { workspace }) => {
-      const version = await generateFileHash(workspace, props.file);
+      const version = await generateFileHash(workspace, local2.file);
       return build3(version, async (write) => {
         const bundle = await bundleTypeScript({
-          file: props.file,
+          file: local2.file,
           external: props.build.external,
           minify: props.build.minify
         });
@@ -10972,6 +10987,7 @@ var createLambdaFunction = (group, ctx, ns, id, local2) => {
     lambda.dependsOn(vpcPolicy);
   }
   return {
+    name,
     lambda,
     policy,
     code
@@ -12607,9 +12623,284 @@ var restFeature = defineFeature({
   }
 });
 
+// src/feature/rpc/index.ts
+import { camelCase as camelCase6, constantCase as constantCase9, paramCase as paramCase6 } from "change-case";
+import { aws as aws16, Node as Node15, Output as Output3 } from "@awsless/formation";
+import { mebibytes as mebibytes2 } from "@awsless/size";
+import { dirname as dirname10, join as join8, relative as relative5 } from "path";
+import { fileURLToPath } from "node:url";
+
+// src/feature/function/prebuild.ts
+import { Asset as Asset4, aws as aws15 } from "@awsless/formation";
+var createPrebuildLambdaFunction = (group, ctx, ns, id, local2) => {
+  let name;
+  if ("stack" in ctx) {
+    name = formatLocalResourceName({
+      appName: ctx.app.name,
+      stackName: ctx.stack.name,
+      resourceType: ns,
+      resourceName: id
+    });
+  } else {
+    name = formatGlobalResourceName({
+      appName: ctx.appConfig.name,
+      resourceType: ns,
+      resourceName: id
+    });
+  }
+  const props = {
+    architecture: "arm64",
+    runtime: "nodejs20.x",
+    ...local2
+  };
+  const code = new aws15.s3.BucketObject(group, "code", {
+    bucket: ctx.shared.get("function-bucket-name"),
+    key: `/lambda/${name}.zip`,
+    body: Asset4.fromFile(props.bundleFile)
+  });
+  const role = new aws15.iam.Role(group, "role", {
+    name,
+    assumedBy: "lambda.amazonaws.com"
+  });
+  const policy = new aws15.iam.RolePolicy(group, "policy", {
+    role: role.name,
+    name: "lambda-policy",
+    version: "2012-10-17"
+  });
+  const lambda = new aws15.lambda.Function(group, `function`, {
+    ...props,
+    name,
+    role: role.arn,
+    code,
+    runtime: props.runtime === "container" ? void 0 : props.runtime,
+    // Remove conflicting props.
+    vpc: void 0,
+    log: props.log
+  });
+  new aws15.lambda.SourceCodeUpdate(group, "update", {
+    functionName: lambda.name,
+    version: Asset4.fromFile(props.bundleHash),
+    architecture: props.architecture,
+    code
+  });
+  ctx.onEnv((name2, value) => {
+    lambda.addEnvironment(name2, value);
+  });
+  ctx.registerPolicy(policy);
+  lambda.addEnvironment("APP", ctx.appConfig.name);
+  lambda.addEnvironment("APP_ID", ctx.appId);
+  if ("stackConfig" in ctx) {
+    lambda.addEnvironment("STACK", ctx.stackConfig.name);
+  }
+  if (props.log?.retention && props.log?.retention?.value > 0n) {
+    const logGroup = new aws15.cloudWatch.LogGroup(group, "log", {
+      name: lambda.name.apply((name2) => `/aws/lambda/${name2}`),
+      retention: props.log.retention
+    });
+    policy.addStatement(
+      {
+        actions: ["logs:CreateLogStream"],
+        resources: [logGroup.arn]
+      },
+      {
+        actions: ["logs:PutLogEvents"],
+        resources: [logGroup.arn.apply((arn) => `${arn}:*`)]
+      }
+    );
+  }
+  if ("permissions" in local2 && local2.permissions) {
+    policy.addStatement(...local2.permissions);
+  }
+  if (props.warm) {
+    const rule = new aws15.events.Rule(group, "warm", {
+      name: `${name}--warm`,
+      schedule: "rate(5 minutes)",
+      enabled: true,
+      targets: [
+        {
+          id: "warmer",
+          arn: lambda.arn,
+          input: {
+            warmer: true,
+            concurrency: props.warm
+          }
+        }
+      ]
+    });
+    new aws15.lambda.Permission(group, `warm`, {
+      action: "lambda:InvokeFunction",
+      principal: "events.amazonaws.com",
+      functionArn: lambda.arn,
+      sourceArn: rule.arn
+    });
+  }
+  if (props.vpc) {
+    lambda.setVpc({
+      securityGroupIds: [ctx.shared.get(`vpc-security-group-id`)],
+      subnetIds: [
+        ctx.shared.get(`vpc-public-subnet-id-1`),
+        ctx.shared.get(`vpc-public-subnet-id-2`)
+      ]
+    });
+    const vpcPolicy = new aws15.iam.RolePolicy(group, "vpc-policy", {
+      role: role.name,
+      name: "lambda-vpc-policy",
+      version: "2012-10-17",
+      statements: [
+        {
+          actions: [
+            "ec2:CreateNetworkInterface",
+            "ec2:DescribeNetworkInterfaces",
+            "ec2:DeleteNetworkInterface",
+            "ec2:AssignPrivateIpAddresses",
+            "ec2:UnassignPrivateIpAddresses"
+          ],
+          resources: ["*"]
+        }
+      ]
+    });
+    lambda.dependsOn(vpcPolicy);
+  }
+  return {
+    name,
+    lambda,
+    policy,
+    code
+  };
+};
+
+// src/feature/rpc/index.ts
+import { days as days5, seconds as seconds3 } from "@awsless/duration";
+var __dirname = dirname10(fileURLToPath(import.meta.url));
+var rpcFeature = defineFeature({
+  name: "rpc",
+  async onTypeGen(ctx) {
+    const types2 = new TypeFile("@awsless/awsless/client");
+    const schemas = new TypeObject(1);
+    for (const id of Object.keys(ctx.appConfig.defaults.rpc ?? {})) {
+      const schema = new TypeObject(2);
+      for (const stack of ctx.stackConfigs) {
+        for (const [name, props] of Object.entries(stack.rpc?.[id] ?? {})) {
+          const relFile = relative5(directories.types, props.file);
+          const varName = camelCase6(`${stack.name}-${name}`);
+          types2.addImport(varName, relFile);
+          schema.addType(name, `Infer<typeof ${varName}>`);
+        }
+      }
+      schemas.addType(id, schema);
+    }
+    types2.addInterface("RpcSchema", schemas);
+    await ctx.write("rpc.d.ts", types2, true);
+  },
+  onApp(ctx) {
+    for (const [id, props] of Object.entries(ctx.appConfig.defaults.rpc ?? {})) {
+      const group = new Node15(ctx.base, "rpc", id);
+      const name = formatGlobalResourceName({
+        appName: ctx.app.name,
+        resourceType: "rpc",
+        resourceName: id
+      });
+      const { lambda } = createPrebuildLambdaFunction(group, ctx, "rpc", id, {
+        bundleFile: join8(__dirname, "/prebuild/rpc/bundle.zip"),
+        bundleHash: join8(__dirname, "/prebuild/rpc/HASH"),
+        memorySize: mebibytes2(256)
+      });
+      const schema = {};
+      lambda.addEnvironment(
+        "SCHEMA",
+        new Output3([], (resolve2) => {
+          ctx.onReady(() => {
+            resolve2(JSON.stringify(schema));
+          });
+        })
+      );
+      ctx.shared.set(`rpc-${id}-schema`, schema);
+      if (props.auth) {
+        const authGroup = new Node15(group, "auth", "authorizer");
+        const auth2 = createLambdaFunction(authGroup, ctx, "rpc", `${id}-auth`, props.auth);
+        lambda.addEnvironment("AUTH", auth2.lambda.name);
+      }
+      const permission = new aws16.lambda.Permission(group, "permission", {
+        principal: "*",
+        action: "lambda:InvokeFunctionUrl",
+        functionArn: lambda.arn,
+        urlAuthType: "none"
+      });
+      const url = new aws16.lambda.Url(group, "url", {
+        targetArn: lambda.arn,
+        authType: "none"
+      }).dependsOn(permission);
+      const domainName = props.domain ? formatFullDomainName(ctx.appConfig, props.domain, props.subDomain) : void 0;
+      const certificateArn = props.domain ? ctx.shared.get(`global-certificate-${props.domain}-arn`) : void 0;
+      const cache = new aws16.cloudFront.CachePolicy(group, "cache", {
+        name,
+        minTtl: seconds3(1),
+        maxTtl: days5(365),
+        defaultTtl: days5(1)
+      });
+      const originRequest = new aws16.cloudFront.OriginRequestPolicy(group, "request", {
+        name,
+        header: {
+          behavior: "all-except",
+          values: ["host", "authentication"]
+        }
+      });
+      const cdn = new aws16.cloudFront.Distribution(group, "cdn", {
+        name,
+        compress: true,
+        certificateArn,
+        viewerProtocol: "https-only",
+        aliases: domainName ? [domainName] : void 0,
+        origins: [
+          {
+            id: "default",
+            domainName: url.url.apply((url2) => url2.split("/")[2]),
+            protocol: "https-only"
+          }
+        ],
+        targetOriginId: "default",
+        cachePolicyId: cache.id,
+        originRequestPolicyId: originRequest.id
+        // responseHeadersPolicyId: responseHeaders.id,
+      });
+      if (props.domain) {
+        const fullDomainName = formatFullDomainName(ctx.appConfig, props.domain, props.subDomain);
+        new aws16.route53.RecordSet(group, "record", {
+          hostedZoneId: ctx.shared.get(`hosted-zone-${props.domain}-id`),
+          type: "A",
+          name: fullDomainName,
+          alias: cdn.aliasTarget
+        });
+        ctx.bind(`RPC_${constantCase9(id)}_ENDPOINT`, fullDomainName);
+      } else {
+        ctx.bind(`RPC_${constantCase9(id)}_ENDPOINT`, cdn.aliasTarget.dnsName);
+      }
+    }
+  },
+  onStack(ctx) {
+    for (const [id, queries] of Object.entries(ctx.stackConfig.rpc ?? {})) {
+      const defaultProps = ctx.appConfig.defaults.rpc?.[id];
+      if (!defaultProps) {
+        throw new FileError(ctx.stackConfig.file, `RPC definition is not defined on app level for "${id}"`);
+      }
+      const schema = ctx.shared.get(`rpc-${id}-schema`);
+      const group = new Node15(ctx.stack, "rpc", id);
+      for (const [name, props] of Object.entries(queries ?? {})) {
+        const queryGroup = new Node15(group, "query", name);
+        const entryId = paramCase6(`${id}-${shortId(name)}`);
+        const lambda = createLambdaFunction(queryGroup, ctx, `rpc`, entryId, {
+          ...props,
+          description: `${id} ${name}`
+        });
+        schema[name] = lambda.name;
+      }
+    }
+  }
+});
+
 // src/feature/search/index.ts
-import { aws as aws15, Node as Node14 } from "@awsless/formation";
-import { constantCase as constantCase9 } from "change-case";
+import { aws as aws17, Node as Node16 } from "@awsless/formation";
+import { constantCase as constantCase10 } from "change-case";
 var typeGenCode4 = `
 import { AnyStruct, Table } from '@awsless/open-search'
 
@@ -12636,9 +12927,9 @@ var searchFeature = defineFeature({
   },
   onStack(ctx) {
     for (const [id, props] of Object.entries(ctx.stackConfig.searchs ?? {})) {
-      const group = new Node14(ctx.stack, "search", id);
+      const group = new Node16(ctx.stack, "search", id);
       const name = `${id}-${shortId([ctx.app.name, ctx.stack.name, this.name, id].join("--"))}`;
-      const openSearch = new aws15.openSearch.Domain(group, "domain", {
+      const openSearch = new aws17.openSearch.Domain(group, "domain", {
         name,
         version: props.version,
         storageSize: props.storage,
@@ -12665,7 +12956,7 @@ var searchFeature = defineFeature({
           ]
         });
       }
-      ctx.addEnv(`SEARCH_${constantCase9(ctx.stack.name)}_${constantCase9(id)}_DOMAIN`, openSearch.domainEndpoint);
+      ctx.addEnv(`SEARCH_${constantCase10(ctx.stack.name)}_${constantCase10(id)}_DOMAIN`, openSearch.domainEndpoint);
       ctx.onPolicy((policy) => {
         policy.addStatement({
           actions: ["es:ESHttp*"],
@@ -12677,10 +12968,10 @@ var searchFeature = defineFeature({
 });
 
 // src/feature/site/index.ts
-import { days as days5, seconds as seconds3 } from "@awsless/duration";
-import { Asset as Asset4, aws as aws16, Node as Node15 } from "@awsless/formation";
+import { days as days6, seconds as seconds4 } from "@awsless/duration";
+import { Asset as Asset5, aws as aws18, Node as Node17 } from "@awsless/formation";
 import { glob as glob2 } from "glob";
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 
 // src/feature/site/util.ts
 import { lookup, contentType } from "mime-types";
@@ -12703,12 +12994,12 @@ var getContentType = (file) => {
 };
 
 // src/feature/site/index.ts
-import { constantCase as constantCase10 } from "change-case";
+import { constantCase as constantCase11 } from "change-case";
 var siteFeature = defineFeature({
   name: "site",
   onStack(ctx) {
     for (const [id, props] of Object.entries(ctx.stackConfig.sites ?? {})) {
-      const group = new Node15(ctx.stack, "site", id);
+      const group = new Node17(ctx.stack, "site", id);
       const name = formatLocalResourceName({
         appName: ctx.app.name,
         stackName: ctx.stack.name,
@@ -12727,7 +13018,7 @@ var siteFeature = defineFeature({
         ctx.onBind((name2, value) => {
           lambda.addEnvironment(name2, value);
         });
-        new aws16.lambda.Permission(group, "permission", {
+        new aws18.lambda.Permission(group, "permission", {
           principal: "*",
           // principal: 'cloudfront.amazonaws.com',
           action: "lambda:InvokeFunctionUrl",
@@ -12736,7 +13027,7 @@ var siteFeature = defineFeature({
           // urlAuthType: 'aws-iam',
           // sourceArn: distribution.arn,
         });
-        const url = new aws16.lambda.Url(group, "url", {
+        const url = new aws18.lambda.Url(group, "url", {
           targetArn: lambda.arn,
           authType: "none"
           // authType: 'aws-iam',
@@ -12748,7 +13039,7 @@ var siteFeature = defineFeature({
         });
       }
       if (props.static) {
-        bucket = new aws16.s3.Bucket(group, "bucket", {
+        bucket = new aws18.s3.Bucket(group, "bucket", {
           name: formatLocalResourceName({
             appName: ctx.app.name,
             stackName: ctx.stack.name,
@@ -12774,7 +13065,7 @@ var siteFeature = defineFeature({
           policy.addStatement(bucket.permissions);
         });
         bucket.deletionPolicy = "after-deployment";
-        const accessControl = new aws16.cloudFront.OriginAccessControl(group, `access`, {
+        const accessControl = new aws18.cloudFront.OriginAccessControl(group, `access`, {
           name,
           type: "s3",
           behavior: "always",
@@ -12786,10 +13077,10 @@ var siteFeature = defineFeature({
           nodir: true
         });
         for (const file of files) {
-          const object = new aws16.s3.BucketObject(group, file, {
+          const object = new aws18.s3.BucketObject(group, file, {
             bucket: bucket.name,
             key: file,
-            body: Asset4.fromFile(join8(props.static, file)),
+            body: Asset5.fromFile(join9(props.static, file)),
             cacheControl: getCacheControl(file),
             contentType: getContentType(file)
           });
@@ -12809,21 +13100,21 @@ var siteFeature = defineFeature({
           statusCodes: [403, 404]
         });
       }
-      const cache = new aws16.cloudFront.CachePolicy(group, "cache", {
+      const cache = new aws18.cloudFront.CachePolicy(group, "cache", {
         name,
-        minTtl: seconds3(1),
-        maxTtl: days5(365),
-        defaultTtl: days5(1),
+        minTtl: seconds4(1),
+        maxTtl: days6(365),
+        defaultTtl: days6(1),
         ...props.cache
       });
-      const originRequest = new aws16.cloudFront.OriginRequestPolicy(group, "request", {
+      const originRequest = new aws18.cloudFront.OriginRequestPolicy(group, "request", {
         name,
         header: {
           behavior: "all-except",
           values: ["host", "authorization"]
         }
       });
-      const responseHeaders = new aws16.cloudFront.ResponseHeadersPolicy(group, "response", {
+      const responseHeaders = new aws18.cloudFront.ResponseHeadersPolicy(group, "response", {
         name,
         cors: props.cors,
         remove: ["server"]
@@ -12833,7 +13124,7 @@ var siteFeature = defineFeature({
       });
       const domainName = props.domain ? formatFullDomainName(ctx.appConfig, props.domain, props.subDomain) : void 0;
       const certificateArn = props.domain ? ctx.shared.get(`global-certificate-${props.domain}-arn`) : void 0;
-      const distribution = new aws16.cloudFront.Distribution(group, "distribution", {
+      const distribution = new aws18.cloudFront.Distribution(group, "distribution", {
         name,
         compress: true,
         certificateArn,
@@ -12861,13 +13152,13 @@ var siteFeature = defineFeature({
           };
         })
       });
-      new aws16.cloudFront.InvalidateCache(group, "invalidate", {
+      new aws18.cloudFront.InvalidateCache(group, "invalidate", {
         distributionId: distribution.id,
         paths: ["/*"],
         versions
       });
       if (props.static) {
-        new aws16.s3.BucketPolicy(group, `policy`, {
+        new aws18.s3.BucketPolicy(group, `policy`, {
           bucketName: bucket.name,
           statements: [
             {
@@ -12894,7 +13185,7 @@ var siteFeature = defineFeature({
         });
       }
       if (domainName) {
-        new aws16.route53.RecordSet(group, `record`, {
+        new aws18.route53.RecordSet(group, `record`, {
           hostedZoneId: ctx.shared.get(`hosted-zone-${props.domain}-id`),
           type: "A",
           name: domainName,
@@ -12902,7 +13193,7 @@ var siteFeature = defineFeature({
         });
       }
       ctx.bind(
-        `SITE_${constantCase10(ctx.stack.name)}_${constantCase10(id)}_ENDPOINT`,
+        `SITE_${constantCase11(ctx.stack.name)}_${constantCase11(id)}_ENDPOINT`,
         domainName ? domainName : distribution.domainName
       );
     }
@@ -12910,8 +13201,8 @@ var siteFeature = defineFeature({
 });
 
 // src/feature/store/index.ts
-import { aws as aws17, Node as Node16 } from "@awsless/formation";
-import { paramCase as paramCase6 } from "change-case";
+import { aws as aws19, Node as Node18 } from "@awsless/formation";
+import { paramCase as paramCase7 } from "change-case";
 var typeGenCode5 = `
 import { Body, PutObjectProps, BodyStream } from '@awsless/s3'
 
@@ -12947,7 +13238,7 @@ var storeFeature = defineFeature({
   },
   onStack(ctx) {
     for (const [id, props] of Object.entries(ctx.stackConfig.stores ?? {})) {
-      const group = new Node16(ctx.stack, "store", id);
+      const group = new Node18(ctx.stack, "store", id);
       const name = formatLocalResourceName({
         appName: ctx.app.name,
         stackName: ctx.stack.name,
@@ -12967,13 +13258,13 @@ var storeFeature = defineFeature({
         "removed:marker": "s3:ObjectRemoved:DeleteMarkerCreated"
       };
       for (const [event, funcProps] of Object.entries(props.events ?? {})) {
-        const eventGroup = new Node16(group, "event", event);
-        const eventId = paramCase6(`${id}-${shortId(event)}`);
+        const eventGroup = new Node18(group, "event", event);
+        const eventId = paramCase7(`${id}-${shortId(event)}`);
         const { lambda } = createAsyncLambdaFunction(eventGroup, ctx, `store`, eventId, {
           ...funcProps,
           description: `${id} event "${event}"`
         });
-        new aws17.lambda.Permission(eventGroup, "permission", {
+        new aws19.lambda.Permission(eventGroup, "permission", {
           action: "lambda:InvokeFunction",
           principal: "s3.amazonaws.com",
           functionArn: lambda.arn,
@@ -12984,7 +13275,7 @@ var storeFeature = defineFeature({
           function: lambda.arn
         });
       }
-      const bucket = new aws17.s3.Bucket(group, "store", {
+      const bucket = new aws19.s3.Bucket(group, "store", {
         name,
         versioning: props.versioning,
         forceDelete: true,
@@ -13012,27 +13303,27 @@ var storeFeature = defineFeature({
 });
 
 // src/feature/stream/index.ts
-import { aws as aws18, Node as Node17 } from "@awsless/formation";
-import { constantCase as constantCase11 } from "change-case";
+import { aws as aws20, Node as Node19 } from "@awsless/formation";
+import { constantCase as constantCase12 } from "change-case";
 var streamFeature = defineFeature({
   name: "stream",
   onStack(ctx) {
     for (const [id, props] of Object.entries(ctx.stackConfig.streams ?? {})) {
-      const group = new Node17(ctx.stack, "stream", id);
+      const group = new Node19(ctx.stack, "stream", id);
       const name = formatLocalResourceName({
         appName: ctx.app.name,
         stackName: ctx.stack.name,
         resourceType: "stream",
         resourceName: id
       });
-      const channel = new aws18.ivs.Channel(group, "channel", {
+      const channel = new aws20.ivs.Channel(group, "channel", {
         name,
         ...props
       });
-      const streamKey = new aws18.ivs.StreamKey(group, "key", {
+      const streamKey = new aws20.ivs.StreamKey(group, "key", {
         channel: channel.arn
       });
-      const prefix = `STREAM_${constantCase11(ctx.stack.name)}_${constantCase11(id)}`;
+      const prefix = `STREAM_${constantCase12(ctx.stack.name)}_${constantCase12(id)}`;
       ctx.bind(`${prefix}_ENDPOINT`, channel.playbackUrl);
       ctx.addEnv(`${prefix}_INGEST_ENDPOINT`, channel.ingestEndpoint);
       ctx.addEnv(`${prefix}_STREAM_KEY`, streamKey.value);
@@ -13041,7 +13332,7 @@ var streamFeature = defineFeature({
 });
 
 // src/feature/table/index.ts
-import { aws as aws19, Node as Node18 } from "@awsless/formation";
+import { aws as aws21, Node as Node20 } from "@awsless/formation";
 var tableFeature = defineFeature({
   name: "table",
   async onTypeGen(ctx) {
@@ -13065,7 +13356,7 @@ var tableFeature = defineFeature({
   },
   onStack(ctx) {
     for (const [id, props] of Object.entries(ctx.stackConfig.tables ?? {})) {
-      const group = new Node18(ctx.stack, "table", id);
+      const group = new Node20(ctx.stack, "table", id);
       const name = formatLocalResourceName({
         appName: ctx.app.name,
         stackName: ctx.stack.name,
@@ -13073,7 +13364,7 @@ var tableFeature = defineFeature({
         resourceName: id
       });
       const deletionProtection = props.deletionProtection ?? ctx.appConfig.defaults.table?.deletionProtection;
-      const table2 = new aws19.dynamodb.Table(group, "table", {
+      const table2 = new aws21.dynamodb.Table(group, "table", {
         ...props,
         name,
         stream: props.stream?.type,
@@ -13086,7 +13377,7 @@ var tableFeature = defineFeature({
         const { lambda, policy } = createLambdaFunction(group, ctx, "table", id, props.stream.consumer);
         lambda.addEnvironment("LOG_VIEWABLE_ERROR", "1");
         const onFailure = getGlobalOnFailure(ctx);
-        const source = new aws19.lambda.EventSourceMapping(group, id, {
+        const source = new aws21.lambda.EventSourceMapping(group, id, {
           functionArn: lambda.arn,
           sourceArn: table2.streamArn,
           batchSize: 100,
@@ -13113,9 +13404,9 @@ var tableFeature = defineFeature({
 });
 
 // src/feature/task/index.ts
-import { Node as Node19 } from "@awsless/formation";
-import { camelCase as camelCase6 } from "change-case";
-import { relative as relative5 } from "path";
+import { Node as Node21 } from "@awsless/formation";
+import { camelCase as camelCase7 } from "change-case";
+import { relative as relative6 } from "path";
 var typeGenCode6 = `
 import { InvokeOptions } from '@awsless/lambda'
 import type { Mock } from 'vitest'
@@ -13150,14 +13441,14 @@ var taskFeature = defineFeature({
       const mock = new TypeObject(2);
       const mockResponse = new TypeObject(2);
       for (const [name, props] of Object.entries(stack.tasks || {})) {
-        const varName = camelCase6(`${stack.name}-${name}`);
+        const varName = camelCase7(`${stack.name}-${name}`);
         const funcName = formatLocalResourceName({
           appName: ctx.appConfig.name,
           stackName: stack.name,
           resourceType: "task",
           resourceName: name
         });
-        const relFile = relative5(directories.types, props.consumer.file);
+        const relFile = relative6(directories.types, props.consumer.file);
         types2.addImport(varName, relFile);
         resource2.addType(name, `Invoke<'${funcName}', typeof ${varName}>`);
         mock.addType(name, `MockBuilder<typeof ${varName}>`);
@@ -13175,7 +13466,7 @@ var taskFeature = defineFeature({
   },
   onStack(ctx) {
     for (const [id, props] of Object.entries(ctx.stackConfig.tasks ?? {})) {
-      const group = new Node19(ctx.stack, "task", id);
+      const group = new Node21(ctx.stack, "task", id);
       createAsyncLambdaFunction(group, ctx, "task", id, props.consumer);
     }
   }
@@ -13192,7 +13483,7 @@ var testFeature = defineFeature({
 });
 
 // src/feature/topic/index.ts
-import { aws as aws20, Node as Node20 } from "@awsless/formation";
+import { aws as aws22, Node as Node22 } from "@awsless/formation";
 var typeGenCode7 = `
 import type { PublishOptions } from '@awsless/sns'
 import type { Mock } from 'vitest'
@@ -13233,13 +13524,13 @@ var topicFeature = defineFeature({
   onApp(ctx) {
     for (const stack of ctx.stackConfigs) {
       for (const id of stack.topics ?? []) {
-        const group = new Node20(ctx.base, "topic", id);
+        const group = new Node22(ctx.base, "topic", id);
         const name = formatGlobalResourceName({
           appName: ctx.appConfig.name,
           resourceType: "topic",
           resourceName: id
         });
-        const topic = new aws20.sns.Topic(group, "topic", {
+        const topic = new aws22.sns.Topic(group, "topic", {
           name
         });
         ctx.shared.set(`topic-${id}-arn`, topic.arn);
@@ -13256,22 +13547,22 @@ var topicFeature = defineFeature({
       });
     }
     for (const [id, props] of Object.entries(ctx.stackConfig.subscribers ?? {})) {
-      const group = new Node20(ctx.stack, "topic", id);
+      const group = new Node22(ctx.stack, "topic", id);
       const topicArn = ctx.shared.get(`topic-${id}-arn`);
       if (typeof props === "string" && isEmail(props)) {
-        new aws20.sns.Subscription(group, id, {
+        new aws22.sns.Subscription(group, id, {
           topicArn,
           protocol: "email",
           endpoint: props
         });
       } else if (typeof props === "object") {
         const { lambda } = createAsyncLambdaFunction(group, ctx, `topic`, id, props);
-        new aws20.sns.Subscription(group, id, {
+        new aws22.sns.Subscription(group, id, {
           topicArn,
           protocol: "lambda",
           endpoint: lambda.arn
         });
-        new aws20.lambda.Permission(group, id, {
+        new aws22.lambda.Permission(group, id, {
           action: "lambda:InvokeFunction",
           principal: "sns.amazonaws.com",
           functionArn: lambda.arn,
@@ -13283,36 +13574,36 @@ var topicFeature = defineFeature({
 });
 
 // src/feature/vpc/index.ts
-import { aws as aws21, combine as combine2, Node as Node21 } from "@awsless/formation";
+import { aws as aws23, combine as combine2, Node as Node23 } from "@awsless/formation";
 var vpcFeature = defineFeature({
   name: "vpc",
   onApp(ctx) {
-    const group = new Node21(ctx.base, "vpc", "main");
-    const vpc = new aws21.ec2.Vpc(group, "vpc", {
+    const group = new Node23(ctx.base, "vpc", "main");
+    const vpc = new aws23.ec2.Vpc(group, "vpc", {
       name: ctx.app.name,
-      cidrBlock: aws21.ec2.Peer.ipv4("10.0.0.0/16")
+      cidrBlock: aws23.ec2.Peer.ipv4("10.0.0.0/16")
       // cidrBlock: aws.ec2.Peer.ipv6('fd00:10:20::/48'),
       // cidrBlock: aws.ec2.Peer.ipv6('2a05:d018:c69:6600::/56'),
       // enableDnsSupport: true,
       // enableDnsHostnames: true,
     });
-    const privateRouteTable = new aws21.ec2.RouteTable(group, "private", {
+    const privateRouteTable = new aws23.ec2.RouteTable(group, "private", {
       vpcId: vpc.id,
       name: "private"
     });
-    const publicRouteTable = new aws21.ec2.RouteTable(group, "public", {
+    const publicRouteTable = new aws23.ec2.RouteTable(group, "public", {
       vpcId: vpc.id,
       name: "public"
     });
-    const gateway = new aws21.ec2.InternetGateway(group, "gateway");
-    const attachment = new aws21.ec2.VPCGatewayAttachment(group, "attachment", {
+    const gateway = new aws23.ec2.InternetGateway(group, "gateway");
+    const attachment = new aws23.ec2.VPCGatewayAttachment(group, "attachment", {
       vpcId: vpc.id,
       internetGatewayId: gateway.id
     });
-    new aws21.ec2.Route(group, "route", {
+    new aws23.ec2.Route(group, "route", {
       gatewayId: gateway.id,
       routeTableId: publicRouteTable.id,
-      destination: aws21.ec2.Peer.anyIpv4()
+      destination: aws23.ec2.Peer.anyIpv4()
       // destination: aws.ec2.Peer.anyIpv6(),
     });
     ctx.shared.set(
@@ -13328,10 +13619,10 @@ var vpcFeature = defineFeature({
       for (const i in zones) {
         const index = Number(i) + 1;
         const id = `${table2.identifier}-${index}`;
-        const subnet = new aws21.ec2.Subnet(group, id, {
+        const subnet = new aws23.ec2.Subnet(group, id, {
           name: `${ctx.app.name}--${table2.identifier}-${index}`,
           vpcId: vpc.id,
-          cidrBlock: aws21.ec2.Peer.ipv4(`10.0.${block++}.0/24`),
+          cidrBlock: aws23.ec2.Peer.ipv4(`10.0.${block++}.0/24`),
           // ipv6CidrBlock: aws.ec2.Peer.ipv6(`fd00:10:20:${++block}::/64`),
           // ipv6CidrBlock: aws.ec2.Peer.ipv6(`2a05:d018:c69:660${++block}::/64`),
           // ipv6CidrBlock: ipv6CidrBlock.ipv6CidrBlock.apply(ip => ),
@@ -13341,7 +13632,7 @@ var vpcFeature = defineFeature({
           mapPublicIpOnLaunch: table2.identifier === "public",
           availabilityZone: ctx.appConfig.region + zones[i]
         });
-        new aws21.ec2.SubnetRouteTableAssociation(group, id, {
+        new aws23.ec2.SubnetRouteTableAssociation(group, id, {
           routeTableId: table2.id,
           subnetId: subnet.id
         });
@@ -13378,7 +13669,8 @@ var features = [
   cronFeature,
   httpFeature,
   restFeature,
-  siteFeature
+  siteFeature,
+  rpcFeature
 ];
 
 // src/shared.ts
@@ -13853,12 +14145,12 @@ import { confirm as confirm4, isCancel as isCancel5 } from "@clack/prompts";
 import { log as log8 } from "@clack/prompts";
 import chalk6 from "chalk";
 import { mkdir as mkdir4, readFile as readFile7, writeFile as writeFile3 } from "fs/promises";
-import { join as join11 } from "path";
+import { join as join12 } from "path";
 
 // src/build/__fingerprint.ts
 import { createHash as createHash5 } from "crypto";
 import { readdir, readFile as readFile6, stat as stat4 } from "fs/promises";
-import { basename as basename4, dirname as dirname10, extname as extname3, join as join9 } from "path";
+import { basename as basename4, dirname as dirname11, extname as extname3, join as join10 } from "path";
 import parseStaticImports from "parse-static-imports";
 var extensions = ["js", "mjs", "jsx", "ts", "mts", "tsx"];
 var generateFileHashes = async (file, hashes) => {
@@ -13880,7 +14172,7 @@ var fingerprintFromDirectory = async (dir) => {
   const files = await readdir(dir, { recursive: true });
   for (const file of files) {
     if (extensions.includes(extname3(file).substring(1)) && file.at(0) !== "_") {
-      await generateFileHashes(join9(dir, file), hashes);
+      await generateFileHashes(join10(dir, file), hashes);
     }
   }
   const merge2 = Buffer.concat(Array.from(hashes.values()).sort());
@@ -13894,7 +14186,7 @@ var readModuleFile = (file) => {
     return readFiles([
       file,
       ...extensions.map((exp) => `${file}.${exp}`),
-      ...extensions.map((exp) => join9(file, `/index.${exp}`))
+      ...extensions.map((exp) => join10(file, `/index.${exp}`))
     ]);
   }
   return readFile6(file, "utf8");
@@ -13914,7 +14206,7 @@ var readFiles = async (files) => {
 };
 var findDependencies = async (file, code) => {
   const imports = await parseStaticImports(code);
-  return imports.map((entry) => entry.moduleName).filter(Boolean).map((value) => value?.startsWith(".") ? join9(dirname10(file), value) : value);
+  return imports.map((entry) => entry.moduleName).filter(Boolean).map((value) => value?.startsWith(".") ? join10(dirname11(file), value) : value);
 };
 
 // src/test/reporter.ts
@@ -13997,10 +14289,10 @@ import { startVitest } from "vitest/node";
 import commonjs3 from "@rollup/plugin-commonjs";
 import nodeResolve3 from "@rollup/plugin-node-resolve";
 import json3 from "@rollup/plugin-json";
-import { dirname as dirname11, join as join10 } from "path";
-import { fileURLToPath } from "url";
+import { dirname as dirname12, join as join11 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 var startTest = async (props) => {
-  const __dirname = dirname11(fileURLToPath(import.meta.url));
+  const __dirname2 = dirname12(fileURLToPath2(import.meta.url));
   const result = await startVitest(
     "test",
     props.filters,
@@ -14014,7 +14306,7 @@ var startTest = async (props) => {
       exclude: ["**/_*", "**/_*/**", ...configDefaults.exclude],
       globals: true,
       reporters: props.reporter,
-      globalSetup: join10(__dirname, "test-global-setup.js")
+      globalSetup: join11(__dirname2, "test-global-setup.js")
       // env: {
       // 	TZ: 'UTC',
       // },
@@ -14108,7 +14400,7 @@ var logTestErrors = (event) => {
 var runTest = async (stack, dir, filters) => {
   await mkdir4(directories.test, { recursive: true });
   const fingerprint = await fingerprintFromDirectory(dir);
-  const file = join11(directories.test, `${stack}.json`);
+  const file = join12(directories.test, `${stack}.json`);
   const exists = await fileExist(file);
   if (exists && !process.env.NO_CACHE) {
     const raw = await readFile7(file, { encoding: "utf8" });
@@ -14418,7 +14710,7 @@ import { log as log10 } from "@clack/prompts";
 
 // src/type-gen/generate.ts
 import { mkdir as mkdir5, writeFile as writeFile4 } from "fs/promises";
-import { dirname as dirname12, join as join12, relative as relative6 } from "path";
+import { dirname as dirname13, join as join13, relative as relative7 } from "path";
 var generateTypes = async (props) => {
   const files = [];
   await Promise.all(
@@ -14427,12 +14719,12 @@ var generateTypes = async (props) => {
         ...props,
         async write(file, data, include = false) {
           const code = data?.toString("utf8");
-          const path = join12(directories.types, file);
+          const path = join13(directories.types, file);
           if (code) {
             if (include) {
-              files.push(relative6(directories.root, path));
+              files.push(relative7(directories.root, path));
             }
-            await mkdir5(dirname12(path), { recursive: true });
+            await mkdir5(dirname13(path), { recursive: true });
             await writeFile4(path, code);
           }
         }
@@ -14441,7 +14733,7 @@ var generateTypes = async (props) => {
   );
   if (files.length) {
     const code = files.map((file) => `/// <reference path='${file}' />`).join("\n");
-    await writeFile4(join12(directories.root, `awsless.d.ts`), code);
+    await writeFile4(join13(directories.root, `awsless.d.ts`), code);
   }
 };