cdk-local 0.70.0 → 0.71.1

package/dist/{local-list-C-wXKogn.js → local-list-EOmrWeTr.js}

@@ -19182,6 +19182,143 @@ function addInvokeAgentCoreSpecificOptions(cmd) {
 	return cmd.addOption(new Option("-e, --event <file>", "JSON event payload file (default: {})")).addOption(new Option("--event-stdin", "Read event JSON from stdin").default(false)).addOption(new Option("--env-vars <file>", "JSON env-var overrides (SAM-compatible: {\"LogicalId\":{\"KEY\":\"VALUE\"}})")).addOption(new Option("--session-id <id>", "AgentCore runtime session id header value (default: a random UUID)")).addOption(new Option("--ws", "Stream over the HTTP-protocol agent's bidirectional /ws WebSocket endpoint (on 8080) instead of POST /invocations: send --event as the first frame and print every received frame to stdout until the agent closes. Ignored for an MCP runtime.").default(false)).addOption(new Option("--ws-interactive", "REPL mode for --ws: after the initial --event frame, read additional frames from stdin (one frame per line, trailing newline stripped) and send each as a text frame until stdin EOFs (Ctrl-D) or the agent closes. Only meaningful with --ws.").default(false)).addOption(new Option("--bearer-token <jwt>", "Bearer JWT to present when the runtime declares a customJwtAuthorizer. Verified against the runtime OIDC discovery URL (signature / issuer / expiry / audience) before the container starts, then forwarded to /invocations as Authorization: Bearer <jwt>.")).addOption(new Option("--no-verify-auth", "Skip inbound JWT verification even when the runtime declares a customJwtAuthorizer (local-dev escape hatch). A --bearer-token, if given, is still forwarded.")).addOption(new Option("--sigv4", "Sign the /invocations POST with AWS SigV4 (service bedrock-agentcore) using the resolved credentials, matching the cloud default when the runtime declares no customJwtAuthorizer. Opt-in: default unsigned. Mutually exclusive with --bearer-token; ignored on a JWT-protected runtime.").default(false)).addOption(new Option("--platform <platform>", "docker --platform for the agent container (linux/amd64 or linux/arm64)").choices(["linux/amd64", "linux/arm64"]).default("linux/arm64")).addOption(new Option("--no-pull", "Skip docker pull (use cached image) — no-op for the local-build path")).addOption(new Option("--no-build", "Skip docker build on the local-asset path (use the previously-built tag). No-op for the ECR / registry pull paths.")).addOption(new Option("--container-host <host>", "Host to bind the agent port to").default("127.0.0.1")).addOption(new Option("--timeout <ms>", "Per-request timeout in milliseconds. Applied to POST /invocations, POST /mcp, and the /ws open-to-close window. Raise this for long-running agent calls that exceed the default.").default(12e4).argParser(parseTimeoutMs)).addOption(new Option("--assume-role [arn]", "Assume the runtime's execution role and forward STS-issued temp credentials to the container so the agent runs with the deployed role. Three forms: (1) `--assume-role <arn>` assumes the explicit ARN; (2) `--assume-role` (bare) uses the runtime's RoleArn when it is a literal ARN; (3) `--no-assume-role` opts out. Off by default — the developer's shell credentials are forwarded unchanged.")).addOption(new Option("--ecr-role-arn <arn>", "Role ARN to assume before authenticating against ECR for cross-account / centralized registries. Same-account / same-region pulls do not need this flag.")).addOption(new Option("--from-cfn-stack [cfn-stack-name]", "Read a deployed CloudFormation stack via ListStackResources and substitute Ref / Fn::ImportValue in env vars with the deployed physical IDs / exports. Bare form uses the resolved stack name; pass an explicit value when the CFn stack name differs.")).addOption(new Option("--stack-region <region>", "Region of the state record to read. Used with --from-cfn-stack as the CFn client region."));
 }
 
+//#endregion
+//#region src/local/container-log-streamer.ts
+/**
+* Spawn `docker logs -f <containerId>` and pipe its stdout / stderr to
+* the host's `process.stdout` / `process.stderr`, prefixing every emitted
+* line with the caller-supplied `prefix`. Returns a stop function that
+* drains any unterminated tail line and SIGTERMs the streamer process —
+* idempotent + safe to call from a `finally` or shutdown handler.
+*
+* Used by `cdkl run-task` (per-container prefix `[<container-name>]`) and
+* by `cdkl start-service` / `cdkl start-alb` (per-replica prefix
+* `[svc=<service> r=<i> c=<container>]`) so application `console.log`
+* output inside a replica is visible in the foreground terminal without
+* having to attach `docker logs -f` in a separate shell. The prefix shape
+* is the caller's concern: this helper only cares about line-buffered
+* pass-through.
+*
+* **Auto re-attach on `docker restart`** (Issue #227 + #214 soft-reload):
+* the docker daemon terminates `docker logs -f` when the container's
+* PID 1 exits — so a `docker restart` (the soft-reload primitive) ends
+* the follow stream even though the container ID is preserved across the
+* restart. The streamer detects an unsolicited child-exit and re-spawns
+* `docker logs -f` with `--since 0s` so only NEW output (from the
+* post-restart PID-1) is forwarded; the v1 prelude is not re-emitted.
+* `stop()` flips an internal "stopping" flag so the re-attach loop sees
+* the intentional teardown and does not respawn.
+*
+* **Cap-reached warning** (Issue #227 review fix — Code #2): the
+* re-attach budget is bounded at 50 to defend against a permanently-
+* broken `docker logs -f` (the container was removed out from under
+* us). When the cap is hit, the streamer surfaces ONE warning line via
+* `process.stderr` naming the prefix + the manual recovery so a long-
+* running `--watch` session does not lose its foreground log surface
+* silently.
+*
+* **Dying-container respawn skip** (Issue #227 review fix — Code #4):
+* when the child exits unsolicited and the container's `State.Status`
+* is `exited` / `dead` / `removing`, the streamer does NOT respawn —
+* the natural-exit path is the service-runner's `cleanupEcsRun(...)`
+* call (~1s after the wait resolves), and a respawn against a
+* dying container is just a wasted `docker logs -f` process + a
+* spurious cap-reached tick. A `docker restart` (the soft-reload
+* primitive) leaves the container in `restarting` / `running`, so
+* the soft-reload re-attach path is preserved. Falls open: an
+* inspect error treats the container as still alive (best-effort —
+* the cap+stop() invariants stay correct either way).
+*
+* The streamer is best-effort. A spawn / pipe error is silently swallowed
+* (the parent's `docker wait` already surfaces the underlying container
+* failure with full context); the loud surface stays on the runner's exit
+* path.
+*/
+function attachContainerLogStreamer(prefix, containerId) {
+	let stopping = false;
+	let current;
+	let stdoutBuf = "";
+	let stderrBuf = "";
+	const maxReattaches = 50;
+	let reattachCount = 0;
+	let pendingRespawn;
+	const spawnOnce = (sinceArg) => {
+		const args = [
+			"logs",
+			"-f",
+			...sinceArg !== void 0 ? ["--since", sinceArg] : [],
+			containerId
+		];
+		const proc = spawn(getDockerCmd(), args, { stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		] });
+		current = proc;
+		proc.stdout?.on("data", (chunk) => {
+			stdoutBuf = writePrefixedLines(prefix, stdoutBuf + chunk.toString("utf-8"), process.stdout);
+		});
+		proc.stderr?.on("data", (chunk) => {
+			stderrBuf = writePrefixedLines(prefix, stderrBuf + chunk.toString("utf-8"), process.stderr);
+		});
+		proc.on("error", () => {});
+		proc.on("exit", () => {
+			if (stopping) return;
+			if (reattachCount >= maxReattaches) {
+				process.stderr.write(`${prefix}cdkl: docker logs -f re-attached ${maxReattaches} times; giving up. Run \`docker logs -f ${containerId}\` manually to keep watching.\n`);
+				return;
+			}
+			reattachCount += 1;
+			execFile(getDockerCmd(), [
+				"inspect",
+				"--format",
+				"{{.State.Status}}",
+				containerId
+			], (err, stdout) => {
+				if (stopping) return;
+				if (!err) {
+					const status = stdout.trim().toLowerCase();
+					if (status === "exited" || status === "dead" || status === "removing") return;
+				}
+				pendingRespawn = setTimeout(() => {
+					pendingRespawn = void 0;
+					if (stopping) return;
+					spawnOnce("0s");
+				}, 200);
+			});
+		});
+	};
+	spawnOnce(void 0);
+	return () => {
+		stopping = true;
+		if (pendingRespawn !== void 0) {
+			clearTimeout(pendingRespawn);
+			pendingRespawn = void 0;
+		}
+		if (stdoutBuf) {
+			process.stdout.write(prefix + stdoutBuf + "\n");
+			stdoutBuf = "";
+		}
+		if (stderrBuf) {
+			process.stderr.write(prefix + stderrBuf + "\n");
+			stderrBuf = "";
+		}
+		if (current && !current.killed) current.kill("SIGTERM");
+	};
+}
+/**
+* Write every complete line in `buffer` to `out`, prefixed with `prefix`.
+* Returns the trailing partial line (no `\n` yet) so the caller can
+* accumulate it with the next `data` chunk. Exported for unit tests; the
+* production callers should use {@link attachContainerLogStreamer}.
+*/
+function writePrefixedLines(prefix, buffer, out) {
+	const lines = buffer.split("\n");
+	const remainder = lines.pop() ?? "";
+	for (const line of lines) out.write(prefix + line + "\n");
+	return remainder;
+}
+
 //#endregion
 //#region src/local/ecs-network.ts
 const execFileAsync$3 = promisify(execFile);
@@ -19770,7 +19907,7 @@ async function runEcsTask(task, options, state) {
 			id,
 			container
 		});
-		if (!options.detach) state.logStoppers.push(streamContainerLogs(container.name, id));
+		if (!options.detach) state.logStoppers.push(attachContainerLogStreamer(`[${container.name}] `, id));
 	}
 	if (options.detach) return {
 		exitCode: 0,
@@ -19910,42 +20047,6 @@ function sleep$1(ms) {
 	return new Promise((res) => setTimeout(res, ms));
 }
 /**
-* Stream `docker logs -f <id>` with `[<container-name>]` prefixes on
-* every line. Returns a stop function for the caller's `finally`.
-*/
-function streamContainerLogs(containerName, containerId) {
-	const proc = spawn(getDockerCmd(), [
-		"logs",
-		"-f",
-		containerId
-	], { stdio: [
-		"ignore",
-		"pipe",
-		"pipe"
-	] });
-	const prefix = `[${containerName}] `;
-	let stdoutBuf = "";
-	let stderrBuf = "";
-	proc.stdout?.on("data", (chunk) => {
-		stdoutBuf = writePrefixed(prefix, stdoutBuf + chunk.toString("utf-8"), process.stdout);
-	});
-	proc.stderr?.on("data", (chunk) => {
-		stderrBuf = writePrefixed(prefix, stderrBuf + chunk.toString("utf-8"), process.stderr);
-	});
-	proc.on("error", () => {});
-	return () => {
-		if (stdoutBuf) process.stdout.write(prefix + stdoutBuf + "\n");
-		if (stderrBuf) process.stderr.write(prefix + stderrBuf + "\n");
-		if (!proc.killed) proc.kill("SIGTERM");
-	};
-}
-function writePrefixed(prefix, buffer, out) {
-	const lines = buffer.split("\n");
-	const remainder = lines.pop() ?? "";
-	for (const line of lines) out.write(prefix + line + "\n");
-	return remainder;
-}
-/**
 * Resolve every container's `Image` to a tag the runner can pass to
 * `docker run`. The map is keyed by container name; entries are
 * populated in parallel up to the asset-manifest bound (single
@@ -20577,6 +20678,7 @@ function extractServiceProperties(stack, serviceLogicalId, resource, stacks, con
 	const desiredCount = parseDesiredCount(props["DesiredCount"], serviceLogicalId);
 	const healthCheckGracePeriodSeconds = parseHealthCheckGrace(props["HealthCheckGracePeriodSeconds"], serviceLogicalId);
 	const serviceName = parseServiceName(props["ServiceName"], serviceLogicalId);
+	const serviceDisplayName = deriveServiceDisplayName(props["ServiceName"], serviceLogicalId, resource.Metadata);
 	if (!options?.suppressLoadBalancerWarning && Array.isArray(props["LoadBalancers"]) && props["LoadBalancers"].length > 0) {
 		const { cliName } = getEmbedConfig();
 		warnings.push(`ECS Service '${serviceLogicalId}' declares LoadBalancers, but \`${cliName} start-service\` runs the replicas only; no local listener fronts them. Reach the containers via their published ports, or run \`${cliName} start-alb <Stack>/<Alb>\` to boot the same replicas behind a local front-door that round-robins the listener rules.`);
@@ -20587,6 +20689,7 @@ function extractServiceProperties(stack, serviceLogicalId, resource, stacks, con
 		serviceLogicalId,
 		resource,
 		serviceName,
+		serviceDisplayName,
 		desiredCount,
 		healthCheckGracePeriodSeconds,
 		task,
@@ -20741,6 +20844,50 @@ function parseServiceName(raw, serviceLogicalId) {
 	return serviceLogicalId;
 }
 /**
+* Issue #227 review fix — derive a CLEAN display name for the per-replica
+* `[svc=<name> r=<i> c=<container>] ` log prefix. L2 constructs
+* (`FargateService`, `ApplicationLoadBalancedFargateService`) do NOT set
+* `ServiceName` explicitly, so the synthesized template's `ServiceName`
+* is absent and {@link parseServiceName} falls back to the
+* hash-suffixed logical id (e.g. `BackendApi5F9D8C32`). That ends up in
+* the foreground prefix as `[svc=BackendApi5F9D8C32 ...]` — noisy +
+* not what Issue #227's spec example showed.
+*
+* Resolution order (display ONLY — does NOT change `service.serviceName`):
+*   1. The explicit CFn `ServiceName` property, if the user set one.
+*   2. The last meaningful segment of the resource's `aws:cdk:path`
+*      Metadata. For a typical L2, this is the construct id the user
+*      wrote in CDK source (e.g. `AppStack/BackendApi/Service` →
+*      `BackendApi`). Trailing CDK-internal segments (`/Service`,
+*      `/Resource`, `/Default`) are stripped so the result matches the
+*      construct id the user typed, not the per-resource CFn segment.
+*   3. The `serviceLogicalId` as today's fallback when neither is
+*      available (synthetic / hand-rolled CFn).
+*
+* Pure helper — keep narrowly scoped to the log-prefix use case so
+* other call sites that rely on `service.serviceName` for awsvpc /
+* Cloud Map / discovery semantics keep their existing fallback
+* behavior.
+*/
+function deriveServiceDisplayName(rawServiceName, serviceLogicalId, metadata) {
+	if (typeof rawServiceName === "string" && rawServiceName.length > 0) return rawServiceName;
+	const cdkPath = typeof metadata?.["aws:cdk:path"] === "string" ? metadata["aws:cdk:path"] : "";
+	if (cdkPath.length > 0) {
+		const segments = cdkPath.split("/");
+		while (segments.length > 1) {
+			const tail = segments[segments.length - 1];
+			if (tail === "Service" || tail === "Resource" || tail === "Default") {
+				segments.pop();
+				continue;
+			}
+			break;
+		}
+		const tail = segments[segments.length - 1];
+		if (typeof tail === "string" && tail.length > 0) return tail;
+	}
+	return serviceLogicalId;
+}
+/**
 * Local copy of the same `pickStack` helper used by the task resolver.
 * Kept in-file rather than exported from `ecs-task-resolver.ts` so future
 * service-specific extensions (e.g. cross-stack service-to-task refs)
@@ -21155,6 +21302,10 @@ async function bootReplica(service, options, instance) {
 	};
 	logger.info(`Booting replica ${instance.index} (${perReplicaCluster})`);
 	await runEcsTask(service.task, perReplicaTaskOptions, instance.state);
+	if (options.streamLogs !== false) for (const started of instance.state.startedContainers) {
+		const prefix = `[svc=${service.serviceDisplayName} r=${instance.index} c=${started.name}] `;
+		instance.state.logStoppers.push(attachContainerLogStreamer(prefix, started.id));
+	}
 	if (options.discovery) await publishReplicaToCloudMap(service, instance, options.discovery, ownerKeyPrefix);
 	if (options.frontDoor) await publishReplicaToFrontDoor(service, instance, options.frontDoor, options.taskOptions.containerHost, ownerKeyPrefix);
 	instance.lastDeployedAssetHash = pickEssentialAssetHash(service);
@@ -21955,11 +22106,22 @@ const REBUILD_TRIGGER_BASENAMES = new Set([
 * `mvn package` etc.). A copy of the source alone would leave the
 * running binary stale, so the user's intent must be a rebuild.
 *
-* Interpreted-language runtimes (Node — `.js` / `.mjs` / `.cjs` /
-* `.ts` when transpiled at runtime, Python — `.py`, Ruby — `.rb`,
-* shell — `.sh`) read source at process start, so a `docker cp` +
-* `docker restart` cycle picks them up. Those extensions are
-* NOT in this set.
+* TypeScript source (`.ts` / `.tsx` / `.mts` / `.cts`) is treated as
+* compiled because the dominant production-container pattern is to
+* pre-compile the source via a Dockerfile `RUN tsc` / `RUN yarn build`
+* step, with the runtime executing the emitted `dist/*.js`. Soft-reload
+* would `docker cp` the new `.ts` into the container's WORKDIR while
+* the running process keeps reading the OLD `dist/` — a silent
+* stale-code failure that violates the file's "slow-but-correct beats
+* fast-but-stale" default policy (lines 14-22). Setups that transpile
+* at runtime lose the soft-reload fast path under this default; an
+* opt-in flag to restore it is a possible follow-up but is not in
+* scope here.
+*
+* Interpreted-language runtimes (Node — `.js` / `.mjs` / `.cjs`,
+* Python — `.py`, Ruby — `.rb`, shell — `.sh`) read source at process
+* start, so a `docker cp` + `docker restart` cycle picks them up.
+* Those extensions are NOT in this set.
 */
 const COMPILED_LANGUAGE_EXTENSIONS = new Set([
 	".go",
@@ -21983,7 +22145,11 @@ const COMPILED_LANGUAGE_EXTENSIONS = new Set([
 	".mli",
 	".elm",
 	".hs",
-	".dart"
+	".dart",
+	".ts",
+	".tsx",
+	".mts",
+	".cts"
 ]);
 /**
 * Classify a single watcher firing into rebuild vs soft-reload. Pure
@@ -24524,7 +24690,8 @@ async function resolveServiceAndRunnerOpts(boot, stacks, options, discovery, ski
 			restartPolicy: options.restartPolicy,
 			taskOptions: taskOpts,
 			discovery,
-			...frontDoorPools && frontDoorPools.length > 0 ? { frontDoor: { pools: frontDoorPools } } : {}
+			...frontDoorPools && frontDoorPools.length > 0 ? { frontDoor: { pools: frontDoorPools } } : {},
+			streamLogs: options.logs !== false
 		}
 	};
 }
@@ -24977,7 +25144,7 @@ async function resolveSharedSidecarCredentials(options) {
 * factory.
 */
 function addCommonEcsServiceOptions(cmd) {
-	cmd.addOption(new Option("--cluster <name>", "Cluster name surfaced to ECS_CONTAINER_METADATA_URI_V4 and used as the docker network prefix").default(getEmbedConfig().resourceNamePrefix)).addOption(new Option("--env-vars <file>", "JSON env-var overrides (SAM-compatible: {\"ContainerName\":{\"KEY\":\"VALUE\"}, \"Parameters\":{}})")).addOption(new Option("--container-host <ip>", "Host IP to bind published container ports to. Must be a numeric IP (Docker rejects hostnames here)").default("127.0.0.1")).addOption(new Option("--assume-task-role [arn]", "Assume the task definition's TaskRoleArn (or the supplied ARN) and forward STS-issued temp credentials via the metadata sidecar so containers run with the deployed task role. Bare flag uses the template's TaskRoleArn; pass an explicit ARN to override.")).addOption(new Option("--no-pull", "Skip docker pull for every container image and the metadata sidecar")).addOption(new Option("--ecr-role-arn <arn>", "Role ARN to assume before authenticating against ECR for cross-account / centralized registries.")).addOption(new Option("--platform <platform>", "Force docker --platform (linux/amd64 or linux/arm64). Default: inferred from task RuntimePlatform.CpuArchitecture")).addOption(new Option("--max-tasks <n>", `Hard cap on local replica count. Caps the template DesiredCount so local dev machines don't run an unbounded number of containers. Cannot exceed ${83} due to the per-replica link-local /24 subnet allocator's range.`).default(3).argParser(parseMaxTasks)).addOption(new Option("--restart-policy <policy>", "How to react when an essential container exits. 'on-failure' (default) restarts only on non-zero exit; 'always' restarts on every exit; 'none' shuts the replica down and runs the service degraded.").default("on-failure").argParser(parseRestartPolicy)).addOption(new Option("--from-cfn-stack [cfn-stack-name]", `Read a deployed CloudFormation stack via ListStackResources and substitute Ref / Fn::ImportValue in container env vars / secrets / image URIs with the deployed physical IDs / exports. Use for CDK apps deployed via the upstream CDK CLI (\`cdk deploy\`). Bare form uses the ${getEmbedConfig().binaryName} stack name; pass an explicit value when the CFn stack name differs. Fn::GetAtt is warn-and-dropped in v1 (CFn ListStackResources does not return per-attribute values).`)).addOption(new Option("--stack-region <region>", "Region of the state record to read. Used with --from-cfn-stack as the CFn client region."));
+	cmd.addOption(new Option("--cluster <name>", "Cluster name surfaced to ECS_CONTAINER_METADATA_URI_V4 and used as the docker network prefix").default(getEmbedConfig().resourceNamePrefix)).addOption(new Option("--env-vars <file>", "JSON env-var overrides (SAM-compatible: {\"ContainerName\":{\"KEY\":\"VALUE\"}, \"Parameters\":{}})")).addOption(new Option("--container-host <ip>", "Host IP to bind published container ports to. Must be a numeric IP (Docker rejects hostnames here)").default("127.0.0.1")).addOption(new Option("--assume-task-role [arn]", "Assume the task definition's TaskRoleArn (or the supplied ARN) and forward STS-issued temp credentials via the metadata sidecar so containers run with the deployed task role. Bare flag uses the template's TaskRoleArn; pass an explicit ARN to override.")).addOption(new Option("--no-pull", "Skip docker pull for every container image and the metadata sidecar")).addOption(new Option("--ecr-role-arn <arn>", "Role ARN to assume before authenticating against ECR for cross-account / centralized registries.")).addOption(new Option("--platform <platform>", "Force docker --platform (linux/amd64 or linux/arm64). Default: inferred from task RuntimePlatform.CpuArchitecture")).addOption(new Option("--max-tasks <n>", `Hard cap on local replica count. Caps the template DesiredCount so local dev machines don't run an unbounded number of containers. Cannot exceed ${83} due to the per-replica link-local /24 subnet allocator's range.`).default(3).argParser(parseMaxTasks)).addOption(new Option("--restart-policy <policy>", "How to react when an essential container exits. 'on-failure' (default) restarts only on non-zero exit; 'always' restarts on every exit; 'none' shuts the replica down and runs the service degraded.").default("on-failure").argParser(parseRestartPolicy)).addOption(new Option("--from-cfn-stack [cfn-stack-name]", `Read a deployed CloudFormation stack via ListStackResources and substitute Ref / Fn::ImportValue in container env vars / secrets / image URIs with the deployed physical IDs / exports. Use for CDK apps deployed via the upstream CDK CLI (\`cdk deploy\`). Bare form uses the ${getEmbedConfig().binaryName} stack name; pass an explicit value when the CFn stack name differs. Fn::GetAtt is warn-and-dropped in v1 (CFn ListStackResources does not return per-attribute values).`)).addOption(new Option("--stack-region <region>", "Region of the state record to read. Used with --from-cfn-stack as the CFn client region.")).addOption(new Option("--no-logs", "Disable foreground streaming of each replica container stdout/stderr. By default every booted replica streams its docker logs to the host terminal with a [svc=<service> r=<replica-index> c=<container>] prefix (parity with `run-task`). Pass --no-logs for multi-replica / multi-service runs whose interleaved log volume is unreadable; `docker logs -f <id>` in a separate terminal stays available."));
 	[
 		...commonOptions(),
 		...appOptions(),
@@ -26005,5 +26172,5 @@ function addListSpecificOptions(cmd) {
 }
 
 //#endregion
-export { translateLambdaResponse as $, buildContainerImage as $t, addStartApiSpecificOptions as A, AGENTCORE_A2A_PROTOCOL as An, invokeAgentCoreWs as At, filterRoutesByApiIdentifiers as B, substituteImagePlaceholders as Bn, signAgentCoreInvocation as Bt, classifySourceChange as C, listTargets as Cn, verifyJwtViaDiscovery as Ct, createLocalRunTaskCommand as D, discoverRoutes as Dn, buildCorsConfigFromCloudFrontChain as Dt, addRunTaskSpecificOptions as E, parseSelectionExpressionPath as En, buildCorsConfigByApiId as Et, createFileWatcher as F, AgentCoreResolutionError as Fn, MCP_PATH as Ft, resolveServiceIntegrationParameters as G, SUPPORTED_CODE_RUNTIMES as Gt, readMtlsMaterialsFromDisk as H, LocalInvokeBuildError as Hn, invokeAgentCore as Ht, attachStageContext as I, pickAgentCoreCandidateStack as In, MCP_PROTOCOL_VERSION as It, computeRequestIdentityHash as J, renderCodeDockerfile as Jt, defaultCredentialsLoader as K, buildAgentCoreCodeImage as Kt, buildStageMap as L, resolveAgentCoreTarget as Ln, mcpInvokeOnce as Lt, createWatchPredicates as M, AGENTCORE_HTTP_PROTOCOL as Mn, A2A_PATH as Mt, resolveApiTargetSubset as N, AGENTCORE_MCP_PROTOCOL as Nn, a2aInvokeOnce as Nt, addInvokeAgentCoreSpecificOptions as O, pickRefLogicalId as On, isFunctionUrlOacFronted as Ot, createAuthorizerCache as P, AGENTCORE_RUNTIME_TYPE as Pn, MCP_CONTAINER_PORT as Pt, matchRoute as Q, architectureToPlatform as Qt, availableApiIdentifiers as R, derivePseudoParametersFromRegion as Rn, parseSseForJsonRpc as Rt, CloudMapRegistry as S, countTargets as Sn, verifyJwtAuthorizer as St, getContainerNetworkIp as T, discoverWebSocketApisOrThrow as Tn, applyCorsResponseHeaders as Tt, startApiServer as U, waitForAgentCorePing as Ut, groupRoutesByServer as V, tryResolveImageFnJoin as Vn, AGENTCORE_SESSION_ID_HEADER as Vt, resolveSelectionExpression as W, downloadAndExtractS3Bundle as Wt, invokeRequestAuthorizer as X, addInvokeSpecificOptions as Xt, evaluateCachedLambdaPolicy as Y, toCmdArgv as Yt, invokeTokenAuthorizer as Z, createLocalInvokeCommand as Zt, parseMaxTasks as _, CfnLocalStateProvider as _n, buildMessageEvent as _t, albStrategy as a, substituteAgainstStateAsync as an, selectIntegrationResponse as at, runEcsServiceEmulator as b, resolveWatchConfig as bn, createJwksCache as bt, resolveAlbTarget as c, resolveEnvVars as cn, HOST_GATEWAY_MIN_VERSION as ct, addStartServiceSpecificOptions as d, createLocalStateProvider as dn, ConnectionRegistry as dt, resolveRuntimeCodeMountPath as en, applyAuthorizerOverlay as et, createLocalStartServiceCommand as f, isCfnFlagPresent as fn, buildMgmtEndpointEnvUrl as ft, buildEcsImageResolutionContext as g, resolveCfnStackName as gn, buildDisconnectEvent as gt, addCommonEcsServiceOptions as h, resolveCfnRegion as hn, buildConnectEvent as ht, addAlbSpecificOptions as i, substituteAgainstState as in, pickResponseTemplate as it, createLocalStartApiCommand as j, AGENTCORE_AGUI_PROTOCOL as jn, A2A_CONTAINER_PORT as jt, createLocalInvokeAgentCoreCommand as k, resolveLambdaArnIntrinsic as kn, matchPreflight as kt, isApplicationLoadBalancer as l, materializeLayerFromArn as ln, probeHostGatewaySupport as lt, MAX_TASKS_SUBNET_RANGE_CAP as m, resolveCfnFallbackRegion as mn, parseConnectionsPath as mt, createLocalListCommand as n, resolveRuntimeImage as nn, buildRestV1Event as nt, createLocalStartAlbCommand as o, substituteEnvVarsFromState as on, tryParseStatus as ot, serviceStrategy as p, rejectExplicitCfnStackWithMultipleStacks as pn, handleConnectionsRequest as pt, buildMethodArn as q, computeCodeImageTag as qt, formatTargetListing as r, EcsTaskResolutionError as rn, evaluateResponseParameters as rt, parseLbPortOverrides as s, substituteEnvVarsFromStateAsync as sn, VtlEvaluationError as st, addListSpecificOptions as t, resolveRuntimeFileExtension as tn, buildHttpApiV2Event as tt, resolveAlbFrontDoor as u, LocalStateSourceError as un, bufferToBody as ut, parseRestartPolicy as v, collectSsmParameterRefs as vn, buildCognitoJwksUrl as vt, SOFT_RELOAD_COMPLETION_LOG_SUFFIX as w, discoverWebSocketApis as wn, attachAuthorizers as wt, buildCloudMapIndex as x, resolveSingleTarget as xn, verifyCognitoJwt as xt, resolveSharedSidecarCredentials as y, resolveSsmParameters as yn, buildJwksUrlFromIssuer as yt, filterRoutesByApiIdentifier as z, formatStateRemedy as zn, AGENTCORE_SIGV4_SERVICE as zt };
-//# sourceMappingURL=local-list-C-wXKogn.js.map
+export { matchRoute as $, architectureToPlatform as $t, createLocalInvokeAgentCoreCommand as A, resolveLambdaArnIntrinsic as An, matchPreflight as At, filterRoutesByApiIdentifier as B, formatStateRemedy as Bn, AGENTCORE_SIGV4_SERVICE as Bt, classifySourceChange as C, countTargets as Cn, verifyJwtAuthorizer as Ct, createLocalRunTaskCommand as D, parseSelectionExpressionPath as Dn, buildCorsConfigByApiId as Dt, addRunTaskSpecificOptions as E, discoverWebSocketApisOrThrow as En, applyCorsResponseHeaders as Et, createAuthorizerCache as F, AGENTCORE_RUNTIME_TYPE as Fn, MCP_CONTAINER_PORT as Ft, resolveSelectionExpression as G, downloadAndExtractS3Bundle as Gt, groupRoutesByServer as H, tryResolveImageFnJoin as Hn, AGENTCORE_SESSION_ID_HEADER as Ht, createFileWatcher as I, AgentCoreResolutionError as In, MCP_PATH as It, buildMethodArn as J, computeCodeImageTag as Jt, resolveServiceIntegrationParameters as K, SUPPORTED_CODE_RUNTIMES as Kt, attachStageContext as L, pickAgentCoreCandidateStack as Ln, MCP_PROTOCOL_VERSION as Lt, createLocalStartApiCommand as M, AGENTCORE_AGUI_PROTOCOL as Mn, A2A_CONTAINER_PORT as Mt, createWatchPredicates as N, AGENTCORE_HTTP_PROTOCOL as Nn, A2A_PATH as Nt, attachContainerLogStreamer as O, discoverRoutes as On, buildCorsConfigFromCloudFrontChain as Ot, resolveApiTargetSubset as P, AGENTCORE_MCP_PROTOCOL as Pn, a2aInvokeOnce as Pt, invokeTokenAuthorizer as Q, createLocalInvokeCommand as Qt, buildStageMap as R, resolveAgentCoreTarget as Rn, mcpInvokeOnce as Rt, CloudMapRegistry as S, resolveSingleTarget as Sn, verifyCognitoJwt as St, getContainerNetworkIp as T, discoverWebSocketApis as Tn, attachAuthorizers as Tt, readMtlsMaterialsFromDisk as U, LocalInvokeBuildError as Un, invokeAgentCore as Ut, filterRoutesByApiIdentifiers as V, substituteImagePlaceholders as Vn, signAgentCoreInvocation as Vt, startApiServer as W, waitForAgentCorePing as Wt, evaluateCachedLambdaPolicy as X, toCmdArgv as Xt, computeRequestIdentityHash as Y, renderCodeDockerfile as Yt, invokeRequestAuthorizer as Z, addInvokeSpecificOptions as Zt, parseMaxTasks as _, resolveCfnStackName as _n, buildDisconnectEvent as _t, albStrategy as a, substituteAgainstState as an, pickResponseTemplate as at, runEcsServiceEmulator as b, resolveSsmParameters as bn, buildJwksUrlFromIssuer as bt, resolveAlbTarget as c, substituteEnvVarsFromStateAsync as cn, VtlEvaluationError as ct, addStartServiceSpecificOptions as d, LocalStateSourceError as dn, bufferToBody as dt, buildContainerImage as en, translateLambdaResponse as et, createLocalStartServiceCommand as f, createLocalStateProvider as fn, ConnectionRegistry as ft, buildEcsImageResolutionContext as g, resolveCfnRegion as gn, buildConnectEvent as gt, addCommonEcsServiceOptions as h, resolveCfnFallbackRegion as hn, parseConnectionsPath as ht, addAlbSpecificOptions as i, EcsTaskResolutionError as in, evaluateResponseParameters as it, addStartApiSpecificOptions as j, AGENTCORE_A2A_PROTOCOL as jn, invokeAgentCoreWs as jt, addInvokeAgentCoreSpecificOptions as k, pickRefLogicalId as kn, isFunctionUrlOacFronted as kt, isApplicationLoadBalancer as l, resolveEnvVars as ln, HOST_GATEWAY_MIN_VERSION as lt, MAX_TASKS_SUBNET_RANGE_CAP as m, rejectExplicitCfnStackWithMultipleStacks as mn, handleConnectionsRequest as mt, createLocalListCommand as n, resolveRuntimeFileExtension as nn, buildHttpApiV2Event as nt, createLocalStartAlbCommand as o, substituteAgainstStateAsync as on, selectIntegrationResponse as ot, serviceStrategy as p, isCfnFlagPresent as pn, buildMgmtEndpointEnvUrl as pt, defaultCredentialsLoader as q, buildAgentCoreCodeImage as qt, formatTargetListing as r, resolveRuntimeImage as rn, buildRestV1Event as rt, parseLbPortOverrides as s, substituteEnvVarsFromState as sn, tryParseStatus as st, addListSpecificOptions as t, resolveRuntimeCodeMountPath as tn, applyAuthorizerOverlay as tt, resolveAlbFrontDoor as u, materializeLayerFromArn as un, probeHostGatewaySupport as ut, parseRestartPolicy as v, CfnLocalStateProvider as vn, buildMessageEvent as vt, SOFT_RELOAD_COMPLETION_LOG_SUFFIX as w, listTargets as wn, verifyJwtViaDiscovery as wt, buildCloudMapIndex as x, resolveWatchConfig as xn, createJwksCache as xt, resolveSharedSidecarCredentials as y, collectSsmParameterRefs as yn, buildCognitoJwksUrl as yt, availableApiIdentifiers as z, derivePseudoParametersFromRegion as zn, parseSseForJsonRpc as zt };
+//# sourceMappingURL=local-list-EOmrWeTr.js.map