cdk-local 0.164.2 → 0.164.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -1,1416 +1,14 @@
1
1
  import { t as __exportAll } from "./rolldown-runtime-w6R9maHv.js";
2
2
  import { c as getEmbedConfig, t as getLogger } from "./logger-uzapot2X.js";
3
- import { r as displayUntrustedValue, u as describeCredentialLoadFailure } from "./assembly-path-CRZKTo_F.js";
4
- import { existsSync, lstatSync, mkdtempSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
3
+ import { A as validateAwsEmulatorEnvVars, B as describeCredentialLoadFailure, C as isRealAwsSentinel, E as realAwsEndpointFor, N as displayUntrustedValue, O as realAwsServicesOf, S as isLegacyAwsEmulatorSentinel, T as readAwsEmulatorEnvVarsFile, X as isLoopbackHostname, _ as MIXED_MODE_RESIGN_PORT, a as buildProxyRequestHandler, c as getAwsEmulatorServiceRouting, h as setAwsEndpointOverride, i as buildProxyClientConfig, m as setAwsEmulatorServiceRouting, u as isAwsServiceRoutedToEmulator, v as REAL_AWS_SENTINEL, w as legacyAwsEmulatorSentinelMessage } from "./aws-proxy-CtjweaLu.js";
4
+ import { existsSync, lstatSync, mkdtempSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
5
5
  import { createHash, generateKeyPairSync, randomBytes, sign } from "node:crypto";
6
- import { Agent, get, request } from "node:http";
7
- import { Agent as Agent$1, get as get$1, request as request$1 } from "node:https";
6
+ import { get } from "node:http";
7
+ import { get as get$1 } from "node:https";
8
8
  import { rootCertificates } from "node:tls";
9
- import { brotliDecompressSync, gunzipSync, inflateSync } from "node:zlib";
10
- import { NodeHttpHandler } from "@smithy/node-http-handler";
11
- import { Agent as Agent$2 } from "agent-base";
12
- import { HttpProxyAgent } from "http-proxy-agent";
13
- import { HttpsProxyAgent } from "https-proxy-agent";
14
- import { getProxyForUrl } from "proxy-from-env";
15
9
  import * as path$1 from "node:path";
16
10
  import { homedir, tmpdir } from "node:os";
17
11
 
18
- //#region src/utils/url-authority.ts
19
- const IPV6_LITERAL_CHARS = /^[0-9A-Fa-f:.]+$/;
20
- function formatHostForAuthority(host) {
21
- const inner = host.length > 1 && host.startsWith("[") && host.endsWith("]") ? host.slice(1, -1) : host;
22
- if (!inner.includes(":")) return host;
23
- const zoneAt = inner.indexOf("%");
24
- const literal = zoneAt === -1 ? inner : inner.slice(0, zoneAt);
25
- if (!IPV6_LITERAL_CHARS.test(literal)) return host;
26
- return `[${literal}]`;
27
- }
28
- function formatAuthority(host, port) {
29
- return `${formatHostForAuthority(host)}:${port}`;
30
- }
31
- function hostFromAuthority(authority) {
32
- if (authority.startsWith("[")) {
33
- const close = authority.indexOf("]");
34
- if (close === -1) return "";
35
- const afterBracket = authority.slice(close + 1);
36
- if (afterBracket !== "" && !/^:\d+$/.test(afterBracket)) return "";
37
- return authority.slice(1, close);
38
- }
39
- const firstColon = authority.indexOf(":");
40
- if (firstColon === -1) return authority;
41
- if (authority.includes(":", firstColon + 1)) return "";
42
- return authority.slice(0, firstColon);
43
- }
44
-
45
- //#endregion
46
- //#region src/utils/loopback-host.ts
47
- function normaliseHostLiteral(hostname) {
48
- return hostname.trim().replace(/^\[/, "").replace(/\]$/, "").toLowerCase();
49
- }
50
- function isLoopbackLiteral(h) {
51
- if (h === "localhost") return true;
52
- if (h === "::1" || h === "0:0:0:0:0:0:0:1") return true;
53
- const mapped = /^::ffff:([0-9a-f]{1,4}):([0-9a-f]{1,4})$/.exec(h);
54
- if (mapped) return parseInt(mapped[1], 16) >> 8 === 127;
55
- const dotted = /^(?:::ffff:)?(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/.exec(h);
56
- if (!dotted) return false;
57
- const octets = dotted.slice(1).map(Number);
58
- if (octets.some((o) => o > 255)) return false;
59
- return octets[0] === 127;
60
- }
61
- function isWildcardLiteral(h) {
62
- return h === "0.0.0.0" || h === "::" || h === "0:0:0:0:0:0:0:0" || h === "::ffff:0.0.0.0" || h === "::ffff:0:0";
63
- }
64
- function isLoopbackHostname(hostname) {
65
- return isLoopbackLiteral(normaliseHostLiteral(hostname));
66
- }
67
- function isWildcardHostname(hostname) {
68
- return isWildcardLiteral(normaliseHostLiteral(hostname));
69
- }
70
- function isLoopbackHost(hostname) {
71
- const h = normaliseHostLiteral(hostname).replace(/\.$/, "");
72
- return h.endsWith(".localhost") || isLoopbackLiteral(h) || isWildcardLiteral(h);
73
- }
74
-
75
- //#endregion
76
- //#region src/utils/own-keys.ts
77
- function defineOwnKey(target, key, value) {
78
- Object.defineProperty(target, key, {
79
- value,
80
- writable: true,
81
- enumerable: true,
82
- configurable: true
83
- });
84
- }
85
-
86
- //#endregion
87
- //#region src/local/env-resolver.ts
88
- const pipeTexts = /* @__PURE__ */ new Map();
89
- function readEnvVarsFileText(filePath) {
90
- let regular = !/^\/(?:dev|proc)\//.test(path$1.resolve(filePath));
91
- try {
92
- regular &&= statSync(filePath).isFile();
93
- } catch {}
94
- if (regular) return readFileSync(filePath, "utf-8");
95
- const kept = pipeTexts.get(filePath);
96
- if (kept !== void 0) return kept;
97
- const text = readFileSync(filePath, "utf-8");
98
- pipeTexts.set(filePath, text);
99
- return text;
100
- }
101
- function resolveEnvVars(logicalId, displayPath, templateEnv, overrides) {
102
- const resolved = {};
103
- const unresolved = [];
104
- if (templateEnv) for (const [key, value] of Object.entries(templateEnv)) if (isLiteralEnvValue(value)) defineOwnKey(resolved, key, String(value));
105
- else unresolved.push(key);
106
- if (overrides) {
107
- applyEnvOverrideMap(resolved, overrides.Parameters);
108
- for (const [key, val] of Object.entries(overrides)) {
109
- if (key === "Parameters") continue;
110
- if (!val || typeof val !== "object") continue;
111
- if (key === logicalId) {
112
- applyEnvOverrideMap(resolved, val);
113
- continue;
114
- }
115
- if (displayPath && (displayPath === key || displayPath.startsWith(`${key}/`))) applyEnvOverrideMap(resolved, val);
116
- }
117
- }
118
- return {
119
- resolved,
120
- unresolved
121
- };
122
- }
123
- function applyEnvOverrideMap(acc, map) {
124
- if (!map) return;
125
- for (const [key, value] of Object.entries(map)) if (value === null) delete acc[key];
126
- else if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") defineOwnKey(acc, key, String(value));
127
- }
128
- function isLiteralEnvValue(value) {
129
- return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
130
- }
131
-
132
- //#endregion
133
- //#region src/local/aws-endpoint-service-ids.ts
134
- const AWS_ENDPOINT_SERVICE_IDS = /* @__PURE__ */ new Set([
135
- "ACCESSANALYZER",
136
- "ACCOUNT",
137
- "ACCOUNT_ACCESS",
138
- "ACM",
139
- "ACM_PCA",
140
- "AGENTTOOLKIT",
141
- "AGENT_REGISTRY",
142
- "AGENT_REGISTRY_CONTROL",
143
- "AIOPS",
144
- "AMP",
145
- "AMPLIFY",
146
- "AMPLIFYBACKEND",
147
- "AMPLIFYUIBUILDER",
148
- "APIGATEWAYMANAGEMENTAPI",
149
- "APIGATEWAYV2",
150
- "API_GATEWAY",
151
- "APPCONFIG",
152
- "APPCONFIGDATA",
153
- "APPFABRIC",
154
- "APPFLOW",
155
- "APPINTEGRATIONS",
156
- "APPLICATIONCOSTPROFILER",
157
- "APPLICATION_AUTO_SCALING",
158
- "APPLICATION_DISCOVERY_SERVICE",
159
- "APPLICATION_INSIGHTS",
160
- "APPLICATION_SIGNALS",
161
- "APPRUNNER",
162
- "APPSTREAM",
163
- "APPSYNC",
164
- "APP_MESH",
165
- "ARC_REGION_SWITCH",
166
- "ARC_ZONAL_SHIFT",
167
- "ARTIFACT",
168
- "ATHENA",
169
- "AUDITMANAGER",
170
- "AUTO_SCALING",
171
- "AUTO_SCALING_PLANS",
172
- "B2BI",
173
- "BACKUP",
174
- "BACKUPSEARCH",
175
- "BACKUP_GATEWAY",
176
- "BATCH",
177
- "BCM_DASHBOARDS",
178
- "BCM_DATA_EXPORTS",
179
- "BCM_PRICING_CALCULATOR",
180
- "BCM_RECOMMENDED_ACTIONS",
181
- "BEDROCK",
182
- "BEDROCK_AGENT",
183
- "BEDROCK_AGENTCORE",
184
- "BEDROCK_AGENTCORE_CONTROL",
185
- "BEDROCK_AGENT_RUNTIME",
186
- "BEDROCK_DATA_AUTOMATION",
187
- "BEDROCK_DATA_AUTOMATION_RUNTIME",
188
- "BEDROCK_RUNTIME",
189
- "BILLING",
190
- "BILLINGCONDUCTOR",
191
- "BRAKET",
192
- "BUDGETS",
193
- "CHATBOT",
194
- "CHIME",
195
- "CHIME_SDK_IDENTITY",
196
- "CHIME_SDK_MEDIA_PIPELINES",
197
- "CHIME_SDK_MEETINGS",
198
- "CHIME_SDK_MESSAGING",
199
- "CHIME_SDK_VOICE",
200
- "CLEANROOMS",
201
- "CLEANROOMSML",
202
- "CLOUD9",
203
- "CLOUDCONTROL",
204
- "CLOUDDIRECTORY",
205
- "CLOUDFORMATION",
206
- "CLOUDFRONT",
207
- "CLOUDFRONT_KEYVALUESTORE",
208
- "CLOUDHSM",
209
- "CLOUDHSM_V2",
210
- "CLOUDSEARCH",
211
- "CLOUDSEARCH_DOMAIN",
212
- "CLOUDTRAIL",
213
- "CLOUDTRAIL_DATA",
214
- "CLOUDWATCH",
215
- "CLOUDWATCHOMNI",
216
- "CLOUDWATCH_LOGS",
217
- "CODEARTIFACT",
218
- "CODEBUILD",
219
- "CODECATALYST",
220
- "CODECOMMIT",
221
- "CODECONNECTIONS",
222
- "CODEDEPLOY",
223
- "CODEGURUPROFILER",
224
- "CODEGURU_REVIEWER",
225
- "CODEGURU_SECURITY",
226
- "CODEPIPELINE",
227
- "CODESTAR_CONNECTIONS",
228
- "CODESTAR_NOTIFICATIONS",
229
- "COGNITO_IDENTITY",
230
- "COGNITO_IDENTITY_PROVIDER",
231
- "COGNITO_SYNC",
232
- "COMPREHEND",
233
- "COMPREHENDMEDICAL",
234
- "COMPUTE_OPTIMIZER",
235
- "COMPUTE_OPTIMIZER_AUTOMATION",
236
- "CONFIG_SERVICE",
237
- "CONNECT",
238
- "CONNECTCAMPAIGNS",
239
- "CONNECTCAMPAIGNSV2",
240
- "CONNECTCASES",
241
- "CONNECTHEALTH",
242
- "CONNECTPARTICIPANT",
243
- "CONNECT_CONTACT_LENS",
244
- "CONTROLCATALOG",
245
- "CONTROLTOWER",
246
- "COST_AND_USAGE_REPORT_SERVICE",
247
- "COST_EXPLORER",
248
- "COST_OPTIMIZATION_HUB",
249
- "CUSTOMER_PROFILES",
250
- "DATABASE_MIGRATION_SERVICE",
251
- "DATABREW",
252
- "DATAEXCHANGE",
253
- "DATASYNC",
254
- "DATAZONE",
255
- "DATA_PIPELINE",
256
- "DAX",
257
- "DEADLINE",
258
- "DETECTIVE",
259
- "DEVICE_FARM",
260
- "DEVOPS_AGENT",
261
- "DEVOPS_GURU",
262
- "DIRECTORY_SERVICE",
263
- "DIRECTORY_SERVICE_DATA",
264
- "DIRECT_CONNECT",
265
- "DLM",
266
- "DOCDB",
267
- "DOCDB_ELASTIC",
268
- "DRS",
269
- "DSQL",
270
- "DYNAMODB",
271
- "DYNAMODB_STREAMS",
272
- "EBS",
273
- "EC2",
274
- "EC2_INSTANCE_CONNECT",
275
- "ECR",
276
- "ECR_PUBLIC",
277
- "ECS",
278
- "EFS",
279
- "EKS",
280
- "EKS_AUTH",
281
- "ELASTICACHE",
282
- "ELASTICSEARCH_SERVICE",
283
- "ELASTIC_BEANSTALK",
284
- "ELASTIC_LOAD_BALANCING",
285
- "ELASTIC_LOAD_BALANCING_V2",
286
- "ELEMENTALINFERENCE",
287
- "EMR",
288
- "EMR_CONTAINERS",
289
- "EMR_SERVERLESS",
290
- "ENDUSERMESSAGING",
291
- "ENTITYRESOLUTION",
292
- "EVENTBRIDGE",
293
- "EVENTBRIDGEV2",
294
- "EVS",
295
- "FIREHOSE",
296
- "FIS",
297
- "FMS",
298
- "FORECAST",
299
- "FORECASTQUERY",
300
- "FRAUDDETECTOR",
301
- "FREETIER",
302
- "FSX",
303
- "GAMELIFT",
304
- "GAMELIFTSTREAMS",
305
- "GEO_MAPS",
306
- "GEO_PLACES",
307
- "GEO_ROUTES",
308
- "GLACIER",
309
- "GLOBAL_ACCELERATOR",
310
- "GLUE",
311
- "GRAFANA",
312
- "GREENGRASS",
313
- "GREENGRASSV2",
314
- "GROUNDSTATION",
315
- "GUARDDUTY",
316
- "HEALTH",
317
- "HEALTHLAKE",
318
- "IAM",
319
- "IAM_TOOLBOX",
320
- "IDENTITYSTORE",
321
- "IMAGEBUILDER",
322
- "IMPORTEXPORT",
323
- "INSPECTOR",
324
- "INSPECTOR2",
325
- "INSPECTOR_SCAN",
326
- "INTERCONNECT",
327
- "INTERNETMONITOR",
328
- "INVOICING",
329
- "IOT",
330
- "IOTDEVICEADVISOR",
331
- "IOTFLEETWISE",
332
- "IOTSECURETUNNELING",
333
- "IOTSITEWISE",
334
- "IOTTHINGSGRAPH",
335
- "IOTTWINMAKER",
336
- "IOT_DATA_PLANE",
337
- "IOT_JOBS_DATA_PLANE",
338
- "IOT_MANAGED_INTEGRATIONS",
339
- "IOT_WIRELESS",
340
- "IVS",
341
- "IVSCHAT",
342
- "IVS_REALTIME",
343
- "KAFKA",
344
- "KAFKACONNECT",
345
- "KENDRA",
346
- "KENDRA_RANKING",
347
- "KEYSPACES",
348
- "KEYSPACESSTREAMS",
349
- "KINESIS",
350
- "KINESIS_ANALYTICS",
351
- "KINESIS_ANALYTICS_V2",
352
- "KINESIS_VIDEO",
353
- "KINESIS_VIDEO_ARCHIVED_MEDIA",
354
- "KINESIS_VIDEO_MEDIA",
355
- "KINESIS_VIDEO_SIGNALING",
356
- "KINESIS_VIDEO_WEBRTC_STORAGE",
357
- "KMS",
358
- "LAKEFORMATION",
359
- "LAMBDA",
360
- "LAMBDA_CORE",
361
- "LAMBDA_MICROVMS",
362
- "LAMBDA_WEB",
363
- "LAUNCH_WIZARD",
364
- "LEX_MODELS_V2",
365
- "LEX_MODEL_BUILDING_SERVICE",
366
- "LEX_RUNTIME_SERVICE",
367
- "LEX_RUNTIME_V2",
368
- "LICENSE_MANAGER",
369
- "LICENSE_MANAGER_LINUX_SUBSCRIPTIONS",
370
- "LICENSE_MANAGER_USER_SUBSCRIPTIONS",
371
- "LIGHTSAIL",
372
- "LOCATION",
373
- "LOOKOUTEQUIPMENT",
374
- "M2",
375
- "MACHINE_LEARNING",
376
- "MACIE2",
377
- "MAILMANAGER",
378
- "MANAGEDBLOCKCHAIN",
379
- "MANAGEDBLOCKCHAIN_QUERY",
380
- "MARKETPLACE_AGREEMENT",
381
- "MARKETPLACE_CATALOG",
382
- "MARKETPLACE_COMMERCE_ANALYTICS",
383
- "MARKETPLACE_DEPLOYMENT",
384
- "MARKETPLACE_DISCOVERY",
385
- "MARKETPLACE_ENTITLEMENT_SERVICE",
386
- "MARKETPLACE_METERING",
387
- "MARKETPLACE_REPORTING",
388
- "MEDIACONNECT",
389
- "MEDIACONVERT",
390
- "MEDIALIVE",
391
- "MEDIAPACKAGE",
392
- "MEDIAPACKAGEV2",
393
- "MEDIAPACKAGE_VOD",
394
- "MEDIASTORE",
395
- "MEDIASTORE_DATA",
396
- "MEDIATAILOR",
397
- "MEDICAL_IMAGING",
398
- "MEMORYDB",
399
- "MGN",
400
- "MIGRATIONHUBORCHESTRATOR",
401
- "MIGRATIONHUBSTRATEGY",
402
- "MIGRATIONHUB_CONFIG",
403
- "MIGRATION_HUB",
404
- "MIGRATION_HUB_REFACTOR_SPACES",
405
- "MPA",
406
- "MQ",
407
- "MTURK",
408
- "MWAA",
409
- "MWAA_SERVERLESS",
410
- "NEPTUNE",
411
- "NEPTUNEDATA",
412
- "NEPTUNE_GRAPH",
413
- "NETWORKFLOWMONITOR",
414
- "NETWORKMANAGER",
415
- "NETWORKMONITOR",
416
- "NETWORK_FIREWALL",
417
- "NETWORK_SECURITY_MANAGER",
418
- "NOTIFICATIONS",
419
- "NOTIFICATIONSCONTACTS",
420
- "NOVA_ACT",
421
- "OAM",
422
- "OBSERVABILITYADMIN",
423
- "ODB",
424
- "OMICS",
425
- "OPENSEARCH",
426
- "OPENSEARCHSERVERLESS",
427
- "ORGANIZATIONS",
428
- "OSIS",
429
- "OUTPOSTS",
430
- "PARTNERCENTRAL_ACCOUNT",
431
- "PARTNERCENTRAL_BENEFITS",
432
- "PARTNERCENTRAL_CHANNEL",
433
- "PARTNERCENTRAL_REVENUE_MEASUREMENT",
434
- "PARTNERCENTRAL_SELLING",
435
- "PAYMENT_CRYPTOGRAPHY",
436
- "PAYMENT_CRYPTOGRAPHY_DATA",
437
- "PCA_CONNECTOR_AD",
438
- "PCA_CONNECTOR_SCEP",
439
- "PCS",
440
- "PERSONALIZE",
441
- "PERSONALIZE_EVENTS",
442
- "PERSONALIZE_RUNTIME",
443
- "PI",
444
- "PINPOINT",
445
- "PINPOINT_EMAIL",
446
- "PINPOINT_SMS_VOICE",
447
- "PINPOINT_SMS_VOICE_V2",
448
- "PIPES",
449
- "POLLY",
450
- "PRICING",
451
- "PRICING_PLAN_MANAGER",
452
- "PROTON",
453
- "QAPPS",
454
- "QBUSINESS",
455
- "QCONNECT",
456
- "QUICKSIGHT",
457
- "RAM",
458
- "RBIN",
459
- "RDS",
460
- "RDS_DATA",
461
- "REDSHIFT",
462
- "REDSHIFT_DATA",
463
- "REDSHIFT_SERVERLESS",
464
- "REKOGNITION",
465
- "REPOSTSPACE",
466
- "RESILIENCEHUB",
467
- "RESILIENCEHUBV2",
468
- "RESOURCE_EXPLORER_2",
469
- "RESOURCE_GROUPS",
470
- "RESOURCE_GROUPS_TAGGING_API",
471
- "ROLESANYWHERE",
472
- "ROUTE53GLOBALRESOLVER",
473
- "ROUTE53PROFILES",
474
- "ROUTE53RESOLVER",
475
- "ROUTE53_RECOVERY_CLUSTER",
476
- "ROUTE53_RECOVERY_CONTROL_CONFIG",
477
- "ROUTE53_RECOVERY_READINESS",
478
- "ROUTE_53",
479
- "ROUTE_53_DOMAINS",
480
- "RTBFABRIC",
481
- "RUM",
482
- "S3",
483
- "S3FILES",
484
- "S3OUTPOSTS",
485
- "S3TABLES",
486
- "S3VECTORS",
487
- "S3_CONTROL",
488
- "SAGEMAKER",
489
- "SAGEMAKERJOBRUNTIME",
490
- "SAGEMAKERTRAININGSESSIONRUNTIME",
491
- "SAGEMAKER_A2I_RUNTIME",
492
- "SAGEMAKER_EDGE",
493
- "SAGEMAKER_FEATURESTORE_RUNTIME",
494
- "SAGEMAKER_GEOSPATIAL",
495
- "SAGEMAKER_METRICS",
496
- "SAGEMAKER_RUNTIME",
497
- "SAVINGSPLANS",
498
- "SCHEDULER",
499
- "SCHEMAS",
500
- "SECRETS_MANAGER",
501
- "SECURITYAGENT",
502
- "SECURITYHUB",
503
- "SECURITYLAKE",
504
- "SECURITY_IR",
505
- "SERVERLESSAPPLICATIONREPOSITORY",
506
- "SERVICEDISCOVERY",
507
- "SERVICE_CATALOG",
508
- "SERVICE_CATALOG_APPREGISTRY",
509
- "SERVICE_QUOTAS",
510
- "SES",
511
- "SESV2",
512
- "SFN",
513
- "SHIELD",
514
- "SIGNER",
515
- "SIGNER_DATA",
516
- "SIGNIN",
517
- "SIMPLEDB",
518
- "SIMPLEDBV2",
519
- "SNOWBALL",
520
- "SNOW_DEVICE_MANAGEMENT",
521
- "SNS",
522
- "SOCIALMESSAGING",
523
- "SQS",
524
- "SSM",
525
- "SSM_CONTACTS",
526
- "SSM_GUICONNECT",
527
- "SSM_INCIDENTS",
528
- "SSM_QUICKSETUP",
529
- "SSM_SAP",
530
- "SSO",
531
- "SSO_ADMIN",
532
- "SSO_OIDC",
533
- "STORAGE_GATEWAY",
534
- "STS",
535
- "SUPPLYCHAIN",
536
- "SUPPORT",
537
- "SUPPORTAUTHZ",
538
- "SUPPORT_APP",
539
- "SUSTAINABILITY",
540
- "SWF",
541
- "SYNTHETICS",
542
- "TAXSETTINGS",
543
- "TEXTRACT",
544
- "TIMESTREAM_INFLUXDB",
545
- "TIMESTREAM_QUERY",
546
- "TIMESTREAM_WRITE",
547
- "TRANSCRIBE",
548
- "TRANSFER",
549
- "TRANSLATE",
550
- "TRUSTEDADVISOR",
551
- "UXC",
552
- "VERIFIEDPERMISSIONS",
553
- "VOICE_ID",
554
- "VPC_LATTICE",
555
- "WAF",
556
- "WAFV2",
557
- "WAF_REGIONAL",
558
- "WELLARCHITECTED",
559
- "WICKR",
560
- "WISDOM",
561
- "WORKDOCS",
562
- "WORKMAIL",
563
- "WORKMAILMESSAGEFLOW",
564
- "WORKSPACES",
565
- "WORKSPACES_INSTANCES",
566
- "WORKSPACES_THIN_CLIENT",
567
- "WORKSPACES_WEB",
568
- "XRAY"
569
- ]);
570
-
571
- //#endregion
572
- //#region src/local/aws-real-endpoints.ts
573
- const AWS_ENDPOINT_PREFIX_OVERRIDES = {
574
- ACCESSANALYZER: "access-analyzer",
575
- ACCOUNT_ACCESS: "account-access",
576
- ACM_PCA: "acm-pca",
577
- AGENT_REGISTRY: "agent-registry",
578
- AGENT_REGISTRY_CONTROL: "agent-registry-control",
579
- AMP: "aps",
580
- APIGATEWAYMANAGEMENTAPI: "execute-api",
581
- APIGATEWAYV2: "apigateway",
582
- APPINTEGRATIONS: "app-integrations",
583
- APPLICATIONCOSTPROFILER: "application-cost-profiler",
584
- APPLICATION_AUTO_SCALING: "application-autoscaling",
585
- APPLICATION_DISCOVERY_SERVICE: "discovery",
586
- APPLICATION_SIGNALS: "application-signals",
587
- APPSTREAM: "appstream2",
588
- ARC_REGION_SWITCH: "arc-region-switch",
589
- ARC_ZONAL_SHIFT: "arc-zonal-shift",
590
- AUTO_SCALING_PLANS: "autoscaling-plans",
591
- BACKUPSEARCH: "backup-search",
592
- BACKUP_GATEWAY: "backup-gateway",
593
- BCM_DASHBOARDS: "bcm-dashboards",
594
- BCM_DATA_EXPORTS: "bcm-data-exports",
595
- BCM_PRICING_CALCULATOR: "bcm-pricing-calculator",
596
- BCM_RECOMMENDED_ACTIONS: "bcm-recommended-actions",
597
- BEDROCK_AGENT: "bedrock-agent",
598
- BEDROCK_AGENTCORE: "bedrock-agentcore",
599
- BEDROCK_AGENTCORE_CONTROL: "bedrock-agentcore-control",
600
- BEDROCK_AGENT_RUNTIME: "bedrock-agent-runtime",
601
- BEDROCK_DATA_AUTOMATION: "bedrock-data-automation",
602
- BEDROCK_DATA_AUTOMATION_RUNTIME: "bedrock-data-automation-runtime",
603
- BEDROCK_RUNTIME: "bedrock-runtime",
604
- CHIME_SDK_IDENTITY: "identity-chime",
605
- CHIME_SDK_MEDIA_PIPELINES: "media-pipelines-chime",
606
- CHIME_SDK_MEETINGS: "meetings-chime",
607
- CHIME_SDK_MESSAGING: "messaging-chime",
608
- CHIME_SDK_VOICE: "voice-chime",
609
- CLEANROOMSML: "cleanrooms-ml",
610
- CLOUDCONTROL: "cloudcontrolapi",
611
- CLOUDFRONT_KEYVALUESTORE: "cloudfront-keyvaluestore",
612
- CLOUDTRAIL_DATA: "cloudtrail-data",
613
- CLOUDWATCH: "monitoring",
614
- CLOUDWATCHOMNI: "cloudwatch-omni",
615
- CLOUDWATCH_LOGS: "logs",
616
- CODEGURUPROFILER: "codeguru-profiler",
617
- CODEGURU_REVIEWER: "codeguru-reviewer",
618
- CODEGURU_SECURITY: "codeguru-security",
619
- CODESTAR_CONNECTIONS: "codestar-connections",
620
- CODESTAR_NOTIFICATIONS: "codestar-notifications",
621
- COGNITO_IDENTITY: "cognito-identity",
622
- COGNITO_IDENTITY_PROVIDER: "cognito-idp",
623
- COGNITO_SYNC: "cognito-sync",
624
- COMPUTE_OPTIMIZER: "compute-optimizer",
625
- COMPUTE_OPTIMIZER_AUTOMATION: "aco-automation",
626
- CONFIG_SERVICE: "config",
627
- CONNECTCAMPAIGNS: "connect-campaigns",
628
- CONNECTCAMPAIGNSV2: "connect-campaigns",
629
- CONNECTCASES: "cases",
630
- CONNECTHEALTH: "health-agent",
631
- CONNECTPARTICIPANT: "participant.connect",
632
- CONNECT_CONTACT_LENS: "contact-lens",
633
- COST_AND_USAGE_REPORT_SERVICE: "cur",
634
- COST_EXPLORER: "ce",
635
- COST_OPTIMIZATION_HUB: "cost-optimization-hub",
636
- CUSTOMER_PROFILES: "profile",
637
- DATABASE_MIGRATION_SERVICE: "dms",
638
- DETECTIVE: "api.detective",
639
- DEVOPS_AGENT: "aidevops",
640
- DEVOPS_GURU: "devops-guru",
641
- DIRECTORY_SERVICE: "ds",
642
- DIRECTORY_SERVICE_DATA: "ds-data",
643
- DOCDB: "rds",
644
- DOCDB_ELASTIC: "docdb-elastic",
645
- DYNAMODB_STREAMS: "streams.dynamodb",
646
- EC2_INSTANCE_CONNECT: "ec2-instance-connect",
647
- ECR: "api.ecr",
648
- ECR_PUBLIC: "api.ecr-public",
649
- EFS: "elasticfilesystem",
650
- EKS_AUTH: "eks-auth",
651
- ELASTICSEARCH_SERVICE: "es",
652
- ELASTIC_LOAD_BALANCING_V2: "elasticloadbalancing",
653
- ELEMENTALINFERENCE: "elemental-inference",
654
- EMR: "elasticmapreduce",
655
- EMR_CONTAINERS: "emr-containers",
656
- EMR_SERVERLESS: "emr-serverless",
657
- ENDUSERMESSAGING: "end-user-messaging",
658
- EVENTBRIDGE: "events",
659
- EVENTBRIDGEV2: "eventsv2",
660
- GEO_MAPS: "geo-maps",
661
- GEO_PLACES: "geo-places",
662
- GEO_ROUTES: "geo-routes",
663
- GREENGRASSV2: "greengrass",
664
- IAM_TOOLBOX: "iam-toolbox",
665
- INSPECTOR_SCAN: "inspector-scan",
666
- IOTDEVICEADVISOR: "api.iotdeviceadvisor",
667
- IOTSECURETUNNELING: "api.tunneling.iot",
668
- IOT_DATA_PLANE: "data-ats.iot",
669
- IOT_JOBS_DATA_PLANE: "data.jobs.iot",
670
- IOT_MANAGED_INTEGRATIONS: "api.iotmanagedintegrations",
671
- IOT_WIRELESS: "api.iotwireless",
672
- KENDRA_RANKING: "kendra-ranking",
673
- KEYSPACES: "cassandra",
674
- KEYSPACESSTREAMS: "cassandra-streams",
675
- KINESIS_ANALYTICS_V2: "kinesisanalytics",
676
- KINESIS_VIDEO_ARCHIVED_MEDIA: "kinesisvideo",
677
- KINESIS_VIDEO_MEDIA: "kinesisvideo",
678
- KINESIS_VIDEO_SIGNALING: "kinesisvideo",
679
- KINESIS_VIDEO_WEBRTC_STORAGE: "kinesisvideo",
680
- LAMBDA_CORE: "lambda",
681
- LAMBDA_MICROVMS: "lambda",
682
- LAMBDA_WEB: "lambda",
683
- LEX_MODELS_V2: "models-v2-lex",
684
- LEX_MODEL_BUILDING_SERVICE: "models.lex",
685
- LEX_RUNTIME_SERVICE: "runtime.lex",
686
- LEX_RUNTIME_V2: "runtime-v2-lex",
687
- LICENSE_MANAGER: "license-manager",
688
- LICENSE_MANAGER_LINUX_SUBSCRIPTIONS: "license-manager-linux-subscriptions",
689
- LICENSE_MANAGER_USER_SUBSCRIPTIONS: "license-manager-user-subscriptions",
690
- LOCATION: "geo",
691
- MAILMANAGER: "mail-manager",
692
- MANAGEDBLOCKCHAIN_QUERY: "managedblockchain-query",
693
- MARKETPLACE_AGREEMENT: "agreement-marketplace",
694
- MARKETPLACE_CATALOG: "catalog.marketplace",
695
- MARKETPLACE_DEPLOYMENT: "deployment-marketplace",
696
- MARKETPLACE_DISCOVERY: "discovery-marketplace",
697
- MARKETPLACE_ENTITLEMENT_SERVICE: "entitlement.marketplace",
698
- MARKETPLACE_METERING: "metering.marketplace",
699
- MARKETPLACE_REPORTING: "reporting-marketplace",
700
- MEDIAPACKAGE_VOD: "mediapackage-vod",
701
- MEDIASTORE_DATA: "data.mediastore",
702
- MEDIATAILOR: "api.mediatailor",
703
- MEDICAL_IMAGING: "medical-imaging",
704
- MEMORYDB: "memory-db",
705
- MIGRATIONHUBORCHESTRATOR: "migrationhub-orchestrator",
706
- MIGRATIONHUBSTRATEGY: "migrationhub-strategy",
707
- MIGRATIONHUB_CONFIG: "migrationhub-config",
708
- MIGRATION_HUB: "mgh",
709
- MIGRATION_HUB_REFACTOR_SPACES: "refactor-spaces",
710
- MTURK: "mturk-requester",
711
- MWAA: "airflow",
712
- MWAA_SERVERLESS: "airflow-serverless",
713
- NEPTUNE: "rds",
714
- NEPTUNEDATA: "neptune-db",
715
- NEPTUNE_GRAPH: "neptune-graph",
716
- NETWORK_FIREWALL: "network-firewall",
717
- NETWORK_SECURITY_MANAGER: "network-security-manager",
718
- NOTIFICATIONSCONTACTS: "notifications-contacts",
719
- NOVA_ACT: "nova-act",
720
- OPENSEARCH: "es",
721
- OPENSEARCHSERVERLESS: "aoss",
722
- PARTNERCENTRAL_ACCOUNT: "partnercentral-account",
723
- PARTNERCENTRAL_BENEFITS: "partnercentral-benefits",
724
- PARTNERCENTRAL_CHANNEL: "partnercentral-channel",
725
- PARTNERCENTRAL_REVENUE_MEASUREMENT: "partnercentral-prm",
726
- PARTNERCENTRAL_SELLING: "partnercentral-selling",
727
- PAYMENT_CRYPTOGRAPHY: "controlplane.payment-cryptography",
728
- PAYMENT_CRYPTOGRAPHY_DATA: "dataplane.payment-cryptography",
729
- PCA_CONNECTOR_AD: "pca-connector-ad",
730
- PCA_CONNECTOR_SCEP: "pca-connector-scep",
731
- PERSONALIZE_EVENTS: "personalize-events",
732
- PERSONALIZE_RUNTIME: "personalize-runtime",
733
- PINPOINT_EMAIL: "email",
734
- PINPOINT_SMS_VOICE: "sms-voice.pinpoint",
735
- PINPOINT_SMS_VOICE_V2: "sms-voice",
736
- PRICING: "api.pricing",
737
- QAPPS: "data.qapps",
738
- QCONNECT: "wisdom",
739
- RDS_DATA: "rds-data",
740
- REDSHIFT_DATA: "redshift-data",
741
- REDSHIFT_SERVERLESS: "redshift-serverless",
742
- RESILIENCEHUBV2: "resiliencehub",
743
- RESOURCE_EXPLORER_2: "resource-explorer-2",
744
- RESOURCE_GROUPS: "resource-groups",
745
- RESOURCE_GROUPS_TAGGING_API: "tagging",
746
- ROUTE53_RECOVERY_CLUSTER: "route53-recovery-cluster",
747
- ROUTE53_RECOVERY_CONTROL_CONFIG: "route53-recovery-control-config",
748
- ROUTE53_RECOVERY_READINESS: "route53-recovery-readiness",
749
- S3OUTPOSTS: "s3-outposts",
750
- S3_CONTROL: "s3-control",
751
- SAGEMAKER: "api.sagemaker",
752
- SAGEMAKERJOBRUNTIME: "job-runtime.sagemaker",
753
- SAGEMAKERTRAININGSESSIONRUNTIME: "training-session-runtime.sagemaker",
754
- SAGEMAKER_A2I_RUNTIME: "a2i-runtime.sagemaker",
755
- SAGEMAKER_EDGE: "edge.sagemaker",
756
- SAGEMAKER_FEATURESTORE_RUNTIME: "featurestore-runtime.sagemaker",
757
- SAGEMAKER_GEOSPATIAL: "sagemaker-geospatial",
758
- SAGEMAKER_METRICS: "metrics.sagemaker",
759
- SAGEMAKER_RUNTIME: "runtime.sagemaker",
760
- SECURITY_IR: "security-ir",
761
- SERVERLESSAPPLICATIONREPOSITORY: "serverlessrepo",
762
- SERVICE_CATALOG_APPREGISTRY: "servicecatalog-appregistry",
763
- SES: "email",
764
- SESV2: "email",
765
- SFN: "states",
766
- SIGNER_DATA: "data-signer",
767
- SIMPLEDB: "sdb",
768
- SIMPLEDBV2: "sdb",
769
- SNOW_DEVICE_MANAGEMENT: "snow-device-management",
770
- SOCIALMESSAGING: "social-messaging",
771
- SSM_CONTACTS: "ssm-contacts",
772
- SSM_GUICONNECT: "ssm-guiconnect",
773
- SSM_INCIDENTS: "ssm-incidents",
774
- SSM_QUICKSETUP: "ssm-quicksetup",
775
- SSM_SAP: "ssm-sap",
776
- SSO: "portal.sso",
777
- SSO_ADMIN: "sso",
778
- SSO_OIDC: "oidc",
779
- SUPPLYCHAIN: "scn",
780
- TAXSETTINGS: "tax",
781
- TIMESTREAM_INFLUXDB: "timestream-influxdb",
782
- TIMESTREAM_QUERY: "query.timestream",
783
- TIMESTREAM_WRITE: "ingest.timestream",
784
- VPC_LATTICE: "vpc-lattice",
785
- WAF_REGIONAL: "waf-regional",
786
- WICKR: "admin.wickr",
787
- WORKSPACES_INSTANCES: "workspaces-instances",
788
- WORKSPACES_THIN_CLIENT: "thinclient",
789
- WORKSPACES_WEB: "workspaces-web"
790
- };
791
- const AWS_GLOBAL_ENDPOINTS = {
792
- account: {
793
- hostname: "account.us-east-1.amazonaws.com",
794
- signingRegion: "us-east-1"
795
- },
796
- billingconductor: {
797
- hostname: "billingconductor.us-east-1.amazonaws.com",
798
- signingRegion: "us-east-1"
799
- },
800
- budgets: {
801
- hostname: "budgets.amazonaws.com",
802
- signingRegion: "us-east-1"
803
- },
804
- ce: {
805
- hostname: "ce.us-east-1.amazonaws.com",
806
- signingRegion: "us-east-1"
807
- },
808
- chime: {
809
- hostname: "chime.us-east-1.amazonaws.com",
810
- signingRegion: "us-east-1"
811
- },
812
- cloudfront: {
813
- hostname: "cloudfront.amazonaws.com",
814
- signingRegion: "us-east-1"
815
- },
816
- health: {
817
- hostname: "global.health.amazonaws.com",
818
- signingRegion: "us-east-1"
819
- },
820
- iam: {
821
- hostname: "iam.amazonaws.com",
822
- signingRegion: "us-east-1"
823
- },
824
- importexport: {
825
- hostname: "importexport.amazonaws.com",
826
- signingRegion: "us-east-1"
827
- },
828
- networkmanager: {
829
- hostname: "networkmanager.us-west-2.amazonaws.com",
830
- signingRegion: "us-west-2"
831
- },
832
- "notifications-contacts": {
833
- hostname: "notifications-contacts.us-east-1.api.aws",
834
- signingRegion: "us-east-1"
835
- },
836
- organizations: {
837
- hostname: "organizations.us-east-1.amazonaws.com",
838
- signingRegion: "us-east-1"
839
- },
840
- route53: {
841
- hostname: "route53.amazonaws.com",
842
- signingRegion: "us-east-1"
843
- },
844
- savingsplans: {
845
- hostname: "savingsplans.amazonaws.com",
846
- signingRegion: "us-east-1"
847
- },
848
- shield: {
849
- hostname: "shield.us-east-1.amazonaws.com",
850
- signingRegion: "us-east-1"
851
- },
852
- tax: {
853
- hostname: "tax.us-east-1.amazonaws.com",
854
- signingRegion: "us-east-1"
855
- },
856
- waf: {
857
- hostname: "waf.amazonaws.com",
858
- signingRegion: "us-east-1"
859
- }
860
- };
861
-
862
- //#endregion
863
- //#region src/local/aws-emulator-mixed-mode.ts
864
- const REAL_AWS_SENTINEL = "real-aws";
865
- const LEGACY_AWS_EMULATOR_SENTINEL = "aws-emulator";
866
- const MIXED_MODE_RESIGN_PORT = 47297;
867
- const ENDPOINT_KEY = /^AWS_ENDPOINT_URL(?:_([A-Z0-9_]+))?$/;
868
- function isSentinel(key, value, sentinel) {
869
- return typeof value === "string" && value.trim() === sentinel && ENDPOINT_KEY.test(key);
870
- }
871
- function isRealAwsSentinel(key, value) {
872
- return isSentinel(key, value, REAL_AWS_SENTINEL);
873
- }
874
- function isLegacyAwsEmulatorSentinel(key, value) {
875
- return isSentinel(key, value, LEGACY_AWS_EMULATOR_SENTINEL);
876
- }
877
- function findSentinels(overrides, match) {
878
- const found = [];
879
- if (!overrides || typeof overrides !== "object") return found;
880
- for (const [section, map] of Object.entries(overrides)) {
881
- if (!map || typeof map !== "object" || Array.isArray(map)) continue;
882
- for (const [key, value] of Object.entries(map)) {
883
- if (!match(key, value)) continue;
884
- found.push({
885
- section,
886
- key,
887
- service: ENDPOINT_KEY.exec(key)[1] ?? ""
888
- });
889
- }
890
- }
891
- return found;
892
- }
893
- function findRealAwsExceptions(overrides) {
894
- return findSentinels(overrides, isRealAwsSentinel);
895
- }
896
- function findLegacyAwsEmulatorSentinels(overrides) {
897
- return findSentinels(overrides, isLegacyAwsEmulatorSentinel);
898
- }
899
- function readAwsEmulatorEnvVarsFile(filePath) {
900
- const none = {
901
- overrides: void 0,
902
- exceptions: [],
903
- legacySentinels: []
904
- };
905
- if (!filePath) return none;
906
- let parsed;
907
- try {
908
- parsed = JSON.parse(readEnvVarsFileText(filePath));
909
- } catch {
910
- return none;
911
- }
912
- if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return none;
913
- const overrides = parsed;
914
- return {
915
- overrides,
916
- exceptions: findRealAwsExceptions(overrides),
917
- legacySentinels: findLegacyAwsEmulatorSentinels(overrides)
918
- };
919
- }
920
- function sectionAppliesTo(section, workload) {
921
- if (section === "Parameters") return false;
922
- if (workload.logicalId !== void 0 && section === workload.logicalId) return true;
923
- if (workload.containerName !== void 0 && section === workload.containerName) return true;
924
- const path = workload.cdkPath;
925
- return path !== void 0 && (path === section || path.startsWith(`${section}/`));
926
- }
927
- function realAwsServicesForWorkload(overrides, workload) {
928
- const out = /* @__PURE__ */ new Set();
929
- const apply = (map) => {
930
- if (!map || typeof map !== "object" || Array.isArray(map)) return;
931
- for (const [key, value] of Object.entries(map)) {
932
- const service = ENDPOINT_KEY.exec(key)?.[1];
933
- if (service === void 0) continue;
934
- if (isRealAwsSentinel(key, value)) out.add(service);
935
- else if (value === null || [
936
- "string",
937
- "number",
938
- "boolean"
939
- ].includes(typeof value)) out.delete(service);
940
- }
941
- };
942
- if (!overrides) return [];
943
- apply(overrides["Parameters"]);
944
- for (const [section, map] of Object.entries(overrides)) if (sectionAppliesTo(section, workload)) apply(map);
945
- return [...out].sort();
946
- }
947
- function correctServiceIdSpelling(service) {
948
- const bare = service.replace(/_/g, "");
949
- for (const id of AWS_ENDPOINT_SERVICE_IDS) if (id.replace(/_/g, "") === bare) return id;
950
- }
951
- function legacyAwsEmulatorSentinelMessage(s) {
952
- return `--env-vars sets ${s.key} under ${displayUntrustedValue(s.section)} to "${LEGACY_AWS_EMULATOR_SENTINEL}", which is no longer supported: --aws-emulator now sends EVERY service to AWS Emulator, and the --env-vars file marks only the exceptions that must reach real AWS, with "${REAL_AWS_SENTINEL}". Remove the "${LEGACY_AWS_EMULATOR_SENTINEL}" entries, and mark each service that must stay on real AWS instead, e.g. "AWS_ENDPOINT_URL_SECRETS_MANAGER": "${REAL_AWS_SENTINEL}".`;
953
- }
954
- function validateAwsEmulatorEnvVars(scan, awsEmulatorOn) {
955
- const legacy = scan.legacySentinels[0];
956
- if (legacy) throw new Error(legacyAwsEmulatorSentinelMessage(legacy));
957
- if (!awsEmulatorOn) return;
958
- if (scan.exceptions.some((s) => s.service === "")) throw new Error(`--env-vars: "AWS_ENDPOINT_URL": "${REAL_AWS_SENTINEL}" would send every AWS call to real AWS, which is what running without --aws-emulator does. Remove --aws-emulator to run against real AWS, or keep it and mark only the services that must reach real AWS, e.g. "AWS_ENDPOINT_URL_SECRETS_MANAGER": "${REAL_AWS_SENTINEL}".`);
959
- const unknown = scan.exceptions.find((s) => !AWS_ENDPOINT_SERVICE_IDS.has(s.service));
960
- if (unknown) {
961
- const fix = correctServiceIdSpelling(unknown.service);
962
- throw new Error(`--env-vars sets ${unknown.key} under ${displayUntrustedValue(unknown.section)} to "${REAL_AWS_SENTINEL}", but the AWS SDKs do not read ${unknown.key}, so the workload's calls would still go to AWS Emulator. ` + (fix ? `Use AWS_ENDPOINT_URL_${fix}.` : "The suffix must be the service's SDK endpoint id (its serviceId, uppercased, spaces as underscores)."));
963
- }
964
- }
965
- function realAwsServicesOf(exceptions) {
966
- return [...new Set(exceptions.map((s) => s.service).filter((s) => s !== ""))].sort();
967
- }
968
- const NO_REGIONAL_ENDPOINT = /* @__PURE__ */ new Set(["APIGATEWAYMANAGEMENTAPI", "CLOUDFRONT_KEYVALUESTORE"]);
969
- const REGION_SHAPE = /^[a-z]{2}(-[a-z]+)+-\d+$/;
970
- function realAwsEndpointFor(service, region) {
971
- if (!REGION_SHAPE.test(region)) throw new Error(`--env-vars marks AWS_ENDPOINT_URL_${service} "${REAL_AWS_SENTINEL}", but the workload's region ${displayUntrustedValue(region)} is not an AWS region name.`);
972
- if (NO_REGIONAL_ENDPOINT.has(service)) throw new Error(`--env-vars marks AWS_ENDPOINT_URL_${service} "${REAL_AWS_SENTINEL}", but ${service} has no regional endpoint to name. Set AWS_ENDPOINT_URL_${service} to the real endpoint URL instead (a literal URL is passed through as-is).`);
973
- const prefix = AWS_ENDPOINT_PREFIX_OVERRIDES[service] ?? service.toLowerCase().replace(/_/g, "");
974
- const isolated = /^(us|eu)-iso[a-z]*-/.test(region);
975
- const china = region.startsWith("cn-");
976
- const gov = region.startsWith("us-gov-");
977
- const global = AWS_GLOBAL_ENDPOINTS[prefix];
978
- if (isolated || global && (china || gov)) throw new Error(`--env-vars marks AWS_ENDPOINT_URL_${service} "${REAL_AWS_SENTINEL}", but ${displayUntrustedValue(region)} has no known real ${service} endpoint. Set AWS_ENDPOINT_URL_${service} to the real endpoint URL instead (a literal URL is passed through as-is).`);
979
- if (global) {
980
- if (global.signingRegion !== region) throw new Error(`--env-vars marks AWS_ENDPOINT_URL_${service} "${REAL_AWS_SENTINEL}", but ${service} is served by one global endpoint (https://${global.hostname}) that accepts only requests signed for ${global.signingRegion}, and an SDK signs a request to an explicit endpoint for the workload's region (${displayUntrustedValue(region)}), which that endpoint refuses. Leave ${service} on AWS Emulator, or run the workload in ${global.signingRegion}.`);
981
- return `https://${global.hostname}`;
982
- }
983
- return `https://${prefix}.${region}.${china ? "amazonaws.com.cn" : "amazonaws.com"}`;
984
- }
985
- const SERVICE_NAMESPACE_ALIASES = {
986
- EVENTBRIDGE: ["EVENTS"],
987
- SFN: ["STEPFUNCTIONS"],
988
- CLOUDWATCHLOGS: ["LOGS"],
989
- COGNITOIDENTITYPROVIDER: ["COGNITO"],
990
- COGNITOIDENTITY: ["COGNITO"],
991
- FIREHOSE: ["KINESISFIREHOSE"],
992
- OPENSEARCH: ["OPENSEARCHSERVICE"],
993
- ELASTICSEARCHSERVICE: ["ELASTICSEARCH"]
994
- };
995
- function resourceTypeMatchesService(resourceType, services) {
996
- const ns = /^AWS::([A-Za-z0-9]+)::/.exec(resourceType)?.[1]?.toUpperCase();
997
- if (!ns) return false;
998
- return services.some((s) => {
999
- const id = s.replace(/_/g, "").toUpperCase();
1000
- return id === ns || (SERVICE_NAMESPACE_ALIASES[id] ?? []).includes(ns);
1001
- });
1002
- }
1003
- const MISSING_LIST_LIMIT = 10;
1004
- function createMixedModeStateProvider(opts) {
1005
- const { real, emulator, realServices } = opts;
1006
- const swaps = /* @__PURE__ */ new Map();
1007
- const toReal = /* @__PURE__ */ new Map();
1008
- const warned = /* @__PURE__ */ new Set();
1009
- const warnedEmulator = /* @__PURE__ */ new Set();
1010
- const swap = (v) => swaps.get(v) ?? v;
1011
- const excepted = (res) => resourceTypeMatchesService(res.resourceType, realServices);
1012
- const provider = {
1013
- label: emulator.label,
1014
- async load(stackName, synthRegion) {
1015
- const [e, r] = await Promise.all([emulator.load(stackName, synthRegion), real.load(stackName, synthRegion)]);
1016
- if (!r) {
1017
- if (e && !warned.has(stackName) && Object.values(e.resources).some(excepted)) {
1018
- warned.add(stackName);
1019
- const why = real.getLastLoadError?.();
1020
- getLogger().warn(`${emulator.label}: stack ${displayUntrustedValue(stackName)} could not be read from real AWS${why ? ` (${why})` : ""}; resources of the services marked "${REAL_AWS_SENTINEL}" (${realServices.join(", ")}) keep their AWS Emulator names. Override them with --env-vars, or deploy the stack to real AWS too.`);
1021
- }
1022
- return e;
1023
- }
1024
- if (!e) {
1025
- const resources = {};
1026
- const dropped = [];
1027
- for (const [id, res] of Object.entries(r.resources)) if (excepted(res)) resources[id] = res;
1028
- else dropped.push(`${displayUntrustedValue(id)} (${displayUntrustedValue(res.resourceType)})`);
1029
- if (dropped.length > 0 && !warnedEmulator.has(stackName)) {
1030
- warnedEmulator.add(stackName);
1031
- const why = emulator.getLastLoadError?.();
1032
- const shown = dropped.slice(0, MISSING_LIST_LIMIT).join(", ");
1033
- const more = dropped.length > MISSING_LIST_LIMIT ? ` and ${dropped.length - MISSING_LIST_LIMIT} more` : "";
1034
- getLogger().warn(`${emulator.label}: stack ${displayUntrustedValue(stackName)} could not be read from AWS Emulator${why ? ` (${why})` : ""}, only from real AWS; resources outside the services marked "${REAL_AWS_SENTINEL}" (${realServices.join(", ")}) stay unresolved: ${shown}${more}. Deploy the stack into AWS Emulator under the same stack name (the same CDK context, e.g. -c stage=dev), or override them with --env-vars.`);
1035
- }
1036
- return {
1037
- resources,
1038
- outputs: {},
1039
- region: r.region
1040
- };
1041
- }
1042
- const resources = { ...e.resources };
1043
- for (const [id, res] of Object.entries(r.resources)) {
1044
- const emuId = e.resources[id]?.physicalId;
1045
- if (emuId && res.physicalId) toReal.set(emuId, res.physicalId);
1046
- if (!excepted(res)) continue;
1047
- const emuRes = e.resources[id];
1048
- if (emuRes?.physicalId && res.physicalId && emuRes.physicalId !== res.physicalId) swaps.set(emuRes.physicalId, res.physicalId);
1049
- resources[id] = res;
1050
- }
1051
- const outputs = {};
1052
- for (const [k, v] of Object.entries(e.outputs)) outputs[k] = swap(v);
1053
- return {
1054
- resources,
1055
- outputs,
1056
- region: e.region
1057
- };
1058
- },
1059
- buildCrossStackResolver: (region) => emulator.buildCrossStackResolver(region),
1060
- dispose() {
1061
- try {
1062
- emulator.dispose();
1063
- } finally {
1064
- real.dispose();
1065
- }
1066
- }
1067
- };
1068
- if (emulator.resolveDeployedFunctionEnv) {
1069
- const fn = emulator.resolveDeployedFunctionEnv.bind(emulator);
1070
- provider.resolveDeployedFunctionEnv = async (id) => {
1071
- const env = await fn(id);
1072
- if (!env) return env;
1073
- const out = {};
1074
- for (const [k, v] of Object.entries(env)) out[k] = swap(v);
1075
- return out;
1076
- };
1077
- }
1078
- if (real.resolveLambdaExecutionRoleArn) {
1079
- const fn = real.resolveLambdaExecutionRoleArn.bind(real);
1080
- provider.resolveLambdaExecutionRoleArn = (id) => fn(toReal.get(id) ?? id);
1081
- }
1082
- if (real.resolveAgentCoreRuntimeRoleArn) {
1083
- const fn = real.resolveAgentCoreRuntimeRoleArn.bind(real);
1084
- provider.resolveAgentCoreRuntimeRoleArn = (id) => fn(toReal.get(id) ?? id);
1085
- }
1086
- if (real.resolveTemplateSsmParameters) provider.resolveTemplateSsmParameters = real.resolveTemplateSsmParameters.bind(real);
1087
- if (emulator.getLastLoadError) provider.getLastLoadError = emulator.getLastLoadError.bind(emulator);
1088
- return provider;
1089
- }
1090
-
1091
- //#endregion
1092
- //#region src/utils/aws-proxy.ts
1093
- const AGENT_OPTS = {
1094
- keepAlive: true,
1095
- maxSockets: 50
1096
- };
1097
- function isProxyEnvConfigured() {
1098
- return PROXY_ENV_VARIABLES.some((key) => Boolean(process.env[key]));
1099
- }
1100
- const PROXY_ENV_VARIABLES = [
1101
- "https_proxy",
1102
- "HTTPS_PROXY",
1103
- "http_proxy",
1104
- "HTTP_PROXY",
1105
- "all_proxy",
1106
- "ALL_PROXY"
1107
- ];
1108
- function isSpeakableProxyEnvValue(value) {
1109
- return !value.includes("://") || isSpeakableProxy(value.trim());
1110
- }
1111
- const AWS_ENDPOINT_PROBES = ["https://sts.amazonaws.com", "http://sts.amazonaws.com"];
1112
- function everySetProxyEnvValueIsUnspeakable() {
1113
- const set = PROXY_ENV_VARIABLES.map((key) => process.env[key] ?? "").filter((v) => v !== "");
1114
- return set.length > 0 && !set.some(isSpeakableProxyEnvValue);
1115
- }
1116
- const warnedProxySchemes = /* @__PURE__ */ new Set();
1117
- function proxySchemeOf(proxyUrl) {
1118
- const match = /^([a-z][a-z0-9+.-]{0,31}):\/\//i.exec(proxyUrl);
1119
- return match ? match[1].toLowerCase() : "(unrecognized)";
1120
- }
1121
- function isSpeakableProxy(proxyUrl) {
1122
- return /^https?:\/\//i.test(proxyUrl);
1123
- }
1124
- function warnUnspeakableProxy(proxyUrl) {
1125
- const scheme = proxySchemeOf(proxyUrl);
1126
- if (warnedProxySchemes.has(scheme)) return;
1127
- try {
1128
- getLogger().child("aws-proxy").warn(`Unsupported proxy scheme "${scheme}" — cdk-local speaks HTTP CONNECT proxies only, so requests it would carry go DIRECT instead of through the proxy. Set HTTPS_PROXY / HTTP_PROXY / ALL_PROXY to an http:// or https:// proxy URL. (The proxy URL is withheld here: it can carry credentials.)`);
1129
- } catch {
1130
- return;
1131
- }
1132
- warnedProxySchemes.add(scheme);
1133
- }
1134
- function resolveProxyForTarget(targetHref) {
1135
- const proxyUrl = getProxyForUrl(targetHref).trim();
1136
- if (proxyUrl === "") return "";
1137
- if (isSpeakableProxy(proxyUrl)) return proxyUrl;
1138
- warnUnspeakableProxy(proxyUrl);
1139
- return "";
1140
- }
1141
- var EnvRoutingProxyAgent = class extends Agent$2 {
1142
- proxyAgents = /* @__PURE__ */ new Map();
1143
- directHttpAgent = new Agent(AGENT_OPTS);
1144
- directHttpsAgent = new Agent$1(AGENT_OPTS);
1145
- constructor() {
1146
- super(AGENT_OPTS);
1147
- }
1148
- connect(_req, options) {
1149
- const secure = options.secureEndpoint;
1150
- const host = options.host ?? "localhost";
1151
- const port = options.port || (secure ? 443 : 80);
1152
- const proxyUrl = resolveProxyForTarget(`${secure ? "https" : "http"}://${formatAuthority(host, port)}`);
1153
- if (!proxyUrl) return secure ? this.directHttpsAgent : this.directHttpAgent;
1154
- const key = `${secure ? "https" : "http"}|${proxyUrl}`;
1155
- let agent = this.proxyAgents.get(key);
1156
- if (!agent) {
1157
- agent = secure ? new HttpsProxyAgent(proxyUrl, AGENT_OPTS) : new HttpProxyAgent(proxyUrl, AGENT_OPTS);
1158
- this.proxyAgents.set(key, agent);
1159
- }
1160
- return agent;
1161
- }
1162
- destroy() {
1163
- for (const agent of this.proxyAgents.values()) agent.destroy();
1164
- this.proxyAgents.clear();
1165
- this.directHttpAgent.destroy();
1166
- this.directHttpsAgent.destroy();
1167
- super.destroy();
1168
- }
1169
- };
1170
- let endpointOverride;
1171
- function setAwsEndpointOverride(o) {
1172
- endpointOverride = o;
1173
- }
1174
- function getAwsEndpointOverride() {
1175
- return endpointOverride;
1176
- }
1177
- let serviceRouting;
1178
- function normalizeAwsEndpointServiceId(serviceId) {
1179
- return serviceId.trim().replace(/ /g, "_").toUpperCase();
1180
- }
1181
- function setAwsEmulatorServiceRouting(r) {
1182
- serviceRouting = r ? {
1183
- realServices: new Set(r.realServices.map(normalizeAwsEndpointServiceId)),
1184
- override: r.override,
1185
- envOverrides: r.envOverrides
1186
- } : void 0;
1187
- }
1188
- function getAwsEmulatorServiceRouting() {
1189
- return serviceRouting ? {
1190
- realServices: [...serviceRouting.realServices].sort(),
1191
- override: serviceRouting.override,
1192
- ...serviceRouting.envOverrides && { envOverrides: serviceRouting.envOverrides }
1193
- } : void 0;
1194
- }
1195
- function awsEmulatorRealServices(workload) {
1196
- if (!serviceRouting) return void 0;
1197
- if (serviceRouting.envOverrides === void 0) return [...serviceRouting.realServices].sort();
1198
- return realAwsServicesForWorkload(serviceRouting.envOverrides, workload ?? {});
1199
- }
1200
- function mixedModeRoutes(serviceId, workload) {
1201
- const real = awsEmulatorRealServices(workload);
1202
- return real !== void 0 && !real.includes(normalizeAwsEndpointServiceId(serviceId));
1203
- }
1204
- function isAwsServiceRoutedToEmulator(serviceId, workload) {
1205
- if (endpointOverride) return true;
1206
- return mixedModeRoutes(serviceId, workload);
1207
- }
1208
- function awsClientConfigForService(serviceId, opts = {}) {
1209
- return buildProxyClientConfig({
1210
- ...opts,
1211
- service: serviceId
1212
- });
1213
- }
1214
- function awsEndpointOverrideClientConfig(o) {
1215
- return endpointOverrideClientConfig(o);
1216
- }
1217
- function deployArtifactsReadEmulator(service, workload) {
1218
- return isAwsServiceRoutedToEmulator(service, workload);
1219
- }
1220
- function deployArtifactClientConfig(opts) {
1221
- return buildProxyClientConfig(opts);
1222
- }
1223
- function endpointOverrideClientConfig(o) {
1224
- const httpsAgent = new Agent$1({
1225
- keepAlive: true,
1226
- ...o.caPem ? { ca: [...rootCertificates, o.caPem] } : {}
1227
- });
1228
- const creds = o.credentials;
1229
- return {
1230
- endpoint: o.endpoint,
1231
- requestHandler: new NodeHttpHandler({ httpsAgent }),
1232
- ...creds ? { credentials: async () => ({
1233
- accessKeyId: creds.accessKeyId,
1234
- secretAccessKey: creds.secretAccessKey,
1235
- ...creds.sessionToken ? { sessionToken: creds.sessionToken } : {}
1236
- }) } : {}
1237
- };
1238
- }
1239
- function buildProxyRequestHandler() {
1240
- const agent = new EnvRoutingProxyAgent();
1241
- return new NodeHttpHandler({
1242
- httpAgent: agent,
1243
- httpsAgent: agent
1244
- });
1245
- }
1246
- function buildProxyClientConfig(opts = {}) {
1247
- if (endpointOverride) return endpointOverrideClientConfig(endpointOverride);
1248
- if (serviceRouting && opts.service !== void 0 && mixedModeRoutes(opts.service, opts.workload)) return endpointOverrideClientConfig(serviceRouting.override);
1249
- if (!isProxyEnvConfigured()) return {};
1250
- if (everySetProxyEnvValueIsUnspeakable()) {
1251
- for (const probe of AWS_ENDPOINT_PROBES) resolveProxyForTarget(probe);
1252
- return {};
1253
- }
1254
- const profile = opts.profile;
1255
- let chain;
1256
- const credentials = async (identityProperties) => {
1257
- chain ??= (async () => {
1258
- const { defaultProvider } = await import("@aws-sdk/credential-provider-node");
1259
- return defaultProvider({
1260
- ...profile ? { profile } : {},
1261
- clientConfig: { requestHandler: buildProxyRequestHandler() }
1262
- });
1263
- })().catch((err) => {
1264
- chain = void 0;
1265
- throw err;
1266
- });
1267
- return (await chain)(identityProperties);
1268
- };
1269
- return {
1270
- requestHandler: buildProxyRequestHandler(),
1271
- credentials
1272
- };
1273
- }
1274
- const MAX_FETCH_REDIRECTS = 20;
1275
- const NULL_BODY_STATUSES = /* @__PURE__ */ new Set([
1276
- 204,
1277
- 205,
1278
- 304
1279
- ]);
1280
- const REQUEST_STALL_TIMEOUT_MS = 3e5;
1281
- function isRedirectStatus(status) {
1282
- return status === 301 || status === 302 || status === 303 || status === 307 || status === 308;
1283
- }
1284
- function parseHttpUrl(href) {
1285
- const parsed = new URL(href);
1286
- if (parsed.protocol !== "http:" && parsed.protocol !== "https:") throw new TypeError(`Unsupported protocol for a proxied request: "${parsed.protocol}"`);
1287
- return parsed;
1288
- }
1289
- function getThroughAgent(url, agent, timeoutMs = REQUEST_STALL_TIMEOUT_MS) {
1290
- return new Promise((resolve, reject) => {
1291
- let settled = false;
1292
- let timer;
1293
- let rearm = () => void 0;
1294
- const succeed = (value) => {
1295
- if (settled) return;
1296
- settled = true;
1297
- if (timer) clearTimeout(timer);
1298
- resolve(value);
1299
- };
1300
- const fail = (err) => {
1301
- if (settled) return;
1302
- settled = true;
1303
- if (timer) clearTimeout(timer);
1304
- reject(err);
1305
- };
1306
- const req = (url.protocol === "https:" ? request$1 : request)(url, {
1307
- agent,
1308
- headers: {
1309
- accept: "*/*",
1310
- "accept-encoding": "identity"
1311
- }
1312
- }, (res) => {
1313
- rearm();
1314
- const chunks = [];
1315
- res.on("data", (chunk) => {
1316
- rearm();
1317
- chunks.push(chunk);
1318
- });
1319
- res.on("error", fail);
1320
- res.on("end", () => {
1321
- if (res.statusCode === void 0) {
1322
- fail(/* @__PURE__ */ new Error("Malformed HTTP response: no status code"));
1323
- return;
1324
- }
1325
- succeed({
1326
- status: res.statusCode,
1327
- statusText: res.statusMessage ?? "",
1328
- headers: res.headers,
1329
- body: Buffer.concat(chunks)
1330
- });
1331
- });
1332
- });
1333
- req.on("error", fail);
1334
- rearm = () => {
1335
- if (settled) return;
1336
- if (timer) clearTimeout(timer);
1337
- timer = setTimeout(() => {
1338
- req.destroy();
1339
- fail(/* @__PURE__ */ new Error(`Proxied request stalled for ${timeoutMs} ms with no progress`));
1340
- }, timeoutMs);
1341
- timer.unref?.();
1342
- };
1343
- rearm();
1344
- req.end();
1345
- });
1346
- }
1347
- function decodeContentEncoding(raw) {
1348
- const header = raw.headers["content-encoding"];
1349
- const encoding = (Array.isArray(header) ? header.join(",") : header ?? "").trim().toLowerCase();
1350
- if (encoding === "" || encoding === "identity") return {
1351
- body: raw.body,
1352
- decoded: false
1353
- };
1354
- try {
1355
- if (encoding === "gzip" || encoding === "x-gzip") return {
1356
- body: gunzipSync(raw.body),
1357
- decoded: true
1358
- };
1359
- if (encoding === "deflate" || encoding === "x-deflate") return {
1360
- body: inflateSync(raw.body),
1361
- decoded: true
1362
- };
1363
- if (encoding === "br") return {
1364
- body: brotliDecompressSync(raw.body),
1365
- decoded: true
1366
- };
1367
- } catch {
1368
- return {
1369
- body: raw.body,
1370
- decoded: false
1371
- };
1372
- }
1373
- return {
1374
- body: raw.body,
1375
- decoded: false
1376
- };
1377
- }
1378
- function toWebResponse(raw) {
1379
- if (raw.status < 200 || raw.status > 599) throw new Error(`Unsupported HTTP status in response: ${raw.status}`);
1380
- const { body, decoded } = decodeContentEncoding(raw);
1381
- const headers = new Headers();
1382
- for (const [name, value] of Object.entries(raw.headers)) {
1383
- if (value === void 0) continue;
1384
- if (decoded && (name === "content-encoding" || name === "content-length")) continue;
1385
- if (Array.isArray(value)) for (const one of value) headers.append(name, one);
1386
- else headers.append(name, value);
1387
- }
1388
- return new Response(NULL_BODY_STATUSES.has(raw.status) ? null : body, {
1389
- status: raw.status,
1390
- statusText: raw.statusText.replace(/[^\t\x20-\x7e\x80-\xff]/g, ""),
1391
- headers
1392
- });
1393
- }
1394
- async function proxyAwareFetch(url, opts = {}) {
1395
- if (!isProxyEnvConfigured()) return globalThis.fetch(url);
1396
- let target = parseHttpUrl(url);
1397
- for (let hop = 0;; hop++) {
1398
- if (isLoopbackHost(target.hostname) || resolveProxyForTarget(target.href) === "") return globalThis.fetch(target.href);
1399
- const agent = new EnvRoutingProxyAgent();
1400
- let raw;
1401
- try {
1402
- raw = await getThroughAgent(target, agent, opts.timeoutMs);
1403
- } finally {
1404
- agent.destroy();
1405
- }
1406
- const location = raw.headers["location"];
1407
- if (!isRedirectStatus(raw.status) || typeof location !== "string" || location === "") return toWebResponse(raw);
1408
- if (hop >= MAX_FETCH_REDIRECTS) throw new Error(`Too many redirects (more than ${MAX_FETCH_REDIRECTS})`);
1409
- target = parseHttpUrl(new URL(location, target).href);
1410
- }
1411
- }
1412
-
1413
- //#endregion
1414
12
  //#region src/local/mixed-mode-tls.ts
1415
13
  function der(tag, content) {
1416
14
  const n = content.length;
@@ -2866,5 +1464,5 @@ function warnWorkloadCredentialsStripped() {
2866
1464
  }
2867
1465
 
2868
1466
  //#endregion
2869
- export { getAwsEndpointOverride as $, parseAwsEndpoint as A, hostFromAuthority as At, workload_aws_wiring_exports as B, effectiveLoopbackPorts as C, readEnvVarsFileText as Ct, javaTruststoreToolOptions as D, isWildcardHostname as Dt, getContainerJavaTruststorePath as E, isLoopbackHostname as Et, resolveHostDefaultCredentials as F, createMixedModeTlsMaterials as G, MIXED_MODE_RESIGN_BODY_CAP_BYTES as H, resolveWorkloadAwsWiring as I, awsEndpointOverrideClientConfig as J, awsClientConfigForService as K, setActiveWorkloadAwsWiring as L, readEmulatorRunFiles as M, readProfileEndpointSettings as N, loopbackForwarderPlan as O, formatAuthority as Ot, resolveAwsEmulatorOption as P, getAwsEmulatorServiceRouting as Q, takeAwsEmulatorStateSourceHint as R, displayEndpointValue as S, applyEnvOverrideMap as St, getContainerCaBundlePath as T, defineOwnKey as Tt, RESIGN_SIDECAR_SCRIPT as U, writeCaBundleFile as V, buildJavaTrustStore as W, deployArtifactClientConfig as X, buildProxyClientConfig as Y, deployArtifactsReadEmulator as Z, HOST_DEFAULT_CREDENTIALS_MISS_TTL_MS as _, realAwsServicesForWorkload as _t, deployAccountStsClientConfig as a, setAwsEndpointOverride as at, awsEmulatorEnvName as b, validateAwsEmulatorEnvVars as bt, resetWorkloadIdentity as c, REAL_AWS_SENTINEL as ct, workloadStsClientConfig as d, findRealAwsExceptions as dt, isAwsServiceRoutedToEmulator as et, AUTH_OFF_PLACEHOLDER_CREDENTIALS as f, isLegacyAwsEmulatorSentinel as ft, HOST_CA_TRUST_ENV_KEYS as g, realAwsEndpointFor as gt, EMULATOR_SCRUBBED_ENV_KEYS as h, readAwsEmulatorEnvVarsFile as ht, assumedRoleRecorded as i, setAwsEmulatorServiceRouting as it, probeAwsEmulatorHealth as j, mergeJavaToolOptions as k, formatHostForAuthority as kt, warnWorkloadCredentialsStripped as l, createMixedModeStateProvider as lt, DEFAULT_AWS_EMULATOR_URL as m, legacyAwsEmulatorSentinelMessage as mt, accountLookupStsClientConfig as n, normalizeAwsEndpointServiceId as nt, readEnvCallerCredentials as o, LEGACY_AWS_EMULATOR_SENTINEL as ot, CA_TRUST_ENV_KEYS as p, isRealAwsSentinel as pt, awsEmulatorRealServices as q, applyWorkloadEnvCredentials as r, proxyAwareFetch as rt, recordAssumedRole as s, MIXED_MODE_RESIGN_PORT as st, SECOND_ASSUME_MESSAGE as t, isProxyEnvConfigured as tt, workloadClientConfig as u, findLegacyAwsEmulatorSentinels as ut, activateWorkloadAwsWiring as v, realAwsServicesOf as vt, getActiveWorkloadAwsWiring as w, resolveEnvVars as wt, collectHostEndpointOverrides as x, AWS_ENDPOINT_SERVICE_IDS as xt, applyWorkloadAwsWiringToEnv as y, resourceTypeMatchesService as yt, workloadGetsEmulatorKeysOnly as z };
2870
- //# sourceMappingURL=workload-identity-BofTjFzQ.js.map
1467
+ export { parseAwsEndpoint as A, workload_aws_wiring_exports as B, effectiveLoopbackPorts as C, javaTruststoreToolOptions as D, getContainerJavaTruststorePath as E, resolveHostDefaultCredentials as F, createMixedModeTlsMaterials as G, MIXED_MODE_RESIGN_BODY_CAP_BYTES as H, resolveWorkloadAwsWiring as I, setActiveWorkloadAwsWiring as L, readEmulatorRunFiles as M, readProfileEndpointSettings as N, loopbackForwarderPlan as O, resolveAwsEmulatorOption as P, takeAwsEmulatorStateSourceHint as R, displayEndpointValue as S, getContainerCaBundlePath as T, RESIGN_SIDECAR_SCRIPT as U, writeCaBundleFile as V, buildJavaTrustStore as W, HOST_DEFAULT_CREDENTIALS_MISS_TTL_MS as _, deployAccountStsClientConfig as a, awsEmulatorEnvName as b, resetWorkloadIdentity as c, workloadStsClientConfig as d, AUTH_OFF_PLACEHOLDER_CREDENTIALS as f, HOST_CA_TRUST_ENV_KEYS as g, EMULATOR_SCRUBBED_ENV_KEYS as h, assumedRoleRecorded as i, probeAwsEmulatorHealth as j, mergeJavaToolOptions as k, warnWorkloadCredentialsStripped as l, DEFAULT_AWS_EMULATOR_URL as m, accountLookupStsClientConfig as n, readEnvCallerCredentials as o, CA_TRUST_ENV_KEYS as p, applyWorkloadEnvCredentials as r, recordAssumedRole as s, SECOND_ASSUME_MESSAGE as t, workloadClientConfig as u, activateWorkloadAwsWiring as v, getActiveWorkloadAwsWiring as w, collectHostEndpointOverrides as x, applyWorkloadAwsWiringToEnv as y, workloadGetsEmulatorKeysOnly as z };
1468
+ //# sourceMappingURL=workload-identity-BONcukjU.js.map