@awsless/awsless 0.0.543 → 0.0.545

package/dist/bin.js

@@ -1,4 +1,7 @@
 #!/usr/bin/env node
+import {
+  shortId
+} from "./chunk-W4ED7XCC.js";
 
 // src/cli/program.ts
 import { Command } from "commander";
@@ -1147,55 +1150,52 @@ var RpcSchema = z22.record(ResourceIdSchema, z22.record(z22.string(), FunctionSc
 
 // src/feature/instance/schema.ts
 import { days as days3, toDays as toDays2 } from "@awsless/duration";
+import { toMebibytes } from "@awsless/size";
 import { z as z23 } from "zod";
-var CpuSizeSchema = z23.union([
-  z23.literal("0.25 vCPU"),
-  z23.literal("0.5 vCPU"),
-  z23.literal("1 vCPU"),
-  z23.literal("2 vCPU"),
-  z23.literal("4 vCPU"),
-  z23.literal("8 vCPU"),
-  z23.literal("16 vCPU")
-]).describe(
-  "The number of vCPU units used by the task. For tasks using the Fargate launch type, this field is required. Valid values: 0.25, 0.5, 1, 2, 4, 8, 16 vCPU."
+var CpuSchema = z23.union([z23.literal(0.25), z23.literal(0.5), z23.literal(1), z23.literal(2), z23.literal(4), z23.literal(8), z23.literal(16)]).transform((v) => `${v} vCPU`).describe(
+  "The number of virtual CPU units (vCPU) used by the task. For tasks using the Fargate launch type, this field is required. Valid values: 0.25, 0.5, 1, 2, 4, 8, 16 vCPU."
 );
-var MemorySizeSchema2 = z23.union([
+var validMemorySize = [
   // 0.25 vCPU
-  z23.literal(512),
-  z23.literal(1024),
-  z23.literal(2048),
+  512,
+  1024,
+  2048,
   // 0.5 vCPU
-  z23.literal(1024),
-  z23.literal(2048),
-  z23.literal(3072),
-  z23.literal(4096),
+  1024,
+  2048,
+  3072,
+  4096,
   // 1 vCPU
-  z23.literal(2048),
-  z23.literal(3072),
-  z23.literal(4096),
-  z23.literal(5120),
-  z23.literal(6144),
-  z23.literal(7168),
-  z23.literal(8192),
+  2048,
+  3072,
+  4096,
+  5120,
+  6144,
+  7168,
+  8192,
   // 2 vCPU
-  z23.literal(4096),
-  z23.literal(5120),
-  z23.literal(6144),
-  z23.literal(7168),
-  z23.literal(8192),
-  z23.literal(9216),
-  z23.literal(10240),
-  z23.literal(11264),
-  z23.literal(12288),
-  z23.literal(13312),
-  z23.literal(14336),
-  z23.literal(15360),
-  z23.literal(16384)
-]).describe(
+  4096,
+  5120,
+  6144,
+  7168,
+  8192,
+  9216,
+  10240,
+  11264,
+  12288,
+  13312,
+  14336,
+  15360,
+  16384
+];
+var MemorySizeSchema2 = SizeSchema.refine(
+  (s) => validMemorySize.includes(toMebibytes(s)),
+  `Invalid memory size. Allowed sizes: ${validMemorySize.join(", ")} MiB`
+).describe(
   "The amount of memory (in MiB) used by the task. For tasks using the Fargate launch type, this field is required and must be compatible with the CPU value. Valid memory values depend on the CPU configuration."
 );
 var HealthCheckSchema = z23.object({
-  command: z23.union([z23.string(), z23.string().array()]).describe("The command that the container runs to determine if it is healthy."),
+  path: z23.string().describe("The path that the container runs to determine if it is healthy."),
   interval: DurationSchema.describe("The time period in seconds between each health check execution."),
   retries: z23.number().int().min(1).max(10).describe(
     "The number of times to retry a failed health check before the container is considered unhealthy."
@@ -1207,13 +1207,6 @@ var HealthCheckSchema = z23.object({
     "The time period in seconds to wait for a health check to succeed before it is considered a failure."
   )
 }).describe("The health check command and associated configuration parameters for the container.");
-var RestartPolicySchema = z23.object({
-  enabled: z23.boolean().describe("Whether to enable the restart policy for the container."),
-  ignoredExitCodes: z23.number().int().array().optional().describe("A list of exit codes that Amazon ECS will ignore and not attempt a restart against."),
-  restartAttemptPeriod: z23.number().int().min(0).max(1800).optional().describe(
-    "A period of time (in seconds) that the container must run for before a restart can be attempted. A container can be restarted only once every restartAttemptPeriod seconds. If a container isn't able to run for this time period and exits early, it will not be restarted. You can set a minimum restartAttemptPeriod of 60 seconds and a maximum restartAttemptPeriod of 1800 seconds."
-  )
-}).describe("The restart policy for the container. This parameter maps to the --restart option to docker run.");
 var EnvironmentSchema2 = z23.record(z23.string(), z23.string()).optional().describe("Environment variable key-value pairs.");
 var ArchitectureSchema3 = z23.enum(["x86_64", "arm64"]).describe("The instruction set architecture that the function supports.");
 var ActionSchema2 = z23.string();
@@ -1267,13 +1260,13 @@ var ISchema = z23.object({
   description: DescriptionSchema2.optional(),
   image: ImageSchema.optional(),
   log: LogSchema2.optional(),
+  cpu: CpuSchema.optional(),
   memorySize: MemorySizeSchema2.optional(),
-  cpuSize: CpuSizeSchema.optional(),
   architecture: ArchitectureSchema3.optional(),
   environment: EnvironmentSchema2.optional(),
   permissions: PermissionsSchema2.optional(),
-  healthCheck: HealthCheckSchema.optional(),
-  restartPolicy: RestartPolicySchema.optional()
+  healthCheck: HealthCheckSchema.optional()
+  // restartPolicy: RestartPolicySchema.optional(),
 });
 var InstanceSchema = z23.union([
   LocalFileSchema.transform((code) => ({
@@ -1284,13 +1277,13 @@ var InstanceSchema = z23.union([
 var InstancesSchema = z23.record(ResourceIdSchema, InstanceSchema).optional().describe("Define the instances in your stack.");
 var InstanceDefaultSchema = z23.object({
   image: ImageSchema.default("public.ecr.aws/aws-cli/aws-cli:amd64"),
-  memorySize: MemorySizeSchema2.default(512),
-  cpuSize: CpuSizeSchema.default("0.25 vCPU"),
+  cpu: CpuSchema.default(0.25),
+  memorySize: MemorySizeSchema2.default("512 MB"),
   architecture: ArchitectureSchema3.default("arm64"),
   environment: EnvironmentSchema2.optional(),
   permissions: PermissionsSchema2.optional(),
   healthCheck: HealthCheckSchema.optional(),
-  restartPolicy: RestartPolicySchema.default({ enabled: true }),
+  // restartPolicy: RestartPolicySchema.default({ enabled: true }),
   log: LogSchema2.default(true).transform((log25) => ({
     retention: log25.retention ?? days3(7)
   }))
@@ -3010,7 +3003,7 @@ var zipFiles = (files) => {
 
 // src/feature/function/util.ts
 import { toDays as toDays4, toSeconds } from "@awsless/duration";
-import { toMebibytes } from "@awsless/size";
+import { toMebibytes as toMebibytes2 } from "@awsless/size";
 import { pascalCase } from "change-case";
 
 // src/util/cache.ts
@@ -3051,12 +3044,6 @@ var listAllFiles = async (list3) => {
   return files;
 };
 
-// src/util/id.ts
-import { createHash as createHash3 } from "crypto";
-var shortId = (ns) => {
-  return createHash3("md5").update(ns).digest("hex").substring(0, 10);
-};
-
 // src/util/temp.ts
 import { mkdir as mkdir3, readdir as readdir2, rm as rm2 } from "fs/promises";
 import { join as join8 } from "path";
@@ -3298,7 +3285,7 @@ var createLambdaFunction = (parentGroup, ctx, ns, id, local) => {
       runtime: props.runtime,
       handler: props.handler,
       timeout: toSeconds(props.timeout),
-      memorySize: toMebibytes(props.memorySize),
+      memorySize: toMebibytes2(props.memorySize),
       architectures: [props.architecture],
       timeouts: {
         create: "30s",
@@ -3732,17 +3719,18 @@ import type { Mock } from 'vitest'
 type Func = (...args: any[]) => any
 
 type Invoke<N extends string, F extends Func> = unknown extends Parameters<F>[0] ? InvokeWithoutPayload<N, F> : InvokeWithPayload<N, F>
+type Options = Omit<InvokeOptions, 'name' | 'payload' | 'type'>
 
 type InvokeWithPayload<Name extends string, F extends Func> = {
 	readonly name: Name
-	readonly cached: (payload: Parameters<F>[0], options?: Omit<InvokeOptions, 'name' | 'payload' | 'type'>) => InvokeResponse<F>
-	(payload: Parameters<F>[0], options?: Omit<InvokeOptions, 'name' | 'payload' | 'type'>): InvokeResponse<F>
+	readonly cached: (payload: Parameters<F>[0], options?: Options) => InvokeResponse<F>
+	(payload: Parameters<F>[0], options?: Options): InvokeResponse<F>
 }
 
 type InvokeWithoutPayload<Name extends string, F extends Func> = {
 	readonly name: Name
-	readonly cached: (payload?: Parameters<F>[0], options?: Omit<InvokeOptions, 'name' | 'payload' | 'type'>) => InvokeResponse<F>
-	(payload?: Parameters<F>[0], options?: Omit<InvokeOptions, 'name' | 'payload' | 'type'>): InvokeResponse<F>
+	readonly cached: (payload?: Parameters<F>[0], options?: Options) => InvokeResponse<F>
+	(payload?: Parameters<F>[0], options?: Options): InvokeResponse<F>
 }
 
 type Response<F extends Func> = PartialDeep<Awaited<InvokeResponse<F>>, { recurseIntoArrays: true }>
@@ -4290,7 +4278,7 @@ import { fileURLToPath } from "node:url";
 // src/feature/function/prebuild.ts
 import { days as days4, seconds as seconds6, toDays as toDays5, toSeconds as toSeconds4 } from "@awsless/duration";
 import { $ as $12, Future as Future2, resolveInputs as resolveInputs2 } from "@awsless/formation";
-import { mebibytes as mebibytes2, toMebibytes as toMebibytes2 } from "@awsless/size";
+import { mebibytes as mebibytes2, toMebibytes as toMebibytes3 } from "@awsless/size";
 import { pascalCase as pascalCase2 } from "change-case";
 var createPrebuildLambdaFunction = (group, ctx, ns, id, props) => {
   let name;
@@ -4382,7 +4370,7 @@ var createPrebuildLambdaFunction = (group, ctx, ns, id, props) => {
     runtime: props.runtime,
     handler: props.handler,
     timeout: toSeconds4(props.timeout ?? seconds6(10)),
-    memorySize: toMebibytes2(props.memorySize ?? mebibytes2(128)),
+    memorySize: toMebibytes3(props.memorySize ?? mebibytes2(128)),
     architectures: [props.architecture ?? "arm64"],
     layers: props.layers?.map((id2) => ctx.shared.entry("layer", "arn", id2)),
     s3Bucket: code.bucket,
@@ -5057,7 +5045,7 @@ var execCommand = async ({ cwd, env, command }) => {
 };
 
 // src/feature/site/index.ts
-import { createHash as createHash4 } from "crypto";
+import { createHash as createHash3 } from "crypto";
 import { Future as Future3 } from "@awsless/formation";
 var siteFeature = defineFeature({
   name: "site",
@@ -5362,7 +5350,7 @@ var siteFeature = defineFeature({
         version: new Future3((resolve) => {
           $combine(...versions).then((versions2) => {
             const combined = versions2.filter((v) => !!v).sort().join(",");
-            const version = createHash4("sha1").update(combined).digest("hex");
+            const version = createHash3("sha1").update(combined).digest("hex");
             resolve(version);
           });
         })
@@ -5748,21 +5736,26 @@ import { camelCase as camelCase7 } from "change-case";
 import { relative as relative6 } from "path";
 import { $ as $18 } from "@awsless/formation";
 var typeGenCode6 = `
+import { Duration } from '@awsless/duration'
 import { InvokeOptions } from '@awsless/lambda'
 import type { Mock } from 'vitest'
 
 type Func = (...args: any[]) => any
 
+type Options = Omit<InvokeOptions, 'name' | 'payload' | 'type'> & {
+	schedule?: Duration | Date
+}
+
 type Invoke<N extends string, F extends Func> = unknown extends Parameters<F>[0] ? InvokeWithoutPayload<N, F> : InvokeWithPayload<N, F>
 
 type InvokeWithPayload<Name extends string, F extends Func> = {
 	readonly name: Name
-	(payload: Parameters<F>[0], options?: Omit<InvokeOptions, 'name' | 'payload' | 'type'>): Promise<void>
+	(payload: Parameters<F>[0], options?: Options): Promise<void>
 }
 
 type InvokeWithoutPayload<Name extends string, F extends Func> = {
 	readonly name: Name
-	(payload?: Parameters<F>[0], options?: Omit<InvokeOptions, 'name' | 'payload' | 'type'>): Promise<void>
+	(payload?: Parameters<F>[0], options?: Options): Promise<void>
 }
 
 type MockHandle<F extends Func> = (payload: Parameters<F>[0]) => void | Promise<void> | Promise<Promise<void>>
@@ -6001,7 +5994,9 @@ var vpcFeature = defineFeature({
       tags: {
         Name: ctx.app.name
       },
-      cidrBlock: "10.0.0.0/16"
+      cidrBlock: "10.0.0.0/16",
+      enableDnsSupport: true,
+      enableDnsHostnames: true
     });
     const privateRouteTable = new $20.aws.route.Table(group, "private", {
       vpcId: vpc.id,
@@ -6803,26 +6798,28 @@ import { $ as $26, Group as Group26 } from "@awsless/formation";
 // src/feature/instance/util.ts
 import { toDays as toDays8, toSeconds as toSeconds10 } from "@awsless/duration";
 import { $ as $25, Future as Future4, Group as Group25, resolveInputs as resolveInputs3 } from "@awsless/formation";
+import { toMebibytes as toMebibytes4 } from "@awsless/size";
 import { generateFileHash as generateFileHash2 } from "@awsless/ts-file-cache";
 import { constantCase as constantCase14, pascalCase as pascalCase3 } from "change-case";
 import deepmerge4 from "deepmerge";
+import { join as join15 } from "path";
 
 // src/feature/instance/build/executable.ts
-import { execSync } from "child_process";
-import { createHash as createHash5 } from "crypto";
+import { createHash as createHash4 } from "crypto";
 import { readFile as readFile4 } from "fs/promises";
 import { join as join14 } from "path";
+import { exec as exec2 } from "promisify-child-process";
 var buildExecutable = async (input, outputPath) => {
   const filePath = join14(outputPath, "program");
   const args = ["build", input, "--compile", "--target", "bun-linux-x64-modern", "--outfile", filePath];
   try {
-    execSync(`bun ${args.join(" ")}`, { encoding: "utf8" });
+    await exec2(`bun ${args.join(" ")}`);
   } catch (error) {
-    throw new Error(`Executable build failed: ${error instanceof Error ? error.message : String(error)}`);
+    throw new Error(`Executable build failed: ${error instanceof Error ? error.message : JSON.stringify(error)}`);
   }
   const file = await readFile4(filePath);
   return {
-    hash: createHash5("sha1").update(file).digest("hex"),
+    hash: createHash4("sha1").update(file).digest("hex"),
     file
   };
 };
@@ -6856,9 +6853,9 @@ var createFargateTask = (parentGroup, ctx, ns, id, local) => {
   });
   const code = new $25.aws.s3.BucketObject(group, "code", {
     bucket: ctx.shared.get("instance", "bucket-name"),
-    key: `fargate/${name}`,
+    key: name,
     source: relativePath(getBuildPath("instance", name, "program")),
-    sourceHash: $hash(getBuildPath("instance", name, "HASH"))
+    sourceHash: $file(getBuildPath("instance", name, "HASH"))
   });
   const executionRole = new $25.aws.iam.Role(group, "execution-role", {
     name: shortId(`${shortName}:execution-role`),
@@ -6935,15 +6932,12 @@ var createFargateTask = (parentGroup, ctx, ns, id, local) => {
       );
     })
   });
-  const addPermission = (...permissions) => {
-    statements.push(...permissions);
-    policy.$.attachDependencies(permissions);
-  };
   ctx.onPermission((statement) => {
-    addPermission(statement);
+    statements.push(statement);
+    policy.$.attachDependencies(statement);
   });
   let logGroup;
-  if (props.log.retention.value > 0n) {
+  if (props.log.retention && props.log.retention.value > 0n) {
     logGroup = new $25.aws.cloudwatch.LogGroup(group, "log", {
       name: `/aws/ecs/${name}`,
       retentionInDays: toDays8(props.log.retention)
@@ -6962,7 +6956,8 @@ var createFargateTask = (parentGroup, ctx, ns, id, local) => {
   const tags = {
     APP: ctx.appConfig.name,
     APP_ID: ctx.appId,
-    STACK: ctx.stackConfig.name
+    STACK: ctx.stackConfig.name,
+    CODE_HASH: code.sourceHash.pipe((v) => v)
   };
   const variables = {};
   const task2 = new $25.aws.ecs.TaskDefinition(
@@ -6970,17 +6965,19 @@ var createFargateTask = (parentGroup, ctx, ns, id, local) => {
     "task",
     {
       family: name,
+      // family: 'test',
       networkMode: "awsvpc",
-      cpu: props.cpuSize,
-      memory: props.memorySize.toString(),
+      cpu: props.cpu,
+      memory: toMebibytes4(props.memorySize).toString(),
       requiresCompatibilities: ["FARGATE"],
       executionRoleArn: executionRole.arn,
       taskRoleArn: role.arn,
-      trackLatest: true,
       runtimePlatform: {
         cpuArchitecture: constantCase14(props.architecture),
         operatingSystemFamily: "LINUX"
       },
+      // trackLatest: false,
+      // skipDestroy: true,
       containerDefinitions: new Future4(async (resolve) => {
         const data = await resolveInputs3(variables);
         const { s3Bucket, s3Key } = await resolveInputs3({
@@ -6991,13 +6988,17 @@ var createFargateTask = (parentGroup, ctx, ns, id, local) => {
           JSON.stringify([
             {
               name: `container-${id}`,
+              essential: true,
               image: props.image,
               protocol: "tcp",
               workingDirectory: "/usr/app",
               entryPoint: ["sh", "-c"],
               command: [
-                `aws s3 cp s3://${s3Bucket}/${s3Key} /usr/app/program && chmod +x /usr/app/program && /usr/app/program`
-                // can only run a single command
+                [
+                  `aws s3 cp s3://${s3Bucket}/${s3Key} /usr/app/program`,
+                  `chmod +x /usr/app/program`,
+                  `/usr/app/program`
+                ].join(" && ")
               ],
               environment: Object.entries(data).map(([name2, value]) => ({
                 name: name2,
@@ -7010,25 +7011,11 @@ var createFargateTask = (parentGroup, ctx, ns, id, local) => {
                   appProtocol: "http",
                   containerPort: 80,
                   hostPort: 80
-                },
-                {
-                  name: "https",
-                  protocol: "tcp",
-                  appProtocol: "http",
-                  containerPort: 443,
-                  hostPort: 443
                 }
               ],
-              ...props.restartPolicy && {
-                restartPolicy: {
-                  enabled: props.restartPolicy.enabled,
-                  ...props.restartPolicy.ignoredExitCodes && {
-                    ignoredExitCodes: props.restartPolicy.ignoredExitCodes
-                  },
-                  ...props.restartPolicy.restartAttemptPeriod && {
-                    restartAttemptPeriod: props.restartPolicy.restartAttemptPeriod
-                  }
-                }
+              restartPolicy: {
+                enabled: true,
+                restartAttemptPeriod: 60
               },
               ...logGroup && {
                 logConfiguration: {
@@ -7043,7 +7030,10 @@ var createFargateTask = (parentGroup, ctx, ns, id, local) => {
                 }
               },
               healthCheck: props.healthCheck ? {
-                command: props.healthCheck.command,
+                command: [
+                  "CMD-SHELL",
+                  `curl -f http://${join15("localhost", props.healthCheck.path)} || exit 1`
+                ],
                 interval: toSeconds10(props.healthCheck.interval),
                 retries: props.healthCheck.retries,
                 startPeriod: toSeconds10(props.healthCheck.startPeriod),
@@ -7059,6 +7049,7 @@ var createFargateTask = (parentGroup, ctx, ns, id, local) => {
       dependsOn: [code]
     }
   );
+  return;
   const securityGroup = new $25.aws.security.Group(group, "security-group", {
     name,
     description: "Security group for the instance",
@@ -7074,15 +7065,6 @@ var createFargateTask = (parentGroup, ctx, ns, id, local) => {
     cidrIpv4: "0.0.0.0/0",
     tags
   });
-  new $25.aws.vpc.SecurityGroupIngressRule(group, "ingress-rule-https", {
-    securityGroupId: securityGroup.id,
-    description: `Allow HTTP traffic on port 443 to the ${name} instance`,
-    fromPort: 443,
-    toPort: 443,
-    ipProtocol: "tcp",
-    cidrIpv4: "0.0.0.0/0",
-    tags
-  });
   new $25.aws.vpc.SecurityGroupEgressRule(group, "egress-rule", {
     securityGroupId: securityGroup.id,
     description: `Allow all outbound traffic from the ${name} instance`,
@@ -7090,9 +7072,25 @@ var createFargateTask = (parentGroup, ctx, ns, id, local) => {
     cidrIpv4: "0.0.0.0/0",
     tags
   });
+  const discoveryService = new $25.aws.service.DiscoveryService(group, `service-discovery`, {
+    name: shortId(`${ctx.stack.name}:${id}`),
+    description: `Service discovery for the ${name} instance`,
+    dnsConfig: {
+      namespaceId: ctx.shared.get("instance", "namespace-id"),
+      routingPolicy: "MULTIVALUE",
+      dnsRecords: [
+        {
+          type: "A",
+          ttl: 300
+        }
+      ]
+    },
+    forceDestroy: true,
+    tags
+  });
   const service = new $25.aws.ecs.Service(group, "service", {
-    cluster: ctx.shared.get("instance", "cluster-arn"),
     name,
+    cluster: ctx.shared.get("instance", "cluster-arn"),
     taskDefinition: task2.arn,
     desiredCount: 1,
     launchType: "FARGATE",
@@ -7102,16 +7100,19 @@ var createFargateTask = (parentGroup, ctx, ns, id, local) => {
       assignPublicIp: true
     },
     forceNewDeployment: true,
-    // serviceRegistries: {
-    // 	registryArn: ctx.shared.get('instance', 'namespace'),
-    // },
-    tags
-    // forceDelete: true,
+    forceDelete: true,
+    serviceRegistries: {
+      registryArn: discoveryService.arn
+    },
     // deploymentCircuitBreaker: {
     // 	enable: true,
     // 	rollback: true,
     // },
     // deploymentController: { type: 'ECS' },
+    triggers: {
+      redeployment: (/* @__PURE__ */ new Date()).toISOString()
+    },
+    tags
     // The internal url (dnsName) doesn't work for ldambda's
     // https://github.com/aws/containers-roadmap/issues/1960
     // serviceConnectConfiguration: {
@@ -7146,6 +7147,20 @@ var createFargateTask = (parentGroup, ctx, ns, id, local) => {
 // src/feature/instance/index.ts
 var instanceFeature = defineFeature({
   name: "instance",
+  async onTypeGen(ctx) {
+    const gen = new TypeFile("@awsless/awsless");
+    const resources2 = new TypeObject(1);
+    for (const stack of ctx.stackConfigs) {
+      const list3 = new TypeObject(2);
+      for (const name of Object.keys(stack.instances ?? {})) {
+        const endpoint = `http://${shortId(`${stack.name}:${name}`)}.${ctx.appConfig.name}`;
+        list3.addType(name, `'${endpoint}'`);
+      }
+      resources2.addType(stack.name, list3);
+    }
+    gen.addInterface("InstanceResources", resources2);
+    await ctx.write("instance.d.ts", gen, true);
+  },
   onBefore(ctx) {
     const group = new Group26(ctx.base, "instance", "asset");
     const bucket = new $26.aws.s3.Bucket(group, "bucket", {
@@ -7177,6 +7192,7 @@ var instanceFeature = defineFeature({
       description: `Private DNS namespace for ${ctx.app.name}`
     });
     ctx.shared.set("instance", "namespace", namespace.name);
+    ctx.shared.set("instance", "namespace-id", namespace.id);
   },
   onStack(ctx) {
     for (const [id, props] of Object.entries(ctx.stackConfig.instances ?? {})) {
@@ -8084,13 +8100,13 @@ import wildstring4 from "wildstring";
 import { log as log15 } from "@awsless/clui";
 import chalk4 from "chalk";
 import { mkdir as mkdir4, readFile as readFile6, writeFile as writeFile3 } from "fs/promises";
-import { join as join17 } from "path";
+import { join as join18 } from "path";
 import wildstring3 from "wildstring";
 
 // src/build/__fingerprint.ts
-import { createHash as createHash6 } from "crypto";
+import { createHash as createHash5 } from "crypto";
 import { readdir as readdir4, readFile as readFile5, stat as stat4 } from "fs/promises";
-import { basename as basename4, dirname as dirname10, extname as extname3, join as join15 } from "path";
+import { basename as basename4, dirname as dirname10, extname as extname3, join as join16 } from "path";
 import parseStaticImports from "parse-static-imports";
 var extensions = ["js", "mjs", "jsx", "ts", "mts", "tsx"];
 var generateFileHashes = async (file, hashes) => {
@@ -8099,7 +8115,7 @@ var generateFileHashes = async (file, hashes) => {
   }
   const code = await readModuleFile(file);
   const deps = await findDependencies(file, code);
-  const hash = createHash6("sha1").update(code).digest();
+  const hash = createHash5("sha1").update(code).digest();
   hashes.set(file, hash);
   for (const dep of deps) {
     if (dep.startsWith("/")) {
@@ -8112,11 +8128,11 @@ var fingerprintFromDirectory = async (dir) => {
   const files = await readdir4(dir, { recursive: true });
   for (const file of files) {
     if (extensions.includes(extname3(file).substring(1)) && file.at(0) !== "_") {
-      await generateFileHashes(join15(dir, file), hashes);
+      await generateFileHashes(join16(dir, file), hashes);
     }
   }
   const merge2 = Buffer.concat(Array.from(hashes.values()).sort());
-  return createHash6("sha1").update(merge2).digest("hex");
+  return createHash5("sha1").update(merge2).digest("hex");
 };
 var readModuleFile = (file) => {
   if (file.endsWith(".js")) {
@@ -8126,7 +8142,7 @@ var readModuleFile = (file) => {
     return readFiles([
       file,
       ...extensions.map((exp) => `${file}.${exp}`),
-      ...extensions.map((exp) => join15(file, `/index.${exp}`))
+      ...extensions.map((exp) => join16(file, `/index.${exp}`))
     ]);
   }
   return readFile5(file, "utf8");
@@ -8146,7 +8162,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(".") ? join15(dirname10(file), value) : value);
+  return imports.map((entry) => entry.moduleName).filter(Boolean).map((value) => value?.startsWith(".") ? join16(dirname10(file), value) : value);
 };
 
 // src/test/reporter.ts
@@ -8226,7 +8242,7 @@ var CustomReporter = class {
 import commonjs2 from "@rollup/plugin-commonjs";
 import json2 from "@rollup/plugin-json";
 import nodeResolve2 from "@rollup/plugin-node-resolve";
-import { dirname as dirname11, join as join16 } from "path";
+import { dirname as dirname11, join as join17 } from "path";
 import { swc as swc2 } from "rollup-plugin-swc3";
 import { fileURLToPath as fileURLToPath4 } from "url";
 import { configDefaults } from "vitest/config";
@@ -8248,7 +8264,7 @@ var startTest = async (props) => {
       reporters: props.reporter,
       setupFiles: [
         //
-        join16(__dirname4, "test-global-setup.js")
+        join17(__dirname4, "test-global-setup.js")
       ]
       // globalSetup: [
       // 	//
@@ -8338,7 +8354,7 @@ var logTestErrors = (event) => {
 var runTest = async (stack, dir, filters, opts) => {
   await mkdir4(directories.test, { recursive: true });
   const fingerprint = await fingerprintFromDirectory(dir);
-  const file = join17(directories.test, `${stack}.json`);
+  const file = join18(directories.test, `${stack}.json`);
   const exists = await fileExist(file);
   if (exists && !process.env.NO_CACHE) {
     const raw = await readFile6(file, { encoding: "utf8" });
@@ -8676,7 +8692,7 @@ import { log as log18 } from "@awsless/clui";
 
 // src/type-gen/generate.ts
 import { mkdir as mkdir5, writeFile as writeFile4 } from "fs/promises";
-import { dirname as dirname12, join as join18, relative as relative7 } from "path";
+import { dirname as dirname12, join as join19, relative as relative7 } from "path";
 var generateTypes = async (props) => {
   const files = [];
   await Promise.all(
@@ -8685,7 +8701,7 @@ var generateTypes = async (props) => {
         ...props,
         async write(file, data, include = false) {
           const code = data?.toString("utf8");
-          const path = join18(directories.types, file);
+          const path = join19(directories.types, file);
           if (code) {
             if (include) {
               files.push(relative7(directories.root, path));
@@ -8699,7 +8715,7 @@ var generateTypes = async (props) => {
   );
   if (files.length) {
     const code = files.map((file) => `/// <reference path='${file}' />`).join("\n");
-    await writeFile4(join18(directories.root, `awsless.d.ts`), code);
+    await writeFile4(join19(directories.root, `awsless.d.ts`), code);
   }
 };