@awsless/awsless 0.0.434 → 0.0.436

package/dist/bin.js

@@ -88,17 +88,17 @@ var require_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    function visit_(key, node, visitor, path2) {
-      const ctrl = callVisitor(key, node, visitor, path2);
+    function visit_(key, node, visitor, path) {
+      const ctrl = callVisitor(key, node, visitor, path);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path2, ctrl);
-        return visit_(key, ctrl, visitor, path2);
+        replaceNode(key, path, ctrl);
+        return visit_(key, ctrl, visitor, path);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path2 = Object.freeze(path2.concat(node));
+          path = Object.freeze(path.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci = visit_(i, node.items[i], visitor, path2);
+            const ci = visit_(i, node.items[i], visitor, path);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -109,13 +109,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path2 = Object.freeze(path2.concat(node));
-          const ck = visit_("key", node.key, visitor, path2);
+          path = Object.freeze(path.concat(node));
+          const ck = visit_("key", node.key, visitor, path);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = visit_("value", node.value, visitor, path2);
+          const cv = visit_("value", node.value, visitor, path);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -136,17 +136,17 @@ var require_visit = __commonJS({
     visitAsync.BREAK = BREAK;
     visitAsync.SKIP = SKIP;
     visitAsync.REMOVE = REMOVE;
-    async function visitAsync_(key, node, visitor, path2) {
-      const ctrl = await callVisitor(key, node, visitor, path2);
+    async function visitAsync_(key, node, visitor, path) {
+      const ctrl = await callVisitor(key, node, visitor, path);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path2, ctrl);
-        return visitAsync_(key, ctrl, visitor, path2);
+        replaceNode(key, path, ctrl);
+        return visitAsync_(key, ctrl, visitor, path);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path2 = Object.freeze(path2.concat(node));
+          path = Object.freeze(path.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci = await visitAsync_(i, node.items[i], visitor, path2);
+            const ci = await visitAsync_(i, node.items[i], visitor, path);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -157,13 +157,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path2 = Object.freeze(path2.concat(node));
-          const ck = await visitAsync_("key", node.key, visitor, path2);
+          path = Object.freeze(path.concat(node));
+          const ck = await visitAsync_("key", node.key, visitor, path);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = await visitAsync_("value", node.value, visitor, path2);
+          const cv = await visitAsync_("value", node.value, visitor, path);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -190,23 +190,23 @@ var require_visit = __commonJS({
       }
       return visitor;
     }
-    function callVisitor(key, node, visitor, path2) {
+    function callVisitor(key, node, visitor, path) {
       if (typeof visitor === "function")
-        return visitor(key, node, path2);
+        return visitor(key, node, path);
       if (identity.isMap(node))
-        return visitor.Map?.(key, node, path2);
+        return visitor.Map?.(key, node, path);
       if (identity.isSeq(node))
-        return visitor.Seq?.(key, node, path2);
+        return visitor.Seq?.(key, node, path);
       if (identity.isPair(node))
-        return visitor.Pair?.(key, node, path2);
+        return visitor.Pair?.(key, node, path);
       if (identity.isScalar(node))
-        return visitor.Scalar?.(key, node, path2);
+        return visitor.Scalar?.(key, node, path);
       if (identity.isAlias(node))
-        return visitor.Alias?.(key, node, path2);
+        return visitor.Alias?.(key, node, path);
       return void 0;
     }
-    function replaceNode(key, path2, node) {
-      const parent = path2[path2.length - 1];
+    function replaceNode(key, path, node) {
+      const parent = path[path.length - 1];
       if (identity.isCollection(parent)) {
         parent.items[key] = node;
       } else if (identity.isPair(parent)) {
@@ -804,10 +804,10 @@ var require_Collection = __commonJS({
     var createNode = require_createNode();
     var identity = require_identity();
     var Node27 = require_Node();
-    function collectionFromPath(schema, path2, value) {
+    function collectionFromPath(schema, path, value) {
       let v = value;
-      for (let i = path2.length - 1; i >= 0; --i) {
-        const k = path2[i];
+      for (let i = path.length - 1; i >= 0; --i) {
+        const k = path[i];
         if (typeof k === "number" && Number.isInteger(k) && k >= 0) {
           const a = [];
           a[k] = v;
@@ -826,7 +826,7 @@ var require_Collection = __commonJS({
         sourceObjects: /* @__PURE__ */ new Map()
       });
     }
-    var isEmptyPath = (path2) => path2 == null || typeof path2 === "object" && !!path2[Symbol.iterator]().next().done;
+    var isEmptyPath = (path) => path == null || typeof path === "object" && !!path[Symbol.iterator]().next().done;
     var Collection = class extends Node27.NodeBase {
       constructor(type, schema) {
         super(type);
@@ -856,11 +856,11 @@ var require_Collection = __commonJS({
        * be a Pair instance or a `{ key, value }` object, which may not have a key
        * that already exists in the map.
        */
-      addIn(path2, value) {
-        if (isEmptyPath(path2))
+      addIn(path, value) {
+        if (isEmptyPath(path))
           this.add(value);
         else {
-          const [key, ...rest] = path2;
+          const [key, ...rest] = path;
           const node = this.get(key, true);
           if (identity.isCollection(node))
             node.addIn(rest, value);
@@ -874,8 +874,8 @@ var require_Collection = __commonJS({
        * Removes a value from the collection.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path2) {
-        const [key, ...rest] = path2;
+      deleteIn(path) {
+        const [key, ...rest] = path;
         if (rest.length === 0)
           return this.delete(key);
         const node = this.get(key, true);
@@ -889,8 +889,8 @@ var require_Collection = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path2, keepScalar) {
-        const [key, ...rest] = path2;
+      getIn(path, keepScalar) {
+        const [key, ...rest] = path;
         const node = this.get(key, true);
         if (rest.length === 0)
           return !keepScalar && identity.isScalar(node) ? node.value : node;
@@ -908,8 +908,8 @@ var require_Collection = __commonJS({
       /**
        * Checks if the collection includes a value with the key `key`.
        */
-      hasIn(path2) {
-        const [key, ...rest] = path2;
+      hasIn(path) {
+        const [key, ...rest] = path;
         if (rest.length === 0)
           return this.has(key);
         const node = this.get(key, true);
@@ -919,8 +919,8 @@ var require_Collection = __commonJS({
        * Sets a value in this collection. For `!!set`, `value` needs to be a
        * boolean to add/remove the item from the set.
        */
-      setIn(path2, value) {
-        const [key, ...rest] = path2;
+      setIn(path, value) {
+        const [key, ...rest] = path;
         if (rest.length === 0) {
           this.set(key, value);
         } else {
@@ -3369,9 +3369,9 @@ var require_Document = __commonJS({
           this.contents.add(value);
       }
       /** Adds a value to the document. */
-      addIn(path2, value) {
+      addIn(path, value) {
         if (assertCollection(this.contents))
-          this.contents.addIn(path2, value);
+          this.contents.addIn(path, value);
       }
       /**
        * Create a new `Alias` node, ensuring that the target `node` has the required anchor.
@@ -3446,14 +3446,14 @@ var require_Document = __commonJS({
        * Removes a value from the document.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path2) {
-        if (Collection.isEmptyPath(path2)) {
+      deleteIn(path) {
+        if (Collection.isEmptyPath(path)) {
           if (this.contents == null)
             return false;
           this.contents = null;
           return true;
         }
-        return assertCollection(this.contents) ? this.contents.deleteIn(path2) : false;
+        return assertCollection(this.contents) ? this.contents.deleteIn(path) : false;
       }
       /**
        * Returns item at `key`, or `undefined` if not found. By default unwraps
@@ -3468,10 +3468,10 @@ var require_Document = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path2, keepScalar) {
-        if (Collection.isEmptyPath(path2))
+      getIn(path, keepScalar) {
+        if (Collection.isEmptyPath(path))
           return !keepScalar && identity.isScalar(this.contents) ? this.contents.value : this.contents;
-        return identity.isCollection(this.contents) ? this.contents.getIn(path2, keepScalar) : void 0;
+        return identity.isCollection(this.contents) ? this.contents.getIn(path, keepScalar) : void 0;
       }
       /**
        * Checks if the document includes a value with the key `key`.
@@ -3482,10 +3482,10 @@ var require_Document = __commonJS({
       /**
        * Checks if the document includes a value at `path`.
        */
-      hasIn(path2) {
-        if (Collection.isEmptyPath(path2))
+      hasIn(path) {
+        if (Collection.isEmptyPath(path))
           return this.contents !== void 0;
-        return identity.isCollection(this.contents) ? this.contents.hasIn(path2) : false;
+        return identity.isCollection(this.contents) ? this.contents.hasIn(path) : false;
       }
       /**
        * Sets a value in this document. For `!!set`, `value` needs to be a
@@ -3502,13 +3502,13 @@ var require_Document = __commonJS({
        * Sets a value in this document. For `!!set`, `value` needs to be a
        * boolean to add/remove the item from the set.
        */
-      setIn(path2, value) {
-        if (Collection.isEmptyPath(path2)) {
+      setIn(path, value) {
+        if (Collection.isEmptyPath(path)) {
           this.contents = value;
         } else if (this.contents == null) {
-          this.contents = Collection.collectionFromPath(this.schema, Array.from(path2), value);
+          this.contents = Collection.collectionFromPath(this.schema, Array.from(path), value);
         } else if (assertCollection(this.contents)) {
-          this.contents.setIn(path2, value);
+          this.contents.setIn(path, value);
         }
       }
       /**
@@ -5437,9 +5437,9 @@ var require_cst_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    visit.itemAtPath = (cst, path2) => {
+    visit.itemAtPath = (cst, path) => {
       let item = cst;
-      for (const [field, index] of path2) {
+      for (const [field, index] of path) {
         const tok = item?.[field];
         if (tok && "items" in tok) {
           item = tok.items[index];
@@ -5448,23 +5448,23 @@ var require_cst_visit = __commonJS({
       }
       return item;
     };
-    visit.parentCollection = (cst, path2) => {
-      const parent = visit.itemAtPath(cst, path2.slice(0, -1));
-      const field = path2[path2.length - 1][0];
+    visit.parentCollection = (cst, path) => {
+      const parent = visit.itemAtPath(cst, path.slice(0, -1));
+      const field = path[path.length - 1][0];
       const coll = parent?.[field];
       if (coll && "items" in coll)
         return coll;
       throw new Error("Parent collection not found");
     };
-    function _visit(path2, item, visitor) {
-      let ctrl = visitor(item, path2);
+    function _visit(path, item, visitor) {
+      let ctrl = visitor(item, path);
       if (typeof ctrl === "symbol")
         return ctrl;
       for (const field of ["key", "value"]) {
         const token = item[field];
         if (token && "items" in token) {
           for (let i = 0; i < token.items.length; ++i) {
-            const ci = _visit(Object.freeze(path2.concat([[field, i]])), token.items[i], visitor);
+            const ci = _visit(Object.freeze(path.concat([[field, i]])), token.items[i], visitor);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -5475,10 +5475,10 @@ var require_cst_visit = __commonJS({
             }
           }
           if (typeof ctrl === "function" && field === "key")
-            ctrl = ctrl(item, path2);
+            ctrl = ctrl(item, path);
         }
       }
-      return typeof ctrl === "function" ? ctrl(item, path2) : ctrl;
+      return typeof ctrl === "function" ? ctrl(item, path) : ctrl;
     }
     exports.visit = visit;
   }
@@ -7262,21 +7262,21 @@ var directories = {
     return join(this.output, "test");
   }
 };
-var setRoot = (path2 = root) => {
-  directories.root = path2;
+var setRoot = (path = root) => {
+  directories.root = path;
 };
-var findRootDir = async (path2, configFiles, level = 5) => {
+var findRootDir = async (path, configFiles, level = 5) => {
   if (!level) {
     throw new TypeError("No awsless project found");
   }
   for (const configFile of configFiles) {
-    const file = join(path2, configFile);
+    const file = join(path, configFile);
     const exists = await fileExist(file);
     if (exists) {
-      return [file, path2];
+      return [file, path];
     }
   }
-  return findRootDir(normalize(join(path2, "..")), configFiles, level - 1);
+  return findRootDir(normalize(join(path, "..")), configFiles, level - 1);
 };
 var fileExist = async (file) => {
   try {
@@ -7588,7 +7588,7 @@ var AlertsDefaultSchema = z2.record(
 ).optional().describe("Define the alerts in your app. Alerts are a way to send messages to one or more email addresses.");
 
 // src/feature/auth/schema.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 
 // src/config/schema/resource-id.ts
 import { paramCase as paramCase2 } from "change-case";
@@ -7598,7 +7598,7 @@ var ResourceIdSchema = z3.string().min(3).max(24).regex(/^[a-z0-9\-]+$/i, "Inval
 // src/feature/function/schema.ts
 import { days, minutes as minutes2, seconds, toDays } from "@awsless/duration";
 import { gibibytes, mebibytes } from "@awsless/size";
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 
 // src/config/schema/duration.ts
 import { z as z4 } from "zod";
@@ -7615,33 +7615,47 @@ var durationMax = (max) => {
   };
 };
 
+// src/config/schema/local-directory.ts
+import { stat as stat2 } from "fs/promises";
+import { z as z6 } from "zod";
+
 // src/config/schema/local-file.ts
 import { stat } from "fs/promises";
 import { join as join3 } from "path";
 import { z as z5 } from "zod";
 var basePath;
-var setLocalBasePath = (path2) => {
-  basePath = path2;
+var setLocalBasePath = (path) => {
+  basePath = path;
 };
-var resolvePath = (path2) => {
-  if (path2.startsWith(".") && basePath) {
-    return join3(basePath, path2);
+var resolvePath = (path) => {
+  if (path.startsWith(".") && basePath) {
+    return join3(basePath, path);
   }
-  return join3(directories.root, path2);
+  return join3(directories.root, path);
 };
-var LocalFileSchema = z5.string().transform((path2) => resolvePath(path2)).refine(async (path2) => {
+var LocalFileSchema = z5.string().transform((path) => resolvePath(path)).refine(async (path) => {
   try {
-    const s = await stat(path2);
+    const s = await stat(path);
     return s.isFile();
   } catch (error) {
     return false;
   }
 }, `File doesn't exist`);
 
+// src/config/schema/local-directory.ts
+var LocalDirectorySchema = z6.string().transform((path) => resolvePath(path)).refine(async (path) => {
+  try {
+    const s = await stat2(path);
+    return s.isDirectory();
+  } catch (error) {
+    return false;
+  }
+}, `Directory doesn't exist`);
+
 // src/config/schema/size.ts
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 import { parse as parse2 } from "@awsless/size";
-var SizeSchema = z6.string().regex(/^[0-9]+ (B|KB|MB|GB|TB|PB)$/, "Invalid size").transform((v) => parse2(v));
+var SizeSchema = z7.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;
@@ -7664,33 +7678,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 = z7.number().int().min(0).describe("The number of simultaneous executions to reserve for the function. You can specify a number from 0.");
-var EnvironmentSchema = z7.record(z7.string(), z7.string()).optional().describe("Environment variable key-value pairs.");
-var ArchitectureSchema = z7.enum(["x86_64", "arm64"]).describe("The instruction set architecture that the function supports.");
-var RetryAttemptsSchema = z7.number().int().min(0).max(2).describe(
+var ReservedConcurrentExecutionsSchema = z8.number().int().min(0).describe("The number of simultaneous executions to reserve for the function. You can specify a number from 0.");
+var EnvironmentSchema = z8.record(z8.string(), z8.string()).optional().describe("Environment variable key-value pairs.");
+var ArchitectureSchema = z8.enum(["x86_64", "arm64"]).describe("The instruction set architecture that the function supports.");
+var RetryAttemptsSchema = z8.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 = z7.enum(["nodejs18.x", "nodejs20.x", "nodejs22.x"]).describe("The identifier of the function's runtime.");
-var ContainerRuntimeSchema = z7.literal("container").describe("The identifier of the function's runtime.");
-var RuntimeSchema = NodeRuntimeSchema.or(ContainerRuntimeSchema);
-var ActionSchema = z7.string();
-var ActionsSchema = z7.union([ActionSchema.transform((v) => [v]), ActionSchema.array()]);
-var ArnSchema = z7.string().startsWith("arn:").transform((v) => v);
-var WildcardSchema = z7.literal("*");
-var ResourceSchema = z7.union([ArnSchema, WildcardSchema]);
-var ResourcesSchema = z7.union([ResourceSchema.transform((v) => [v]), ResourceSchema.array()]);
-var PermissionSchema = z7.object({
-  effect: z7.enum(["allow", "deny"]).default("allow"),
+var NodeRuntimeSchema = z8.enum(["nodejs18.x", "nodejs20.x", "nodejs22.x"]);
+var ContainerRuntimeSchema = z8.literal("container");
+var RuntimeSchema = NodeRuntimeSchema.or(ContainerRuntimeSchema).describe("The identifier of the function's runtime.");
+var ActionSchema = z8.string();
+var ActionsSchema = z8.union([ActionSchema.transform((v) => [v]), ActionSchema.array()]);
+var ArnSchema = z8.string().startsWith("arn:").transform((v) => v);
+var WildcardSchema = z8.literal("*");
+var ResourceSchema = z8.union([ArnSchema, WildcardSchema]);
+var ResourcesSchema = z8.union([ResourceSchema.transform((v) => [v]), ResourceSchema.array()]);
+var PermissionSchema = z8.object({
+  effect: z8.enum(["allow", "deny"]).default("allow"),
   actions: ActionsSchema,
   resources: ResourcesSchema
 });
-var PermissionsSchema = z7.union([PermissionSchema.transform((v) => [v]), PermissionSchema.array()]).describe("Add IAM permissions to your function.");
-var WarmSchema = z7.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 = z7.boolean().describe("Put the function inside your global VPC.");
-var MinifySchema = z7.boolean().describe("Minify the function code.");
-var HandlerSchema = z7.string().describe("The name of the exported method within your code that Lambda calls to run your function.");
-var FileSchema = LocalFileSchema.describe("The file path of the function code.");
-var DescriptionSchema = z7.string().describe("A description of the function.");
+var PermissionsSchema = z8.union([PermissionSchema.transform((v) => [v]), PermissionSchema.array()]).describe("Add IAM permissions to your function.");
+var WarmSchema = z8.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 = z8.boolean().describe("Put the function inside your global VPC.");
+var MinifySchema = z8.boolean().describe("Minify the function code.");
+var HandlerSchema = z8.string().describe("The name of the exported method within your code that Lambda calls to run your function.");
+var DescriptionSchema = z8.string().describe("A description of the function.");
 var validLogRetentionDays = [
   ...[1n, 3n, 5n, 7n, 14n, 30n, 60n, 90n, 120n, 150n],
   ...[180n, 365n, 400n, 545n, 731n, 1096n, 1827n, 2192n],
@@ -7705,47 +7718,59 @@ var LogRetentionSchema = DurationSchema.refine(
   },
   `Invalid log retention. Valid days are: ${validLogRetentionDays.map((days7) => `${days7}`).join(", ")}`
 ).describe("The log retention duration.");
-var LogSubscriptionSchema = z7.union([
+var LogSubscriptionSchema = z8.union([
   LocalFileSchema.transform((file) => ({
     file
   })),
-  z7.object({
+  z8.object({
     subscriber: LocalFileSchema,
-    filter: z7.string().optional()
+    filter: z8.string().optional()
   })
 ]).describe(
   "Log Subscription allow you to subscribe to a real-time stream of log events and have them delivered to a specific destination"
 );
-var LogSchema = z7.union([
-  z7.boolean().transform((enabled) => ({ retention: enabled ? days(7) : days(0) })),
+var LogSchema = z8.union([
+  z8.boolean().transform((enabled) => ({ retention: enabled ? days(7) : days(0) })),
   LogRetentionSchema.transform((retention) => ({ retention })),
-  z7.object({
+  z8.object({
     subscription: LogSubscriptionSchema.optional(),
     retention: LogRetentionSchema.optional(),
-    format: z7.enum(["text", "json"]).describe(
+    format: z8.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: z7.enum(["debug", "info", "warn"]).describe(
+    system: z8.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: z7.enum(["trace", "debug", "info", "warn", "error", "fatal"]).describe(
+    level: z8.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 = z7.string().array().describe(
+var LayersSchema = z8.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 BuildSchema = z7.object({
-  minify: MinifySchema.default(true),
-  external: z7.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 = z7.object({
-  file: FileSchema,
+var FileCodeSchema = z8.object({
+  file: LocalFileSchema.describe("The file path of the function code."),
+  minify: MinifySchema.optional().default(true),
+  external: z8.string().array().optional().describe(`A list of external packages that won't be included in the bundle.`)
+});
+var BundleCodeSchema = z8.object({
+  bundle: LocalDirectorySchema.describe("The directory that needs to be bundled.")
+});
+var CodeSchema = z8.union([
+  LocalFileSchema.transform((file) => ({
+    file
+  })),
+  FileCodeSchema,
+  BundleCodeSchema
+]).describe("Specify the code of your function.");
+var FnSchema = z8.object({
+  code: CodeSchema,
   // node
   handler: HandlerSchema.optional(),
-  build: BuildSchema.optional(),
+  // build: BuildSchema.optional(),
+  // bundle: BundleSchema.optional(),
   // container
   // ...
   runtime: RuntimeSchema.optional(),
@@ -7763,20 +7788,23 @@ var FnSchema = z7.object({
   environment: EnvironmentSchema.optional(),
   permissions: PermissionsSchema.optional()
 });
-var FunctionSchema = z7.union([
+var FunctionSchema = z8.union([
   LocalFileSchema.transform((file) => ({
-    file
+    code: {
+      file
+    }
   })),
   FnSchema
 ]);
-var FunctionsSchema = z7.record(ResourceIdSchema, FunctionSchema).optional().describe("Define the functions in your stack.");
-var FunctionDefaultSchema = z7.object({
+var FunctionsSchema = z8.record(ResourceIdSchema, FunctionSchema).optional().describe("Define the functions in your stack.");
+var FunctionDefaultSchema = z8.object({
   runtime: RuntimeSchema.default("nodejs20.x"),
   // node
   handler: HandlerSchema.default("index.default"),
-  build: BuildSchema.default({
-    minify: true
-  }),
+  // build: BuildSchema.default({
+  // 	type: 'simple',
+  // 	minify: true,
+  // }),
   // container
   warm: WarmSchema.default(0),
   vpc: VPCSchema.default(false),
@@ -7798,7 +7826,7 @@ var FunctionDefaultSchema = z7.object({
 }).default({});
 
 // src/feature/auth/schema.ts
-var TriggersSchema = z8.object({
+var TriggersSchema = z9.object({
   beforeToken: FunctionSchema.optional().describe("A pre jwt token generation AWS Lambda trigger."),
   beforeLogin: FunctionSchema.optional().describe("A pre user login AWS Lambda trigger."),
   afterLogin: FunctionSchema.optional().describe("A post user login AWS Lambda trigger."),
@@ -7811,42 +7839,42 @@ var TriggersSchema = z8.object({
   createChallenge: FunctionSchema.optional().describe("Creates an authentication challenge."),
   verifyChallenge: FunctionSchema.optional().describe("Verifies the authentication challenge response.")
 }).describe("Specifies the configuration for AWS Lambda triggers.");
-var AuthSchema = z8.record(
+var AuthSchema = z9.record(
   ResourceIdSchema,
-  z8.object({
-    access: z8.boolean().default(false).describe("Give access to every function in this stack to your cognito instance."),
+  z9.object({
+    access: z9.boolean().default(false).describe("Give access to every function in this stack to your cognito instance."),
     triggers: TriggersSchema.optional()
   })
 ).optional().describe("Define the auth triggers in your stack.");
-var AuthDefaultSchema = z8.record(
+var AuthDefaultSchema = z9.record(
   ResourceIdSchema,
-  z8.object({
-    allowUserRegistration: z8.boolean().default(true).describe("Specifies whether users can create an user account or if only the administrator can."),
-    messaging: z8.object({
+  z9.object({
+    allowUserRegistration: z9.boolean().default(true).describe("Specifies whether users can create an user account or if only the administrator can."),
+    messaging: z9.object({
       fromEmail: EmailSchema.describe("Specifies the sender's email address."),
-      fromName: z8.string().optional().describe("Specifies the sender's name."),
+      fromName: z9.string().optional().describe("Specifies the sender's name."),
       replyTo: EmailSchema.optional().describe(
         "The destination to which the receiver of the email should reply."
       )
     }).optional().describe("The email configuration for sending messages."),
     // secret: z.boolean().default(false).describe('Specifies whether you want to generate a client secret.'),
-    username: z8.object({
-      emailAlias: z8.boolean().default(true).describe("Allow the user email to be used as username."),
-      caseSensitive: z8.boolean().default(false).describe(
+    username: z9.object({
+      emailAlias: z9.boolean().default(true).describe("Allow the user email to be used as username."),
+      caseSensitive: z9.boolean().default(false).describe(
         "Specifies whether username case sensitivity will be enabled. When usernames and email addresses are case insensitive, users can sign in as the same user when they enter a different capitalization of their user name."
       )
     }).default({}).describe("The username policy."),
-    password: z8.object({
-      minLength: z8.number().int().min(6).max(99).default(12).describe("Required users to have at least the minimum password length."),
-      uppercase: z8.boolean().default(true).describe("Required users to use at least one uppercase letter in their password."),
-      lowercase: z8.boolean().default(true).describe("Required users to use at least one lowercase letter in their password."),
-      numbers: z8.boolean().default(true).describe("Required users to use at least one number in their password."),
-      symbols: z8.boolean().default(true).describe("Required users to use at least one symbol in their password."),
+    password: z9.object({
+      minLength: z9.number().int().min(6).max(99).default(12).describe("Required users to have at least the minimum password length."),
+      uppercase: z9.boolean().default(true).describe("Required users to use at least one uppercase letter in their password."),
+      lowercase: z9.boolean().default(true).describe("Required users to use at least one lowercase letter in their password."),
+      numbers: z9.boolean().default(true).describe("Required users to use at least one number in their password."),
+      symbols: z9.boolean().default(true).describe("Required users to use at least one symbol in their password."),
       temporaryPasswordValidity: DurationSchema.default("7 days").describe(
         "The duration a temporary password is valid. If the user doesn't sign in during this time, an administrator must reset their password."
       )
     }).default({}).describe("The password policy."),
-    validity: z8.object({
+    validity: z9.object({
       idToken: DurationSchema.default("1 hour").describe(
         "The ID token time limit. After this limit expires, your user can't use their ID token."
       ),
@@ -7862,18 +7890,18 @@ var AuthDefaultSchema = z8.record(
 ).default({}).describe("Define the authenticatable users in your app.");
 
 // src/feature/domain/schema.ts
-import { z as z9 } from "zod";
-var DomainNameSchema = z9.string().regex(/[a-z\-\_\.]/g, "Invalid domain name").describe(
+import { z as z10 } from "zod";
+var DomainNameSchema = z10.string().regex(/[a-z\-\_\.]/g, "Invalid domain name").describe(
   "Enter a fully qualified domain name, for example, www.example.com. You can optionally include a trailing dot. If you omit the trailing dot, Amazon Route 53 assumes that the domain name that you specify is fully qualified. This means that Route 53 treats www.example.com (without a trailing dot) and www.example.com. (with a trailing dot) as identical."
 );
-var DNSTypeSchema = z9.enum(["A", "AAAA", "CAA", "CNAME", "DS", "MX", "NAPTR", "NS", "PTR", "SOA", "SPF", "SRV", "TXT"]).describe("The DNS record type.");
+var DNSTypeSchema = z10.enum(["A", "AAAA", "CAA", "CNAME", "DS", "MX", "NAPTR", "NS", "PTR", "SOA", "SPF", "SRV", "TXT"]).describe("The DNS record type.");
 var TTLSchema = DurationSchema.describe("The resource record cache time to live (TTL).");
-var RecordsSchema = z9.string().array().describe("One or more values that correspond with the value that you specified for the Type property.");
-var DomainsDefaultSchema = z9.record(
+var RecordsSchema = z10.string().array().describe("One or more values that correspond with the value that you specified for the Type property.");
+var DomainsDefaultSchema = z10.record(
   ResourceIdSchema,
-  z9.object({
+  z10.object({
     domain: DomainNameSchema.describe("Define the domain name"),
-    dns: z9.object({
+    dns: z10.object({
       name: DomainNameSchema.optional(),
       type: DNSTypeSchema,
       ttl: TTLSchema,
@@ -7883,18 +7911,18 @@ var DomainsDefaultSchema = z9.record(
 ).optional().describe("Define the domains for your application.");
 
 // src/feature/graphql/schema.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 var AuthorizerTtl = DurationSchema.describe(
   `The number of seconds a response should be cached for. The maximum value is one hour (3600 seconds). The Lambda function can override this by returning a ttlOverride key in its response.`
 );
-var GraphQLDefaultSchema = z10.record(
+var GraphQLDefaultSchema = z11.record(
   ResourceIdSchema,
-  z10.object({
+  z11.object({
     domain: ResourceIdSchema.describe("The domain id to link your API with.").optional(),
-    subDomain: z10.string().optional(),
-    auth: z10.union([
+    subDomain: z11.string().optional(),
+    auth: z11.union([
       ResourceIdSchema,
-      z10.object({
+      z11.object({
         authorizer: FunctionSchema,
         ttl: AuthorizerTtl.default("1 hour")
       })
@@ -7906,22 +7934,22 @@ var GraphQLDefaultSchema = z10.record(
     resolver: LocalFileSchema.optional()
   })
 ).describe(`Define the global GraphQL API's.`).optional();
-var GraphQLSchema = z10.record(
+var GraphQLSchema = z11.record(
   ResourceIdSchema,
-  z10.object({
+  z11.object({
     // schema: z.union([LocalFileSchema.transform(v => [v]), z.array(LocalFileSchema).min(1)]).optional(),
     schema: LocalFileSchema.describe("The graphql schema file."),
-    resolvers: z10.record(
+    resolvers: z11.record(
       // TypeName
-      z10.string(),
-      z10.record(
+      z11.string(),
+      z11.record(
         // FieldName
-        z10.string(),
-        z10.union([
+        z11.string(),
+        z11.union([
           FunctionSchema.transform((consumer) => ({
             consumer
           })),
-          z10.object({
+          z11.object({
             consumer: FunctionSchema,
             resolver: LocalFileSchema.optional()
           })
@@ -7932,34 +7960,20 @@ var GraphQLSchema = z10.record(
 ).describe("Define the schema & resolvers in your stack for your global GraphQL API.").optional();
 
 // src/feature/http/schema.ts
-import { z as z11 } from "zod";
-var RouteSchema = z11.string().regex(/^(POST|GET|PUT|DELETE|HEAD|OPTIONS)(\s\/[a-z0-9\+\_\-\/\{\}]*)$/gi, "Invalid route").transform((v) => v);
-var HttpDefaultSchema = z11.record(
+import { z as z12 } from "zod";
+var RouteSchema = z12.string().regex(/^(POST|GET|PUT|DELETE|HEAD|OPTIONS)(\s\/[a-z0-9\+\_\-\/\{\}]*)$/gi, "Invalid route").transform((v) => v);
+var HttpDefaultSchema = z12.record(
   ResourceIdSchema,
-  z11.object({
+  z12.object({
     domain: ResourceIdSchema.describe("The domain id to link your API with."),
-    subDomain: z11.string().optional()
+    subDomain: z12.string().optional()
     // auth: ResourceIdSchema.optional(),
   })
 ).optional().describe("Define your global HTTP API's.");
-var HttpSchema = z11.record(ResourceIdSchema, z11.record(RouteSchema, FunctionSchema)).optional().describe("Define routes in your stack for your global HTTP API.");
+var HttpSchema = z12.record(ResourceIdSchema, z12.record(RouteSchema, FunctionSchema)).optional().describe("Define routes in your stack for your global HTTP API.");
 
 // src/feature/instance/schema.ts
 import { z as z13 } from "zod";
-
-// src/config/schema/local-directory.ts
-import { stat as stat2 } from "fs/promises";
-import { z as z12 } from "zod";
-var LocalDirectorySchema = z12.string().transform((path2) => resolvePath(path2)).refine(async (path2) => {
-  try {
-    const s = await stat2(path2);
-    return s.isDirectory();
-  } catch (error) {
-    return false;
-  }
-}, `Directory doesn't exist`);
-
-// src/feature/instance/schema.ts
 var ImageSchema = z13.string().regex(/^ami\-[0-9a-f]+/).describe("The ID of the AMI.");
 var TypeSchema = z13.enum([
   "t3.nano",
@@ -7980,7 +7994,7 @@ var TypeSchema = z13.enum([
   "g4dn.xlarge"
 ]).describe(`The instance type.`);
 var CommandSchema = z13.string().describe(`The script you want to execute when the instance starts up.`);
-var CodeSchema = LocalDirectorySchema.describe(`The code directory that will be deployed to your instance.`);
+var CodeSchema2 = LocalDirectorySchema.describe(`The code directory that will be deployed to your instance.`);
 var ConnectSchema = z13.boolean().describe("Allows you to connect to all instances with an Instance Connect Endpoint.");
 var EnvironmentSchema2 = z13.record(z13.string(), z13.string()).optional().describe("Environment variable key-value pairs.");
 var ActionSchema2 = z13.string();
@@ -8003,7 +8017,7 @@ var InstancesSchema = z13.record(
   z13.object({
     image: ImageSchema,
     type: TypeSchema,
-    code: CodeSchema,
+    code: CodeSchema2,
     user: z13.string().default("ec2-user"),
     command: CommandSchema.optional(),
     environment: EnvironmentSchema2.optional(),
@@ -8898,8 +8912,8 @@ var TypeFile = class {
   codes = /* @__PURE__ */ new Set();
   interfaces = /* @__PURE__ */ new Map();
   imports = /* @__PURE__ */ new Map();
-  addImport(varName, path2) {
-    this.imports.set(varName, path2);
+  addImport(varName, path) {
+    this.imports.set(varName, path);
     return this;
   }
   addCode(code) {
@@ -8922,11 +8936,11 @@ var TypeFile = class {
       lines.push(
         ...[
           "// Imports",
-          ...Array.from(this.imports.entries()).map(([varName, path2]) => {
+          ...Array.from(this.imports.entries()).map(([varName, path]) => {
             if (typeof varName === "string") {
-              return `import ${camelCase(varName)} from '${path2}'`;
+              return `import ${camelCase(varName)} from '${path}'`;
             }
-            return `import { ${Object.entries(varName).map(([key, alias]) => `${key} as ${camelCase(alias)}`).join(", ")} } from '${path2}'`;
+            return `import { ${Object.entries(varName).map(([key, alias]) => `${key} as ${camelCase(alias)}`).join(", ")} } from '${path}'`;
           }),
           ""
         ]
@@ -10465,10 +10479,10 @@ var build = (type, name, builder, props) => {
     }
     const time = createTimer();
     const meta = await callback(async (file, data2) => {
-      const path2 = getBuildPath(type, name, file);
-      const base2 = dirname5(path2);
+      const path = getBuildPath(type, name, file);
+      const base2 = dirname5(path);
       await mkdir2(base2, { recursive: true });
-      await writeFile2(path2, data2);
+      await writeFile2(path, data2);
     });
     const data = { ...meta, buildTime: time() };
     await writeCache(cacheFile, version, data);
@@ -10603,18 +10617,18 @@ import { hashElement } from "folder-hash";
 import { mkdir as mkdir3, readdir, rm as rm2 } from "fs/promises";
 import { join as join8 } from "path";
 var createTempFolder = async (name) => {
-  const path2 = join8(directories.temp, name);
+  const path = join8(directories.temp, name);
   await mkdir3(join8(directories.temp, name), { recursive: true });
   process.on("SIGTERM", async () => {
-    await rm2(path2, { recursive: true });
+    await rm2(path, { recursive: true });
   });
   return {
-    path: path2,
+    path,
     async files() {
-      return readdir(path2, { recursive: true });
+      return readdir(path, { recursive: true });
     },
     async delete() {
-      await rm2(path2, { recursive: true });
+      await rm2(path, { recursive: true });
     }
   };
 };
@@ -10627,6 +10641,71 @@ var formatFilterPattern = (filters) => {
   return `{${filters.map((filter) => `$.level = "${filter.toUpperCase()}"`).join(" || ")}}`;
 };
 
+// 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 join9, relative as relative2 } from "node:path";
+var zipBundle = async ({ directory }) => {
+  const zip2 = new JSZip2();
+  const list4 = await readdir2(directory, {
+    recursive: true,
+    withFileTypes: true
+  });
+  for (const file of list4) {
+    if (file.isFile()) {
+      const path = join9(file.path, file.name);
+      const rel = relative2(directory, path);
+      zip2.file(rel, createReadStream2(path));
+    }
+  }
+  return zip2.generateAsync({
+    type: "nodebuffer",
+    compression: "DEFLATE",
+    compressionOptions: {
+      level: 9
+    }
+  });
+};
+
+// 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 join10 } 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((resolve2) => {
+    const hash = createHash3("md5");
+    const stream = createReadStream3(file);
+    stream.on("data", (data) => hash.update(data));
+    stream.on("end", () => resolve2(hash.digest("hex")));
+  });
+};
+var listAllFiles = async (list4) => {
+  const files = [];
+  for (const entry of list4) {
+    const stat5 = await lstat2(entry);
+    if (stat5.isDirectory()) {
+      const dirents = await readdir3(entry, {
+        recursive: true,
+        withFileTypes: true
+      });
+      files.push(...dirents.filter((d) => d.isFile()).map((file) => join10(file.path, file.name)));
+    } else if (stat5.isFile()) {
+      files.push(entry);
+    }
+  }
+  return files;
+};
+
 // src/feature/function/build/container/build.ts
 import { exec } from "promisify-child-process";
 var buildDockerImage = async (opts) => {
@@ -10671,7 +10750,10 @@ var createLambdaFunction = (group, ctx, ns, id, local2) => {
   let code;
   if (props.runtime === "container") {
     ctx.registerBuild("function", name, async (build3) => {
-      const cwd = dirname7(local2.file);
+      if (!("file" in local2.code)) {
+        throw new Error('code.file needs to be set for functions with the "container" runtime');
+      }
+      const cwd = dirname7(local2.code.file);
       const version = await hashElement(cwd, {
         files: {
           exclude: ["stack.json"]
@@ -10698,18 +10780,19 @@ var createLambdaFunction = (group, ctx, ns, id, local2) => {
     code = {
       imageUri: image.uri
     };
-  } else {
+  } else if ("file" in local2.code) {
+    const fileCode = local2.code;
     ctx.registerBuild("function", name, async (build3, { workspace }) => {
-      const version = await generateFileHash(workspace, local2.file);
+      const version = await generateFileHash(workspace, fileCode.file);
       return build3(version, async (write) => {
         const temp = await createTempFolder(`function--${name}`);
         const bundle = await bundleTypeScript({
-          file: local2.file,
+          file: fileCode.file,
           external: [
-            ...props.build.external ?? [],
+            ...fileCode.external ?? [],
             ...(props.layers ?? []).flatMap((id2) => ctx.shared.get(`layer-${id2}-packages`))
           ],
-          minify: props.build.minify,
+          minify: fileCode.minify,
           nativeDir: temp.path
         });
         const nativeFiles = await temp.files();
@@ -10737,6 +10820,28 @@ var createLambdaFunction = (group, ctx, ns, id, local2) => {
       key: `/lambda/${name}.zip`,
       body: Asset.fromFile(getBuildPath("function", name, "bundle.zip"))
     });
+  } else {
+    const bundleCode = local2.code;
+    ctx.registerBuild("function", name, async (build3) => {
+      const version = await bundleCacheKey({
+        directory: bundleCode.bundle
+      });
+      return build3(version, async (write) => {
+        const bundle = await zipBundle({
+          directory: bundleCode.bundle
+        });
+        await write("HASH", version);
+        await write("bundle.zip", bundle);
+        return {
+          size: formatByteSize(bundle.byteLength)
+        };
+      });
+    });
+    code = new aws2.s3.BucketObject(group, "code", {
+      bucket: ctx.shared.get("function-bucket-name"),
+      key: `/lambda/${name}.zip`,
+      body: Asset.fromFile(getBuildPath("function", name, "bundle.zip"))
+    });
   }
   const role = new aws2.iam.Role(group, "role", {
     name,
@@ -11177,13 +11282,13 @@ var SsmStore = class {
   }
   async list() {
     debug("Load remote config values");
-    const path2 = configParameterPrefix(this.props.appConfig.name);
+    const path = configParameterPrefix(this.props.appConfig.name);
     const values = {};
     let token;
     while (true) {
       const result = await this.client.send(
         new GetParametersByPathCommand({
-          Path: path2,
+          Path: path,
           WithDecryption: true,
           MaxResults: 10,
           Recursive: true,
@@ -11408,7 +11513,7 @@ var domainFeature = defineFeature({
 // src/feature/function/index.ts
 import { aws as aws7, Node as Node6 } from "@awsless/formation";
 import { camelCase as camelCase3 } from "change-case";
-import { relative as relative2 } from "path";
+import { relative as relative3 } from "path";
 import deepmerge2 from "deepmerge";
 import { days as days3 } from "@awsless/duration";
 var typeGenCode2 = `
@@ -11458,16 +11563,18 @@ var functionFeature = defineFeature({
           resourceType: "function",
           resourceName: name
         });
-        const relFile = relative2(directories.types, props.file);
-        if (props.runtime === "container") {
-          resource2.addType(name, `Invoke<'${funcName}', Func>`);
-          mock.addType(name, `MockBuilder<Func>`);
-          mockResponse.addType(name, `MockObject<Func>`);
-        } else {
-          types2.addImport(varName, relFile);
-          resource2.addType(name, `Invoke<'${funcName}', typeof ${varName}>`);
-          mock.addType(name, `MockBuilder<typeof ${varName}>`);
-          mockResponse.addType(name, `MockObject<typeof ${varName}>`);
+        if ("file" in local2.code) {
+          const relFile = relative3(directories.types, local2.code.file);
+          if (props.runtime === "container") {
+            resource2.addType(name, `Invoke<'${funcName}', Func>`);
+            mock.addType(name, `MockBuilder<Func>`);
+            mockResponse.addType(name, `MockObject<Func>`);
+          } else {
+            types2.addImport(varName, relFile);
+            resource2.addType(name, `Invoke<'${funcName}', typeof ${varName}>`);
+            mock.addType(name, `MockBuilder<typeof ${varName}>`);
+            mockResponse.addType(name, `MockObject<typeof ${varName}>`);
+          }
         }
       }
       mocks.addType(stack.name, mock);
@@ -11536,12 +11643,12 @@ import { mergeTypeDefs } from "@graphql-tools/merge";
 import { readFile as readFile5 } from "fs/promises";
 import { buildSchema, print } from "graphql";
 import { Asset as Asset2, aws as aws8, Node as Node7 } from "@awsless/formation";
-import { createHash as createHash4 } from "crypto";
+import { createHash as createHash5 } from "crypto";
 
 // src/util/id.ts
-import { createHash as createHash3 } from "crypto";
+import { createHash as createHash4 } from "crypto";
 var shortId = (ns) => {
-  return createHash3("md5").update(ns).digest("hex").substring(0, 10);
+  return createHash4("md5").update(ns).digest("hex").substring(0, 10);
 };
 
 // src/feature/domain/util.ts
@@ -11749,12 +11856,12 @@ var graphqlFeature = defineFeature({
           const file = stack.graphql?.[id]?.schema;
           if (file) {
             const source = await readFile5(file, "utf8");
-            const finger2 = createHash4("sha1").update(source).digest("hex");
+            const finger2 = createHash5("sha1").update(source).digest("hex");
             sources.push(source);
             fingers.push(finger2);
           }
         }
-        const finger = createHash4("sha1").update(sources.sort().join(" ")).digest("hex");
+        const finger = createHash5("sha1").update(sources.sort().join(" ")).digest("hex");
         return build3(finger, async (write) => {
           const defs = mergeTypeDefs([scalarSchema, baseSchema, ...sources]);
           const output = print(defs);
@@ -11890,11 +11997,11 @@ var graphqlFeature = defineFeature({
 // src/feature/http/index.ts
 import { aws as aws9, Node as Node8 } from "@awsless/formation";
 import { camelCase as camelCase4, constantCase as constantCase6 } from "change-case";
-import { relative as relative3 } from "path";
+import { relative as relative4 } from "path";
 var parseRoute = (route) => {
   const [method, ...paths] = route.split(" ");
-  const path2 = paths.join(" ");
-  return { method, path: path2 };
+  const path = paths.join(" ");
+  return { method, path };
 };
 var strToInt = (str) => {
   return parseInt(Buffer.from(str, "utf8").toString("hex"), 16);
@@ -11915,12 +12022,12 @@ var httpFeature = defineFeature({
       for (const [id, routes] of Object.entries(stack.http ?? {})) {
         if (!(id in api)) api[id] = {};
         for (const [route, props] of Object.entries(routes)) {
-          const { path: path2, method } = parseRoute(route);
+          const { path, method } = parseRoute(route);
           const file = typeof props === "string" ? props : props.file;
           if (!(method in api[id])) {
             api[id][method] = {};
           }
-          api[id][method][path2] = file;
+          api[id][method][path] = file;
         }
       }
     }
@@ -11928,15 +12035,15 @@ var httpFeature = defineFeature({
       const idType = new TypeObject(2);
       for (const [method, paths] of Object.entries(routes)) {
         const methodType = new TypeObject(3);
-        for (const [path2, file] of Object.entries(paths)) {
+        for (const [path, file] of Object.entries(paths)) {
           const paramType = new TypeObject(4);
-          for (const param of path2.matchAll(/{([a-z0-9]+)}/g)) {
+          for (const param of path.matchAll(/{([a-z0-9]+)}/g)) {
             paramType.addType(param[0], "string | number");
           }
-          const varName = camelCase4(`${id}-${path2}-${method}`);
-          const relFile = relative3(directories.types, file);
+          const varName = camelCase4(`${id}-${path}-${method}`);
+          const relFile = relative4(directories.types, file);
           types2.addImport(varName, relFile);
-          methodType.add(`'${path2}'`, `Route<typeof ${varName}, ${paramType.toString() || "never"}>`);
+          methodType.add(`'${path}'`, `Route<typeof ${varName}, ${paramType.toString() || "never"}>`);
         }
         idType.addConst(method, methodType);
       }
@@ -12030,7 +12137,7 @@ var httpFeature = defineFeature({
       const group = new Node8(ctx.stack, "http", id);
       for (const [routeKey, routeProps] of Object.entries(routes)) {
         const routeGroup = new Node8(group, "route", routeKey);
-        const { method, path: path2 } = parseRoute(routeKey);
+        const { method, path } = parseRoute(routeKey);
         const routeId = shortId(routeKey);
         const { lambda } = createLambdaFunction(routeGroup, ctx, "http", `${id}-${routeId}`, {
           ...routeProps,
@@ -12058,7 +12165,7 @@ var httpFeature = defineFeature({
           priority: generatePriority(ctx.stackConfig.name, routeKey),
           conditions: [
             aws9.elb.ListenerCondition.httpRequestMethods([method]),
-            aws9.elb.ListenerCondition.pathPatterns([path2])
+            aws9.elb.ListenerCondition.pathPatterns([path])
           ],
           actions: [aws9.elb.ListenerAction.forward([target.arn])]
         }).dependsOn(target);
@@ -12416,7 +12523,7 @@ var pubsubFeature = defineFeature({
 import { aws as aws14, Node as Node13 } from "@awsless/formation";
 import { camelCase as camelCase5, constantCase as constantCase8 } from "change-case";
 import deepmerge3 from "deepmerge";
-import { relative as relative4 } from "path";
+import { relative as relative5 } from "path";
 var typeGenCode3 = `
 import { SendMessageOptions, SendMessageBatchOptions, BatchItem } from '@awsless/sqs'
 import type { Mock } from 'vitest'
@@ -12454,7 +12561,7 @@ var queueFeature = defineFeature({
           resourceName: name
         });
         const file = typeof fileOrProps === "string" ? fileOrProps : typeof fileOrProps.consumer === "string" ? fileOrProps.consumer : fileOrProps.consumer.file;
-        const relFile = relative4(directories.types, file);
+        const relFile = relative5(directories.types, file);
         gen.addImport(varName, relFile);
         mock.addType(name, `MockBuilder<typeof ${varName}>`);
         resource2.addType(name, `Send<'${queueName}', typeof ${varName}>`);
@@ -12602,7 +12709,7 @@ var restFeature = defineFeature({
 import { camelCase as camelCase6, constantCase as constantCase10, paramCase as paramCase7 } from "change-case";
 import { Asset as Asset5, aws as aws17, Node as Node16 } from "@awsless/formation";
 import { mebibytes as mebibytes2 } from "@awsless/size";
-import { dirname as dirname10, join as join9, relative as relative5 } from "path";
+import { dirname as dirname10, join as join11, relative as relative6 } from "path";
 import { fileURLToPath } from "node:url";
 
 // src/feature/function/prebuild.ts
@@ -12648,6 +12755,7 @@ var createPrebuildLambdaFunction = (group, ctx, ns, id, local2) => {
     role: role.arn,
     code,
     runtime: props.runtime === "container" ? void 0 : props.runtime,
+    layers: (props.layers ?? []).map((id2) => ctx.shared.get(`layer-${id2}-arn`)),
     // Remove conflicting props.
     vpc: void 0,
     log: props.log
@@ -12760,7 +12868,7 @@ var rpcFeature = defineFeature({
       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 relFile = relative6(directories.types, props.file);
           const varName = camelCase6(`${stack.name}-${name}`);
           types2.addImport(varName, relFile);
           schema.addType(name, `Handle<typeof ${varName}>`);
@@ -12798,8 +12906,8 @@ var rpcFeature = defineFeature({
         resourceName: id
       });
       const { lambda, policy, code } = createPrebuildLambdaFunction(group, ctx, "rpc", id, {
-        bundleFile: join9(__dirname, "/prebuild/rpc/bundle.zip"),
-        bundleHash: join9(__dirname, "/prebuild/rpc/HASH"),
+        bundleFile: join11(__dirname, "/prebuild/rpc/bundle.zip"),
+        bundleHash: join11(__dirname, "/prebuild/rpc/HASH"),
         memorySize: mebibytes2(256),
         warm: 3,
         log: props.log
@@ -12987,7 +13095,7 @@ var searchFeature = defineFeature({
 import { days as days6, seconds as seconds4 } from "@awsless/duration";
 import { Asset as Asset6, aws as aws19, Node as Node18 } from "@awsless/formation";
 import { glob as glob2 } from "glob";
-import { join as join10 } from "path";
+import { join as join12 } from "path";
 
 // src/feature/site/util.ts
 import { lookup, contentType } from "mime-types";
@@ -13097,7 +13205,7 @@ var siteFeature = defineFeature({
             const object = new aws19.s3.BucketObject(group, file, {
               bucket: bucket.name,
               key: file,
-              body: Asset6.fromFile(join10(props.static, file)),
+              body: Asset6.fromFile(join12(props.static, file)),
               cacheControl: getCacheControl(file),
               contentType: getContentType(file)
             });
@@ -13478,7 +13586,7 @@ var tableFeature = defineFeature({
 // src/feature/task/index.ts
 import { Node as Node22 } from "@awsless/formation";
 import { camelCase as camelCase7 } from "change-case";
-import { relative as relative6 } from "path";
+import { relative as relative7 } from "path";
 var typeGenCode6 = `
 import { InvokeOptions } from '@awsless/lambda'
 import type { Mock } from 'vitest'
@@ -13520,7 +13628,7 @@ var taskFeature = defineFeature({
           resourceType: "task",
           resourceName: name
         });
-        const relFile = relative6(directories.types, props.consumer.file);
+        const relFile = relative7(directories.types, props.consumer.file);
         types2.addImport(varName, relFile);
         resource2.addType(name, `Invoke<'${funcName}', typeof ${varName}>`);
         mock.addType(name, `MockBuilder<typeof ${varName}>`);
@@ -13808,7 +13916,6 @@ var alertFeature = defineFeature({
 
 // src/feature/layer/index.ts
 import { Asset as Asset7, aws as aws26, Node as Node26 } from "@awsless/formation";
-import path from "path";
 var layerFeature = defineFeature({
   name: "layer",
   onBefore(ctx) {
@@ -13849,7 +13956,7 @@ var layerFeature = defineFeature({
           resourceType: "layer",
           resourceName: shortId(id)
         }),
-        description: `${id} (${path.parse(props.file).name}${path.parse(props.file).ext})`,
+        description: id,
         architectures: props.architecture ? [props.architecture] : void 0,
         runtimes: props.runtimes,
         code: {
@@ -14036,11 +14143,11 @@ var logConfigError = (error) => {
     const inStack = issue.path[0] === "stacks" && typeof issue.path[1] === "number";
     const length = issue.path.length;
     const end = ["}"];
-    issue.path.forEach((path2, i) => {
+    issue.path.forEach((path, i) => {
       const index = i + 1;
-      context = context[path2];
-      if (typeof path2 === "string") {
-        const key = path2 + `: `;
+      context = context[path];
+      if (typeof path === "string") {
+        const key = path + `: `;
         if (index === length) {
           const space = " ".repeat(key.length);
           const value = format(context);
@@ -14670,13 +14777,13 @@ import wildstring4 from "wildstring";
 import { log as log8 } from "@clack/prompts";
 import chalk6 from "chalk";
 import { mkdir as mkdir5, readFile as readFile7, writeFile as writeFile3 } from "fs/promises";
-import { join as join13 } from "path";
+import { join as join15 } from "path";
 import wildstring3 from "wildstring";
 
 // src/build/__fingerprint.ts
-import { createHash as createHash5 } from "crypto";
-import { readdir as readdir2, readFile as readFile6, stat as stat4 } from "fs/promises";
-import { basename as basename5, dirname as dirname11, extname as extname3, join as join11 } from "path";
+import { createHash as createHash6 } from "crypto";
+import { readdir as readdir4, readFile as readFile6, stat as stat4 } from "fs/promises";
+import { basename as basename5, dirname as dirname11, extname as extname3, join as join13 } from "path";
 import parseStaticImports from "parse-static-imports";
 var extensions = ["js", "mjs", "jsx", "ts", "mts", "tsx"];
 var generateFileHashes = async (file, hashes) => {
@@ -14685,7 +14792,7 @@ var generateFileHashes = async (file, hashes) => {
   }
   const code = await readModuleFile(file);
   const deps = await findDependencies(file, code);
-  const hash = createHash5("sha1").update(code).digest();
+  const hash = createHash6("sha1").update(code).digest();
   hashes.set(file, hash);
   for (const dep of deps) {
     if (dep.startsWith("/")) {
@@ -14695,14 +14802,14 @@ var generateFileHashes = async (file, hashes) => {
 };
 var fingerprintFromDirectory = async (dir) => {
   const hashes = /* @__PURE__ */ new Map();
-  const files = await readdir2(dir, { recursive: true });
+  const files = await readdir4(dir, { recursive: true });
   for (const file of files) {
     if (extensions.includes(extname3(file).substring(1)) && file.at(0) !== "_") {
-      await generateFileHashes(join11(dir, file), hashes);
+      await generateFileHashes(join13(dir, file), hashes);
     }
   }
   const merge2 = Buffer.concat(Array.from(hashes.values()).sort());
-  return createHash5("sha1").update(merge2).digest("hex");
+  return createHash6("sha1").update(merge2).digest("hex");
 };
 var readModuleFile = (file) => {
   if (file.endsWith(".js")) {
@@ -14712,7 +14819,7 @@ var readModuleFile = (file) => {
     return readFiles([
       file,
       ...extensions.map((exp) => `${file}.${exp}`),
-      ...extensions.map((exp) => join11(file, `/index.${exp}`))
+      ...extensions.map((exp) => join13(file, `/index.${exp}`))
     ]);
   }
   return readFile6(file, "utf8");
@@ -14732,7 +14839,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(".") ? join11(dirname11(file), value) : value);
+  return imports.map((entry) => entry.moduleName).filter(Boolean).map((value) => value?.startsWith(".") ? join13(dirname11(file), value) : value);
 };
 
 // src/test/reporter.ts
@@ -14815,7 +14922,7 @@ 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 dirname12, join as join12 } from "path";
+import { dirname as dirname12, join as join14 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var startTest = async (props) => {
   const __dirname2 = dirname12(fileURLToPath2(import.meta.url));
@@ -14832,7 +14939,7 @@ var startTest = async (props) => {
       exclude: ["**/_*", "**/_*/**", ...configDefaults.exclude],
       globals: true,
       reporters: props.reporter,
-      globalSetup: join12(__dirname2, "test-global-setup.js")
+      globalSetup: join14(__dirname2, "test-global-setup.js")
       // env: {
       // 	TZ: 'UTC',
       // },
@@ -14926,7 +15033,7 @@ var logTestErrors = (event) => {
 var runTest = async (stack, dir, filters) => {
   await mkdir5(directories.test, { recursive: true });
   const fingerprint = await fingerprintFromDirectory(dir);
-  const file = join13(directories.test, `${stack}.json`);
+  const file = join15(directories.test, `${stack}.json`);
   const exists = await fileExist(file);
   if (exists && !process.env.NO_CACHE) {
     const raw = await readFile7(file, { encoding: "utf8" });
@@ -14988,8 +15095,8 @@ var runTests = async (tests, stackFilters = [], testFilters = []) => {
         continue;
       }
     }
-    for (const path2 of test2.paths) {
-      const result = await runTest(test2.name, path2, testFilters);
+    for (const path of test2.paths) {
+      const result = await runTest(test2.name, path, testFilters);
       if (!result) {
         return false;
       }
@@ -15180,12 +15287,13 @@ var bind = (program2) => {
       } else {
         log9.warning("No bindings available.");
       }
+      const configList = opts.config ?? [];
       const configs = {};
-      for (const name of opts.config) {
+      for (const name of configList) {
         configs[`CONFIG_${constantCase14(name)}`] = name;
       }
-      if (opts.config.length > 0) {
-        note3(wrap(opts.config.map((v) => color.label(constantCase14(v)))), "Bind Config");
+      if (configList.length ?? 0 > 0) {
+        note3(wrap(configList.map((v) => color.label(constantCase14(v)))), "Bind Config");
       }
       if (commands7.length === 0) {
         return "No command to execute.";
@@ -15248,7 +15356,7 @@ import { log as log10 } from "@clack/prompts";
 
 // src/type-gen/generate.ts
 import { mkdir as mkdir6, writeFile as writeFile4 } from "fs/promises";
-import { dirname as dirname13, join as join14, relative as relative7 } from "path";
+import { dirname as dirname13, join as join16, relative as relative8 } from "path";
 var generateTypes = async (props) => {
   const files = [];
   await Promise.all(
@@ -15257,13 +15365,13 @@ var generateTypes = async (props) => {
         ...props,
         async write(file, data, include = false) {
           const code = data?.toString("utf8");
-          const path2 = join14(directories.types, file);
+          const path = join16(directories.types, file);
           if (code) {
             if (include) {
-              files.push(relative7(directories.root, path2));
+              files.push(relative8(directories.root, path));
             }
-            await mkdir6(dirname13(path2), { recursive: true });
-            await writeFile4(path2, code);
+            await mkdir6(dirname13(path), { recursive: true });
+            await writeFile4(path, code);
           }
         }
       });
@@ -15271,7 +15379,7 @@ var generateTypes = async (props) => {
   );
   if (files.length) {
     const code = files.map((file) => `/// <reference path='${file}' />`).join("\n");
-    await writeFile4(join14(directories.root, `awsless.d.ts`), code);
+    await writeFile4(join16(directories.root, `awsless.d.ts`), code);
   }
 };