cdk-local-lambda 0.0.2

package/lib/cli/commands/local.js

@@ -0,0 +1,1172 @@
+/**
+ * Local command for running Lambda functions locally using Docker.
+ *
+ * This command:
+ * 1. Starts CDK watch with CDK_LIVE=true and hotswap
+ * 2. Discovers Lambda functions with live-lambda:handler tag
+ * 3. Connects to AppSync Events
+ * 4. Subscribes to invocation channels
+ * 5. For each function, maintains ONE Docker container that handles all invocations
+ * 6. Sends responses back via AppSync
+ * 7. Re-discovers functions after each CDK deploy
+ */
+import { spawn } from "node:child_process";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { LambdaClient, ListFunctionsCommand, ListTagsCommand, } from "@aws-sdk/client-lambda";
+import { GetParameterCommand, SSMClient } from "@aws-sdk/client-ssm";
+import { Command, Options } from "@effect/cli";
+import { Command as PlatformCommand, } from "@effect/platform";
+import { BunContext } from "@effect/platform-bun";
+import { Duration, Effect, Exit, Fiber, Logger, LogLevel, Queue, Ref, Schedule, Scope, Stream, } from "effect";
+import { BOOTSTRAP_STACK_NAME, BOOTSTRAP_VERSION, buildChannelName, LIVE_LAMBDA_DOCKER_TAG, LIVE_LAMBDA_TAG, SSM_BASE_PATH, } from "../../shared/types.js";
+import { makeAppSyncClient } from "../appsync/client.js";
+import { buildExtensionWrapperCommand, Docker, DockerLive, makeLambdaContainerConfig, } from "../docker/container.js";
+import { watchDockerContexts, } from "../docker/watcher.js";
+import { notifyExtensionsInvoke, queueInvocation, startRuntimeApiServer, waitForResponse, } from "../runtime-api/server.js";
+/**
+ * Default idle timeout before proactively stopping containers.
+ * Set slightly below the poll timeout (240s) to stop container before
+ * the Lambda RIC gets a 503 error.
+ */
+const DEFAULT_IDLE_TIMEOUT_MS = 230_000; // 230 seconds (~4 minutes)
+/**
+ * Check if bootstrap stack version matches the expected version.
+ * Returns true if version matches, false if missing or mismatched.
+ */
+const checkBootstrapVersion = (qualifier) => Effect.gen(function* () {
+    const ssmClient = new SSMClient({});
+    const basePath = `${SSM_BASE_PATH}/${qualifier}`;
+    const result = yield* Effect.tryPromise({
+        try: async () => {
+            const response = await ssmClient.send(new GetParameterCommand({ Name: `${basePath}/version` }));
+            return response.Parameter?.Value;
+        },
+        catch: () => null,
+    }).pipe(Effect.catchAll(() => Effect.succeed(null)));
+    if (result === null) {
+        yield* Effect.logInfo("Bootstrap stack version parameter not found");
+        return false;
+    }
+    if (result !== BOOTSTRAP_VERSION) {
+        yield* Effect.logInfo(`Bootstrap stack version mismatch: found ${result}, expected ${BOOTSTRAP_VERSION}`);
+        return false;
+    }
+    return true;
+});
+/**
+ * Run the bootstrap stack deployment.
+ */
+const runBootstrap = (options) => Effect.gen(function* () {
+    yield* Effect.logInfo("Running bootstrap stack deployment...");
+    // Resolve the CDK app path relative to this module
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = path.dirname(__filename);
+    const cdkAppPath = path.resolve(__dirname, "..", "cdk-app.js");
+    const args = [
+        "cdk",
+        "deploy",
+        BOOTSTRAP_STACK_NAME,
+        "--require-approval",
+        "never",
+        "--app",
+        `bun ${cdkAppPath}`,
+    ];
+    if (options.profile) {
+        args.push("--profile", options.profile);
+    }
+    const env = {
+        ...process.env,
+    };
+    if (options.region) {
+        env.AWS_REGION = options.region;
+        env.CDK_DEFAULT_REGION = options.region;
+    }
+    yield* Effect.logInfo(`Running: npx ${args.join(" ")}`);
+    const command = PlatformCommand.make("npx", ...args).pipe(PlatformCommand.env(env), PlatformCommand.stdin("inherit"));
+    const proc = yield* PlatformCommand.start(command);
+    // Stream output to console
+    yield* Stream.merge(proc.stdout, proc.stderr).pipe(Stream.decodeText(), Stream.splitLines, Stream.runForEach((line) => Effect.sync(() => {
+        process.stdout.write(`${line}\n`);
+    })));
+    const exitCode = yield* proc.exitCode;
+    if (exitCode !== 0) {
+        return yield* Effect.fail(new Error(`Bootstrap deployment failed with exit code ${exitCode}`));
+    }
+    yield* Effect.logInfo("Bootstrap stack deployed successfully!");
+}).pipe(Effect.scoped);
+/**
+ * Ensure bootstrap stack is deployed with correct version.
+ * Automatically deploys if missing or outdated.
+ */
+const ensureBootstrap = (options) => Effect.gen(function* () {
+    yield* Effect.logDebug("[Local] Checking bootstrap stack version...");
+    const versionOk = yield* checkBootstrapVersion(options.qualifier);
+    if (!versionOk) {
+        yield* Effect.logInfo("[Local] Bootstrap stack needs to be deployed or updated.");
+        yield* runBootstrap({ profile: options.profile, region: options.region });
+    }
+    else {
+        yield* Effect.logDebug("[Local] Bootstrap stack version OK.");
+    }
+});
+/**
+ * Read AppSync endpoints from SSM.
+ */
+const getAppSyncEndpoints = (qualifier) => Effect.gen(function* () {
+    const ssmClient = new SSMClient({});
+    const basePath = `${SSM_BASE_PATH}/${qualifier}`;
+    const getParam = (name) => Effect.tryPromise({
+        try: async () => {
+            const result = await ssmClient.send(new GetParameterCommand({ Name: `${basePath}/${name}` }));
+            return result.Parameter?.Value ?? "";
+        },
+        catch: (error) => new Error(`Failed to get SSM parameter ${name}: ${String(error)}`),
+    });
+    const httpEndpoint = yield* getParam("http-endpoint");
+    const realtimeEndpoint = yield* getParam("realtime-endpoint");
+    return { httpEndpoint, realtimeEndpoint };
+});
+/**
+ * CloudFormation stack name tag (set automatically by CDK)
+ */
+const CFN_STACK_NAME_TAG = "aws:cloudformation:stack-name";
+/**
+ * Discover Lambda functions with live-lambda tags.
+ * @param stackFilter - Optional list of stack names to filter by
+ */
+const discoverFunctions = (stackFilter) => Effect.gen(function* () {
+    const lambdaClient = new LambdaClient({});
+    const functions = [];
+    // List all functions
+    let nextMarker;
+    do {
+        const listResponse = yield* Effect.tryPromise({
+            try: () => lambdaClient.send(new ListFunctionsCommand({ Marker: nextMarker })),
+            catch: (error) => new Error(`Failed to list functions: ${String(error)}`),
+        });
+        for (const fn of listResponse.Functions ?? []) {
+            // Get tags for each function
+            const tagsResult = yield* Effect.tryPromise({
+                try: () => lambdaClient.send(new ListTagsCommand({ Resource: fn.FunctionArn })),
+                catch: () => new Error(`Failed to get tags for ${fn.FunctionName}`),
+            }).pipe(Effect.catchAll(() => Effect.succeed({ Tags: {} })));
+            const tags = tagsResult.Tags ?? {};
+            // Check for live-lambda tag (handler) or docker-context tag
+            if (tags[LIVE_LAMBDA_TAG] || tags[LIVE_LAMBDA_DOCKER_TAG]) {
+                // Filter by stack name if specified
+                if (stackFilter && stackFilter.length > 0) {
+                    const stackName = tags[CFN_STACK_NAME_TAG];
+                    if (!stackName || !stackFilter.includes(stackName)) {
+                        continue;
+                    }
+                }
+                // Determine architecture from Lambda config
+                const architectures = fn.Architectures ?? ["x86_64"];
+                const architecture = architectures.includes("arm64")
+                    ? "arm64"
+                    : "x86_64";
+                const discovered = {
+                    functionName: fn.FunctionName,
+                    functionArn: fn.FunctionArn,
+                    localHandler: tags[LIVE_LAMBDA_TAG] ?? "",
+                    dockerContextPath: tags[LIVE_LAMBDA_DOCKER_TAG],
+                    memoryMB: fn.MemorySize ?? 128,
+                    architecture,
+                };
+                functions.push(discovered);
+            }
+        }
+        nextMarker = listResponse.NextMarker;
+    } while (nextMarker);
+    return functions;
+});
+/**
+ * Start a long-running Docker container for a function.
+ * Builds the image from the local Docker context path, then runs it.
+ * The container continuously polls our Runtime API for invocations.
+ * Uses Effect.forkDaemon to ensure the container runs independently with context.
+ */
+const startFunctionContainer = (fn, port, projectRoot, additionalEnv, invocationContexts) => Effect.gen(function* () {
+    if (!fn.dockerContextPath) {
+        return yield* Effect.fail(new Error(`Function ${fn.functionName} has no Docker context path`));
+    }
+    const docker = yield* Docker;
+    const dockerRuntime = yield* docker.getRuntimeInfo();
+    const runtimeApiHost = dockerRuntime.isDockerDesktop
+        ? "host.docker.internal"
+        : "runtime.api";
+    // Generate a local image name from function name
+    const imageName = `live-lambda-${fn.functionName.toLowerCase().replace(/[^a-z0-9-]/g, "-")}`;
+    // Resolve the context path relative to project root
+    const contextPath = fn.dockerContextPath.startsWith("/")
+        ? fn.dockerContextPath
+        : `${projectRoot}/${fn.dockerContextPath}`;
+    // Determine platform from architecture
+    const platform = fn.architecture === "arm64" ? "linux/arm64" : "linux/amd64";
+    // Build the Docker image from local context
+    yield* docker
+        .build({
+        contextPath,
+        imageName,
+        platform,
+    })
+        .pipe(Effect.scoped);
+    // Inspect the image to get original entrypoint/cmd for extension wrapper
+    const imageConfig = yield* docker.inspect(imageName).pipe(Effect.scoped);
+    const extensionWrapper = buildExtensionWrapperCommand(imageConfig.entrypoint, imageConfig.cmd);
+    const containerConfig = makeLambdaContainerConfig({
+        imageUri: imageName,
+        runtimeApiHost,
+        runtimeApiPort: port,
+        functionName: fn.functionName,
+        functionVersion: "$LATEST",
+        memoryMB: fn.memoryMB,
+        timeoutSeconds: 3600, // Long timeout - container stays running
+        platform,
+        additionalEnv,
+        invocationContexts,
+    });
+    // Apply extension wrapper to start extensions before the app
+    containerConfig.entrypoint = extensionWrapper.entrypoint;
+    containerConfig.command = extensionWrapper.command;
+    yield* Effect.logInfo(`Starting container for ${fn.functionName} on port ${port}`);
+    // Use Effect.forkDaemon to run the container independently with context preserved
+    // Effect.scoped provides the scope needed by docker.run
+    const fiber = yield* docker.run(containerConfig).pipe(Effect.scoped, Effect.map(() => undefined), Effect.forkDaemon);
+    return fiber;
+}).pipe(Effect.provide(DockerLive));
+// Type guards for response types
+const isLambdaResponse = (r) => "body" in r && !("errorType" in r);
+const isLambdaError = (r) => "requestId" in r && "errorType" in r;
+const isLambdaInitError = (r) => !("requestId" in r) && "errorType" in r;
+/**
+ * Reset the idle timer for a container.
+ * After the timeout expires with no new responses, the container is stopped.
+ * This prevents the confusing 503 error from the Lambda RIC when the poll times out.
+ */
+const resetIdleTimer = (container, containersRef, idleTimeoutMs) => Effect.gen(function* () {
+    // Cancel existing timer if any
+    if (container.idleTimerFiber) {
+        yield* Fiber.interrupt(container.idleTimerFiber).pipe(Effect.catchAll(() => Effect.void));
+        container.idleTimerFiber = null;
+    }
+    // Start new timer - use never for error type since we catch all errors
+    const timerFiber = yield* Effect.gen(function* () {
+        yield* Effect.sleep(Duration.millis(idleTimeoutMs));
+        // Timer expired - stop container proactively
+        yield* Effect.logInfo(`[Local] Stopping idle container ${container.fn.functionName} (will restart on next invocation)`);
+        // Stop the container using Docker with fast timeout (1s)
+        // The container may be blocked on long-polling, so we need to force kill
+        const docker = yield* Docker;
+        yield* docker.stop(container.containerName, 1).pipe(Effect.scoped, Effect.catchAll(() => Effect.void));
+        // Remove from map so next invocation creates fresh container
+        const currentContainers = yield* Ref.get(containersRef);
+        currentContainers.delete(container.fn.functionName);
+        yield* Ref.set(containersRef, currentContainers);
+    }).pipe(Effect.provide(DockerLive), Effect.catchAll(() => Effect.void), Effect.forkDaemon);
+    container.idleTimerFiber = timerFiber;
+});
+/**
+ * Process responses from a container and dispatch to waiting callers.
+ * After each response, resets the idle timer to proactively stop the container
+ * before the poll timeout causes confusing Lambda RIC errors.
+ */
+const processContainerResponses = (container, containersRef, idleTimeoutMs, client, invocationContexts) => Effect.gen(function* () {
+    const responseChannel = buildChannelName.response(container.fn.functionName);
+    // Continuously process responses from the container
+    while (true) {
+        const result = yield* waitForResponse(container.runtimeState);
+        let response;
+        if (isLambdaResponse(result)) {
+            response = {
+                type: "response",
+                requestId: result.requestId,
+                result: result.body,
+            };
+        }
+        else if (isLambdaError(result)) {
+            response = {
+                type: "response",
+                requestId: result.requestId,
+                error: {
+                    errorType: result.errorType,
+                    errorMessage: result.errorMessage,
+                    stackTrace: result.stackTrace,
+                },
+            };
+        }
+        else if (isLambdaInitError(result)) {
+            yield* Effect.logError(`[Local] Init error: ${result.errorType}: ${result.errorMessage}`);
+            continue;
+        }
+        else {
+            continue;
+        }
+        // Send response back via AppSync
+        yield* client.publishResponse(responseChannel, response);
+        yield* Effect.logDebug(`[Local] Sent response for ${response.requestId}`);
+        // Print end marker with timing
+        const ctx = invocationContexts.get(response.requestId);
+        if (ctx) {
+            const durationMs = Date.now() - ctx.start;
+            if (response.error) {
+                console.log(`[${ctx.num}] \u2514\u2500\u2500 \u2717 ${response.error.errorType}: ${response.error.errorMessage} (${durationMs}ms) \u2500\u2500`);
+            }
+            else {
+                console.log(`[${ctx.num}] \u2514\u2500\u2500 \u2713 Done (${durationMs}ms) \u2500\u2500`);
+            }
+            invocationContexts.delete(response.requestId);
+        }
+        // Reset idle timer - container will be stopped if no new invocations arrive
+        yield* resetIdleTimer(container, containersRef, idleTimeoutMs);
+    }
+});
+/**
+ * Start a Node.js worker process for a function.
+ * Spawns Bun to run the runtime wrapper with the handler path.
+ * The worker continuously polls our Runtime API for invocations.
+ */
+const startNodejsWorker = (fn, port, projectRoot, env, invocationContexts) => Effect.gen(function* () {
+    if (!fn.localHandler) {
+        return yield* Effect.fail(new Error(`Function ${fn.functionName} has no local handler path`));
+    }
+    // Resolve the runtime wrapper path relative to this module
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = path.dirname(__filename);
+    const runtimeWrapperPath = path.resolve(__dirname, "..", "runtime-wrapper", "nodejs-runtime.js");
+    // Get absolute path to bun for pure env isolation (no PATH dependency)
+    const bunPath = Bun.which("bun");
+    if (!bunPath) {
+        return yield* Effect.fail(new Error("Could not find 'bun' executable in PATH"));
+    }
+    // Build environment for the worker process
+    // Pure isolation: only env from bridge + local overrides, no local PATH/HOME
+    const workerEnv = {
+        // Start with env vars from the bridge Lambda (AWS credentials, user-defined vars)
+        ...env,
+        // Local overrides (these are set by the daemon, not from bridge)
+        AWS_LAMBDA_RUNTIME_API: `localhost:${port}`,
+        _HANDLER: fn.localHandler,
+        LAMBDA_TASK_ROOT: projectRoot,
+        // Memory limit for context object
+        AWS_LAMBDA_FUNCTION_MEMORY_SIZE: String(fn.memoryMB),
+    };
+    yield* Effect.logDebug(`[Local] Starting Node.js worker for ${fn.functionName} on port ${port}`);
+    yield* Effect.logDebug(`[Local] Handler: ${fn.localHandler}`);
+    // Spawn Bun with --watch to automatically restart when handler files change
+    // This enables hot-reload without needing to restart the daemon
+    // Use absolute bun path for pure env isolation (no PATH dependency)
+    const workerProcess = spawn(bunPath, ["--watch", runtimeWrapperPath], {
+        cwd: projectRoot,
+        env: workerEnv,
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    // Pattern to parse Lambda log format: TIMESTAMP\tREQUEST_ID\tLEVEL\tMESSAGE
+    // Lambda uses tabs between fields. Captures: [1] = request ID, [2] = level + message
+    const lambdaLogPattern = /^(\d{4}-\d{2}-\d{2}T[\d:.]+Z)[\t\s]+([0-9a-f-]{36})[\t\s]+(.*)$/i;
+    // Helper to format log line with invocation prefix
+    const formatLine = (rawLine) => {
+        // Strip carriage returns that can cause terminal corruption
+        const line = rawLine.replace(/\r/g, "");
+        const match = lambdaLogPattern.exec(line);
+        if (match) {
+            const requestId = match[2];
+            const ctx = invocationContexts.get(requestId);
+            if (ctx) {
+                // Strip timestamp and request ID, keep just LEVEL MESSAGE
+                return { prefix: `[${ctx.num}]`, content: match[3] };
+            }
+        }
+        return { prefix: "[Worker]", content: line };
+    };
+    // Forward stdout/stderr with invocation number prefix
+    workerProcess.stdout?.on("data", (data) => {
+        const lines = data.toString().trim().split("\n");
+        for (const rawLine of lines) {
+            const { prefix, content } = formatLine(rawLine);
+            console.log(`${prefix} ${content}`);
+        }
+    });
+    workerProcess.stderr?.on("data", (data) => {
+        const lines = data.toString().trim().split("\n");
+        for (const rawLine of lines) {
+            const { prefix, content } = formatLine(rawLine);
+            console.error(`${prefix} ${content}`);
+        }
+    });
+    workerProcess.on("error", (err) => {
+        Effect.runSync(Effect.logError(`Worker error: ${err.message}`).pipe(Effect.annotateLogs("function", fn.functionName)));
+    });
+    workerProcess.on("close", (code) => {
+        Effect.runSync(Effect.logInfo(`Worker exited with code ${code}`).pipe(Effect.annotateLogs("function", fn.functionName)));
+    });
+    return workerProcess;
+});
+/**
+ * Process responses from a Node.js worker and dispatch to waiting callers.
+ */
+const processWorkerResponses = (worker, client, invocationContexts) => Effect.gen(function* () {
+    const responseChannel = buildChannelName.response(worker.fn.functionName);
+    // Continuously process responses from the worker
+    while (true) {
+        const result = yield* waitForResponse(worker.runtimeState);
+        let response;
+        if (isLambdaResponse(result)) {
+            response = {
+                type: "response",
+                requestId: result.requestId,
+                result: result.body,
+            };
+        }
+        else if (isLambdaError(result)) {
+            response = {
+                type: "response",
+                requestId: result.requestId,
+                error: {
+                    errorType: result.errorType,
+                    errorMessage: result.errorMessage,
+                    stackTrace: result.stackTrace,
+                },
+            };
+        }
+        else if (isLambdaInitError(result)) {
+            yield* Effect.logError(`[Local] Worker init error: ${result.errorType}: ${result.errorMessage}`);
+            continue;
+        }
+        else {
+            continue;
+        }
+        // Send response back via AppSync
+        yield* client.publishResponse(responseChannel, response);
+        yield* Effect.logDebug(`[Local] Sent response for ${response.requestId}`);
+        // Print end marker with timing
+        const ctx = invocationContexts.get(response.requestId);
+        if (ctx) {
+            const durationMs = Date.now() - ctx.start;
+            if (response.error) {
+                console.log(`[${ctx.num}] \u2514\u2500\u2500 \u2717 ${response.error.errorType}: ${response.error.errorMessage} (${durationMs}ms) \u2500\u2500`);
+            }
+            else {
+                console.log(`[${ctx.num}] \u2514\u2500\u2500 \u2713 Done (${durationMs}ms) \u2500\u2500`);
+            }
+            invocationContexts.delete(response.requestId);
+        }
+    }
+});
+/**
+ * Environment variables to completely filter out from invocation env.
+ * These are not relevant for local execution.
+ */
+const ENV_VARS_TO_FILTER = new Set(["AWS_LAMBDA_LOG_STREAM_NAME"]);
+/**
+ * Environment variables to ignore when calculating if env has changed.
+ * These change frequently but don't require a container restart.
+ *
+ * TODO: AWS credentials (ACCESS_KEY_ID, SECRET_ACCESS_KEY, SESSION_TOKEN)
+ * do expire and will need refreshing. For now we ignore them to avoid
+ * unnecessary restarts, but we should implement credential refresh logic
+ * that updates the container's credentials without a full restart.
+ */
+const ENV_VARS_TO_IGNORE_IN_DIFF = new Set([
+    "AWS_ACCESS_KEY_ID",
+    "AWS_SECRET_ACCESS_KEY",
+    "AWS_SESSION_TOKEN",
+]);
+/**
+ * Filter out irrelevant env vars from invocation environment.
+ */
+const sanitizeInvocationEnv = (env) => {
+    const result = {};
+    for (const [key, value] of Object.entries(env)) {
+        if (!ENV_VARS_TO_FILTER.has(key)) {
+            result[key] = value;
+        }
+    }
+    return result;
+};
+/**
+ * Compute which environment variables have changed between two env objects.
+ * Returns a human-readable summary of the changes.
+ * Ignores env vars in ENV_VARS_TO_IGNORE_IN_DIFF.
+ */
+const getEnvDiff = (oldEnv, newEnv) => {
+    const changes = [];
+    // Check for added or modified keys
+    for (const key of Object.keys(newEnv)) {
+        if (ENV_VARS_TO_IGNORE_IN_DIFF.has(key))
+            continue;
+        if (!(key in oldEnv)) {
+            changes.push(`+${key}`);
+        }
+        else if (oldEnv[key] !== newEnv[key]) {
+            changes.push(`~${key}`);
+        }
+    }
+    // Check for removed keys
+    for (const key of Object.keys(oldEnv)) {
+        if (ENV_VARS_TO_IGNORE_IN_DIFF.has(key))
+            continue;
+        if (!(key in newEnv)) {
+            changes.push(`-${key}`);
+        }
+    }
+    return changes.join(", ");
+};
+/**
+ * Ensure a Node.js worker is started for a function.
+ * If the worker already exists, return it.
+ * Otherwise, create the Runtime API server, add to workers map, and start the worker.
+ */
+const ensureWorkerStarted = (fn, invocationEnv, workersRef, serverScope, projectRoot, appSyncClient, invocationContexts) => Effect.gen(function* () {
+    // Check if worker already exists
+    const currentWorkers = yield* Ref.get(workersRef);
+    const existing = currentWorkers.get(fn.functionName);
+    if (existing) {
+        // Check if env vars have changed (e.g., after CDK redeploy)
+        const envDiff = getEnvDiff(existing.env, invocationEnv);
+        if (envDiff) {
+            yield* Effect.logInfo(`[Local] Environment changed for ${fn.functionName}, restarting worker... (${envDiff})`);
+            // Kill the old worker
+            yield* Effect.try(() => existing.workerProcess.kill("SIGTERM")).pipe(Effect.catchAll(() => Effect.void));
+            // Remove from map so we create a new one below
+            currentWorkers.delete(fn.functionName);
+            yield* Ref.set(workersRef, currentWorkers);
+        }
+        else {
+            return existing;
+        }
+    }
+    // Worker doesn't exist - start it lazily
+    yield* Effect.logDebug(`[Local] Starting Node.js worker for first invocation of ${fn.functionName}...`);
+    // Create Runtime API server on ephemeral port
+    const { port, state: runtimeState } = yield* startRuntimeApiServer({
+        functionMetadata: {
+            functionName: fn.functionName,
+            functionVersion: "$LATEST",
+            handler: fn.localHandler,
+        },
+    }).pipe(Effect.provideService(Scope.Scope, serverScope));
+    // Create worker object (without process initially - will be set after start)
+    // We add to map BEFORE starting worker to handle concurrent invocations
+    const worker = {
+        fn,
+        runtimeState,
+        port,
+        workerProcess: undefined, // Will be set shortly
+        env: invocationEnv,
+    };
+    // Add to map immediately to prevent race conditions
+    currentWorkers.set(fn.functionName, worker);
+    yield* Ref.set(workersRef, currentWorkers);
+    // Start the worker process - remove from map on failure
+    const workerProcess = yield* startNodejsWorker(fn, port, projectRoot, invocationEnv, invocationContexts).pipe(Effect.catchAll((error) => Effect.gen(function* () {
+        // Remove broken worker from map on failure
+        yield* Effect.logError(`[Local] Failed to start worker for ${fn.functionName}: ${error}`);
+        const current = yield* Ref.get(workersRef);
+        current.delete(fn.functionName);
+        yield* Ref.set(workersRef, current);
+        return yield* Effect.fail(error);
+    })));
+    // Update worker with the process
+    worker.workerProcess = workerProcess;
+    // Start processing responses in the background
+    Effect.runFork(processWorkerResponses(worker, appSyncClient, invocationContexts));
+    return worker;
+});
+/**
+ * Ensure a container is started for a function.
+ * If the container already exists, return it.
+ * If the env vars have changed, restart the container.
+ * Otherwise, create the Runtime API server, add to containers map, and start the container.
+ */
+const ensureContainerStarted = (fn, invocationEnv, containersRef, serverScope, projectRoot, idleTimeoutMs, pollTimeoutMs, appSyncClient, invocationContexts) => Effect.gen(function* () {
+    // Check if container already exists
+    const currentContainers = yield* Ref.get(containersRef);
+    const existing = currentContainers.get(fn.functionName);
+    if (existing) {
+        // Check if env vars have changed (e.g., after CDK redeploy)
+        const envDiff = getEnvDiff(existing.env, invocationEnv);
+        if (envDiff) {
+            // IMPORTANT: Update env immediately (before any yields) to prevent
+            // other concurrent invocations from also detecting the change and
+            // triggering duplicate restarts
+            existing.env = invocationEnv;
+            // If already restarting for env change, just return the existing container
+            // The invocation will be queued and picked up by the new container
+            if (existing.isRebuilding) {
+                yield* Effect.logDebug(`[Local] Environment change restart already in progress for ${fn.functionName}, queueing invocation`);
+                return existing;
+            }
+            yield* Effect.logInfo(`[Local] Environment changed for ${fn.functionName}, restarting container... (${envDiff})`);
+            existing.isRebuilding = true;
+            // Stop the Docker container forcefully (timeout=1s)
+            // This sends SIGTERM and then SIGKILL after 1 second
+            // We must do this BEFORE interrupting the fiber, because the fiber is
+            // blocked waiting for the docker process to exit
+            yield* Effect.gen(function* () {
+                const docker = yield* Docker;
+                yield* docker.stop(existing.containerName, 1).pipe(Effect.scoped);
+            }).pipe(Effect.provide(DockerLive), Effect.catchAll((error) => Effect.logDebug(`[Local] Error stopping container (may already be stopped): ${error}`)));
+            // Now interrupt the fiber (it should complete quickly since container stopped)
+            yield* Fiber.interrupt(existing.containerFiber).pipe(Effect.catchAll(() => Effect.void));
+            // Restart the container with new environment, reusing existing RuntimeAPI
+            const newFiber = yield* startFunctionContainer(fn, existing.port, projectRoot, invocationEnv, invocationContexts).pipe(Effect.catchAll((error) => Effect.gen(function* () {
+                yield* Effect.logError(`[Local] Failed to restart container for ${fn.functionName}: ${error}`);
+                existing.isRebuilding = false;
+                return yield* Effect.fail(error);
+            })));
+            // Update container with new fiber
+            existing.containerFiber = newFiber;
+            existing.isRebuilding = false;
+            return existing;
+        }
+        else {
+            return existing;
+        }
+    }
+    // Container doesn't exist - start it lazily
+    yield* Effect.logInfo(`[Local] Starting container for first invocation of ${fn.functionName}...`);
+    // Create Runtime API server on ephemeral port
+    // Use poll timeout that's shorter than idle timeout so container exits naturally
+    const { port, state: runtimeState } = yield* startRuntimeApiServer({
+        pollTimeoutMs,
+        functionMetadata: {
+            functionName: fn.functionName,
+            functionVersion: "$LATEST",
+            handler: "index.handler",
+        },
+    }).pipe(Effect.provideService(Scope.Scope, serverScope));
+    // Generate container name and image name
+    const containerName = `lambda-${fn.functionName.replace(/[^a-zA-Z0-9]/g, "-")}`;
+    const imageName = `live-lambda-${fn.functionName.toLowerCase().replace(/[^a-z0-9-]/g, "-")}`;
+    // Create container object (without fiber initially - will be set after start)
+    // We add to map BEFORE starting container to handle concurrent invocations
+    const container = {
+        fn,
+        runtimeState,
+        port,
+        containerFiber: undefined, // Will be set shortly
+        containerName,
+        imageName,
+        isRebuilding: false,
+        pendingResponses: new Map(),
+        idleTimerFiber: null,
+        env: invocationEnv,
+    };
+    // Add to map immediately to prevent race conditions
+    currentContainers.set(fn.functionName, container);
+    yield* Ref.set(containersRef, currentContainers);
+    // Build and start the container - remove from map on failure
+    const containerFiber = yield* startFunctionContainer(fn, port, projectRoot, invocationEnv, invocationContexts).pipe(Effect.catchAll((error) => Effect.gen(function* () {
+        // Remove broken container from map on failure
+        yield* Effect.logError(`[Local] Failed to start container for ${fn.functionName}: ${error}`);
+        const current = yield* Ref.get(containersRef);
+        current.delete(fn.functionName);
+        yield* Ref.set(containersRef, current);
+        return yield* Effect.fail(error);
+    })));
+    // Update container with the fiber
+    container.containerFiber = containerFiber;
+    // Start processing responses in the background using forkDaemon
+    yield* processContainerResponses(container, containersRef, idleTimeoutMs, appSyncClient, invocationContexts).pipe(Effect.forkDaemon);
+    return container;
+});
+/**
+ * Rebuild a Docker container after file changes.
+ * Invocations arriving during rebuild will be queued and picked up by the new container.
+ */
+const rebuildDockerContainer = (functionId, containersRef, projectRoot) => Effect.gen(function* () {
+    const containers = yield* Ref.get(containersRef);
+    const container = containers.get(functionId);
+    if (!container) {
+        yield* Effect.logInfo(`[Local] Cannot rebuild ${functionId} - container not found`);
+        return;
+    }
+    // Mark as rebuilding - invocations will still queue but we log it
+    container.isRebuilding = true;
+    yield* Effect.logDebug(`[Local] Rebuilding container for ${functionId}...`);
+    const docker = yield* Docker;
+    // Stop the existing container using Docker service
+    const containerId = container.containerName;
+    yield* Effect.logInfo(`[Local] Stopping container with name prefix: ${containerId}`);
+    const stopCount = yield* docker.stop(containerId).pipe(Effect.scoped, Effect.catchAll((error) => Effect.gen(function* () {
+        yield* Effect.logInfo(`Note: Container stop had issue: ${error}`);
+        return 0;
+    })));
+    yield* Effect.logDebug(`[Local] Stopped ${stopCount} container(s)`);
+    // Resolve the context path
+    const fn = container.fn;
+    const contextPath = fn.dockerContextPath?.startsWith("/")
+        ? fn.dockerContextPath
+        : `${projectRoot}/${fn.dockerContextPath}`;
+    // Determine platform from architecture
+    const platform = fn.architecture === "arm64" ? "linux/arm64" : "linux/amd64";
+    // Rebuild the Docker image
+    yield* docker
+        .build({
+        contextPath,
+        imageName: container.imageName,
+        platform,
+    })
+        .pipe(Effect.scoped);
+    // Inspect the image to get original entrypoint/cmd for extension wrapper
+    const imageConfig = yield* docker
+        .inspect(container.imageName)
+        .pipe(Effect.scoped);
+    const extensionWrapper = buildExtensionWrapperCommand(imageConfig.entrypoint, imageConfig.cmd);
+    // Restart the container by triggering container startup
+    // The existing fiber will have exited when we stopped the container
+    // We need to start a new one
+    const dockerRuntime = yield* docker.getRuntimeInfo();
+    const runtimeApiHost = dockerRuntime.isDockerDesktop
+        ? "host.docker.internal"
+        : "runtime.api";
+    yield* Effect.logInfo(`[Local] New container will connect to Runtime API at ${runtimeApiHost}:${container.port}`);
+    const containerConfig = makeLambdaContainerConfig({
+        imageUri: container.imageName,
+        runtimeApiHost,
+        runtimeApiPort: container.port,
+        functionName: fn.functionName,
+        functionVersion: "$LATEST",
+        memoryMB: fn.memoryMB,
+        timeoutSeconds: 3600,
+        platform,
+    });
+    // Apply extension wrapper to start extensions before the app
+    containerConfig.entrypoint = extensionWrapper.entrypoint;
+    containerConfig.command = extensionWrapper.command;
+    // Start the new container
+    yield* Effect.logDebug(`[Local] Starting new container for ${functionId}...`);
+    // Use Effect.forkDaemon to run the container independently
+    const newFiber = yield* docker.run(containerConfig).pipe(Effect.scoped, Effect.tap((result) => Effect.gen(function* () {
+        // Only suppress errors for expected exit codes from docker stop:
+        // 0: clean, 143: SIGTERM, 137: SIGKILL
+        const code = result.exitCode;
+        if (code !== 0 && code !== 143 && code !== 137) {
+            yield* Effect.logError(`Container for ${functionId} exited with code ${code}`);
+            yield* Effect.logError(`stderr: ${result.stderr}`);
+        }
+    })), Effect.map(() => undefined), Effect.catchAll((error) => Effect.logError(`Container error for ${functionId}: ${error}`)), Effect.forkDaemon);
+    // Update the container state with the new fiber
+    container.containerFiber = newFiber;
+    // Wait a moment for the container to start and begin polling
+    yield* Effect.sleep("2 seconds");
+    container.isRebuilding = false;
+    yield* Effect.logDebug(`[Local] Container rebuilt for ${functionId}`);
+}).pipe(Effect.provide(DockerLive));
+/**
+ * Handle incoming invocations for a Docker container function by queueing them.
+ * Starts the container lazily if not already running.
+ * Invocations are queued even if a rebuild is in progress - the new container will pick them up.
+ */
+const handleDockerInvocation = (fn, invocation, containersRef, serverScope, projectRoot, idleTimeoutMs, pollTimeoutMs, appSyncClient, invocationCounter, invocationContexts) => Effect.gen(function* () {
+    // Ensure container is started (lazy startup on first invocation)
+    // Use env from invocation (captured from bridge Lambda on first invoke)
+    const container = yield* ensureContainerStarted(fn, sanitizeInvocationEnv(invocation.env ?? {}), containersRef, serverScope, projectRoot, idleTimeoutMs, pollTimeoutMs, appSyncClient, invocationContexts);
+    // Assign invocation number and track context for logging
+    const invocationNum = yield* Ref.updateAndGet(invocationCounter, (n) => n + 1);
+    const startTime = Date.now();
+    invocationContexts.set(invocation.requestId, {
+        num: invocationNum,
+        start: startTime,
+        fn: fn.functionName,
+        isDocker: true,
+    });
+    // Print start marker
+    console.log(`\n[${invocationNum}] \u250c\u2500\u2500 [Docker] ${fn.functionName} \u2500\u2500`);
+    // Log if queuing during a rebuild
+    if (container.isRebuilding) {
+        yield* Effect.logDebug(`[Local] Queueing invocation ${invocation.requestId} for ${fn.functionName} (rebuild in progress, will be picked up by new container)`);
+    }
+    else {
+        yield* Effect.logDebug(`[Local] Queueing invocation ${invocation.requestId} for ${fn.functionName}`);
+    }
+    const lambdaInvocation = {
+        requestId: invocation.requestId,
+        event: invocation.event,
+        invokedFunctionArn: invocation.context.invokedFunctionArn,
+        deadlineMs: Date.now() + invocation.context.getRemainingTimeInMillis,
+        functionName: fn.functionName,
+        functionVersion: invocation.context.functionVersion,
+        memoryLimitMB: fn.memoryMB,
+        logGroupName: invocation.context.logGroupName,
+        logStreamName: invocation.context.logStreamName,
+    };
+    yield* Effect.logDebug(`[Local] Queueing to Runtime API on port ${container.port}`);
+    // Notify extensions about the invocation (for Lambda Web Adapter support)
+    yield* notifyExtensionsInvoke(container.runtimeState, lambdaInvocation);
+    yield* queueInvocation(container.runtimeState, lambdaInvocation);
+    yield* Effect.logDebug(`[Local] Invocation queued successfully`);
+});
+/**
+ * Handle incoming invocations for a Node.js function by queueing them.
+ * Starts the worker lazily if not already running.
+ */
+const handleNodejsInvocation = (fn, invocation, workersRef, serverScope, projectRoot, appSyncClient, invocationCounter, invocationContexts) => Effect.gen(function* () {
+    // Get env vars from invocation (forwarded from bridge Lambda)
+    const invocationEnv = sanitizeInvocationEnv(invocation.env ?? {});
+    // Ensure worker is started (lazy startup on first invocation)
+    const worker = yield* ensureWorkerStarted(fn, invocationEnv, workersRef, serverScope, projectRoot, appSyncClient, invocationContexts);
+    // Assign invocation number and track context for logging
+    const invocationNum = yield* Ref.updateAndGet(invocationCounter, (n) => n + 1);
+    const startTime = Date.now();
+    invocationContexts.set(invocation.requestId, {
+        num: invocationNum,
+        start: startTime,
+        fn: fn.functionName,
+        isDocker: false,
+    });
+    // Print start marker
+    console.log(`\n[${invocationNum}] \u250c\u2500\u2500 ${fn.functionName} \u2500\u2500`);
+    yield* Effect.logDebug(`[Local] Queueing invocation ${invocation.requestId} for ${fn.functionName}`);
+    const lambdaInvocation = {
+        requestId: invocation.requestId,
+        event: invocation.event,
+        invokedFunctionArn: invocation.context.invokedFunctionArn,
+        deadlineMs: Date.now() + invocation.context.getRemainingTimeInMillis,
+        functionName: fn.functionName,
+        functionVersion: invocation.context.functionVersion,
+        memoryLimitMB: fn.memoryMB,
+        logGroupName: invocation.context.logGroupName,
+        logStreamName: invocation.context.logStreamName,
+    };
+    yield* queueInvocation(worker.runtimeState, lambdaInvocation);
+});
+/**
+ * Start CDK watch process with CDK_LIVE=true using Effect's Command.
+ * Returns the process and a queue of events.
+ */
+const startCdkWatch = (options, scope) => Effect.gen(function* () {
+    const args = [
+        "cdk",
+        "watch",
+        "--hotswap-fallback",
+        "--no-logs",
+        "--method=direct",
+    ];
+    if (options.stacks && options.stacks.length > 0) {
+        args.push(...options.stacks);
+    }
+    else if (options.all) {
+        args.push("--all");
+    }
+    if (options.profile) {
+        args.push("--profile", options.profile);
+    }
+    const env = {
+        ...process.env,
+        CDK_LIVE: "true",
+    };
+    if (options.region) {
+        env.AWS_REGION = options.region;
+        env.CDK_DEFAULT_REGION = options.region;
+    }
+    yield* Effect.logDebug(`Starting: npx ${args.join(" ")}`);
+    const command = PlatformCommand.make("npx", ...args).pipe(PlatformCommand.env(env), PlatformCommand.runInShell(true), PlatformCommand.stdin("inherit"));
+    // Extend the process resource lifetime to the provided scope
+    const proc = yield* PlatformCommand.start(command).pipe(Scope.extend(scope));
+    // Event queue for callers to subscribe to
+    const events = yield* Queue.unbounded();
+    // State tracking for deploy status messages
+    let isDeploying = false;
+    let isFirstDeploy = true;
+    let outputBuffer = "";
+    const discoveredStacks = new Set();
+    // Patterns to detect CDK watch behavior
+    const deployCompletePattern = /✅\s+\S+|Deployment time:/;
+    const deployStartPattern = /Deploying|hotswap|Hotswapping|Bundling/i;
+    const noChangesPattern = /no changes|identical|up to date/i;
+    const errorPattern = /error|failed|Error|Failed|ERR!/i;
+    const stackNamePattern = /^(\S+):\s*deploying|✅\s+(\S+)/;
+    // Merge stdout and stderr, decode to text, split into lines
+    const outputStream = Stream.merge(proc.stdout, proc.stderr).pipe(Stream.decodeText(), Stream.splitLines);
+    // Fork stream processing in background
+    yield* outputStream.pipe(Stream.runForEach((line) => Effect.gen(function* () {
+        outputBuffer += line + "\n";
+        // Log all output at debug level
+        yield* Effect.logDebug(`[CDK] ${line}`);
+        // Try to extract stack name
+        const match = stackNamePattern.exec(line.trim());
+        if (match) {
+            const stackName = match[1] || match[2];
+            if (stackName && !discoveredStacks.has(stackName)) {
+                discoveredStacks.add(stackName);
+                yield* Queue.offer(events, {
+                    _tag: "StackDiscovered",
+                    stackName,
+                });
+            }
+        }
+        // Detect deploy start
+        if (!isDeploying && deployStartPattern.test(line)) {
+            isDeploying = true;
+            if (!isFirstDeploy) {
+                yield* Effect.logInfo("[CDK] Deploying...");
+            }
+        }
+        // Detect errors - output immediately
+        if (errorPattern.test(line)) {
+            yield* Effect.sync(() => process.stderr.write(line + "\n"));
+        }
+        // Check for deploy completion (only trigger once per deploy cycle)
+        if (isDeploying && deployCompletePattern.test(line)) {
+            isDeploying = false;
+            isFirstDeploy = false;
+            outputBuffer = "";
+            yield* Effect.logInfo("[CDK] Deploy complete");
+            // Small delay to ensure AWS has propagated the changes
+            yield* Effect.sleep("1 second");
+            yield* Queue.offer(events, { _tag: "DeployComplete" });
+        }
+        // Check for no changes
+        if (noChangesPattern.test(line)) {
+            isDeploying = false;
+            outputBuffer = "";
+        }
+    })), 
+    // Log errors and exit code when stream ends
+    Effect.tapError((error) => Effect.logError(`[CDK] CDK watch error: ${error}`)), Effect.ensuring(proc.exitCode.pipe(Effect.flatMap((code) => code !== 0
+        ? Effect.logError(`[CDK] CDK watch exited with code ${code}`)
+        : Effect.logDebug(`[CDK] CDK watch exited with code ${code}`)), Effect.catchAll(() => Effect.void))), Effect.fork);
+    return { process: proc, events };
+});
+/**
+ * Common CLI options.
+ */
+const profileOption = Options.text("profile").pipe(Options.optional, Options.withDescription("AWS profile to use"));
+const regionOption = Options.text("region").pipe(Options.optional, Options.withDescription("AWS region"));
+const qualifierOption = Options.text("qualifier").pipe(Options.withDefault("hnb659fds"), Options.withDescription("CDK bootstrap qualifier"));
+const stacksOption = Options.text("stacks").pipe(Options.optional, Options.withDescription("Stack names to deploy (comma-separated, default: all)"));
+const allStacksOption = Options.boolean("all").pipe(Options.withDefault(false), Options.withDescription("Deploy all stacks (like cdk deploy --all)"));
+const debugOption = Options.boolean("debug").pipe(Options.withDefault(false), Options.withDescription("Enable debug logging"));
+const idleTimeoutOption = Options.integer("idle-timeout").pipe(Options.withDefault(DEFAULT_IDLE_TIMEOUT_MS), Options.withDescription("Idle timeout in ms before stopping containers (default: 230000)"));
+const pollTimeoutOption = Options.integer("poll-timeout").pipe(Options.optional, Options.withDescription("Poll timeout in ms for Runtime API (default: idle-timeout - 10s). Must be shorter than idle-timeout."));
+/**
+ * Local command definition.
+ */
+export const localCommand = Command.make("local", {
+    profile: profileOption,
+    region: regionOption,
+    qualifier: qualifierOption,
+    stacks: stacksOption,
+    all: allStacksOption,
+    debug: debugOption,
+    idleTimeout: idleTimeoutOption,
+    pollTimeout: pollTimeoutOption,
+}, ({ profile, region, qualifier, stacks, all, debug, idleTimeout, pollTimeout, }) => {
+    const logLevel = debug ? LogLevel.Debug : LogLevel.Info;
+    return Effect.gen(function* () {
+        yield* Effect.logInfo("[Local] Starting local Lambda development...");
+        const profileValue = profile._tag === "Some" ? profile.value : undefined;
+        const regionValue = region._tag === "Some" ? region.value : undefined;
+        const stacksFromOption = stacks._tag === "Some"
+            ? stacks.value.split(",").map((s) => s.trim())
+            : undefined;
+        // Poll timeout should be shorter than idle timeout so containers exit naturally
+        // before we try to stop them. Default: idle timeout - 10 seconds.
+        const effectivePollTimeout = pollTimeout._tag === "Some"
+            ? pollTimeout.value
+            : Math.max(idleTimeout - 10_000, 5_000); // At least 5 seconds
+        if (profileValue) {
+            process.env.AWS_PROFILE = profileValue;
+        }
+        if (regionValue) {
+            process.env.AWS_REGION = regionValue;
+        }
+        // Bootstrap check must complete first
+        yield* ensureBootstrap({
+            qualifier,
+            profile: profileValue,
+            region: regionValue,
+        });
+        // Stack filter - populated from CDK watch output, used to filter Lambda discovery
+        // Using object so closure in startOrUpdateDaemon sees updates
+        const filterState = { stacks: stacksFromOption ?? [] };
+        // Create a long-lived scope for all Runtime API servers and CDK watch process
+        // Resources will run until this scope is closed (when the program ends)
+        const serverScope = yield* Scope.make();
+        // Start CDK watch immediately after bootstrap
+        // Stack names are discovered from CDK watch output (no need for separate cdk ls)
+        yield* Effect.logInfo("[CDK] Deploying...");
+        const { process: cdkWatchProcess, events: cdkEvents } = yield* startCdkWatch({
+            profile: profileValue,
+            region: regionValue,
+            stacks: stacksFromOption,
+            all,
+        }, serverScope);
+        // Track running Docker containers by function name
+        const containers = yield* Ref.make(new Map());
+        // Track running Node.js workers by function name
+        const workers = yield* Ref.make(new Map());
+        // Track registered functions (for lazy container/worker startup)
+        const registeredFunctions = yield* Ref.make(new Map());
+        // Track Docker functions with active file watchers
+        const watchedDockerFunctions = new Set();
+        // Invocation tracking for improved logging output
+        const invocationCounter = yield* Ref.make(0);
+        // Use a plain Map for invocation contexts so it can be accessed from stream callbacks
+        const invocationContexts = new Map();
+        // Project root is the current working directory (where CDK app lives)
+        const projectRoot = process.cwd();
+        let appSyncClient = null;
+        // Track if we've logged the "Watching" message (only log once)
+        const logState = { hasLoggedWatching: false, hasDiscoveredOnce: false };
+        // Function to start/update the daemon with discovered functions
+        const startOrUpdateDaemon = Effect.gen(function* () {
+            // Only show "Discovering functions..." on first run
+            if (!logState.hasDiscoveredOnce) {
+                yield* Effect.logInfo("[Local] Discovering functions...");
+            }
+            // Get AppSync endpoints (may need to wait for first deploy)
+            if (!appSyncClient) {
+                yield* Effect.logDebug("[Local] Reading AppSync endpoints from SSM...");
+                const endpoints = yield* getAppSyncEndpoints(qualifier).pipe(Effect.retry({ times: 10, schedule: Schedule.spaced("3 seconds") }));
+                yield* Effect.logDebug(`[Local] HTTP endpoint: ${endpoints.httpEndpoint}`);
+                appSyncClient = makeAppSyncClient(endpoints);
+            }
+            // Discover functions (filtered to stacks in this CDK project)
+            yield* Effect.logDebug("[Local] Discovering Lambda functions...");
+            const functions = yield* discoverFunctions(filterState.stacks);
+            if (functions.length === 0) {
+                yield* Effect.logInfo("[Local] No functions found with live-lambda tags yet. Have you patched your CDK project (bootstrap) and added the LiveLambdaAspect?");
+                return;
+            }
+            const currentRegistered = yield* Ref.get(registeredFunctions);
+            // Collect new functions to register
+            const newFunctions = [];
+            for (const fn of functions) {
+                const isDocker = Boolean(fn.dockerContextPath);
+                const isNodejs = !isDocker && Boolean(fn.localHandler);
+                if (!isDocker && !isNodejs) {
+                    yield* Effect.logDebug(`[Local] Skipping ${fn.functionName} - no Docker context or local handler`);
+                    continue;
+                }
+                if (currentRegistered.has(fn.functionName)) {
+                    yield* Effect.logDebug(`[Local] Already watching ${fn.functionName}`);
+                    continue;
+                }
+                newFunctions.push({ fn, isDocker });
+            }
+            // Print summary of discovered functions
+            if (newFunctions.length > 0) {
+                const summary = newFunctions
+                    .map(({ fn, isDocker }) => {
+                    const mode = isDocker ? "docker" : "node";
+                    const shortName = fn.functionName.includes("-")
+                        ? fn.functionName.split("-").slice(-2, -1)[0] || fn.functionName
+                        : fn.functionName;
+                    return `${shortName} (${mode})`;
+                })
+                    .join(", ");
+                // Use different message for first discovery vs subsequent
+                const prefix = logState.hasDiscoveredOnce
+                    ? "[Local] Functions added:"
+                    : "[Local] Functions:";
+                yield* Effect.logInfo(`${prefix} ${summary}`);
+            }
+            // Register functions and set up subscriptions
+            for (const { fn, isDocker } of newFunctions) {
+                yield* Effect.logDebug(`[Local] Registering ${fn.functionName} (${isDocker ? "Docker" : "Node.js"})`);
+                // Register the function
+                currentRegistered.set(fn.functionName, fn);
+                // Subscribe to invocations for this function
+                const invocationChannel = buildChannelName.invocation(fn.functionName);
+                yield* Effect.logDebug(`[Local] Subscribing to invocations for ${fn.functionName}`);
+                // Subscribe using forkDaemon to run independently with context preserved
+                // Route to Docker or Node.js handler based on function type
+                if (isDocker) {
+                    yield* appSyncClient
+                        .subscribeToInvocations(invocationChannel)
+                        .pipe(Stream.runForEach((invocation) => handleDockerInvocation(fn, invocation, containers, serverScope, projectRoot, idleTimeout, effectivePollTimeout, appSyncClient, invocationCounter, invocationContexts).pipe(Effect.catchAll((error) => Effect.logError(`[Local] Docker invocation error: ${error}`)))), Effect.forkDaemon);
+                }
+                else {
+                    yield* appSyncClient
+                        .subscribeToInvocations(invocationChannel)
+                        .pipe(Stream.runForEach((invocation) => handleNodejsInvocation(fn, invocation, workers, serverScope, projectRoot, appSyncClient, invocationCounter, invocationContexts).pipe(Effect.catchAll((error) => Effect.logError(`[Local] Node.js invocation error: ${error}`)))), Effect.forkDaemon);
+                }
+            }
+            yield* Ref.set(registeredFunctions, currentRegistered);
+            // Start file watchers for new Docker functions
+            const newDockerFunctions = [];
+            for (const fn of functions) {
+                if (fn.dockerContextPath &&
+                    !watchedDockerFunctions.has(fn.functionName)) {
+                    // Resolve the context path
+                    const contextPath = fn.dockerContextPath.startsWith("/")
+                        ? fn.dockerContextPath
+                        : `${projectRoot}/${fn.dockerContextPath}`;
+                    newDockerFunctions.push({
+                        functionId: fn.functionName,
+                        dockerContextPath: contextPath,
+                    });
+                    watchedDockerFunctions.add(fn.functionName);
+                }
+            }
+            // Start watching new Docker contexts
+            if (newDockerFunctions.length > 0) {
+                yield* Effect.logDebug(`[Local] Starting file watchers for ${newDockerFunctions.length} Docker function(s)...`);
+                // Fork a daemon fiber to handle file change events with context preserved
+                yield* watchDockerContexts(newDockerFunctions, 500).pipe(Stream.runForEach((event) => Effect.gen(function* () {
+                    yield* Effect.logDebug(`[Local] File changed in ${event.functionId}: ${event.filePath}`);
+                    yield* rebuildDockerContainer(event.functionId, containers, projectRoot).pipe(Effect.catchAll((error) => Effect.logError(`[Local] Rebuild failed for ${event.functionId}: ${error}`)));
+                })), Effect.forkDaemon);
+            }
+            if (!logState.hasLoggedWatching) {
+                logState.hasLoggedWatching = true;
+                yield* Effect.logInfo("[Local] Ready for invocations");
+            }
+            // Mark that we've completed first discovery
+            logState.hasDiscoveredOnce = true;
+        });
+        // Handle CDK watch events (stack discovery and deploy completion)
+        yield* Queue.take(cdkEvents).pipe(Effect.flatMap((event) => Effect.gen(function* () {
+            switch (event._tag) {
+                case "StackDiscovered":
+                    // Add discovered stack to filter (if not using --stacks)
+                    if (!stacksFromOption &&
+                        !filterState.stacks.includes(event.stackName)) {
+                        filterState.stacks.push(event.stackName);
+                        yield* Effect.logDebug(`[Local] Discovered stack: ${event.stackName}`);
+                    }
+                    break;
+                case "DeployComplete":
+                    // Run daemon update on deploy completion
+                    yield* startOrUpdateDaemon.pipe(Effect.catchAll((error) => Effect.logError(`Failed to update daemon: ${error}`)));
+                    break;
+            }
+        })), Effect.forever, Effect.fork);
+        // Handle cleanup on exit
+        const cleanup = async () => {
+            await Effect.runPromise(Effect.gen(function* () {
+                yield* Effect.logInfo("\nShutting down...");
+                // Stop CDK watch
+                yield* cdkWatchProcess
+                    .kill("SIGTERM")
+                    .pipe(Effect.catchAll(() => Effect.void));
+                // Stop all Docker containers using the Docker service
+                const docker = yield* Docker;
+                const currentContainers = yield* Ref.get(containers);
+                for (const [name, container] of currentContainers) {
+                    yield* Effect.logInfo(`Stopping container: ${name}`);
+                    yield* docker.stop(container.containerName).pipe(Effect.scoped, Effect.catchAll(() => Effect.void));
+                }
+                // Stop all Node.js workers
+                const currentWorkers = yield* Ref.get(workers);
+                for (const [name, worker] of currentWorkers) {
+                    yield* Effect.logInfo(`Stopping worker: ${name}`);
+                    yield* Effect.try(() => worker.workerProcess.kill("SIGTERM")).pipe(Effect.catchAll(() => Effect.void));
+                }
+                // Close the server scope to clean up Runtime API servers
+                yield* Scope.close(serverScope, Exit.void);
+            }).pipe(Effect.provide(DockerLive), Effect.provide(BunContext.layer), Effect.provide(Logger.pretty), Effect.provide(Logger.minimumLogLevel(logLevel))));
+            process.exit(0);
+        };
+        process.on("SIGINT", cleanup);
+        process.on("SIGTERM", cleanup);
+        yield* Effect.logInfo("[Local] Press Ctrl+C to stop");
+        // Keep the process running
+        yield* Effect.never;
+    }).pipe(Effect.provide(Logger.pretty), Effect.provide(Logger.minimumLogLevel(logLevel)));
+}).pipe(Command.withDescription("Start local Lambda development with CDK watch and Docker containers"));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"local.js","sourceRoot":"","sources":["../../../src/cli/commands/local.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAqB,KAAK,EAAE,MAAM,oBAAoB,CAAA;AAC7D,OAAO,KAAK,IAAI,MAAM,WAAW,CAAA;AACjC,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AACxC,OAAO,EACL,YAAY,EACZ,oBAAoB,EACpB,eAAe,GAChB,MAAM,wBAAwB,CAAA;AAC/B,OAAO,EAAE,mBAAmB,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AACpE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAA;AAC9C,OAAO,EAEL,OAAO,IAAI,eAAe,GAC3B,MAAM,kBAAkB,CAAA;AAEzB,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAA;AACjD,OAAO,EACL,QAAQ,EACR,MAAM,EACN,IAAI,EACJ,KAAK,EACL,MAAM,EACN,QAAQ,EACR,KAAK,EACL,GAAG,EACH,QAAQ,EACR,KAAK,EACL,MAAM,GACP,MAAM,QAAQ,CAAA;AACf,OAAO,EACL,oBAAoB,EACpB,iBAAiB,EACjB,gBAAgB,EAEhB,sBAAsB,EACtB,eAAe,EAEf,aAAa,GACd,MAAM,uBAAuB,CAAA;AAC9B,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAA;AACxD,OAAO,EACL,4BAA4B,EAC5B,MAAM,EACN,UAAU,EACV,yBAAyB,GAC1B,MAAM,wBAAwB,CAAA;AAC/B,OAAO,EAEL,mBAAmB,GACpB,MAAM,sBAAsB,CAAA;AAC7B,OAAO,EACL,sBAAsB,EACtB,eAAe,EAEf,qBAAqB,EACrB,eAAe,GAChB,MAAM,0BAA0B,CAAA;AAqBjC;;;;GAIG;AACH,MAAM,uBAAuB,GAAG,OAAO,CAAA,CAAC,2BAA2B;AAyDnE;;;GAGG;AACH,MAAM,qBAAqB,GAAG,CAAC,SAAiB,EAAE,EAAE,CAClD,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;IAClB,MAAM,SAAS,GAAG,IAAI,SAAS,CAAC,EAAE,CAAC,CAAA;IACnC,MAAM,QAAQ,GAAG,GAAG,aAAa,IAAI,SAAS,EAAE,CAAA;IAEhD,MAAM,MAAM,GAAG,KAAK,CAAC,CAAC,MAAM,CAAC,UAAU,CAAC;QACtC,GAAG,EAAE,KAAK,IAAI,EAAE;YACd,MAAM,QAAQ,GAAG,MAAM,SAAS,CAAC,IAAI,CACnC,IAAI,mBAAmB,CAAC,EAAE,IAAI,EAAE,GAAG,QAAQ,UAAU,EAAE,CAAC,CACzD,CAAA;YACD,OAAO,QAAQ,CAAC,SAAS,EAAE,KAAK,CAAA;QAClC,CAAC;QACD,KAAK,EAAE,GAAG,EAAE,CAAC,IAAI;KAClB,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAA;IAEpD,IAAI,MAAM,KAAK,IAAI,EAAE,CAAC;QACpB,KAAK,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,6CAA6C,CAAC,CAAA;QACpE,OAAO,KAAK,CAAA;IACd,CAAC;IAED,IAAI,MAAM,KAAK,iBAAiB,EAAE,CAAC;QACjC,KAAK,CAAC,CAAC,MAAM,CAAC,OAAO,CACnB,2CAA2C,MAAM,cAAc,iBAAiB,EAAE,CACnF,CAAA;QACD,OAAO,KAAK,CAAA;IACd,CAAC;IAED,OAAO,IAAI,CAAA;AACb,CAAC,CAAC,CAAA;AAEJ;;GAEG;AACH,MAAM,YAAY,GAAG,CAAC,OAA8C,EAAE,EAAE,CACtE,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;IAClB,KAAK,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,uCAAuC,CAAC,CAAA;IAE9D,mDAAmD;IACnD,MAAM,UAAU,GAAG,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;IACjD,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,CAAA;IAC1C,MAAM,UAAU,GAAG,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,IAAI,EAAE,YAAY,CAAC,CAAA;IAE9D,MAAM,IAAI,GAAG;QACX,KAAK;QACL,QAAQ;QACR,oBAAoB;QACpB,oBAAoB;QACpB,OAAO;QACP,OAAO;QACP,OAAO,UAAU,EAAE;KACpB,CAAA;IAED,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;QACpB,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;IACzC,CAAC;IAED,MAAM,GAAG,GAA2B;QAClC,GAAG,OAAO,CAAC,GAAG;KACW,CAAA;IAC3B,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;QACnB,GAAG,CAAC,UAAU,GAAG,OAAO,CAAC,MAAM,CAAA;QAC/B,GAAG,CAAC,kBAAkB,GAAG,OAAO,CAAC,MAAM,CAAA;IACzC,CAAC;IAED,KAAK,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,gBAAgB,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAA;IAEvD,MAAM,OAAO,GAAG,eAAe,CAAC,IAAI,CAAC,KAAK,EAAE,GAAG,IAAI,CAAC,CAAC,IAAI,CACvD,eAAe,CAAC,GAAG,CAAC,GAAG,CAAC,EACxB,eAAe,CAAC,KAAK,CAAC,SAAS,CAAC,CACjC,CAAA;IAED,MAAM,IAAI,GAAG,KAAK,CAAC,CAAC,eAAe,CAAC,KAAK,CAAC,OAAO,CAAC,CAAA;IAElD,2BAA2B;IAC3B,KAAK,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,IAAI,CAChD,MAAM,CAAC,UAAU,EAAE,EACnB,MAAM,CAAC,UAAU,EACjB,MAAM,CAAC,UAAU,CAAC,CAAC,IAAI,EAAE,EAAE,CACzB,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE;QACf,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,IAAI,IAAI,CAAC,CAAA;IACnC,CAAC,CAAC,CACH,CACF,CAAA;IAED,MAAM,QAAQ,GAAG,KAAK,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAA;IACrC,IAAI,QAAQ,KAAK,CAAC,EAAE,CAAC;QACnB,OAAO,KAAK,CAAC,CAAC,MAAM,CAAC,IAAI,CACvB,IAAI,KAAK,CAAC,8CAA8C,QAAQ,EAAE,CAAC,CACpE,CAAA;IACH,CAAC;IAED,KAAK,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,wCAAwC,CAAC,CAAA;AACjE,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAA;AAExB;;;GAGG;AACH,MAAM,eAAe,GAAG,CAAC,OAIxB,EAAE,EAAE,CACH,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;IAClB,KAAK,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,6CAA6C,CAAC,CAAA;IAErE,MAAM,SAAS,GAAG,KAAK,CAAC,CAAC,qBAAqB,CAAC,OAAO,CAAC,SAAS,CAAC,CAAA;IAEjE,IAAI,CAAC,SAAS,EAAE,CAAC;QACf,KAAK,CAAC,CAAC,MAAM,CAAC,OAAO,CACnB,0DAA0D,CAC3D,CAAA;QACD,KAAK,CAAC,CAAC,YAAY,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,MAAM,EAAE,CAAC,CAAA;IAC3E,CAAC;SAAM,CAAC;QACN,KAAK,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,qCAAqC,CAAC,CAAA;IAC/D,CAAC;AACH,CAAC,CAAC,CAAA;AAEJ;;GAEG;AACH,MAAM,mBAAmB,GAAG,CAAC,SAAiB,EAAE,EAAE,CAChD,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;IAClB,MAAM,SAAS,GAAG,IAAI,SAAS,CAAC,EAAE,CAAC,CAAA;IACnC,MAAM,QAAQ,GAAG,GAAG,aAAa,IAAI,SAAS,EAAE,CAAA;IAEhD,MAAM,QAAQ,GAAG,CAAC,IAAY,EAAE,EAAE,CAChC,MAAM,CAAC,UAAU,CAAC;QAChB,GAAG,EAAE,KAAK,IAAI,EAAE;YACd,MAAM,MAAM,GAAG,MAAM,SAAS,CAAC,IAAI,CACjC,IAAI,mBAAmB,CAAC,EAAE,IAAI,EAAE,GAAG,QAAQ,IAAI,IAAI,EAAE,EAAE,CAAC,CACzD,CAAA;YACD,OAAO,MAAM,CAAC,SAAS,EAAE,KAAK,IAAI,EAAE,CAAA;QACtC,CAAC;QACD,KAAK,EAAE,CAAC,KAAK,EAAE,EAAE,CACf,IAAI,KAAK,CAAC,+BAA+B,IAAI,KAAK,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;KACrE,CAAC,CAAA;IAEJ,MAAM,YAAY,GAAG,KAAK,CAAC,CAAC,QAAQ,CAAC,eAAe,CAAC,CAAA;IACrD,MAAM,gBAAgB,GAAG,KAAK,CAAC,CAAC,QAAQ,CAAC,mBAAmB,CAAC,CAAA;IAE7D,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,CAAA;AAC3C,CAAC,CAAC,CAAA;AAEJ;;GAEG;AACH,MAAM,kBAAkB,GAAG,+BAA+B,CAAA;AAE1D;;;GAGG;AACH,MAAM,iBAAiB,GAAG,CAAC,WAAsB,EAAE,EAAE,CACnD,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;IAClB,MAAM,YAAY,GAAG,IAAI,YAAY,CAAC,EAAE,CAAC,CAAA;IACzC,MAAM,SAAS,GAAyB,EAAE,CAAA;IAE1C,qBAAqB;IACrB,IAAI,UAA8B,CAAA;IAClC,GAAG,CAAC;QACF,MAAM,YAAY,GAAG,KAAK,CAAC,CAAC,MAAM,CAAC,UAAU,CAAC;YAC5C,GAAG,EAAE,GAAG,EAAE,CACR,YAAY,CAAC,IAAI,CAAC,IAAI,oBAAoB,CAAC,EAAE,MAAM,EAAE,UAAU,EAAE,CAAC,CAAC;YACrE,KAAK,EAAE,CAAC,KAAK,EAAE,EAAE,CACf,IAAI,KAAK,CAAC,6BAA6B,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;SAC1D,CAAC,CAAA;QAEF,KAAK,MAAM,EAAE,IAAI,YAAY,CAAC,SAAS,IAAI,EAAE,EAAE,CAAC;YAC9C,6BAA6B;YAC7B,MAAM,UAAU,GAAG,KAAK,CAAC,CAAC,MAAM,CAAC,UAAU,CAAC;gBAC1C,GAAG,EAAE,GAAG,EAAE,CACR,YAAY,CAAC,IAAI,CACf,IAAI,eAAe,CAAC,EAAE,QAAQ,EAAE,EAAE,CAAC,WAAW,EAAE,CAAC,CAClD;gBACH,KAAK,EAAE,GAAG,EAAE,CAAC,IAAI,KAAK,CAAC,0BAA0B,EAAE,CAAC,YAAY,EAAE,CAAC;aACpE,CAAC,CAAC,IAAI,CACL,MAAM,CAAC,QAAQ,CAAC,GAAG,EAAE,CACnB,MAAM,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,EAA4B,EAAE,CAAC,CACvD,CACF,CAAA;YAED,MAAM,IAAI,GAAG,UAAU,CAAC,IAAI,IAAI,EAAE,CAAA;YAElC,4DAA4D;YAC5D,IAAI,IAAI,CAAC,eAAe,CAAC,IAAI,IAAI,CAAC,sBAAsB,CAAC,EAAE,CAAC;gBAC1D,oCAAoC;gBACpC,IAAI,WAAW,IAAI,WAAW,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;oBAC1C,MAAM,SAAS,GAAG,IAAI,CAAC,kBAAkB,CAAC,CAAA;oBAC1C,IAAI,CAAC,SAAS,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC;wBACnD,SAAQ;oBACV,CAAC;gBACH,CAAC;gBAED,4CAA4C;gBAC5C,MAAM,aAAa,GAAG,EAAE,CAAC,aAAa,IAAI,CAAC,QAAQ,CAAC,CAAA;gBACpD,MAAM,YAAY,GAAG,aAAa,CAAC,QAAQ,CAAC,OAAO,CAAC;oBAClD,CAAC,CAAE,OAAiB;oBACpB,CAAC,CAAE,QAAkB,CAAA;gBAEvB,MAAM,UAAU,GAAuB;oBACrC,YAAY,EAAE,EAAE,CAAC,YAAa;oBAC9B,WAAW,EAAE,EAAE,CAAC,WAAY;oBAC5B,YAAY,EAAE,IAAI,CAAC,eAAe,CAAC,IAAI,EAAE;oBACzC,iBAAiB,EAAE,IAAI,CAAC,sBAAsB,CAAC;oBAC/C,QAAQ,EAAE,EAAE,CAAC,UAAU,IAAI,GAAG;oBAC9B,YAAY;iBACb,CAAA;gBACD,SAAS,CAAC,IAAI,CAAC,UAAU,CAAC,CAAA;YAC5B,CAAC;QACH,CAAC;QAED,UAAU,GAAG,YAAY,CAAC,UAAU,CAAA;IACtC,CAAC,QAAQ,UAAU,EAAC;IAEpB,OAAO,SAAS,CAAA;AAClB,CAAC,CAAC,CAAA;AAEJ;;;;;GAKG;AACH,MAAM,sBAAsB,GAAG,CAC7B,EAAsB,EACtB,IAAY,EACZ,WAAmB,EACnB,aAAqC,EACrC,kBAAiD,EAKjD,EAAE,CACF,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;IAClB,IAAI,CAAC,EAAE,CAAC,iBAAiB,EAAE,CAAC;QAC1B,OAAO,KAAK,CAAC,CAAC,MAAM,CAAC,IAAI,CACvB,IAAI,KAAK,CAAC,YAAY,EAAE,CAAC,YAAY,6BAA6B,CAAC,CACpE,CAAA;IACH,CAAC;IAED,MAAM,MAAM,GAAG,KAAK,CAAC,CAAC,MAAM,CAAA;IAE5B,MAAM,aAAa,GAAG,KAAK,CAAC,CAAC,MAAM,CAAC,cAAc,EAAE,CAAA;IACpD,MAAM,cAAc,GAAG,aAAa,CAAC,eAAe;QAClD,CAAC,CAAC,sBAAsB;QACxB,CAAC,CAAC,aAAa,CAAA;IAEjB,iDAAiD;IACjD,MAAM,SAAS,GAAG,eAAe,EAAE,CAAC,YAAY,CAAC,WAAW,EAAE,CAAC,OAAO,CAAC,aAAa,EAAE,GAAG,CAAC,EAAE,CAAA;IAE5F,oDAAoD;IACpD,MAAM,WAAW,GAAG,EAAE,CAAC,iBAAiB,CAAC,UAAU,CAAC,GAAG,CAAC;QACtD,CAAC,CAAC,EAAE,CAAC,iBAAiB;QACtB,CAAC,CAAC,GAAG,WAAW,IAAI,EAAE,CAAC,iBAAiB,EAAE,CAAA;IAE5C,uCAAuC;IACvC,MAAM,QAAQ,GAAG,EAAE,CAAC,YAAY,KAAK,OAAO,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,aAAa,CAAA;IAE5E,4CAA4C;IAC5C,KAAK,CAAC,CAAC,MAAM;SACV,KAAK,CAAC;QACL,WAAW;QACX,SAAS;QACT,QAAQ;KACT,CAAC;SACD,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAA;IAEtB,yEAAyE;IACzE,MAAM,WAAW,GAAG,KAAK,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAA;IACxE,MAAM,gBAAgB,GAAG,4BAA4B,CACnD,WAAW,CAAC,UAAU,EACtB,WAAW,CAAC,GAAG,CAChB,CAAA;IAED,MAAM,eAAe,GAAG,yBAAyB,CAAC;QAChD,QAAQ,EAAE,SAAS;QACnB,cAAc;QACd,cAAc,EAAE,IAAI;QACpB,YAAY,EAAE,EAAE,CAAC,YAAY;QAC7B,eAAe,EAAE,SAAS;QAC1B,QAAQ,EAAE,EAAE,CAAC,QAAQ;QACrB,cAAc,EAAE,IAAI,EAAE,yCAAyC;QAC/D,QAAQ;QACR,aAAa;QACb,kBAAkB;KACnB,CAAC,CAAA;IAEF,6DAA6D;IAC7D,eAAe,CAAC,UAAU,GAAG,gBAAgB,CAAC,UAAU,CAAA;IACxD,eAAe,CAAC,OAAO,GAAG,gBAAgB,CAAC,OAAO,CAAA;IAElD,KAAK,CAAC,CAAC,MAAM,CAAC,OAAO,CACnB,0BAA0B,EAAE,CAAC,YAAY,YAAY,IAAI,EAAE,CAC5D,CAAA;IAED,kFAAkF;IAClF,wDAAwD;IACxD,MAAM,KAAK,GAAG,KAAK,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC,IAAI,CACnD,MAAM,CAAC,MAAM,EACb,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,SAAiB,CAAC,EACnC,MAAM,CAAC,UAAU,CAClB,CAAA;IAED,OAAO,KAAK,CAAA;AACd,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAA;AAErC,iCAAiC;AACjC,MAAM,gBAAgB,GAAG,CACvB,CAAiD,EAC5B,EAAE,CAAC,MAAM,IAAI,CAAC,IAAI,CAAC,CAAC,WAAW,IAAI,CAAC,CAAC,CAAA;AAE5D,MAAM,aAAa,GAAG,CACpB,CAAiD,EAC/B,EAAE,CAAC,WAAW,IAAI,CAAC,IAAI,WAAW,IAAI,CAAC,CAAA;AAE3D,MAAM,iBAAiB,GAAG,CACxB,CAAiD,EAC3B,EAAE,CAAC,CAAC,CAAC,WAAW,IAAI,CAAC,CAAC,IAAI,WAAW,IAAI,CAAC,CAAA;AAElE;;;;GAIG;AACH,MAAM,cAAc,GAAG,CACrB,SAA4B,EAC5B,aAAsD,EACtD,aAAqB,EACwC,EAAE,CAC/D,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;IAClB,+BAA+B;IAC/B,IAAI,SAAS,CAAC,cAAc,EAAE,CAAC;QAC7B,KAAK,CAAC,CAAC,KAAK,CAAC,SAAS,CAAC,SAAS,CAAC,cAAc,CAAC,CAAC,IAAI,CACnD,MAAM,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,CACnC,CAAA;QACD,SAAS,CAAC,cAAc,GAAG,IAAI,CAAA;IACjC,CAAC;IAED,uEAAuE;IACvE,MAAM,UAAU,GAAoC,KAAK,CAAC,CAAC,MAAM,CAAC,GAAG,CACnE,QAAQ,CAAC;QACP,KAAK,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,QAAQ,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC,CAAA;QAEnD,6CAA6C;QAC7C,KAAK,CAAC,CAAC,MAAM,CAAC,OAAO,CACnB,mCAAmC,SAAS,CAAC,EAAE,CAAC,YAAY,oCAAoC,CACjG,CAAA;QAED,yDAAyD;QACzD,yEAAyE;QACzE,MAAM,MAAM,GAAG,KAAK,CAAC,CAAC,MAAM,CAAA;QAC5B,KAAK,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,aAAa,EAAE,CAAC,CAAC,CAAC,IAAI,CACjD,MAAM,CAAC,MAAM,EACb,MAAM,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,CACnC,CAAA;QAED,6DAA6D;QAC7D,MAAM,iBAAiB,GAAG,KAAK,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,aAAa,CAAC,CAAA;QACvD,iBAAiB,CAAC,MAAM,CAAC,SAAS,CAAC,EAAE,CAAC,YAAY,CAAC,CAAA;QACnD,KAAK,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,aAAa,EAAE,iBAAiB,CAAC,CAAA;IAClD,CAAC,CACF,CAAC,IAAI,CACJ,MAAM,CAAC,OAAO,CAAC,UAAU,CAAC,EAC1B,MAAM,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,EAClC,MAAM,CAAC,UAAU,CAClB,CAAA;IAED,SAAS,CAAC,cAAc,GAAG,UAAU,CAAA;AACvC,CAAC,CAAC,CAAA;AAEJ;;;;GAIG;AACH,MAAM,yBAAyB,GAAG,CAChC,SAA4B,EAC5B,aAAsD,EACtD,aAAqB,EACrB,MAA4C,EAC5C,kBAAkD,EACW,EAAE,CAC/D,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;IAClB,MAAM,eAAe,GAAG,gBAAgB,CAAC,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC,YAAY,CAAC,CAAA;IAE5E,oDAAoD;IACpD,OAAO,IAAI,EAAE,CAAC;QACZ,MAAM,MAAM,GAAG,KAAK,CAAC,CAAC,eAAe,CAAC,SAAS,CAAC,YAAY,CAAC,CAAA;QAE7D,IAAI,QAAyB,CAAA;QAC7B,IAAI,gBAAgB,CAAC,MAAM,CAAC,EAAE,CAAC;YAC7B,QAAQ,GAAG;gBACT,IAAI,EAAE,UAAU;gBAChB,SAAS,EAAE,MAAM,CAAC,SAAS;gBAC3B,MAAM,EAAE,MAAM,CAAC,IAAI;aACpB,CAAA;QACH,CAAC;aAAM,IAAI,aAAa,CAAC,MAAM,CAAC,EAAE,CAAC;YACjC,QAAQ,GAAG;gBACT,IAAI,EAAE,UAAU;gBAChB,SAAS,EAAE,MAAM,CAAC,SAAS;gBAC3B,KAAK,EAAE;oBACL,SAAS,EAAE,MAAM,CAAC,SAAS;oBAC3B,YAAY,EAAE,MAAM,CAAC,YAAY;oBACjC,UAAU,EAAE,MAAM,CAAC,UAAU;iBAC9B;aACF,CAAA;QACH,CAAC;aAAM,IAAI,iBAAiB,CAAC,MAAM,CAAC,EAAE,CAAC;YACrC,KAAK,CAAC,CAAC,MAAM,CAAC,QAAQ,CACpB,uBAAuB,MAAM,CAAC,SAAS,KAAK,MAAM,CAAC,YAAY,EAAE,CAClE,CAAA;YACD,SAAQ;QACV,CAAC;aAAM,CAAC;YACN,SAAQ;QACV,CAAC;QAED,iCAAiC;QACjC,KAAK,CAAC,CAAC,MAAM,CAAC,eAAe,CAAC,eAAe,EAAE,QAAQ,CAAC,CAAA;QACxD,KAAK,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,6BAA6B,QAAQ,CAAC,SAAS,EAAE,CAAC,CAAA;QAEzE,+BAA+B;QAC/B,MAAM,GAAG,GAAG,kBAAkB,CAAC,GAAG,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAA;QACtD,IAAI,GAAG,EAAE,CAAC;YACR,MAAM,UAAU,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,GAAG,CAAC,KAAK,CAAA;YACzC,IAAI,QAAQ,CAAC,KAAK,EAAE,CAAC;gBACnB,OAAO,CAAC,GAAG,CACT,IAAI,GAAG,CAAC,GAAG,+BAA+B,QAAQ,CAAC,KAAK,CAAC,SAAS,KAAK,QAAQ,CAAC,KAAK,CAAC,YAAY,KAAK,UAAU,kBAAkB,CACpI,CAAA;YACH,CAAC;iBAAM,CAAC;gBACN,OAAO,CAAC,GAAG,CACT,IAAI,GAAG,CAAC,GAAG,qCAAqC,UAAU,kBAAkB,CAC7E,CAAA;YACH,CAAC;YACD,kBAAkB,CAAC,MAAM,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAA;QAC/C,CAAC;QAED,4EAA4E;QAC5E,KAAK,CAAC,CAAC,cAAc,CAAC,SAAS,EAAE,aAAa,EAAE,aAAa,CAAC,CAAA;IAChE,CAAC;AACH,CAAC,CAAC,CAAA;AAEJ;;;;GAIG;AACH,MAAM,iBAAiB,GAAG,CACxB,EAAsB,EACtB,IAAY,EACZ,WAAmB,EACnB,GAA2B,EAC3B,kBAAkD,EACd,EAAE,CACtC,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;IAClB,IAAI,CAAC,EAAE,CAAC,YAAY,EAAE,CAAC;QACrB,OAAO,KAAK,CAAC,CAAC,MAAM,CAAC,IAAI,CACvB,IAAI,KAAK,CAAC,YAAY,EAAE,CAAC,YAAY,4BAA4B,CAAC,CACnE,CAAA;IACH,CAAC;IAED,2DAA2D;IAC3D,MAAM,UAAU,GAAG,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;IACjD,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,CAAA;IAC1C,MAAM,kBAAkB,GAAG,IAAI,CAAC,OAAO,CACrC,SAAS,EACT,IAAI,EACJ,iBAAiB,EACjB,mBAAmB,CACpB,CAAA;IAED,uEAAuE;IACvE,MAAM,OAAO,GAAG,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,CAAA;IAChC,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,OAAO,KAAK,CAAC,CAAC,MAAM,CAAC,IAAI,CACvB,IAAI,KAAK,CAAC,yCAAyC,CAAC,CACrD,CAAA;IACH,CAAC;IAED,2CAA2C;IAC3C,6EAA6E;IAC7E,MAAM,SAAS,GAAsB;QACnC,kFAAkF;QAClF,GAAG,GAAG;QACN,iEAAiE;QACjE,sBAAsB,EAAE,aAAa,IAAI,EAAE;QAC3C,QAAQ,EAAE,EAAE,CAAC,YAAY;QACzB,gBAAgB,EAAE,WAAW;QAC7B,kCAAkC;QAClC,+BAA+B,EAAE,MAAM,CAAC,EAAE,CAAC,QAAQ,CAAC;KACrD,CAAA;IAED,KAAK,CAAC,CAAC,MAAM,CAAC,QAAQ,CACpB,uCAAuC,EAAE,CAAC,YAAY,YAAY,IAAI,EAAE,CACzE,CAAA;IACD,KAAK,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,oBAAoB,EAAE,CAAC,YAAY,EAAE,CAAC,CAAA;IAE7D,4EAA4E;IAC5E,gEAAgE;IAChE,oEAAoE;IACpE,MAAM,aAAa,GAAG,KAAK,CAAC,OAAO,EAAE,CAAC,SAAS,EAAE,kBAAkB,CAAC,EAAE;QACpE,GAAG,EAAE,WAAW;QAChB,GAAG,EAAE,SAAS;QACd,KAAK,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,CAAC;KAClC,CAAC,CAAA;IAEF,4EAA4E;IAC5E,qFAAqF;IACrF,MAAM,gBAAgB,GACpB,kEAAkE,CAAA;IAEpE,mDAAmD;IACnD,MAAM,UAAU,GAAG,CACjB,OAAe,EACsB,EAAE;QACvC,4DAA4D;QAC5D,MAAM,IAAI,GAAG,OAAO,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAA;QACvC,MAAM,KAAK,GAAG,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;QACzC,IAAI,KAAK,EAAE,CAAC;YACV,MAAM,SAAS,GAAG,KAAK,CAAC,CAAC,CAAC,CAAA;YAC1B,MAAM,GAAG,GAAG,kBAAkB,CAAC,GAAG,CAAC,SAAS,CAAC,CAAA;YAC7C,IAAI,GAAG,EAAE,CAAC;gBACR,0DAA0D;gBAC1D,OAAO,EAAE,MAAM,EAAE,IAAI,GAAG,CAAC,GAAG,GAAG,EAAE,OAAO,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,CAAA;YACtD,CAAC;QACH,CAAC;QACD,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,IAAI,EAAE,CAAA;IAC9C,CAAC,CAAA;IAED,sDAAsD;IACtD,aAAa,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,EAAE,CAAC,IAAY,EAAE,EAAE;QAChD,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,CAAA;QAChD,KAAK,MAAM,OAAO,IAAI,KAAK,EAAE,CAAC;YAC5B,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,UAAU,CAAC,OAAO,CAAC,CAAA;YAC/C,OAAO,CAAC,GAAG,CAAC,GAAG,MAAM,IAAI,OAAO,EAAE,CAAC,CAAA;QACrC,CAAC;IACH,CAAC,CAAC,CAAA;IAEF,aAAa,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,EAAE,CAAC,IAAY,EAAE,EAAE;QAChD,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,CAAA;QAChD,KAAK,MAAM,OAAO,IAAI,KAAK,EAAE,CAAC;YAC5B,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,UAAU,CAAC,OAAO,CAAC,CAAA;YAC/C,OAAO,CAAC,KAAK,CAAC,GAAG,MAAM,IAAI,OAAO,EAAE,CAAC,CAAA;QACvC,CAAC;IACH,CAAC,CAAC,CAAA;IAEF,aAAa,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,EAAE;QAChC,MAAM,CAAC,OAAO,CACZ,MAAM,CAAC,QAAQ,CAAC,iBAAiB,GAAG,CAAC,OAAO,EAAE,CAAC,CAAC,IAAI,CAClD,MAAM,CAAC,YAAY,CAAC,UAAU,EAAE,EAAE,CAAC,YAAY,CAAC,CACjD,CACF,CAAA;IACH,CAAC,CAAC,CAAA;IAEF,aAAa,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,IAAI,EAAE,EAAE;QACjC,MAAM,CAAC,OAAO,CACZ,MAAM,CAAC,OAAO,CAAC,2BAA2B,IAAI,EAAE,CAAC,CAAC,IAAI,CACpD,MAAM,CAAC,YAAY,CAAC,UAAU,EAAE,EAAE,CAAC,YAAY,CAAC,CACjD,CACF,CAAA;IACH,CAAC,CAAC,CAAA;IAEF,OAAO,aAAa,CAAA;AACtB,CAAC,CAAC,CAAA;AAEJ;;GAEG;AACH,MAAM,sBAAsB,GAAG,CAC7B,MAAoB,EACpB,MAA4C,EAC5C,kBAAkD,EAClD,EAAE,CACF,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;IAClB,MAAM,eAAe,GAAG,gBAAgB,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,YAAY,CAAC,CAAA;IAEzE,iDAAiD;IACjD,OAAO,IAAI,EAAE,CAAC;QACZ,MAAM,MAAM,GAAG,KAAK,CAAC,CAAC,eAAe,CAAC,MAAM,CAAC,YAAY,CAAC,CAAA;QAE1D,IAAI,QAAyB,CAAA;QAC7B,IAAI,gBAAgB,CAAC,MAAM,CAAC,EAAE,CAAC;YAC7B,QAAQ,GAAG;gBACT,IAAI,EAAE,UAAU;gBAChB,SAAS,EAAE,MAAM,CAAC,SAAS;gBAC3B,MAAM,EAAE,MAAM,CAAC,IAAI;aACpB,CAAA;QACH,CAAC;aAAM,IAAI,aAAa,CAAC,MAAM,CAAC,EAAE,CAAC;YACjC,QAAQ,GAAG;gBACT,IAAI,EAAE,UAAU;gBAChB,SAAS,EAAE,MAAM,CAAC,SAAS;gBAC3B,KAAK,EAAE;oBACL,SAAS,EAAE,MAAM,CAAC,SAAS;oBAC3B,YAAY,EAAE,MAAM,CAAC,YAAY;oBACjC,UAAU,EAAE,MAAM,CAAC,UAAU;iBAC9B;aACF,CAAA;QACH,CAAC;aAAM,IAAI,iBAAiB,CAAC,MAAM,CAAC,EAAE,CAAC;YACrC,KAAK,CAAC,CAAC,MAAM,CAAC,QAAQ,CACpB,8BAA8B,MAAM,CAAC,SAAS,KAAK,MAAM,CAAC,YAAY,EAAE,CACzE,CAAA;YACD,SAAQ;QACV,CAAC;aAAM,CAAC;YACN,SAAQ;QACV,CAAC;QAED,iCAAiC;QACjC,KAAK,CAAC,CAAC,MAAM,CAAC,eAAe,CAAC,eAAe,EAAE,QAAQ,CAAC,CAAA;QACxD,KAAK,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,6BAA6B,QAAQ,CAAC,SAAS,EAAE,CAAC,CAAA;QAEzE,+BAA+B;QAC/B,MAAM,GAAG,GAAG,kBAAkB,CAAC,GAAG,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAA;QACtD,IAAI,GAAG,EAAE,CAAC;YACR,MAAM,UAAU,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,GAAG,CAAC,KAAK,CAAA;YACzC,IAAI,QAAQ,CAAC,KAAK,EAAE,CAAC;gBACnB,OAAO,CAAC,GAAG,CACT,IAAI,GAAG,CAAC,GAAG,+BAA+B,QAAQ,CAAC,KAAK,CAAC,SAAS,KAAK,QAAQ,CAAC,KAAK,CAAC,YAAY,KAAK,UAAU,kBAAkB,CACpI,CAAA;YACH,CAAC;iBAAM,CAAC;gBACN,OAAO,CAAC,GAAG,CACT,IAAI,GAAG,CAAC,GAAG,qCAAqC,UAAU,kBAAkB,CAC7E,CAAA;YACH,CAAC;YACD,kBAAkB,CAAC,MAAM,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAA;QAC/C,CAAC;IACH,CAAC;AACH,CAAC,CAAC,CAAA;AAEJ;;;GAGG;AACH,MAAM,kBAAkB,GAAG,IAAI,GAAG,CAAC,CAAC,4BAA4B,CAAC,CAAC,CAAA;AAElE;;;;;;;;GAQG;AACH,MAAM,0BAA0B,GAAG,IAAI,GAAG,CAAC;IACzC,mBAAmB;IACnB,uBAAuB;IACvB,mBAAmB;CACpB,CAAC,CAAA;AAEF;;GAEG;AACH,MAAM,qBAAqB,GAAG,CAC5B,GAA2B,EACH,EAAE;IAC1B,MAAM,MAAM,GAA2B,EAAE,CAAA;IACzC,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;QAC/C,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;YACjC,MAAM,CAAC,GAAG,CAAC,GAAG,KAAK,CAAA;QACrB,CAAC;IACH,CAAC;IACD,OAAO,MAAM,CAAA;AACf,CAAC,CAAA;AAED;;;;GAIG;AACH,MAAM,UAAU,GAAG,CACjB,MAA8B,EAC9B,MAA8B,EACtB,EAAE;IACV,MAAM,OAAO,GAAa,EAAE,CAAA;IAE5B,mCAAmC;IACnC,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;QACtC,IAAI,0BAA0B,CAAC,GAAG,CAAC,GAAG,CAAC;YAAE,SAAQ;QACjD,IAAI,CAAC,CAAC,GAAG,IAAI,MAAM,CAAC,EAAE,CAAC;YACrB,OAAO,CAAC,IAAI,CAAC,IAAI,GAAG,EAAE,CAAC,CAAA;QACzB,CAAC;aAAM,IAAI,MAAM,CAAC,GAAG,CAAC,KAAK,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC;YACvC,OAAO,CAAC,IAAI,CAAC,IAAI,GAAG,EAAE,CAAC,CAAA;QACzB,CAAC;IACH,CAAC;IAED,yBAAyB;IACzB,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;QACtC,IAAI,0BAA0B,CAAC,GAAG,CAAC,GAAG,CAAC;YAAE,SAAQ;QACjD,IAAI,CAAC,CAAC,GAAG,IAAI,MAAM,CAAC,EAAE,CAAC;YACrB,OAAO,CAAC,IAAI,CAAC,IAAI,GAAG,EAAE,CAAC,CAAA;QACzB,CAAC;IACH,CAAC;IAED,OAAO,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;AAC3B,CAAC,CAAA;AAED;;;;GAIG;AACH,MAAM,mBAAmB,GAAG,CAC1B,EAAsB,EACtB,aAAqC,EACrC,UAA8C,EAC9C,WAAwB,EACxB,WAAmB,EACnB,aAAmD,EACnD,kBAAkD,EACd,EAAE,CACtC,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;IAClB,iCAAiC;IACjC,MAAM,cAAc,GAAG,KAAK,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,UAAU,CAAC,CAAA;IACjD,MAAM,QAAQ,GAAG,cAAc,CAAC,GAAG,CAAC,EAAE,CAAC,YAAY,CAAC,CAAA;IACpD,IAAI,QAAQ,EAAE,CAAC;QACb,4DAA4D;QAC5D,MAAM,OAAO,GAAG,UAAU,CAAC,QAAQ,CAAC,GAAG,EAAE,aAAa,CAAC,CAAA;QACvD,IAAI,OAAO,EAAE,CAAC;YACZ,KAAK,CAAC,CAAC,MAAM,CAAC,OAAO,CACnB,mCAAmC,EAAE,CAAC,YAAY,2BAA2B,OAAO,GAAG,CACxF,CAAA;YACD,sBAAsB;YACtB,KAAK,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,QAAQ,CAAC,aAAa,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAClE,MAAM,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,CACnC,CAAA;YACD,+CAA+C;YAC/C,cAAc,CAAC,MAAM,CAAC,EAAE,CAAC,YAAY,CAAC,CAAA;YACtC,KAAK,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,UAAU,EAAE,cAAc,CAAC,CAAA;QAC5C,CAAC;aAAM,CAAC;YACN,OAAO,QAAQ,CAAA;QACjB,CAAC;IACH,CAAC;IAED,yCAAyC;IACzC,KAAK,CAAC,CAAC,MAAM,CAAC,QAAQ,CACpB,2DAA2D,EAAE,CAAC,YAAY,KAAK,CAChF,CAAA;IAED,8CAA8C;IAC9C,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,YAAY,EAAE,GAAG,KAAK,CAAC,CAAC,qBAAqB,CAAC;QACjE,gBAAgB,EAAE;YAChB,YAAY,EAAE,EAAE,CAAC,YAAY;YAC7B,eAAe,EAAE,SAAS;YAC1B,OAAO,EAAE,EAAE,CAAC,YAAY;SACzB;KACF,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC,CAAA;IAExD,6EAA6E;IAC7E,wEAAwE;IACxE,MAAM,MAAM,GAAiB;QAC3B,EAAE;QACF,YAAY;QACZ,IAAI;QACJ,aAAa,EAAE,SAAoC,EAAE,sBAAsB;QAC3E,GAAG,EAAE,aAAa;KACnB,CAAA;IAED,oDAAoD;IACpD,cAAc,CAAC,GAAG,CAAC,EAAE,CAAC,YAAY,EAAE,MAAM,CAAC,CAAA;IAC3C,KAAK,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,UAAU,EAAE,cAAc,CAAC,CAAA;IAE1C,wDAAwD;IACxD,MAAM,aAAa,GAAG,KAAK,CAAC,CAAC,iBAAiB,CAC5C,EAAE,EACF,IAAI,EACJ,WAAW,EACX,aAAa,EACb,kBAAkB,CACnB,CAAC,IAAI,CACJ,MAAM,CAAC,QAAQ,CAAC,CAAC,KAAK,EAAE,EAAE,CACxB,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;QAClB,2CAA2C;QAC3C,KAAK,CAAC,CAAC,MAAM,CAAC,QAAQ,CACpB,sCAAsC,EAAE,CAAC,YAAY,KAAK,KAAK,EAAE,CAClE,CAAA;QACD,MAAM,OAAO,GAAG,KAAK,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,UAAU,CAAC,CAAA;QAC1C,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC,YAAY,CAAC,CAAA;QAC/B,KAAK,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,UAAU,EAAE,OAAO,CAAC,CAAA;QACnC,OAAO,KAAK,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;IAClC,CAAC,CAAC,CACH,CACF,CAAA;IAED,iCAAiC;IACjC,MAAM,CAAC,aAAa,GAAG,aAAa,CAAA;IAEpC,+CAA+C;IAC/C,MAAM,CAAC,OAAO,CACZ,sBAAsB,CAAC,MAAM,EAAE,aAAa,EAAE,kBAAkB,CAAC,CAClE,CAAA;IAED,OAAO,MAAM,CAAA;AACf,CAAC,CAAC,CAAA;AAEJ;;;;;GAKG;AACH,MAAM,sBAAsB,GAAG,CAC7B,EAAsB,EACtB,aAAqC,EACrC,aAAsD,EACtD,WAAwB,EACxB,WAAmB,EACnB,aAAqB,EACrB,aAAqB,EACrB,aAAmD,EACnD,kBAAkD,EACwB,EAAE,CAC5E,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;IAClB,oCAAoC;IACpC,MAAM,iBAAiB,GAAG,KAAK,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,aAAa,CAAC,CAAA;IACvD,MAAM,QAAQ,GAAG,iBAAiB,CAAC,GAAG,CAAC,EAAE,CAAC,YAAY,CAAC,CAAA;IACvD,IAAI,QAAQ,EAAE,CAAC;QACb,4DAA4D;QAC5D,MAAM,OAAO,GAAG,UAAU,CAAC,QAAQ,CAAC,GAAG,EAAE,aAAa,CAAC,CAAA;QACvD,IAAI,OAAO,EAAE,CAAC;YACZ,mEAAmE;YACnE,kEAAkE;YAClE,gCAAgC;YAChC,QAAQ,CAAC,GAAG,GAAG,aAAa,CAAA;YAE5B,2EAA2E;YAC3E,mEAAmE;YACnE,IAAI,QAAQ,CAAC,YAAY,EAAE,CAAC;gBAC1B,KAAK,CAAC,CAAC,MAAM,CAAC,QAAQ,CACpB,8DAA8D,EAAE,CAAC,YAAY,uBAAuB,CACrG,CAAA;gBACD,OAAO,QAAQ,CAAA;YACjB,CAAC;YAED,KAAK,CAAC,CAAC,MAAM,CAAC,OAAO,CACnB,mCAAmC,EAAE,CAAC,YAAY,8BAA8B,OAAO,GAAG,CAC3F,CAAA;YACD,QAAQ,CAAC,YAAY,GAAG,IAAI,CAAA;YAE5B,oDAAoD;YACpD,qDAAqD;YACrD,sEAAsE;YACtE,iDAAiD;YACjD,KAAK,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;gBACzB,MAAM,MAAM,GAAG,KAAK,CAAC,CAAC,MAAM,CAAA;gBAC5B,KAAK,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,aAAa,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAA;YACnE,CAAC,CAAC,CAAC,IAAI,CACL,MAAM,CAAC,OAAO,CAAC,UAAU,CAAC,EAC1B,MAAM,CAAC,QAAQ,CAAC,CAAC,KAAK,EAAE,EAAE,CACxB,MAAM,CAAC,QAAQ,CACb,8DAA8D,KAAK,EAAE,CACtE,CACF,CACF,CAAA;YAED,+EAA+E;YAC/E,KAAK,CAAC,CAAC,KAAK,CAAC,SAAS,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAC,IAAI,CAClD,MAAM,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,CACnC,CAAA;YAED,0EAA0E;YAC1E,MAAM,QAAQ,GAAG,KAAK,CAAC,CAAC,sBAAsB,CAC5C,EAAE,EACF,QAAQ,CAAC,IAAI,EACb,WAAW,EACX,aAAa,EACb,kBAAkB,CACnB,CAAC,IAAI,CACJ,MAAM,CAAC,QAAQ,CAAC,CAAC,KAAK,EAAE,EAAE,CACxB,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;gBAClB,KAAK,CAAC,CAAC,MAAM,CAAC,QAAQ,CACpB,2CAA2C,EAAE,CAAC,YAAY,KAAK,KAAK,EAAE,CACvE,CAAA;gBACD,QAAQ,CAAC,YAAY,GAAG,KAAK,CAAA;gBAC7B,OAAO,KAAK,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;YAClC,CAAC,CAAC,CACH,CACF,CAAA;YAED,kCAAkC;YAClC,QAAQ,CAAC,cAAc,GAAG,QAAQ,CAAA;YAClC,QAAQ,CAAC,YAAY,GAAG,KAAK,CAAA;YAE7B,OAAO,QAAQ,CAAA;QACjB,CAAC;aAAM,CAAC;YACN,OAAO,QAAQ,CAAA;QACjB,CAAC;IACH,CAAC;IAED,4CAA4C;IAC5C,KAAK,CAAC,CAAC,MAAM,CAAC,OAAO,CACnB,sDAAsD,EAAE,CAAC,YAAY,KAAK,CAC3E,CAAA;IAED,8CAA8C;IAC9C,iFAAiF;IACjF,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,YAAY,EAAE,GAAG,KAAK,CAAC,CAAC,qBAAqB,CAAC;QACjE,aAAa;QACb,gBAAgB,EAAE;YAChB,YAAY,EAAE,EAAE,CAAC,YAAY;YAC7B,eAAe,EAAE,SAAS;YAC1B,OAAO,EAAE,eAAe;SACzB;KACF,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC,CAAA;IAExD,yCAAyC;IACzC,MAAM,aAAa,GAAG,UAAU,EAAE,CAAC,YAAY,CAAC,OAAO,CAAC,eAAe,EAAE,GAAG,CAAC,EAAE,CAAA;IAC/E,MAAM,SAAS,GAAG,eAAe,EAAE,CAAC,YAAY,CAAC,WAAW,EAAE,CAAC,OAAO,CAAC,aAAa,EAAE,GAAG,CAAC,EAAE,CAAA;IAE5F,8EAA8E;IAC9E,2EAA2E;IAC3E,MAAM,SAAS,GAAsB;QACnC,EAAE;QACF,YAAY;QACZ,IAAI;QACJ,cAAc,EAAE,SAAuD,EAAE,sBAAsB;QAC/F,aAAa;QACb,SAAS;QACT,YAAY,EAAE,KAAK;QACnB,gBAAgB,EAAE,IAAI,GAAG,EAAE;QAC3B,cAAc,EAAE,IAAI;QACpB,GAAG,EAAE,aAAa;KACnB,CAAA;IAED,oDAAoD;IACpD,iBAAiB,CAAC,GAAG,CAAC,EAAE,CAAC,YAAY,EAAE,SAAS,CAAC,CAAA;IACjD,KAAK,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,aAAa,EAAE,iBAAiB,CAAC,CAAA;IAEhD,6DAA6D;IAC7D,MAAM,cAAc,GAAG,KAAK,CAAC,CAAC,sBAAsB,CAClD,EAAE,EACF,IAAI,EACJ,WAAW,EACX,aAAa,EACb,kBAAkB,CACnB,CAAC,IAAI,CACJ,MAAM,CAAC,QAAQ,CAAC,CAAC,KAAK,EAAE,EAAE,CACxB,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;QAClB,8CAA8C;QAC9C,KAAK,CAAC,CAAC,MAAM,CAAC,QAAQ,CACpB,yCAAyC,EAAE,CAAC,YAAY,KAAK,KAAK,EAAE,CACrE,CAAA;QACD,MAAM,OAAO,GAAG,KAAK,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,aAAa,CAAC,CAAA;QAC7C,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC,YAAY,CAAC,CAAA;QAC/B,KAAK,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,aAAa,EAAE,OAAO,CAAC,CAAA;QACtC,OAAO,KAAK,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;IAClC,CAAC,CAAC,CACH,CACF,CAAA;IAED,kCAAkC;IAClC,SAAS,CAAC,cAAc,GAAG,cAAc,CAAA;IAEzC,gEAAgE;IAChE,KAAK,CAAC,CAAC,yBAAyB,CAC9B,SAAS,EACT,aAAa,EACb,aAAa,EACb,aAAa,EACb,kBAAkB,CACnB,CAAC,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,CAAA;IAEzB,OAAO,SAAS,CAAA;AAClB,CAAC,CAAC,CAAA;AAEJ;;;GAGG;AACH,MAAM,sBAAsB,GAAG,CAC7B,UAAkB,EAClB,aAAsD,EACtD,WAAmB,EAC0C,EAAE,CAC/D,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;IAClB,MAAM,UAAU,GAAG,KAAK,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,aAAa,CAAC,CAAA;IAChD,MAAM,SAAS,GAAG,UAAU,CAAC,GAAG,CAAC,UAAU,CAAC,CAAA;IAE5C,IAAI,CAAC,SAAS,EAAE,CAAC;QACf,KAAK,CAAC,CAAC,MAAM,CAAC,OAAO,CACnB,0BAA0B,UAAU,wBAAwB,CAC7D,CAAA;QACD,OAAM;IACR,CAAC;IAED,kEAAkE;IAClE,SAAS,CAAC,YAAY,GAAG,IAAI,CAAA;IAE7B,KAAK,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,oCAAoC,UAAU,KAAK,CAAC,CAAA;IAE3E,MAAM,MAAM,GAAG,KAAK,CAAC,CAAC,MAAM,CAAA;IAE5B,mDAAmD;IACnD,MAAM,WAAW,GAAG,SAAS,CAAC,aAAa,CAAA;IAC3C,KAAK,CAAC,CAAC,MAAM,CAAC,OAAO,CACnB,gDAAgD,WAAW,EAAE,CAC9D,CAAA;IAED,MAAM,SAAS,GAAG,KAAK,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,IAAI,CACpD,MAAM,CAAC,MAAM,EACb,MAAM,CAAC,QAAQ,CAAC,CAAC,KAAK,EAAE,EAAE,CACxB,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;QAClB,KAAK,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,mCAAmC,KAAK,EAAE,CAAC,CAAA;QACjE,OAAO,CAAC,CAAA;IACV,CAAC,CAAC,CACH,CACF,CAAA;IACD,KAAK,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,mBAAmB,SAAS,eAAe,CAAC,CAAA;IAEnE,2BAA2B;IAC3B,MAAM,EAAE,GAAG,SAAS,CAAC,EAAE,CAAA;IACvB,MAAM,WAAW,GAAG,EAAE,CAAC,iBAAiB,EAAE,UAAU,CAAC,GAAG,CAAC;QACvD,CAAC,CAAC,EAAE,CAAC,iBAAiB;QACtB,CAAC,CAAC,GAAG,WAAW,IAAI,EAAE,CAAC,iBAAiB,EAAE,CAAA;IAE5C,uCAAuC;IACvC,MAAM,QAAQ,GAAG,EAAE,CAAC,YAAY,KAAK,OAAO,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,aAAa,CAAA;IAE5E,2BAA2B;IAC3B,KAAK,CAAC,CAAC,MAAM;SACV,KAAK,CAAC;QACL,WAAW;QACX,SAAS,EAAE,SAAS,CAAC,SAAS;QAC9B,QAAQ;KACT,CAAC;SACD,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAA;IAEtB,yEAAyE;IACzE,MAAM,WAAW,GAAG,KAAK,CAAC,CAAC,MAAM;SAC9B,OAAO,CAAC,SAAS,CAAC,SAAS,CAAC;SAC5B,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAA;IACtB,MAAM,gBAAgB,GAAG,4BAA4B,CACnD,WAAW,CAAC,UAAU,EACtB,WAAW,CAAC,GAAG,CAChB,CAAA;IAED,wDAAwD;IACxD,oEAAoE;IACpE,6BAA6B;IAC7B,MAAM,aAAa,GAAG,KAAK,CAAC,CAAC,MAAM,CAAC,cAAc,EAAE,CAAA;IACpD,MAAM,cAAc,GAAG,aAAa,CAAC,eAAe;QAClD,CAAC,CAAC,sBAAsB;QACxB,CAAC,CAAC,aAAa,CAAA;IAEjB,KAAK,CAAC,CAAC,MAAM,CAAC,OAAO,CACnB,wDAAwD,cAAc,IAAI,SAAS,CAAC,IAAI,EAAE,CAC3F,CAAA;IAED,MAAM,eAAe,GAAG,yBAAyB,CAAC;QAChD,QAAQ,EAAE,SAAS,CAAC,SAAS;QAC7B,cAAc;QACd,cAAc,EAAE,SAAS,CAAC,IAAI;QAC9B,YAAY,EAAE,EAAE,CAAC,YAAY;QAC7B,eAAe,EAAE,SAAS;QAC1B,QAAQ,EAAE,EAAE,CAAC,QAAQ;QACrB,cAAc,EAAE,IAAI;QACpB,QAAQ;KACT,CAAC,CAAA;IAEF,6DAA6D;IAC7D,eAAe,CAAC,UAAU,GAAG,gBAAgB,CAAC,UAAU,CAAA;IACxD,eAAe,CAAC,OAAO,GAAG,gBAAgB,CAAC,OAAO,CAAA;IAElD,0BAA0B;IAC1B,KAAK,CAAC,CAAC,MAAM,CAAC,QAAQ,CACpB,sCAAsC,UAAU,KAAK,CACtD,CAAA;IAED,2DAA2D;IAC3D,MAAM,QAAQ,GAAG,KAAK,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC,IAAI,CACtD,MAAM,CAAC,MAAM,EACb,MAAM,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CACpB,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;QAClB,iEAAiE;QACjE,uCAAuC;QACvC,MAAM,IAAI,GAAG,MAAM,CAAC,QAAQ,CAAA;QAC5B,IAAI,IAAI,KAAK,CAAC,IAAI,IAAI,KAAK,GAAG,IAAI,IAAI,KAAK,GAAG,EAAE,CAAC;YAC/C,KAAK,CAAC,CAAC,MAAM,CAAC,QAAQ,CACpB,iBAAiB,UAAU,qBAAqB,IAAI,EAAE,CACvD,CAAA;YACD,KAAK,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,WAAW,MAAM,CAAC,MAAM,EAAE,CAAC,CAAA;QACpD,CAAC;IACH,CAAC,CAAC,CACH,EACD,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,SAAiB,CAAC,EACnC,MAAM,CAAC,QAAQ,CAAC,CAAC,KAAK,EAAE,EAAE,CACxB,MAAM,CAAC,QAAQ,CAAC,uBAAuB,UAAU,KAAK,KAAK,EAAE,CAAC,CAC/D,EACD,MAAM,CAAC,UAAU,CAClB,CAAA;IAED,gDAAgD;IAChD,SAAS,CAAC,cAAc,GAAG,QAAQ,CAAA;IAEnC,6DAA6D;IAC7D,KAAK,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,WAAW,CAAC,CAAA;IAEhC,SAAS,CAAC,YAAY,GAAG,KAAK,CAAA;IAC9B,KAAK,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,iCAAiC,UAAU,EAAE,CAAC,CAAA;AACvE,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAA;AAErC;;;;GAIG;AACH,MAAM,sBAAsB,GAAG,CAC7B,EAAsB,EACtB,UAA6B,EAC7B,aAAsD,EACtD,WAAwB,EACxB,WAAmB,EACnB,aAAqB,EACrB,aAAqB,EACrB,aAAmD,EACnD,iBAAkC,EAClC,kBAAkD,EACW,EAAE,CAC/D,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;IAClB,iEAAiE;IACjE,wEAAwE;IACxE,MAAM,SAAS,GAAG,KAAK,CAAC,CAAC,sBAAsB,CAC7C,EAAE,EACF,qBAAqB,CAAC,UAAU,CAAC,GAAG,IAAI,EAAE,CAAC,EAC3C,aAAa,EACb,WAAW,EACX,WAAW,EACX,aAAa,EACb,aAAa,EACb,aAAa,EACb,kBAAkB,CACnB,CAAA;IAED,yDAAyD;IACzD,MAAM,aAAa,GAAG,KAAK,CAAC,CAAC,GAAG,CAAC,YAAY,CAC3C,iBAAiB,EACjB,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,CACb,CAAA;IACD,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAA;IAC5B,kBAAkB,CAAC,GAAG,CAAC,UAAU,CAAC,SAAS,EAAE;QAC3C,GAAG,EAAE,aAAa;QAClB,KAAK,EAAE,SAAS;QAChB,EAAE,EAAE,EAAE,CAAC,YAAY;QACnB,QAAQ,EAAE,IAAI;KACf,CAAC,CAAA;IAEF,qBAAqB;IACrB,OAAO,CAAC,GAAG,CACT,MAAM,aAAa,iCAAiC,EAAE,CAAC,YAAY,eAAe,CACnF,CAAA;IAED,kCAAkC;IAClC,IAAI,SAAS,CAAC,YAAY,EAAE,CAAC;QAC3B,KAAK,CAAC,CAAC,MAAM,CAAC,QAAQ,CACpB,+BAA+B,UAAU,CAAC,SAAS,QAAQ,EAAE,CAAC,YAAY,4DAA4D,CACvI,CAAA;IACH,CAAC;SAAM,CAAC;QACN,KAAK,CAAC,CAAC,MAAM,CAAC,QAAQ,CACpB,+BAA+B,UAAU,CAAC,SAAS,QAAQ,EAAE,CAAC,YAAY,EAAE,CAC7E,CAAA;IACH,CAAC;IAED,MAAM,gBAAgB,GAAqB;QACzC,SAAS,EAAE,UAAU,CAAC,SAAS;QAC/B,KAAK,EAAE,UAAU,CAAC,KAAK;QACvB,kBAAkB,EAAE,UAAU,CAAC,OAAO,CAAC,kBAAkB;QACzD,UAAU,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,UAAU,CAAC,OAAO,CAAC,wBAAwB;QACpE,YAAY,EAAE,EAAE,CAAC,YAAY;QAC7B,eAAe,EAAE,UAAU,CAAC,OAAO,CAAC,eAAe;QACnD,aAAa,EAAE,EAAE,CAAC,QAAQ;QAC1B,YAAY,EAAE,UAAU,CAAC,OAAO,CAAC,YAAY;QAC7C,aAAa,EAAE,UAAU,CAAC,OAAO,CAAC,aAAa;KAChD,CAAA;IAED,KAAK,CAAC,CAAC,MAAM,CAAC,QAAQ,CACpB,2CAA2C,SAAS,CAAC,IAAI,EAAE,CAC5D,CAAA;IACD,0EAA0E;IAC1E,KAAK,CAAC,CAAC,sBAAsB,CAAC,SAAS,CAAC,YAAY,EAAE,gBAAgB,CAAC,CAAA;IACvE,KAAK,CAAC,CAAC,eAAe,CAAC,SAAS,CAAC,YAAY,EAAE,gBAAgB,CAAC,CAAA;IAChE,KAAK,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,wCAAwC,CAAC,CAAA;AAClE,CAAC,CAAC,CAAA;AAEJ;;;GAGG;AACH,MAAM,sBAAsB,GAAG,CAC7B,EAAsB,EACtB,UAA6B,EAC7B,UAA8C,EAC9C,WAAwB,EACxB,WAAmB,EACnB,aAAmD,EACnD,iBAAkC,EAClC,kBAAkD,EACtB,EAAE,CAC9B,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;IAClB,8DAA8D;IAC9D,MAAM,aAAa,GAAG,qBAAqB,CAAC,UAAU,CAAC,GAAG,IAAI,EAAE,CAAC,CAAA;IAEjE,8DAA8D;IAC9D,MAAM,MAAM,GAAG,KAAK,CAAC,CAAC,mBAAmB,CACvC,EAAE,EACF,aAAa,EACb,UAAU,EACV,WAAW,EACX,WAAW,EACX,aAAa,EACb,kBAAkB,CACnB,CAAA;IAED,yDAAyD;IACzD,MAAM,aAAa,GAAG,KAAK,CAAC,CAAC,GAAG,CAAC,YAAY,CAC3C,iBAAiB,EACjB,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,CACb,CAAA;IACD,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAA;IAC5B,kBAAkB,CAAC,GAAG,CAAC,UAAU,CAAC,SAAS,EAAE;QAC3C,GAAG,EAAE,aAAa;QAClB,KAAK,EAAE,SAAS;QAChB,EAAE,EAAE,EAAE,CAAC,YAAY;QACnB,QAAQ,EAAE,KAAK;KAChB,CAAC,CAAA;IAEF,qBAAqB;IACrB,OAAO,CAAC,GAAG,CACT,MAAM,aAAa,wBAAwB,EAAE,CAAC,YAAY,eAAe,CAC1E,CAAA;IAED,KAAK,CAAC,CAAC,MAAM,CAAC,QAAQ,CACpB,+BAA+B,UAAU,CAAC,SAAS,QAAQ,EAAE,CAAC,YAAY,EAAE,CAC7E,CAAA;IAED,MAAM,gBAAgB,GAAqB;QACzC,SAAS,EAAE,UAAU,CAAC,SAAS;QAC/B,KAAK,EAAE,UAAU,CAAC,KAAK;QACvB,kBAAkB,EAAE,UAAU,CAAC,OAAO,CAAC,kBAAkB;QACzD,UAAU,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,UAAU,CAAC,OAAO,CAAC,wBAAwB;QACpE,YAAY,EAAE,EAAE,CAAC,YAAY;QAC7B,eAAe,EAAE,UAAU,CAAC,OAAO,CAAC,eAAe;QACnD,aAAa,EAAE,EAAE,CAAC,QAAQ;QAC1B,YAAY,EAAE,UAAU,CAAC,OAAO,CAAC,YAAY;QAC7C,aAAa,EAAE,UAAU,CAAC,OAAO,CAAC,aAAa;KAChD,CAAA;IAED,KAAK,CAAC,CAAC,eAAe,CAAC,MAAM,CAAC,YAAY,EAAE,gBAAgB,CAAC,CAAA;AAC/D,CAAC,CAAC,CAAA;AASJ;;;GAGG;AACH,MAAM,aAAa,GAAG,CACpB,OAKC,EACD,KAAkB,EAKlB,EAAE,CACF,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;IAClB,MAAM,IAAI,GAAG;QACX,KAAK;QACL,OAAO;QACP,oBAAoB;QACpB,WAAW;QACX,iBAAiB;KAClB,CAAA;IAED,IAAI,OAAO,CAAC,MAAM,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAChD,IAAI,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;IAC9B,CAAC;SAAM,IAAI,OAAO,CAAC,GAAG,EAAE,CAAC;QACvB,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;IACpB,CAAC;IAED,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;QACpB,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;IACzC,CAAC;IAED,MAAM,GAAG,GAA2B;QAClC,GAAG,OAAO,CAAC,GAAG;QACd,QAAQ,EAAE,MAAM;KACS,CAAA;IAE3B,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;QACnB,GAAG,CAAC,UAAU,GAAG,OAAO,CAAC,MAAM,CAAA;QAC/B,GAAG,CAAC,kBAAkB,GAAG,OAAO,CAAC,MAAM,CAAA;IACzC,CAAC;IAED,KAAK,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,iBAAiB,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAA;IAEzD,MAAM,OAAO,GAAG,eAAe,CAAC,IAAI,CAAC,KAAK,EAAE,GAAG,IAAI,CAAC,CAAC,IAAI,CACvD,eAAe,CAAC,GAAG,CAAC,GAAG,CAAC,EACxB,eAAe,CAAC,UAAU,CAAC,IAAI,CAAC,EAChC,eAAe,CAAC,KAAK,CAAC,SAAS,CAAC,CACjC,CAAA;IAED,6DAA6D;IAC7D,MAAM,IAAI,GAAG,KAAK,CAAC,CAAC,eAAe,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAA;IAE5E,0CAA0C;IAC1C,MAAM,MAAM,GAAG,KAAK,CAAC,CAAC,KAAK,CAAC,SAAS,EAAiB,CAAA;IAEtD,4CAA4C;IAC5C,IAAI,WAAW,GAAG,KAAK,CAAA;IACvB,IAAI,aAAa,GAAG,IAAI,CAAA;IACxB,IAAI,YAAY,GAAG,EAAE,CAAA;IACrB,MAAM,gBAAgB,GAAG,IAAI,GAAG,EAAU,CAAA;IAE1C,wCAAwC;IACxC,MAAM,qBAAqB,GAAG,0BAA0B,CAAA;IACxD,MAAM,kBAAkB,GAAG,yCAAyC,CAAA;IACpE,MAAM,gBAAgB,GAAG,kCAAkC,CAAA;IAC3D,MAAM,YAAY,GAAG,iCAAiC,CAAA;IACtD,MAAM,gBAAgB,GAAG,+BAA+B,CAAA;IAExD,4DAA4D;IAC5D,MAAM,YAAY,GAAG,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,IAAI,CAC9D,MAAM,CAAC,UAAU,EAAE,EACnB,MAAM,CAAC,UAAU,CAClB,CAAA;IAED,uCAAuC;IACvC,KAAK,CAAC,CAAC,YAAY,CAAC,IAAI,CACtB,MAAM,CAAC,UAAU,CAAC,CAAC,IAAI,EAAE,EAAE,CACzB,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;QAClB,YAAY,IAAI,IAAI,GAAG,IAAI,CAAA;QAE3B,gCAAgC;QAChC,KAAK,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,SAAS,IAAI,EAAE,CAAC,CAAA;QAEvC,4BAA4B;QAC5B,MAAM,KAAK,GAAG,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAA;QAChD,IAAI,KAAK,EAAE,CAAC;YACV,MAAM,SAAS,GAAG,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,CAAA;YACtC,IAAI,SAAS,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,CAAC;gBAClD,gBAAgB,CAAC,GAAG,CAAC,SAAS,CAAC,CAAA;gBAC/B,KAAK,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,MAAM,EAAE;oBACzB,IAAI,EAAE,iBAAiB;oBACvB,SAAS;iBACV,CAAC,CAAA;YACJ,CAAC;QACH,CAAC;QAED,sBAAsB;QACtB,IAAI,CAAC,WAAW,IAAI,kBAAkB,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;YAClD,WAAW,GAAG,IAAI,CAAA;YAClB,IAAI,CAAC,aAAa,EAAE,CAAC;gBACnB,KAAK,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,oBAAoB,CAAC,CAAA;YAC7C,CAAC;QACH,CAAC;QAED,qCAAqC;QACrC,IAAI,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;YAC5B,KAAK,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,GAAG,IAAI,CAAC,CAAC,CAAA;QAC7D,CAAC;QAED,mEAAmE;QACnE,IAAI,WAAW,IAAI,qBAAqB,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;YACpD,WAAW,GAAG,KAAK,CAAA;YACnB,aAAa,GAAG,KAAK,CAAA;YACrB,YAAY,GAAG,EAAE,CAAA;YACjB,KAAK,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,uBAAuB,CAAC,CAAA;YAC9C,uDAAuD;YACvD,KAAK,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,UAAU,CAAC,CAAA;YAC/B,KAAK,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,MAAM,EAAE,EAAE,IAAI,EAAE,gBAAgB,EAAE,CAAC,CAAA;QACxD,CAAC;QAED,uBAAuB;QACvB,IAAI,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;YAChC,WAAW,GAAG,KAAK,CAAA;YACnB,YAAY,GAAG,EAAE,CAAA;QACnB,CAAC;IACH,CAAC,CAAC,CACH;IACD,4CAA4C;IAC5C,MAAM,CAAC,QAAQ,CAAC,CAAC,KAAK,EAAE,EAAE,CACxB,MAAM,CAAC,QAAQ,CAAC,0BAA0B,KAAK,EAAE,CAAC,CACnD,EACD,MAAM,CAAC,QAAQ,CACb,IAAI,CAAC,QAAQ,CAAC,IAAI,CAChB,MAAM,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE,CACtB,IAAI,KAAK,CAAC;QACR,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,oCAAoC,IAAI,EAAE,CAAC;QAC7D,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,oCAAoC,IAAI,EAAE,CAAC,CAChE,EACD,MAAM,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,CACnC,CACF,EACD,MAAM,CAAC,IAAI,CACZ,CAAA;IAED,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,CAAA;AAClC,CAAC,CAAC,CAAA;AAEJ;;GAEG;AACH,MAAM,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,IAAI,CAChD,OAAO,CAAC,QAAQ,EAChB,OAAO,CAAC,eAAe,CAAC,oBAAoB,CAAC,CAC9C,CAAA;AAED,MAAM,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,IAAI,CAC9C,OAAO,CAAC,QAAQ,EAChB,OAAO,CAAC,eAAe,CAAC,YAAY,CAAC,CACtC,CAAA;AAED,MAAM,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,IAAI,CACpD,OAAO,CAAC,WAAW,CAAC,WAAW,CAAC,EAChC,OAAO,CAAC,eAAe,CAAC,yBAAyB,CAAC,CACnD,CAAA;AAED,MAAM,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,IAAI,CAC9C,OAAO,CAAC,QAAQ,EAChB,OAAO,CAAC,eAAe,CACrB,uDAAuD,CACxD,CACF,CAAA;AAED,MAAM,eAAe,GAAG,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,IAAI,CACjD,OAAO,CAAC,WAAW,CAAC,KAAK,CAAC,EAC1B,OAAO,CAAC,eAAe,CAAC,2CAA2C,CAAC,CACrE,CAAA;AAED,MAAM,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,IAAI,CAC/C,OAAO,CAAC,WAAW,CAAC,KAAK,CAAC,EAC1B,OAAO,CAAC,eAAe,CAAC,sBAAsB,CAAC,CAChD,CAAA;AAED,MAAM,iBAAiB,GAAG,OAAO,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC,IAAI,CAC5D,OAAO,CAAC,WAAW,CAAC,uBAAuB,CAAC,EAC5C,OAAO,CAAC,eAAe,CACrB,iEAAiE,CAClE,CACF,CAAA;AAED,MAAM,iBAAiB,GAAG,OAAO,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC,IAAI,CAC5D,OAAO,CAAC,QAAQ,EAChB,OAAO,CAAC,eAAe,CACrB,sGAAsG,CACvG,CACF,CAAA;AAED;;GAEG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,OAAO,CAAC,IAAI,CACtC,OAAO,EACP;IACE,OAAO,EAAE,aAAa;IACtB,MAAM,EAAE,YAAY;IACpB,SAAS,EAAE,eAAe;IAC1B,MAAM,EAAE,YAAY;IACpB,GAAG,EAAE,eAAe;IACpB,KAAK,EAAE,WAAW;IAClB,WAAW,EAAE,iBAAiB;IAC9B,WAAW,EAAE,iBAAiB;CAC/B,EACD,CAAC,EACC,OAAO,EACP,MAAM,EACN,SAAS,EACT,MAAM,EACN,GAAG,EACH,KAAK,EACL,WAAW,EACX,WAAW,GACZ,EAAE,EAAE;IACH,MAAM,QAAQ,GAAG,KAAK,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAA;IACvD,OAAO,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;QACzB,KAAK,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,8CAA8C,CAAC,CAAA;QAErE,MAAM,YAAY,GAAG,OAAO,CAAC,IAAI,KAAK,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAA;QACxE,MAAM,WAAW,GAAG,MAAM,CAAC,IAAI,KAAK,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAA;QACrE,MAAM,gBAAgB,GACpB,MAAM,CAAC,IAAI,KAAK,MAAM;YACpB,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;YAC9C,CAAC,CAAC,SAAS,CAAA;QAEf,gFAAgF;QAChF,kEAAkE;QAClE,MAAM,oBAAoB,GACxB,WAAW,CAAC,IAAI,KAAK,MAAM;YACzB,CAAC,CAAC,WAAW,CAAC,KAAK;YACnB,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,WAAW,GAAG,MAAM,EAAE,KAAK,CAAC,CAAA,CAAC,qBAAqB;QAEjE,IAAI,YAAY,EAAE,CAAC;YACjB,OAAO,CAAC,GAAG,CAAC,WAAW,GAAG,YAAY,CAAA;QACxC,CAAC;QACD,IAAI,WAAW,EAAE,CAAC;YAChB,OAAO,CAAC,GAAG,CAAC,UAAU,GAAG,WAAW,CAAA;QACtC,CAAC;QAED,sCAAsC;QACtC,KAAK,CAAC,CAAC,eAAe,CAAC;YACrB,SAAS;YACT,OAAO,EAAE,YAAY;YACrB,MAAM,EAAE,WAAW;SACpB,CAAC,CAAA;QAEF,kFAAkF;QAClF,8DAA8D;QAC9D,MAAM,WAAW,GAAG,EAAE,MAAM,EAAE,gBAAgB,IAAK,EAAe,EAAE,CAAA;QAEpE,8EAA8E;QAC9E,wEAAwE;QACxE,MAAM,WAAW,GAAG,KAAK,CAAC,CAAC,KAAK,CAAC,IAAI,EAAE,CAAA;QAEvC,8CAA8C;QAC9C,iFAAiF;QACjF,KAAK,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,oBAAoB,CAAC,CAAA;QAE3C,MAAM,EAAE,OAAO,EAAE,eAAe,EAAE,MAAM,EAAE,SAAS,EAAE,GACnD,KAAK,CAAC,CAAC,aAAa,CAClB;YACE,OAAO,EAAE,YAAY;YACrB,MAAM,EAAE,WAAW;YACnB,MAAM,EAAE,gBAAgB;YACxB,GAAG;SACJ,EACD,WAAW,CACZ,CAAA;QAEH,mDAAmD;QACnD,MAAM,UAAU,GAAG,KAAK,CAAC,CAAC,GAAG,CAAC,IAAI,CAChC,IAAI,GAAG,EAAE,CACV,CAAA;QAED,iDAAiD;QACjD,MAAM,OAAO,GAAG,KAAK,CAAC,CAAC,GAAG,CAAC,IAAI,CAA4B,IAAI,GAAG,EAAE,CAAC,CAAA;QAErE,iEAAiE;QACjE,MAAM,mBAAmB,GAAG,KAAK,CAAC,CAAC,GAAG,CAAC,IAAI,CAEzC,IAAI,GAAG,EAAE,CAAC,CAAA;QAEZ,mDAAmD;QACnD,MAAM,sBAAsB,GAAG,IAAI,GAAG,EAAU,CAAA;QAEhD,kDAAkD;QAClD,MAAM,iBAAiB,GAAG,KAAK,CAAC,CAAC,GAAG,CAAC,IAAI,CAAS,CAAC,CAAC,CAAA;QACpD,sFAAsF;QACtF,MAAM,kBAAkB,GAAG,IAAI,GAAG,EAA6B,CAAA;QAE/D,sEAAsE;QACtE,MAAM,WAAW,GAAG,OAAO,CAAC,GAAG,EAAE,CAAA;QAEjC,IAAI,aAAa,GAAgD,IAAI,CAAA;QAErE,+DAA+D;QAC/D,MAAM,QAAQ,GAAG,EAAE,iBAAiB,EAAE,KAAK,EAAE,iBAAiB,EAAE,KAAK,EAAE,CAAA;QAEvE,gEAAgE;QAChE,MAAM,mBAAmB,GAAG,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;YAC9C,oDAAoD;YACpD,IAAI,CAAC,QAAQ,CAAC,iBAAiB,EAAE,CAAC;gBAChC,KAAK,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,kCAAkC,CAAC,CAAA;YAC3D,CAAC;YAED,4DAA4D;YAC5D,IAAI,CAAC,aAAa,EAAE,CAAC;gBACnB,KAAK,CAAC,CAAC,MAAM,CAAC,QAAQ,CACpB,+CAA+C,CAChD,CAAA;gBACD,MAAM,SAAS,GAAG,KAAK,CAAC,CAAC,mBAAmB,CAAC,SAAS,CAAC,CAAC,IAAI,CAC1D,MAAM,CAAC,KAAK,CAAC,EAAE,KAAK,EAAE,EAAE,EAAE,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,WAAW,CAAC,EAAE,CAAC,CACpE,CAAA;gBACD,KAAK,CAAC,CAAC,MAAM,CAAC,QAAQ,CACpB,0BAA0B,SAAS,CAAC,YAAY,EAAE,CACnD,CAAA;gBACD,aAAa,GAAG,iBAAiB,CAAC,SAAS,CAAC,CAAA;YAC9C,CAAC;YAED,8DAA8D;YAC9D,KAAK,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,yCAAyC,CAAC,CAAA;YACjE,MAAM,SAAS,GAAG,KAAK,CAAC,CAAC,iBAAiB,CAAC,WAAW,CAAC,MAAM,CAAC,CAAA;YAE9D,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;gBAC3B,KAAK,CAAC,CAAC,MAAM,CAAC,OAAO,CACnB,qIAAqI,CACtI,CAAA;gBACD,OAAM;YACR,CAAC;YAED,MAAM,iBAAiB,GAAG,KAAK,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,mBAAmB,CAAC,CAAA;YAE7D,oCAAoC;YACpC,MAAM,YAAY,GAGb,EAAE,CAAA;YAEP,KAAK,MAAM,EAAE,IAAI,SAAS,EAAE,CAAC;gBAC3B,MAAM,QAAQ,GAAG,OAAO,CAAC,EAAE,CAAC,iBAAiB,CAAC,CAAA;gBAC9C,MAAM,QAAQ,GAAG,CAAC,QAAQ,IAAI,OAAO,CAAC,EAAE,CAAC,YAAY,CAAC,CAAA;gBAEtD,IAAI,CAAC,QAAQ,IAAI,CAAC,QAAQ,EAAE,CAAC;oBAC3B,KAAK,CAAC,CAAC,MAAM,CAAC,QAAQ,CACpB,oBAAoB,EAAE,CAAC,YAAY,uCAAuC,CAC3E,CAAA;oBACD,SAAQ;gBACV,CAAC;gBAED,IAAI,iBAAiB,CAAC,GAAG,CAAC,EAAE,CAAC,YAAY,CAAC,EAAE,CAAC;oBAC3C,KAAK,CAAC,CAAC,MAAM,CAAC,QAAQ,CACpB,4BAA4B,EAAE,CAAC,YAAY,EAAE,CAC9C,CAAA;oBACD,SAAQ;gBACV,CAAC;gBAED,YAAY,CAAC,IAAI,CAAC,EAAE,EAAE,EAAE,QAAQ,EAAE,CAAC,CAAA;YACrC,CAAC;YAED,wCAAwC;YACxC,IAAI,YAAY,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBAC5B,MAAM,OAAO,GAAG,YAAY;qBACzB,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,QAAQ,EAAE,EAAE,EAAE;oBACxB,MAAM,IAAI,GAAG,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAA;oBACzC,MAAM,SAAS,GAAG,EAAE,CAAC,YAAY,CAAC,QAAQ,CAAC,GAAG,CAAC;wBAC7C,CAAC,CAAC,EAAE,CAAC,YAAY,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,YAAY;wBAChE,CAAC,CAAC,EAAE,CAAC,YAAY,CAAA;oBACnB,OAAO,GAAG,SAAS,KAAK,IAAI,GAAG,CAAA;gBACjC,CAAC,CAAC;qBACD,IAAI,CAAC,IAAI,CAAC,CAAA;gBACb,0DAA0D;gBAC1D,MAAM,MAAM,GAAG,QAAQ,CAAC,iBAAiB;oBACvC,CAAC,CAAC,0BAA0B;oBAC5B,CAAC,CAAC,oBAAoB,CAAA;gBACxB,KAAK,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,GAAG,MAAM,IAAI,OAAO,EAAE,CAAC,CAAA;YAC/C,CAAC;YAED,8CAA8C;YAC9C,KAAK,MAAM,EAAE,EAAE,EAAE,QAAQ,EAAE,IAAI,YAAY,EAAE,CAAC;gBAC5C,KAAK,CAAC,CAAC,MAAM,CAAC,QAAQ,CACpB,uBAAuB,EAAE,CAAC,YAAY,KAAK,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,SAAS,GAAG,CAC9E,CAAA;gBAED,wBAAwB;gBACxB,iBAAiB,CAAC,GAAG,CAAC,EAAE,CAAC,YAAY,EAAE,EAAE,CAAC,CAAA;gBAE1C,6CAA6C;gBAC7C,MAAM,iBAAiB,GAAG,gBAAgB,CAAC,UAAU,CAAC,EAAE,CAAC,YAAY,CAAC,CAAA;gBACtE,KAAK,CAAC,CAAC,MAAM,CAAC,QAAQ,CACpB,0CAA0C,EAAE,CAAC,YAAY,EAAE,CAC5D,CAAA;gBAED,yEAAyE;gBACzE,4DAA4D;gBAC5D,IAAI,QAAQ,EAAE,CAAC;oBACb,KAAK,CAAC,CAAC,aAAc;yBAClB,sBAAsB,CAAC,iBAAiB,CAAC;yBACzC,IAAI,CACH,MAAM,CAAC,UAAU,CAAC,CAAC,UAAU,EAAE,EAAE,CAC/B,sBAAsB,CACpB,EAAE,EACF,UAAU,EACV,UAAU,EACV,WAAW,EACX,WAAW,EACX,WAAW,EACX,oBAAoB,EACpB,aAAc,EACd,iBAAiB,EACjB,kBAAkB,CACnB,CAAC,IAAI,CACJ,MAAM,CAAC,QAAQ,CAAC,CAAC,KAAK,EAAE,EAAE,CACxB,MAAM,CAAC,QAAQ,CACb,oCAAoC,KAAK,EAAE,CAC5C,CACF,CACF,CACF,EACD,MAAM,CAAC,UAAU,CAClB,CAAA;gBACL,CAAC;qBAAM,CAAC;oBACN,KAAK,CAAC,CAAC,aAAc;yBAClB,sBAAsB,CAAC,iBAAiB,CAAC;yBACzC,IAAI,CACH,MAAM,CAAC,UAAU,CAAC,CAAC,UAAU,EAAE,EAAE,CAC/B,sBAAsB,CACpB,EAAE,EACF,UAAU,EACV,OAAO,EACP,WAAW,EACX,WAAW,EACX,aAAc,EACd,iBAAiB,EACjB,kBAAkB,CACnB,CAAC,IAAI,CACJ,MAAM,CAAC,QAAQ,CAAC,CAAC,KAAK,EAAE,EAAE,CACxB,MAAM,CAAC,QAAQ,CACb,qCAAqC,KAAK,EAAE,CAC7C,CACF,CACF,CACF,EACD,MAAM,CAAC,UAAU,CAClB,CAAA;gBACL,CAAC;YACH,CAAC;YAED,KAAK,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,mBAAmB,EAAE,iBAAiB,CAAC,CAAA;YAEtD,+CAA+C;YAC/C,MAAM,kBAAkB,GAA4B,EAAE,CAAA;YACtD,KAAK,MAAM,EAAE,IAAI,SAAS,EAAE,CAAC;gBAC3B,IACE,EAAE,CAAC,iBAAiB;oBACpB,CAAC,sBAAsB,CAAC,GAAG,CAAC,EAAE,CAAC,YAAY,CAAC,EAC5C,CAAC;oBACD,2BAA2B;oBAC3B,MAAM,WAAW,GAAG,EAAE,CAAC,iBAAiB,CAAC,UAAU,CAAC,GAAG,CAAC;wBACtD,CAAC,CAAC,EAAE,CAAC,iBAAiB;wBACtB,CAAC,CAAC,GAAG,WAAW,IAAI,EAAE,CAAC,iBAAiB,EAAE,CAAA;oBAE5C,kBAAkB,CAAC,IAAI,CAAC;wBACtB,UAAU,EAAE,EAAE,CAAC,YAAY;wBAC3B,iBAAiB,EAAE,WAAW;qBAC/B,CAAC,CAAA;oBACF,sBAAsB,CAAC,GAAG,CAAC,EAAE,CAAC,YAAY,CAAC,CAAA;gBAC7C,CAAC;YACH,CAAC;YAED,qCAAqC;YACrC,IAAI,kBAAkB,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBAClC,KAAK,CAAC,CAAC,MAAM,CAAC,QAAQ,CACpB,sCAAsC,kBAAkB,CAAC,MAAM,wBAAwB,CACxF,CAAA;gBAED,0EAA0E;gBAC1E,KAAK,CAAC,CAAC,mBAAmB,CAAC,kBAAkB,EAAE,GAAG,CAAC,CAAC,IAAI,CACtD,MAAM,CAAC,UAAU,CAAC,CAAC,KAAK,EAAE,EAAE,CAC1B,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;oBAClB,KAAK,CAAC,CAAC,MAAM,CAAC,QAAQ,CACpB,2BAA2B,KAAK,CAAC,UAAU,KAAK,KAAK,CAAC,QAAQ,EAAE,CACjE,CAAA;oBACD,KAAK,CAAC,CAAC,sBAAsB,CAC3B,KAAK,CAAC,UAAU,EAChB,UAAU,EACV,WAAW,CACZ,CAAC,IAAI,CACJ,MAAM,CAAC,QAAQ,CAAC,CAAC,KAAK,EAAE,EAAE,CACxB,MAAM,CAAC,QAAQ,CACb,8BAA8B,KAAK,CAAC,UAAU,KAAK,KAAK,EAAE,CAC3D,CACF,CACF,CAAA;gBACH,CAAC,CAAC,CACH,EACD,MAAM,CAAC,UAAU,CAClB,CAAA;YACH,CAAC;YAED,IAAI,CAAC,QAAQ,CAAC,iBAAiB,EAAE,CAAC;gBAChC,QAAQ,CAAC,iBAAiB,GAAG,IAAI,CAAA;gBACjC,KAAK,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,+BAA+B,CAAC,CAAA;YACxD,CAAC;YAED,4CAA4C;YAC5C,QAAQ,CAAC,iBAAiB,GAAG,IAAI,CAAA;QACnC,CAAC,CAAC,CAAA;QAEF,kEAAkE;QAClE,KAAK,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,IAAI,CAC/B,MAAM,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE,CACvB,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;YAClB,QAAQ,KAAK,CAAC,IAAI,EAAE,CAAC;gBACnB,KAAK,iBAAiB;oBACpB,yDAAyD;oBACzD,IACE,CAAC,gBAAgB;wBACjB,CAAC,WAAW,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,SAAS,CAAC,EAC7C,CAAC;wBACD,WAAW,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAA;wBACxC,KAAK,CAAC,CAAC,MAAM,CAAC,QAAQ,CACpB,6BAA6B,KAAK,CAAC,SAAS,EAAE,CAC/C,CAAA;oBACH,CAAC;oBACD,MAAK;gBACP,KAAK,gBAAgB;oBACnB,yCAAyC;oBACzC,KAAK,CAAC,CAAC,mBAAmB,CAAC,IAAI,CAC7B,MAAM,CAAC,QAAQ,CAAC,CAAC,KAAK,EAAE,EAAE,CACxB,MAAM,CAAC,QAAQ,CAAC,4BAA4B,KAAK,EAAE,CAAC,CACrD,CACF,CAAA;oBACD,MAAK;YACT,CAAC;QACH,CAAC,CAAC,CACH,EACD,MAAM,CAAC,OAAO,EACd,MAAM,CAAC,IAAI,CACZ,CAAA;QAED,yBAAyB;QACzB,MAAM,OAAO,GAAG,KAAK,IAAI,EAAE;YACzB,MAAM,MAAM,CAAC,UAAU,CACrB,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;gBAClB,KAAK,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,oBAAoB,CAAC,CAAA;gBAE3C,iBAAiB;gBACjB,KAAK,CAAC,CAAC,eAAe;qBACnB,IAAI,CAAC,SAAS,CAAC;qBACf,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAA;gBAE3C,sDAAsD;gBACtD,MAAM,MAAM,GAAG,KAAK,CAAC,CAAC,MAAM,CAAA;gBAC5B,MAAM,iBAAiB,GAAG,KAAK,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,UAAU,CAAC,CAAA;gBACpD,KAAK,MAAM,CAAC,IAAI,EAAE,SAAS,CAAC,IAAI,iBAAiB,EAAE,CAAC;oBAClD,KAAK,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,uBAAuB,IAAI,EAAE,CAAC,CAAA;oBACpD,KAAK,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC,IAAI,CAC9C,MAAM,CAAC,MAAM,EACb,MAAM,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,CACnC,CAAA;gBACH,CAAC;gBAED,2BAA2B;gBAC3B,MAAM,cAAc,GAAG,KAAK,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,OAAO,CAAC,CAAA;gBAC9C,KAAK,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,IAAI,cAAc,EAAE,CAAC;oBAC5C,KAAK,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,oBAAoB,IAAI,EAAE,CAAC,CAAA;oBACjD,KAAK,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,CACrB,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,SAAS,CAAC,CACrC,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAA;gBAC5C,CAAC;gBAED,yDAAyD;gBACzD,KAAK,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,WAAW,EAAE,IAAI,CAAC,IAAI,CAAC,CAAA;YAC5C,CAAC,CAAC,CAAC,IAAI,CACL,MAAM,CAAC,OAAO,CAAC,UAAU,CAAC,EAC1B,MAAM,CAAC,OAAO,CAAC,UAAU,CAAC,KAAK,CAAC,EAChC,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,EAC7B,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,eAAe,CAAC,QAAQ,CAAC,CAAC,CACjD,CACF,CAAA;YAED,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAA;QACjB,CAAC,CAAA;QAED,OAAO,CAAC,EAAE,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAA;QAC7B,OAAO,CAAC,EAAE,CAAC,SAAS,EAAE,OAAO,CAAC,CAAA;QAE9B,KAAK,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,8BAA8B,CAAC,CAAA;QAErD,2BAA2B;QAC3B,KAAK,CAAC,CAAC,MAAM,CAAC,KAAK,CAAA;IACrB,CAAC,CAAC,CAAC,IAAI,CACL,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,EAC7B,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,eAAe,CAAC,QAAQ,CAAC,CAAC,CACjD,CAAA;AACH,CAAC,CACF,CAAC,IAAI,CACJ,OAAO,CAAC,eAAe,CACrB,qEAAqE,CACtE,CACF,CAAA","sourcesContent":["/**\n * Local command for running Lambda functions locally using Docker.\n *\n * This command:\n * 1. Starts CDK watch with CDK_LIVE=true and hotswap\n * 2. Discovers Lambda functions with live-lambda:handler tag\n * 3. Connects to AppSync Events\n * 4. Subscribes to invocation channels\n * 5. For each function, maintains ONE Docker container that handles all invocations\n * 6. Sends responses back via AppSync\n * 7. Re-discovers functions after each CDK deploy\n */\n\nimport { type ChildProcess, spawn } from \"node:child_process\"\nimport * as path from \"node:path\"\nimport { fileURLToPath } from \"node:url\"\nimport {\n  LambdaClient,\n  ListFunctionsCommand,\n  ListTagsCommand,\n} from \"@aws-sdk/client-lambda\"\nimport { GetParameterCommand, SSMClient } from \"@aws-sdk/client-ssm\"\nimport { Command, Options } from \"@effect/cli\"\nimport {\n  type CommandExecutor,\n  Command as PlatformCommand,\n} from \"@effect/platform\"\nimport type { Process as EffectProcess } from \"@effect/platform/CommandExecutor\"\nimport { BunContext } from \"@effect/platform-bun\"\nimport {\n  Duration,\n  Effect,\n  Exit,\n  Fiber,\n  Logger,\n  LogLevel,\n  Queue,\n  Ref,\n  Schedule,\n  Scope,\n  Stream,\n} from \"effect\"\nimport {\n  BOOTSTRAP_STACK_NAME,\n  BOOTSTRAP_VERSION,\n  buildChannelName,\n  type InvocationMessage,\n  LIVE_LAMBDA_DOCKER_TAG,\n  LIVE_LAMBDA_TAG,\n  type ResponseMessage,\n  SSM_BASE_PATH,\n} from \"../../shared/types.js\"\nimport { makeAppSyncClient } from \"../appsync/client.js\"\nimport {\n  buildExtensionWrapperCommand,\n  Docker,\n  DockerLive,\n  makeLambdaContainerConfig,\n} from \"../docker/container.js\"\nimport {\n  type WatchedDockerFunction,\n  watchDockerContexts,\n} from \"../docker/watcher.js\"\nimport {\n  notifyExtensionsInvoke,\n  queueInvocation,\n  type RuntimeApiState,\n  startRuntimeApiServer,\n  waitForResponse,\n} from \"../runtime-api/server.js\"\nimport type {\n  LambdaError,\n  LambdaInitError,\n  LambdaInvocation,\n  LambdaResponse,\n} from \"../runtime-api/types.js\"\n\n/**\n * Discovered Lambda function info.\n */\ninterface DiscoveredFunction {\n  functionName: string\n  functionArn: string\n  localHandler: string\n  /** Local Docker context path for DockerImageFunction */\n  dockerContextPath?: string\n  memoryMB: number\n  architecture?: \"arm64\" | \"x86_64\"\n}\n\n/**\n * Default idle timeout before proactively stopping containers.\n * Set slightly below the poll timeout (240s) to stop container before\n * the Lambda RIC gets a 503 error.\n */\nconst DEFAULT_IDLE_TIMEOUT_MS = 230_000 // 230 seconds (~4 minutes)\n\n/**\n * State for a running function container.\n */\ninterface FunctionContainer {\n  fn: DiscoveredFunction\n  runtimeState: RuntimeApiState\n  /** The port the Runtime API server is listening on */\n  port: number\n  containerFiber: Fiber.RuntimeFiber<void, Error>\n  containerName: string\n  /** Docker image name for rebuilds */\n  imageName: string\n  /** Whether the container is currently being rebuilt (invocations will queue) */\n  isRebuilding: boolean\n  /** Map of requestId -> response resolver */\n  pendingResponses: Map<\n    string,\n    {\n      resolve: (response: ResponseMessage) => void\n    }\n  >\n  /** Fiber for the idle shutdown timer, cancelled when new responses arrive */\n  idleTimerFiber: Fiber.RuntimeFiber<void, never> | null\n  /** Environment variables captured from first invocation */\n  env: Record<string, string>\n}\n\n/**\n * State for a running Node.js worker process.\n */\ninterface NodejsWorker {\n  fn: DiscoveredFunction\n  runtimeState: RuntimeApiState\n  /** The port the Runtime API server is listening on */\n  port: number\n  /** The spawned Bun process */\n  workerProcess: ChildProcess\n  /** Environment variables captured from first invocation */\n  env: Record<string, string>\n}\n\n/**\n * Invocation context for tracking and logging.\n */\nexport interface InvocationContext {\n  /** Sequential invocation number */\n  num: number\n  /** Start timestamp in milliseconds */\n  start: number\n  /** Function name */\n  fn: string\n  /** Whether this is a Docker container invocation */\n  isDocker: boolean\n}\n\n/**\n * Check if bootstrap stack version matches the expected version.\n * Returns true if version matches, false if missing or mismatched.\n */\nconst checkBootstrapVersion = (qualifier: string) =>\n  Effect.gen(function* () {\n    const ssmClient = new SSMClient({})\n    const basePath = `${SSM_BASE_PATH}/${qualifier}`\n\n    const result = yield* Effect.tryPromise({\n      try: async () => {\n        const response = await ssmClient.send(\n          new GetParameterCommand({ Name: `${basePath}/version` }),\n        )\n        return response.Parameter?.Value\n      },\n      catch: () => null,\n    }).pipe(Effect.catchAll(() => Effect.succeed(null)))\n\n    if (result === null) {\n      yield* Effect.logInfo(\"Bootstrap stack version parameter not found\")\n      return false\n    }\n\n    if (result !== BOOTSTRAP_VERSION) {\n      yield* Effect.logInfo(\n        `Bootstrap stack version mismatch: found ${result}, expected ${BOOTSTRAP_VERSION}`,\n      )\n      return false\n    }\n\n    return true\n  })\n\n/**\n * Run the bootstrap stack deployment.\n */\nconst runBootstrap = (options: { profile?: string; region?: string }) =>\n  Effect.gen(function* () {\n    yield* Effect.logInfo(\"Running bootstrap stack deployment...\")\n\n    // Resolve the CDK app path relative to this module\n    const __filename = fileURLToPath(import.meta.url)\n    const __dirname = path.dirname(__filename)\n    const cdkAppPath = path.resolve(__dirname, \"..\", \"cdk-app.js\")\n\n    const args = [\n      \"cdk\",\n      \"deploy\",\n      BOOTSTRAP_STACK_NAME,\n      \"--require-approval\",\n      \"never\",\n      \"--app\",\n      `bun ${cdkAppPath}`,\n    ]\n\n    if (options.profile) {\n      args.push(\"--profile\", options.profile)\n    }\n\n    const env: Record<string, string> = {\n      ...process.env,\n    } as Record<string, string>\n    if (options.region) {\n      env.AWS_REGION = options.region\n      env.CDK_DEFAULT_REGION = options.region\n    }\n\n    yield* Effect.logInfo(`Running: npx ${args.join(\" \")}`)\n\n    const command = PlatformCommand.make(\"npx\", ...args).pipe(\n      PlatformCommand.env(env),\n      PlatformCommand.stdin(\"inherit\"),\n    )\n\n    const proc = yield* PlatformCommand.start(command)\n\n    // Stream output to console\n    yield* Stream.merge(proc.stdout, proc.stderr).pipe(\n      Stream.decodeText(),\n      Stream.splitLines,\n      Stream.runForEach((line) =>\n        Effect.sync(() => {\n          process.stdout.write(`${line}\\n`)\n        }),\n      ),\n    )\n\n    const exitCode = yield* proc.exitCode\n    if (exitCode !== 0) {\n      return yield* Effect.fail(\n        new Error(`Bootstrap deployment failed with exit code ${exitCode}`),\n      )\n    }\n\n    yield* Effect.logInfo(\"Bootstrap stack deployed successfully!\")\n  }).pipe(Effect.scoped)\n\n/**\n * Ensure bootstrap stack is deployed with correct version.\n * Automatically deploys if missing or outdated.\n */\nconst ensureBootstrap = (options: {\n  qualifier: string\n  profile?: string\n  region?: string\n}) =>\n  Effect.gen(function* () {\n    yield* Effect.logDebug(\"[Local] Checking bootstrap stack version...\")\n\n    const versionOk = yield* checkBootstrapVersion(options.qualifier)\n\n    if (!versionOk) {\n      yield* Effect.logInfo(\n        \"[Local] Bootstrap stack needs to be deployed or updated.\",\n      )\n      yield* runBootstrap({ profile: options.profile, region: options.region })\n    } else {\n      yield* Effect.logDebug(\"[Local] Bootstrap stack version OK.\")\n    }\n  })\n\n/**\n * Read AppSync endpoints from SSM.\n */\nconst getAppSyncEndpoints = (qualifier: string) =>\n  Effect.gen(function* () {\n    const ssmClient = new SSMClient({})\n    const basePath = `${SSM_BASE_PATH}/${qualifier}`\n\n    const getParam = (name: string) =>\n      Effect.tryPromise({\n        try: async () => {\n          const result = await ssmClient.send(\n            new GetParameterCommand({ Name: `${basePath}/${name}` }),\n          )\n          return result.Parameter?.Value ?? \"\"\n        },\n        catch: (error) =>\n          new Error(`Failed to get SSM parameter ${name}: ${String(error)}`),\n      })\n\n    const httpEndpoint = yield* getParam(\"http-endpoint\")\n    const realtimeEndpoint = yield* getParam(\"realtime-endpoint\")\n\n    return { httpEndpoint, realtimeEndpoint }\n  })\n\n/**\n * CloudFormation stack name tag (set automatically by CDK)\n */\nconst CFN_STACK_NAME_TAG = \"aws:cloudformation:stack-name\"\n\n/**\n * Discover Lambda functions with live-lambda tags.\n * @param stackFilter - Optional list of stack names to filter by\n */\nconst discoverFunctions = (stackFilter?: string[]) =>\n  Effect.gen(function* () {\n    const lambdaClient = new LambdaClient({})\n    const functions: DiscoveredFunction[] = []\n\n    // List all functions\n    let nextMarker: string | undefined\n    do {\n      const listResponse = yield* Effect.tryPromise({\n        try: () =>\n          lambdaClient.send(new ListFunctionsCommand({ Marker: nextMarker })),\n        catch: (error) =>\n          new Error(`Failed to list functions: ${String(error)}`),\n      })\n\n      for (const fn of listResponse.Functions ?? []) {\n        // Get tags for each function\n        const tagsResult = yield* Effect.tryPromise({\n          try: () =>\n            lambdaClient.send(\n              new ListTagsCommand({ Resource: fn.FunctionArn }),\n            ),\n          catch: () => new Error(`Failed to get tags for ${fn.FunctionName}`),\n        }).pipe(\n          Effect.catchAll(() =>\n            Effect.succeed({ Tags: {} as Record<string, string> }),\n          ),\n        )\n\n        const tags = tagsResult.Tags ?? {}\n\n        // Check for live-lambda tag (handler) or docker-context tag\n        if (tags[LIVE_LAMBDA_TAG] || tags[LIVE_LAMBDA_DOCKER_TAG]) {\n          // Filter by stack name if specified\n          if (stackFilter && stackFilter.length > 0) {\n            const stackName = tags[CFN_STACK_NAME_TAG]\n            if (!stackName || !stackFilter.includes(stackName)) {\n              continue\n            }\n          }\n\n          // Determine architecture from Lambda config\n          const architectures = fn.Architectures ?? [\"x86_64\"]\n          const architecture = architectures.includes(\"arm64\")\n            ? (\"arm64\" as const)\n            : (\"x86_64\" as const)\n\n          const discovered: DiscoveredFunction = {\n            functionName: fn.FunctionName!,\n            functionArn: fn.FunctionArn!,\n            localHandler: tags[LIVE_LAMBDA_TAG] ?? \"\",\n            dockerContextPath: tags[LIVE_LAMBDA_DOCKER_TAG],\n            memoryMB: fn.MemorySize ?? 128,\n            architecture,\n          }\n          functions.push(discovered)\n        }\n      }\n\n      nextMarker = listResponse.NextMarker\n    } while (nextMarker)\n\n    return functions\n  })\n\n/**\n * Start a long-running Docker container for a function.\n * Builds the image from the local Docker context path, then runs it.\n * The container continuously polls our Runtime API for invocations.\n * Uses Effect.forkDaemon to ensure the container runs independently with context.\n */\nconst startFunctionContainer = (\n  fn: DiscoveredFunction,\n  port: number,\n  projectRoot: string,\n  additionalEnv: Record<string, string>,\n  invocationContexts?: Map<string, { num: number }>,\n): Effect.Effect<\n  Fiber.RuntimeFiber<void, Error>,\n  Error,\n  CommandExecutor.CommandExecutor\n> =>\n  Effect.gen(function* () {\n    if (!fn.dockerContextPath) {\n      return yield* Effect.fail(\n        new Error(`Function ${fn.functionName} has no Docker context path`),\n      )\n    }\n\n    const docker = yield* Docker\n\n    const dockerRuntime = yield* docker.getRuntimeInfo()\n    const runtimeApiHost = dockerRuntime.isDockerDesktop\n      ? \"host.docker.internal\"\n      : \"runtime.api\"\n\n    // Generate a local image name from function name\n    const imageName = `live-lambda-${fn.functionName.toLowerCase().replace(/[^a-z0-9-]/g, \"-\")}`\n\n    // Resolve the context path relative to project root\n    const contextPath = fn.dockerContextPath.startsWith(\"/\")\n      ? fn.dockerContextPath\n      : `${projectRoot}/${fn.dockerContextPath}`\n\n    // Determine platform from architecture\n    const platform = fn.architecture === \"arm64\" ? \"linux/arm64\" : \"linux/amd64\"\n\n    // Build the Docker image from local context\n    yield* docker\n      .build({\n        contextPath,\n        imageName,\n        platform,\n      })\n      .pipe(Effect.scoped)\n\n    // Inspect the image to get original entrypoint/cmd for extension wrapper\n    const imageConfig = yield* docker.inspect(imageName).pipe(Effect.scoped)\n    const extensionWrapper = buildExtensionWrapperCommand(\n      imageConfig.entrypoint,\n      imageConfig.cmd,\n    )\n\n    const containerConfig = makeLambdaContainerConfig({\n      imageUri: imageName,\n      runtimeApiHost,\n      runtimeApiPort: port,\n      functionName: fn.functionName,\n      functionVersion: \"$LATEST\",\n      memoryMB: fn.memoryMB,\n      timeoutSeconds: 3600, // Long timeout - container stays running\n      platform,\n      additionalEnv,\n      invocationContexts,\n    })\n\n    // Apply extension wrapper to start extensions before the app\n    containerConfig.entrypoint = extensionWrapper.entrypoint\n    containerConfig.command = extensionWrapper.command\n\n    yield* Effect.logInfo(\n      `Starting container for ${fn.functionName} on port ${port}`,\n    )\n\n    // Use Effect.forkDaemon to run the container independently with context preserved\n    // Effect.scoped provides the scope needed by docker.run\n    const fiber = yield* docker.run(containerConfig).pipe(\n      Effect.scoped,\n      Effect.map(() => undefined as void),\n      Effect.forkDaemon,\n    )\n\n    return fiber\n  }).pipe(Effect.provide(DockerLive))\n\n// Type guards for response types\nconst isLambdaResponse = (\n  r: LambdaResponse | LambdaError | LambdaInitError,\n): r is LambdaResponse => \"body\" in r && !(\"errorType\" in r)\n\nconst isLambdaError = (\n  r: LambdaResponse | LambdaError | LambdaInitError,\n): r is LambdaError => \"requestId\" in r && \"errorType\" in r\n\nconst isLambdaInitError = (\n  r: LambdaResponse | LambdaError | LambdaInitError,\n): r is LambdaInitError => !(\"requestId\" in r) && \"errorType\" in r\n\n/**\n * Reset the idle timer for a container.\n * After the timeout expires with no new responses, the container is stopped.\n * This prevents the confusing 503 error from the Lambda RIC when the poll times out.\n */\nconst resetIdleTimer = (\n  container: FunctionContainer,\n  containersRef: Ref.Ref<Map<string, FunctionContainer>>,\n  idleTimeoutMs: number,\n): Effect.Effect<void, never, CommandExecutor.CommandExecutor> =>\n  Effect.gen(function* () {\n    // Cancel existing timer if any\n    if (container.idleTimerFiber) {\n      yield* Fiber.interrupt(container.idleTimerFiber).pipe(\n        Effect.catchAll(() => Effect.void),\n      )\n      container.idleTimerFiber = null\n    }\n\n    // Start new timer - use never for error type since we catch all errors\n    const timerFiber: Fiber.RuntimeFiber<void, never> = yield* Effect.gen(\n      function* () {\n        yield* Effect.sleep(Duration.millis(idleTimeoutMs))\n\n        // Timer expired - stop container proactively\n        yield* Effect.logInfo(\n          `[Local] Stopping idle container ${container.fn.functionName} (will restart on next invocation)`,\n        )\n\n        // Stop the container using Docker with fast timeout (1s)\n        // The container may be blocked on long-polling, so we need to force kill\n        const docker = yield* Docker\n        yield* docker.stop(container.containerName, 1).pipe(\n          Effect.scoped,\n          Effect.catchAll(() => Effect.void),\n        )\n\n        // Remove from map so next invocation creates fresh container\n        const currentContainers = yield* Ref.get(containersRef)\n        currentContainers.delete(container.fn.functionName)\n        yield* Ref.set(containersRef, currentContainers)\n      },\n    ).pipe(\n      Effect.provide(DockerLive),\n      Effect.catchAll(() => Effect.void),\n      Effect.forkDaemon,\n    )\n\n    container.idleTimerFiber = timerFiber\n  })\n\n/**\n * Process responses from a container and dispatch to waiting callers.\n * After each response, resets the idle timer to proactively stop the container\n * before the poll timeout causes confusing Lambda RIC errors.\n */\nconst processContainerResponses = (\n  container: FunctionContainer,\n  containersRef: Ref.Ref<Map<string, FunctionContainer>>,\n  idleTimeoutMs: number,\n  client: ReturnType<typeof makeAppSyncClient>,\n  invocationContexts: Map<string, InvocationContext>,\n): Effect.Effect<void, Error, CommandExecutor.CommandExecutor> =>\n  Effect.gen(function* () {\n    const responseChannel = buildChannelName.response(container.fn.functionName)\n\n    // Continuously process responses from the container\n    while (true) {\n      const result = yield* waitForResponse(container.runtimeState)\n\n      let response: ResponseMessage\n      if (isLambdaResponse(result)) {\n        response = {\n          type: \"response\",\n          requestId: result.requestId,\n          result: result.body,\n        }\n      } else if (isLambdaError(result)) {\n        response = {\n          type: \"response\",\n          requestId: result.requestId,\n          error: {\n            errorType: result.errorType,\n            errorMessage: result.errorMessage,\n            stackTrace: result.stackTrace,\n          },\n        }\n      } else if (isLambdaInitError(result)) {\n        yield* Effect.logError(\n          `[Local] Init error: ${result.errorType}: ${result.errorMessage}`,\n        )\n        continue\n      } else {\n        continue\n      }\n\n      // Send response back via AppSync\n      yield* client.publishResponse(responseChannel, response)\n      yield* Effect.logDebug(`[Local] Sent response for ${response.requestId}`)\n\n      // Print end marker with timing\n      const ctx = invocationContexts.get(response.requestId)\n      if (ctx) {\n        const durationMs = Date.now() - ctx.start\n        if (response.error) {\n          console.log(\n            `[${ctx.num}] \\u2514\\u2500\\u2500 \\u2717 ${response.error.errorType}: ${response.error.errorMessage} (${durationMs}ms) \\u2500\\u2500`,\n          )\n        } else {\n          console.log(\n            `[${ctx.num}] \\u2514\\u2500\\u2500 \\u2713 Done (${durationMs}ms) \\u2500\\u2500`,\n          )\n        }\n        invocationContexts.delete(response.requestId)\n      }\n\n      // Reset idle timer - container will be stopped if no new invocations arrive\n      yield* resetIdleTimer(container, containersRef, idleTimeoutMs)\n    }\n  })\n\n/**\n * Start a Node.js worker process for a function.\n * Spawns Bun to run the runtime wrapper with the handler path.\n * The worker continuously polls our Runtime API for invocations.\n */\nconst startNodejsWorker = (\n  fn: DiscoveredFunction,\n  port: number,\n  projectRoot: string,\n  env: Record<string, string>,\n  invocationContexts: Map<string, InvocationContext>,\n): Effect.Effect<ChildProcess, Error> =>\n  Effect.gen(function* () {\n    if (!fn.localHandler) {\n      return yield* Effect.fail(\n        new Error(`Function ${fn.functionName} has no local handler path`),\n      )\n    }\n\n    // Resolve the runtime wrapper path relative to this module\n    const __filename = fileURLToPath(import.meta.url)\n    const __dirname = path.dirname(__filename)\n    const runtimeWrapperPath = path.resolve(\n      __dirname,\n      \"..\",\n      \"runtime-wrapper\",\n      \"nodejs-runtime.js\",\n    )\n\n    // Get absolute path to bun for pure env isolation (no PATH dependency)\n    const bunPath = Bun.which(\"bun\")\n    if (!bunPath) {\n      return yield* Effect.fail(\n        new Error(\"Could not find 'bun' executable in PATH\"),\n      )\n    }\n\n    // Build environment for the worker process\n    // Pure isolation: only env from bridge + local overrides, no local PATH/HOME\n    const workerEnv: NodeJS.ProcessEnv = {\n      // Start with env vars from the bridge Lambda (AWS credentials, user-defined vars)\n      ...env,\n      // Local overrides (these are set by the daemon, not from bridge)\n      AWS_LAMBDA_RUNTIME_API: `localhost:${port}`,\n      _HANDLER: fn.localHandler,\n      LAMBDA_TASK_ROOT: projectRoot,\n      // Memory limit for context object\n      AWS_LAMBDA_FUNCTION_MEMORY_SIZE: String(fn.memoryMB),\n    }\n\n    yield* Effect.logDebug(\n      `[Local] Starting Node.js worker for ${fn.functionName} on port ${port}`,\n    )\n    yield* Effect.logDebug(`[Local] Handler: ${fn.localHandler}`)\n\n    // Spawn Bun with --watch to automatically restart when handler files change\n    // This enables hot-reload without needing to restart the daemon\n    // Use absolute bun path for pure env isolation (no PATH dependency)\n    const workerProcess = spawn(bunPath, [\"--watch\", runtimeWrapperPath], {\n      cwd: projectRoot,\n      env: workerEnv,\n      stdio: [\"ignore\", \"pipe\", \"pipe\"],\n    })\n\n    // Pattern to parse Lambda log format: TIMESTAMP\\tREQUEST_ID\\tLEVEL\\tMESSAGE\n    // Lambda uses tabs between fields. Captures: [1] = request ID, [2] = level + message\n    const lambdaLogPattern =\n      /^(\\d{4}-\\d{2}-\\d{2}T[\\d:.]+Z)[\\t\\s]+([0-9a-f-]{36})[\\t\\s]+(.*)$/i\n\n    // Helper to format log line with invocation prefix\n    const formatLine = (\n      rawLine: string,\n    ): { prefix: string; content: string } => {\n      // Strip carriage returns that can cause terminal corruption\n      const line = rawLine.replace(/\\r/g, \"\")\n      const match = lambdaLogPattern.exec(line)\n      if (match) {\n        const requestId = match[2]\n        const ctx = invocationContexts.get(requestId)\n        if (ctx) {\n          // Strip timestamp and request ID, keep just LEVEL MESSAGE\n          return { prefix: `[${ctx.num}]`, content: match[3] }\n        }\n      }\n      return { prefix: \"[Worker]\", content: line }\n    }\n\n    // Forward stdout/stderr with invocation number prefix\n    workerProcess.stdout?.on(\"data\", (data: Buffer) => {\n      const lines = data.toString().trim().split(\"\\n\")\n      for (const rawLine of lines) {\n        const { prefix, content } = formatLine(rawLine)\n        console.log(`${prefix} ${content}`)\n      }\n    })\n\n    workerProcess.stderr?.on(\"data\", (data: Buffer) => {\n      const lines = data.toString().trim().split(\"\\n\")\n      for (const rawLine of lines) {\n        const { prefix, content } = formatLine(rawLine)\n        console.error(`${prefix} ${content}`)\n      }\n    })\n\n    workerProcess.on(\"error\", (err) => {\n      Effect.runSync(\n        Effect.logError(`Worker error: ${err.message}`).pipe(\n          Effect.annotateLogs(\"function\", fn.functionName),\n        ),\n      )\n    })\n\n    workerProcess.on(\"close\", (code) => {\n      Effect.runSync(\n        Effect.logInfo(`Worker exited with code ${code}`).pipe(\n          Effect.annotateLogs(\"function\", fn.functionName),\n        ),\n      )\n    })\n\n    return workerProcess\n  })\n\n/**\n * Process responses from a Node.js worker and dispatch to waiting callers.\n */\nconst processWorkerResponses = (\n  worker: NodejsWorker,\n  client: ReturnType<typeof makeAppSyncClient>,\n  invocationContexts: Map<string, InvocationContext>,\n) =>\n  Effect.gen(function* () {\n    const responseChannel = buildChannelName.response(worker.fn.functionName)\n\n    // Continuously process responses from the worker\n    while (true) {\n      const result = yield* waitForResponse(worker.runtimeState)\n\n      let response: ResponseMessage\n      if (isLambdaResponse(result)) {\n        response = {\n          type: \"response\",\n          requestId: result.requestId,\n          result: result.body,\n        }\n      } else if (isLambdaError(result)) {\n        response = {\n          type: \"response\",\n          requestId: result.requestId,\n          error: {\n            errorType: result.errorType,\n            errorMessage: result.errorMessage,\n            stackTrace: result.stackTrace,\n          },\n        }\n      } else if (isLambdaInitError(result)) {\n        yield* Effect.logError(\n          `[Local] Worker init error: ${result.errorType}: ${result.errorMessage}`,\n        )\n        continue\n      } else {\n        continue\n      }\n\n      // Send response back via AppSync\n      yield* client.publishResponse(responseChannel, response)\n      yield* Effect.logDebug(`[Local] Sent response for ${response.requestId}`)\n\n      // Print end marker with timing\n      const ctx = invocationContexts.get(response.requestId)\n      if (ctx) {\n        const durationMs = Date.now() - ctx.start\n        if (response.error) {\n          console.log(\n            `[${ctx.num}] \\u2514\\u2500\\u2500 \\u2717 ${response.error.errorType}: ${response.error.errorMessage} (${durationMs}ms) \\u2500\\u2500`,\n          )\n        } else {\n          console.log(\n            `[${ctx.num}] \\u2514\\u2500\\u2500 \\u2713 Done (${durationMs}ms) \\u2500\\u2500`,\n          )\n        }\n        invocationContexts.delete(response.requestId)\n      }\n    }\n  })\n\n/**\n * Environment variables to completely filter out from invocation env.\n * These are not relevant for local execution.\n */\nconst ENV_VARS_TO_FILTER = new Set([\"AWS_LAMBDA_LOG_STREAM_NAME\"])\n\n/**\n * Environment variables to ignore when calculating if env has changed.\n * These change frequently but don't require a container restart.\n *\n * TODO: AWS credentials (ACCESS_KEY_ID, SECRET_ACCESS_KEY, SESSION_TOKEN)\n * do expire and will need refreshing. For now we ignore them to avoid\n * unnecessary restarts, but we should implement credential refresh logic\n * that updates the container's credentials without a full restart.\n */\nconst ENV_VARS_TO_IGNORE_IN_DIFF = new Set([\n  \"AWS_ACCESS_KEY_ID\",\n  \"AWS_SECRET_ACCESS_KEY\",\n  \"AWS_SESSION_TOKEN\",\n])\n\n/**\n * Filter out irrelevant env vars from invocation environment.\n */\nconst sanitizeInvocationEnv = (\n  env: Record<string, string>,\n): Record<string, string> => {\n  const result: Record<string, string> = {}\n  for (const [key, value] of Object.entries(env)) {\n    if (!ENV_VARS_TO_FILTER.has(key)) {\n      result[key] = value\n    }\n  }\n  return result\n}\n\n/**\n * Compute which environment variables have changed between two env objects.\n * Returns a human-readable summary of the changes.\n * Ignores env vars in ENV_VARS_TO_IGNORE_IN_DIFF.\n */\nconst getEnvDiff = (\n  oldEnv: Record<string, string>,\n  newEnv: Record<string, string>,\n): string => {\n  const changes: string[] = []\n\n  // Check for added or modified keys\n  for (const key of Object.keys(newEnv)) {\n    if (ENV_VARS_TO_IGNORE_IN_DIFF.has(key)) continue\n    if (!(key in oldEnv)) {\n      changes.push(`+${key}`)\n    } else if (oldEnv[key] !== newEnv[key]) {\n      changes.push(`~${key}`)\n    }\n  }\n\n  // Check for removed keys\n  for (const key of Object.keys(oldEnv)) {\n    if (ENV_VARS_TO_IGNORE_IN_DIFF.has(key)) continue\n    if (!(key in newEnv)) {\n      changes.push(`-${key}`)\n    }\n  }\n\n  return changes.join(\", \")\n}\n\n/**\n * Ensure a Node.js worker is started for a function.\n * If the worker already exists, return it.\n * Otherwise, create the Runtime API server, add to workers map, and start the worker.\n */\nconst ensureWorkerStarted = (\n  fn: DiscoveredFunction,\n  invocationEnv: Record<string, string>,\n  workersRef: Ref.Ref<Map<string, NodejsWorker>>,\n  serverScope: Scope.Scope,\n  projectRoot: string,\n  appSyncClient: ReturnType<typeof makeAppSyncClient>,\n  invocationContexts: Map<string, InvocationContext>,\n): Effect.Effect<NodejsWorker, Error> =>\n  Effect.gen(function* () {\n    // Check if worker already exists\n    const currentWorkers = yield* Ref.get(workersRef)\n    const existing = currentWorkers.get(fn.functionName)\n    if (existing) {\n      // Check if env vars have changed (e.g., after CDK redeploy)\n      const envDiff = getEnvDiff(existing.env, invocationEnv)\n      if (envDiff) {\n        yield* Effect.logInfo(\n          `[Local] Environment changed for ${fn.functionName}, restarting worker... (${envDiff})`,\n        )\n        // Kill the old worker\n        yield* Effect.try(() => existing.workerProcess.kill(\"SIGTERM\")).pipe(\n          Effect.catchAll(() => Effect.void),\n        )\n        // Remove from map so we create a new one below\n        currentWorkers.delete(fn.functionName)\n        yield* Ref.set(workersRef, currentWorkers)\n      } else {\n        return existing\n      }\n    }\n\n    // Worker doesn't exist - start it lazily\n    yield* Effect.logDebug(\n      `[Local] Starting Node.js worker for first invocation of ${fn.functionName}...`,\n    )\n\n    // Create Runtime API server on ephemeral port\n    const { port, state: runtimeState } = yield* startRuntimeApiServer({\n      functionMetadata: {\n        functionName: fn.functionName,\n        functionVersion: \"$LATEST\",\n        handler: fn.localHandler,\n      },\n    }).pipe(Effect.provideService(Scope.Scope, serverScope))\n\n    // Create worker object (without process initially - will be set after start)\n    // We add to map BEFORE starting worker to handle concurrent invocations\n    const worker: NodejsWorker = {\n      fn,\n      runtimeState,\n      port,\n      workerProcess: undefined as unknown as ChildProcess, // Will be set shortly\n      env: invocationEnv,\n    }\n\n    // Add to map immediately to prevent race conditions\n    currentWorkers.set(fn.functionName, worker)\n    yield* Ref.set(workersRef, currentWorkers)\n\n    // Start the worker process - remove from map on failure\n    const workerProcess = yield* startNodejsWorker(\n      fn,\n      port,\n      projectRoot,\n      invocationEnv,\n      invocationContexts,\n    ).pipe(\n      Effect.catchAll((error) =>\n        Effect.gen(function* () {\n          // Remove broken worker from map on failure\n          yield* Effect.logError(\n            `[Local] Failed to start worker for ${fn.functionName}: ${error}`,\n          )\n          const current = yield* Ref.get(workersRef)\n          current.delete(fn.functionName)\n          yield* Ref.set(workersRef, current)\n          return yield* Effect.fail(error)\n        }),\n      ),\n    )\n\n    // Update worker with the process\n    worker.workerProcess = workerProcess\n\n    // Start processing responses in the background\n    Effect.runFork(\n      processWorkerResponses(worker, appSyncClient, invocationContexts),\n    )\n\n    return worker\n  })\n\n/**\n * Ensure a container is started for a function.\n * If the container already exists, return it.\n * If the env vars have changed, restart the container.\n * Otherwise, create the Runtime API server, add to containers map, and start the container.\n */\nconst ensureContainerStarted = (\n  fn: DiscoveredFunction,\n  invocationEnv: Record<string, string>,\n  containersRef: Ref.Ref<Map<string, FunctionContainer>>,\n  serverScope: Scope.Scope,\n  projectRoot: string,\n  idleTimeoutMs: number,\n  pollTimeoutMs: number,\n  appSyncClient: ReturnType<typeof makeAppSyncClient>,\n  invocationContexts: Map<string, InvocationContext>,\n): Effect.Effect<FunctionContainer, Error, CommandExecutor.CommandExecutor> =>\n  Effect.gen(function* () {\n    // Check if container already exists\n    const currentContainers = yield* Ref.get(containersRef)\n    const existing = currentContainers.get(fn.functionName)\n    if (existing) {\n      // Check if env vars have changed (e.g., after CDK redeploy)\n      const envDiff = getEnvDiff(existing.env, invocationEnv)\n      if (envDiff) {\n        // IMPORTANT: Update env immediately (before any yields) to prevent\n        // other concurrent invocations from also detecting the change and\n        // triggering duplicate restarts\n        existing.env = invocationEnv\n\n        // If already restarting for env change, just return the existing container\n        // The invocation will be queued and picked up by the new container\n        if (existing.isRebuilding) {\n          yield* Effect.logDebug(\n            `[Local] Environment change restart already in progress for ${fn.functionName}, queueing invocation`,\n          )\n          return existing\n        }\n\n        yield* Effect.logInfo(\n          `[Local] Environment changed for ${fn.functionName}, restarting container... (${envDiff})`,\n        )\n        existing.isRebuilding = true\n\n        // Stop the Docker container forcefully (timeout=1s)\n        // This sends SIGTERM and then SIGKILL after 1 second\n        // We must do this BEFORE interrupting the fiber, because the fiber is\n        // blocked waiting for the docker process to exit\n        yield* Effect.gen(function* () {\n          const docker = yield* Docker\n          yield* docker.stop(existing.containerName, 1).pipe(Effect.scoped)\n        }).pipe(\n          Effect.provide(DockerLive),\n          Effect.catchAll((error) =>\n            Effect.logDebug(\n              `[Local] Error stopping container (may already be stopped): ${error}`,\n            ),\n          ),\n        )\n\n        // Now interrupt the fiber (it should complete quickly since container stopped)\n        yield* Fiber.interrupt(existing.containerFiber).pipe(\n          Effect.catchAll(() => Effect.void),\n        )\n\n        // Restart the container with new environment, reusing existing RuntimeAPI\n        const newFiber = yield* startFunctionContainer(\n          fn,\n          existing.port,\n          projectRoot,\n          invocationEnv,\n          invocationContexts,\n        ).pipe(\n          Effect.catchAll((error) =>\n            Effect.gen(function* () {\n              yield* Effect.logError(\n                `[Local] Failed to restart container for ${fn.functionName}: ${error}`,\n              )\n              existing.isRebuilding = false\n              return yield* Effect.fail(error)\n            }),\n          ),\n        )\n\n        // Update container with new fiber\n        existing.containerFiber = newFiber\n        existing.isRebuilding = false\n\n        return existing\n      } else {\n        return existing\n      }\n    }\n\n    // Container doesn't exist - start it lazily\n    yield* Effect.logInfo(\n      `[Local] Starting container for first invocation of ${fn.functionName}...`,\n    )\n\n    // Create Runtime API server on ephemeral port\n    // Use poll timeout that's shorter than idle timeout so container exits naturally\n    const { port, state: runtimeState } = yield* startRuntimeApiServer({\n      pollTimeoutMs,\n      functionMetadata: {\n        functionName: fn.functionName,\n        functionVersion: \"$LATEST\",\n        handler: \"index.handler\",\n      },\n    }).pipe(Effect.provideService(Scope.Scope, serverScope))\n\n    // Generate container name and image name\n    const containerName = `lambda-${fn.functionName.replace(/[^a-zA-Z0-9]/g, \"-\")}`\n    const imageName = `live-lambda-${fn.functionName.toLowerCase().replace(/[^a-z0-9-]/g, \"-\")}`\n\n    // Create container object (without fiber initially - will be set after start)\n    // We add to map BEFORE starting container to handle concurrent invocations\n    const container: FunctionContainer = {\n      fn,\n      runtimeState,\n      port,\n      containerFiber: undefined as unknown as Fiber.RuntimeFiber<void, Error>, // Will be set shortly\n      containerName,\n      imageName,\n      isRebuilding: false,\n      pendingResponses: new Map(),\n      idleTimerFiber: null,\n      env: invocationEnv,\n    }\n\n    // Add to map immediately to prevent race conditions\n    currentContainers.set(fn.functionName, container)\n    yield* Ref.set(containersRef, currentContainers)\n\n    // Build and start the container - remove from map on failure\n    const containerFiber = yield* startFunctionContainer(\n      fn,\n      port,\n      projectRoot,\n      invocationEnv,\n      invocationContexts,\n    ).pipe(\n      Effect.catchAll((error) =>\n        Effect.gen(function* () {\n          // Remove broken container from map on failure\n          yield* Effect.logError(\n            `[Local] Failed to start container for ${fn.functionName}: ${error}`,\n          )\n          const current = yield* Ref.get(containersRef)\n          current.delete(fn.functionName)\n          yield* Ref.set(containersRef, current)\n          return yield* Effect.fail(error)\n        }),\n      ),\n    )\n\n    // Update container with the fiber\n    container.containerFiber = containerFiber\n\n    // Start processing responses in the background using forkDaemon\n    yield* processContainerResponses(\n      container,\n      containersRef,\n      idleTimeoutMs,\n      appSyncClient,\n      invocationContexts,\n    ).pipe(Effect.forkDaemon)\n\n    return container\n  })\n\n/**\n * Rebuild a Docker container after file changes.\n * Invocations arriving during rebuild will be queued and picked up by the new container.\n */\nconst rebuildDockerContainer = (\n  functionId: string,\n  containersRef: Ref.Ref<Map<string, FunctionContainer>>,\n  projectRoot: string,\n): Effect.Effect<void, Error, CommandExecutor.CommandExecutor> =>\n  Effect.gen(function* () {\n    const containers = yield* Ref.get(containersRef)\n    const container = containers.get(functionId)\n\n    if (!container) {\n      yield* Effect.logInfo(\n        `[Local] Cannot rebuild ${functionId} - container not found`,\n      )\n      return\n    }\n\n    // Mark as rebuilding - invocations will still queue but we log it\n    container.isRebuilding = true\n\n    yield* Effect.logDebug(`[Local] Rebuilding container for ${functionId}...`)\n\n    const docker = yield* Docker\n\n    // Stop the existing container using Docker service\n    const containerId = container.containerName\n    yield* Effect.logInfo(\n      `[Local] Stopping container with name prefix: ${containerId}`,\n    )\n\n    const stopCount = yield* docker.stop(containerId).pipe(\n      Effect.scoped,\n      Effect.catchAll((error) =>\n        Effect.gen(function* () {\n          yield* Effect.logInfo(`Note: Container stop had issue: ${error}`)\n          return 0\n        }),\n      ),\n    )\n    yield* Effect.logDebug(`[Local] Stopped ${stopCount} container(s)`)\n\n    // Resolve the context path\n    const fn = container.fn\n    const contextPath = fn.dockerContextPath?.startsWith(\"/\")\n      ? fn.dockerContextPath\n      : `${projectRoot}/${fn.dockerContextPath}`\n\n    // Determine platform from architecture\n    const platform = fn.architecture === \"arm64\" ? \"linux/arm64\" : \"linux/amd64\"\n\n    // Rebuild the Docker image\n    yield* docker\n      .build({\n        contextPath,\n        imageName: container.imageName,\n        platform,\n      })\n      .pipe(Effect.scoped)\n\n    // Inspect the image to get original entrypoint/cmd for extension wrapper\n    const imageConfig = yield* docker\n      .inspect(container.imageName)\n      .pipe(Effect.scoped)\n    const extensionWrapper = buildExtensionWrapperCommand(\n      imageConfig.entrypoint,\n      imageConfig.cmd,\n    )\n\n    // Restart the container by triggering container startup\n    // The existing fiber will have exited when we stopped the container\n    // We need to start a new one\n    const dockerRuntime = yield* docker.getRuntimeInfo()\n    const runtimeApiHost = dockerRuntime.isDockerDesktop\n      ? \"host.docker.internal\"\n      : \"runtime.api\"\n\n    yield* Effect.logInfo(\n      `[Local] New container will connect to Runtime API at ${runtimeApiHost}:${container.port}`,\n    )\n\n    const containerConfig = makeLambdaContainerConfig({\n      imageUri: container.imageName,\n      runtimeApiHost,\n      runtimeApiPort: container.port,\n      functionName: fn.functionName,\n      functionVersion: \"$LATEST\",\n      memoryMB: fn.memoryMB,\n      timeoutSeconds: 3600,\n      platform,\n    })\n\n    // Apply extension wrapper to start extensions before the app\n    containerConfig.entrypoint = extensionWrapper.entrypoint\n    containerConfig.command = extensionWrapper.command\n\n    // Start the new container\n    yield* Effect.logDebug(\n      `[Local] Starting new container for ${functionId}...`,\n    )\n\n    // Use Effect.forkDaemon to run the container independently\n    const newFiber = yield* docker.run(containerConfig).pipe(\n      Effect.scoped,\n      Effect.tap((result) =>\n        Effect.gen(function* () {\n          // Only suppress errors for expected exit codes from docker stop:\n          // 0: clean, 143: SIGTERM, 137: SIGKILL\n          const code = result.exitCode\n          if (code !== 0 && code !== 143 && code !== 137) {\n            yield* Effect.logError(\n              `Container for ${functionId} exited with code ${code}`,\n            )\n            yield* Effect.logError(`stderr: ${result.stderr}`)\n          }\n        }),\n      ),\n      Effect.map(() => undefined as void),\n      Effect.catchAll((error) =>\n        Effect.logError(`Container error for ${functionId}: ${error}`),\n      ),\n      Effect.forkDaemon,\n    )\n\n    // Update the container state with the new fiber\n    container.containerFiber = newFiber\n\n    // Wait a moment for the container to start and begin polling\n    yield* Effect.sleep(\"2 seconds\")\n\n    container.isRebuilding = false\n    yield* Effect.logDebug(`[Local] Container rebuilt for ${functionId}`)\n  }).pipe(Effect.provide(DockerLive))\n\n/**\n * Handle incoming invocations for a Docker container function by queueing them.\n * Starts the container lazily if not already running.\n * Invocations are queued even if a rebuild is in progress - the new container will pick them up.\n */\nconst handleDockerInvocation = (\n  fn: DiscoveredFunction,\n  invocation: InvocationMessage,\n  containersRef: Ref.Ref<Map<string, FunctionContainer>>,\n  serverScope: Scope.Scope,\n  projectRoot: string,\n  idleTimeoutMs: number,\n  pollTimeoutMs: number,\n  appSyncClient: ReturnType<typeof makeAppSyncClient>,\n  invocationCounter: Ref.Ref<number>,\n  invocationContexts: Map<string, InvocationContext>,\n): Effect.Effect<void, Error, CommandExecutor.CommandExecutor> =>\n  Effect.gen(function* () {\n    // Ensure container is started (lazy startup on first invocation)\n    // Use env from invocation (captured from bridge Lambda on first invoke)\n    const container = yield* ensureContainerStarted(\n      fn,\n      sanitizeInvocationEnv(invocation.env ?? {}),\n      containersRef,\n      serverScope,\n      projectRoot,\n      idleTimeoutMs,\n      pollTimeoutMs,\n      appSyncClient,\n      invocationContexts,\n    )\n\n    // Assign invocation number and track context for logging\n    const invocationNum = yield* Ref.updateAndGet(\n      invocationCounter,\n      (n) => n + 1,\n    )\n    const startTime = Date.now()\n    invocationContexts.set(invocation.requestId, {\n      num: invocationNum,\n      start: startTime,\n      fn: fn.functionName,\n      isDocker: true,\n    })\n\n    // Print start marker\n    console.log(\n      `\\n[${invocationNum}] \\u250c\\u2500\\u2500 [Docker] ${fn.functionName} \\u2500\\u2500`,\n    )\n\n    // Log if queuing during a rebuild\n    if (container.isRebuilding) {\n      yield* Effect.logDebug(\n        `[Local] Queueing invocation ${invocation.requestId} for ${fn.functionName} (rebuild in progress, will be picked up by new container)`,\n      )\n    } else {\n      yield* Effect.logDebug(\n        `[Local] Queueing invocation ${invocation.requestId} for ${fn.functionName}`,\n      )\n    }\n\n    const lambdaInvocation: LambdaInvocation = {\n      requestId: invocation.requestId,\n      event: invocation.event,\n      invokedFunctionArn: invocation.context.invokedFunctionArn,\n      deadlineMs: Date.now() + invocation.context.getRemainingTimeInMillis,\n      functionName: fn.functionName,\n      functionVersion: invocation.context.functionVersion,\n      memoryLimitMB: fn.memoryMB,\n      logGroupName: invocation.context.logGroupName,\n      logStreamName: invocation.context.logStreamName,\n    }\n\n    yield* Effect.logDebug(\n      `[Local] Queueing to Runtime API on port ${container.port}`,\n    )\n    // Notify extensions about the invocation (for Lambda Web Adapter support)\n    yield* notifyExtensionsInvoke(container.runtimeState, lambdaInvocation)\n    yield* queueInvocation(container.runtimeState, lambdaInvocation)\n    yield* Effect.logDebug(`[Local] Invocation queued successfully`)\n  })\n\n/**\n * Handle incoming invocations for a Node.js function by queueing them.\n * Starts the worker lazily if not already running.\n */\nconst handleNodejsInvocation = (\n  fn: DiscoveredFunction,\n  invocation: InvocationMessage,\n  workersRef: Ref.Ref<Map<string, NodejsWorker>>,\n  serverScope: Scope.Scope,\n  projectRoot: string,\n  appSyncClient: ReturnType<typeof makeAppSyncClient>,\n  invocationCounter: Ref.Ref<number>,\n  invocationContexts: Map<string, InvocationContext>,\n): Effect.Effect<void, Error> =>\n  Effect.gen(function* () {\n    // Get env vars from invocation (forwarded from bridge Lambda)\n    const invocationEnv = sanitizeInvocationEnv(invocation.env ?? {})\n\n    // Ensure worker is started (lazy startup on first invocation)\n    const worker = yield* ensureWorkerStarted(\n      fn,\n      invocationEnv,\n      workersRef,\n      serverScope,\n      projectRoot,\n      appSyncClient,\n      invocationContexts,\n    )\n\n    // Assign invocation number and track context for logging\n    const invocationNum = yield* Ref.updateAndGet(\n      invocationCounter,\n      (n) => n + 1,\n    )\n    const startTime = Date.now()\n    invocationContexts.set(invocation.requestId, {\n      num: invocationNum,\n      start: startTime,\n      fn: fn.functionName,\n      isDocker: false,\n    })\n\n    // Print start marker\n    console.log(\n      `\\n[${invocationNum}] \\u250c\\u2500\\u2500 ${fn.functionName} \\u2500\\u2500`,\n    )\n\n    yield* Effect.logDebug(\n      `[Local] Queueing invocation ${invocation.requestId} for ${fn.functionName}`,\n    )\n\n    const lambdaInvocation: LambdaInvocation = {\n      requestId: invocation.requestId,\n      event: invocation.event,\n      invokedFunctionArn: invocation.context.invokedFunctionArn,\n      deadlineMs: Date.now() + invocation.context.getRemainingTimeInMillis,\n      functionName: fn.functionName,\n      functionVersion: invocation.context.functionVersion,\n      memoryLimitMB: fn.memoryMB,\n      logGroupName: invocation.context.logGroupName,\n      logStreamName: invocation.context.logStreamName,\n    }\n\n    yield* queueInvocation(worker.runtimeState, lambdaInvocation)\n  })\n\n/**\n * CDK watch event types.\n */\ntype CdkWatchEvent =\n  | { readonly _tag: \"StackDiscovered\"; readonly stackName: string }\n  | { readonly _tag: \"DeployComplete\" }\n\n/**\n * Start CDK watch process with CDK_LIVE=true using Effect's Command.\n * Returns the process and a queue of events.\n */\nconst startCdkWatch = (\n  options: {\n    profile?: string\n    region?: string\n    stacks?: string[]\n    all?: boolean\n  },\n  scope: Scope.Scope,\n): Effect.Effect<\n  { process: EffectProcess; events: Queue.Queue<CdkWatchEvent> },\n  Error,\n  CommandExecutor.CommandExecutor\n> =>\n  Effect.gen(function* () {\n    const args = [\n      \"cdk\",\n      \"watch\",\n      \"--hotswap-fallback\",\n      \"--no-logs\",\n      \"--method=direct\",\n    ]\n\n    if (options.stacks && options.stacks.length > 0) {\n      args.push(...options.stacks)\n    } else if (options.all) {\n      args.push(\"--all\")\n    }\n\n    if (options.profile) {\n      args.push(\"--profile\", options.profile)\n    }\n\n    const env: Record<string, string> = {\n      ...process.env,\n      CDK_LIVE: \"true\",\n    } as Record<string, string>\n\n    if (options.region) {\n      env.AWS_REGION = options.region\n      env.CDK_DEFAULT_REGION = options.region\n    }\n\n    yield* Effect.logDebug(`Starting: npx ${args.join(\" \")}`)\n\n    const command = PlatformCommand.make(\"npx\", ...args).pipe(\n      PlatformCommand.env(env),\n      PlatformCommand.runInShell(true),\n      PlatformCommand.stdin(\"inherit\"),\n    )\n\n    // Extend the process resource lifetime to the provided scope\n    const proc = yield* PlatformCommand.start(command).pipe(Scope.extend(scope))\n\n    // Event queue for callers to subscribe to\n    const events = yield* Queue.unbounded<CdkWatchEvent>()\n\n    // State tracking for deploy status messages\n    let isDeploying = false\n    let isFirstDeploy = true\n    let outputBuffer = \"\"\n    const discoveredStacks = new Set<string>()\n\n    // Patterns to detect CDK watch behavior\n    const deployCompletePattern = /✅\\s+\\S+|Deployment time:/\n    const deployStartPattern = /Deploying|hotswap|Hotswapping|Bundling/i\n    const noChangesPattern = /no changes|identical|up to date/i\n    const errorPattern = /error|failed|Error|Failed|ERR!/i\n    const stackNamePattern = /^(\\S+):\\s*deploying|✅\\s+(\\S+)/\n\n    // Merge stdout and stderr, decode to text, split into lines\n    const outputStream = Stream.merge(proc.stdout, proc.stderr).pipe(\n      Stream.decodeText(),\n      Stream.splitLines,\n    )\n\n    // Fork stream processing in background\n    yield* outputStream.pipe(\n      Stream.runForEach((line) =>\n        Effect.gen(function* () {\n          outputBuffer += line + \"\\n\"\n\n          // Log all output at debug level\n          yield* Effect.logDebug(`[CDK] ${line}`)\n\n          // Try to extract stack name\n          const match = stackNamePattern.exec(line.trim())\n          if (match) {\n            const stackName = match[1] || match[2]\n            if (stackName && !discoveredStacks.has(stackName)) {\n              discoveredStacks.add(stackName)\n              yield* Queue.offer(events, {\n                _tag: \"StackDiscovered\",\n                stackName,\n              })\n            }\n          }\n\n          // Detect deploy start\n          if (!isDeploying && deployStartPattern.test(line)) {\n            isDeploying = true\n            if (!isFirstDeploy) {\n              yield* Effect.logInfo(\"[CDK] Deploying...\")\n            }\n          }\n\n          // Detect errors - output immediately\n          if (errorPattern.test(line)) {\n            yield* Effect.sync(() => process.stderr.write(line + \"\\n\"))\n          }\n\n          // Check for deploy completion (only trigger once per deploy cycle)\n          if (isDeploying && deployCompletePattern.test(line)) {\n            isDeploying = false\n            isFirstDeploy = false\n            outputBuffer = \"\"\n            yield* Effect.logInfo(\"[CDK] Deploy complete\")\n            // Small delay to ensure AWS has propagated the changes\n            yield* Effect.sleep(\"1 second\")\n            yield* Queue.offer(events, { _tag: \"DeployComplete\" })\n          }\n\n          // Check for no changes\n          if (noChangesPattern.test(line)) {\n            isDeploying = false\n            outputBuffer = \"\"\n          }\n        }),\n      ),\n      // Log errors and exit code when stream ends\n      Effect.tapError((error) =>\n        Effect.logError(`[CDK] CDK watch error: ${error}`),\n      ),\n      Effect.ensuring(\n        proc.exitCode.pipe(\n          Effect.flatMap((code) =>\n            code !== 0\n              ? Effect.logError(`[CDK] CDK watch exited with code ${code}`)\n              : Effect.logDebug(`[CDK] CDK watch exited with code ${code}`),\n          ),\n          Effect.catchAll(() => Effect.void),\n        ),\n      ),\n      Effect.fork,\n    )\n\n    return { process: proc, events }\n  })\n\n/**\n * Common CLI options.\n */\nconst profileOption = Options.text(\"profile\").pipe(\n  Options.optional,\n  Options.withDescription(\"AWS profile to use\"),\n)\n\nconst regionOption = Options.text(\"region\").pipe(\n  Options.optional,\n  Options.withDescription(\"AWS region\"),\n)\n\nconst qualifierOption = Options.text(\"qualifier\").pipe(\n  Options.withDefault(\"hnb659fds\"),\n  Options.withDescription(\"CDK bootstrap qualifier\"),\n)\n\nconst stacksOption = Options.text(\"stacks\").pipe(\n  Options.optional,\n  Options.withDescription(\n    \"Stack names to deploy (comma-separated, default: all)\",\n  ),\n)\n\nconst allStacksOption = Options.boolean(\"all\").pipe(\n  Options.withDefault(false),\n  Options.withDescription(\"Deploy all stacks (like cdk deploy --all)\"),\n)\n\nconst debugOption = Options.boolean(\"debug\").pipe(\n  Options.withDefault(false),\n  Options.withDescription(\"Enable debug logging\"),\n)\n\nconst idleTimeoutOption = Options.integer(\"idle-timeout\").pipe(\n  Options.withDefault(DEFAULT_IDLE_TIMEOUT_MS),\n  Options.withDescription(\n    \"Idle timeout in ms before stopping containers (default: 230000)\",\n  ),\n)\n\nconst pollTimeoutOption = Options.integer(\"poll-timeout\").pipe(\n  Options.optional,\n  Options.withDescription(\n    \"Poll timeout in ms for Runtime API (default: idle-timeout - 10s). Must be shorter than idle-timeout.\",\n  ),\n)\n\n/**\n * Local command definition.\n */\nexport const localCommand = Command.make(\n  \"local\",\n  {\n    profile: profileOption,\n    region: regionOption,\n    qualifier: qualifierOption,\n    stacks: stacksOption,\n    all: allStacksOption,\n    debug: debugOption,\n    idleTimeout: idleTimeoutOption,\n    pollTimeout: pollTimeoutOption,\n  },\n  ({\n    profile,\n    region,\n    qualifier,\n    stacks,\n    all,\n    debug,\n    idleTimeout,\n    pollTimeout,\n  }) => {\n    const logLevel = debug ? LogLevel.Debug : LogLevel.Info\n    return Effect.gen(function* () {\n      yield* Effect.logInfo(\"[Local] Starting local Lambda development...\")\n\n      const profileValue = profile._tag === \"Some\" ? profile.value : undefined\n      const regionValue = region._tag === \"Some\" ? region.value : undefined\n      const stacksFromOption =\n        stacks._tag === \"Some\"\n          ? stacks.value.split(\",\").map((s) => s.trim())\n          : undefined\n\n      // Poll timeout should be shorter than idle timeout so containers exit naturally\n      // before we try to stop them. Default: idle timeout - 10 seconds.\n      const effectivePollTimeout =\n        pollTimeout._tag === \"Some\"\n          ? pollTimeout.value\n          : Math.max(idleTimeout - 10_000, 5_000) // At least 5 seconds\n\n      if (profileValue) {\n        process.env.AWS_PROFILE = profileValue\n      }\n      if (regionValue) {\n        process.env.AWS_REGION = regionValue\n      }\n\n      // Bootstrap check must complete first\n      yield* ensureBootstrap({\n        qualifier,\n        profile: profileValue,\n        region: regionValue,\n      })\n\n      // Stack filter - populated from CDK watch output, used to filter Lambda discovery\n      // Using object so closure in startOrUpdateDaemon sees updates\n      const filterState = { stacks: stacksFromOption ?? ([] as string[]) }\n\n      // Create a long-lived scope for all Runtime API servers and CDK watch process\n      // Resources will run until this scope is closed (when the program ends)\n      const serverScope = yield* Scope.make()\n\n      // Start CDK watch immediately after bootstrap\n      // Stack names are discovered from CDK watch output (no need for separate cdk ls)\n      yield* Effect.logInfo(\"[CDK] Deploying...\")\n\n      const { process: cdkWatchProcess, events: cdkEvents } =\n        yield* startCdkWatch(\n          {\n            profile: profileValue,\n            region: regionValue,\n            stacks: stacksFromOption,\n            all,\n          },\n          serverScope,\n        )\n\n      // Track running Docker containers by function name\n      const containers = yield* Ref.make<Map<string, FunctionContainer>>(\n        new Map(),\n      )\n\n      // Track running Node.js workers by function name\n      const workers = yield* Ref.make<Map<string, NodejsWorker>>(new Map())\n\n      // Track registered functions (for lazy container/worker startup)\n      const registeredFunctions = yield* Ref.make<\n        Map<string, DiscoveredFunction>\n      >(new Map())\n\n      // Track Docker functions with active file watchers\n      const watchedDockerFunctions = new Set<string>()\n\n      // Invocation tracking for improved logging output\n      const invocationCounter = yield* Ref.make<number>(0)\n      // Use a plain Map for invocation contexts so it can be accessed from stream callbacks\n      const invocationContexts = new Map<string, InvocationContext>()\n\n      // Project root is the current working directory (where CDK app lives)\n      const projectRoot = process.cwd()\n\n      let appSyncClient: ReturnType<typeof makeAppSyncClient> | null = null\n\n      // Track if we've logged the \"Watching\" message (only log once)\n      const logState = { hasLoggedWatching: false, hasDiscoveredOnce: false }\n\n      // Function to start/update the daemon with discovered functions\n      const startOrUpdateDaemon = Effect.gen(function* () {\n        // Only show \"Discovering functions...\" on first run\n        if (!logState.hasDiscoveredOnce) {\n          yield* Effect.logInfo(\"[Local] Discovering functions...\")\n        }\n\n        // Get AppSync endpoints (may need to wait for first deploy)\n        if (!appSyncClient) {\n          yield* Effect.logDebug(\n            \"[Local] Reading AppSync endpoints from SSM...\",\n          )\n          const endpoints = yield* getAppSyncEndpoints(qualifier).pipe(\n            Effect.retry({ times: 10, schedule: Schedule.spaced(\"3 seconds\") }),\n          )\n          yield* Effect.logDebug(\n            `[Local] HTTP endpoint: ${endpoints.httpEndpoint}`,\n          )\n          appSyncClient = makeAppSyncClient(endpoints)\n        }\n\n        // Discover functions (filtered to stacks in this CDK project)\n        yield* Effect.logDebug(\"[Local] Discovering Lambda functions...\")\n        const functions = yield* discoverFunctions(filterState.stacks)\n\n        if (functions.length === 0) {\n          yield* Effect.logInfo(\n            \"[Local] No functions found with live-lambda tags yet. Have you patched your CDK project (bootstrap) and added the LiveLambdaAspect?\",\n          )\n          return\n        }\n\n        const currentRegistered = yield* Ref.get(registeredFunctions)\n\n        // Collect new functions to register\n        const newFunctions: Array<{\n          fn: DiscoveredFunction\n          isDocker: boolean\n        }> = []\n\n        for (const fn of functions) {\n          const isDocker = Boolean(fn.dockerContextPath)\n          const isNodejs = !isDocker && Boolean(fn.localHandler)\n\n          if (!isDocker && !isNodejs) {\n            yield* Effect.logDebug(\n              `[Local] Skipping ${fn.functionName} - no Docker context or local handler`,\n            )\n            continue\n          }\n\n          if (currentRegistered.has(fn.functionName)) {\n            yield* Effect.logDebug(\n              `[Local] Already watching ${fn.functionName}`,\n            )\n            continue\n          }\n\n          newFunctions.push({ fn, isDocker })\n        }\n\n        // Print summary of discovered functions\n        if (newFunctions.length > 0) {\n          const summary = newFunctions\n            .map(({ fn, isDocker }) => {\n              const mode = isDocker ? \"docker\" : \"node\"\n              const shortName = fn.functionName.includes(\"-\")\n                ? fn.functionName.split(\"-\").slice(-2, -1)[0] || fn.functionName\n                : fn.functionName\n              return `${shortName} (${mode})`\n            })\n            .join(\", \")\n          // Use different message for first discovery vs subsequent\n          const prefix = logState.hasDiscoveredOnce\n            ? \"[Local] Functions added:\"\n            : \"[Local] Functions:\"\n          yield* Effect.logInfo(`${prefix} ${summary}`)\n        }\n\n        // Register functions and set up subscriptions\n        for (const { fn, isDocker } of newFunctions) {\n          yield* Effect.logDebug(\n            `[Local] Registering ${fn.functionName} (${isDocker ? \"Docker\" : \"Node.js\"})`,\n          )\n\n          // Register the function\n          currentRegistered.set(fn.functionName, fn)\n\n          // Subscribe to invocations for this function\n          const invocationChannel = buildChannelName.invocation(fn.functionName)\n          yield* Effect.logDebug(\n            `[Local] Subscribing to invocations for ${fn.functionName}`,\n          )\n\n          // Subscribe using forkDaemon to run independently with context preserved\n          // Route to Docker or Node.js handler based on function type\n          if (isDocker) {\n            yield* appSyncClient!\n              .subscribeToInvocations(invocationChannel)\n              .pipe(\n                Stream.runForEach((invocation) =>\n                  handleDockerInvocation(\n                    fn,\n                    invocation,\n                    containers,\n                    serverScope,\n                    projectRoot,\n                    idleTimeout,\n                    effectivePollTimeout,\n                    appSyncClient!,\n                    invocationCounter,\n                    invocationContexts,\n                  ).pipe(\n                    Effect.catchAll((error) =>\n                      Effect.logError(\n                        `[Local] Docker invocation error: ${error}`,\n                      ),\n                    ),\n                  ),\n                ),\n                Effect.forkDaemon,\n              )\n          } else {\n            yield* appSyncClient!\n              .subscribeToInvocations(invocationChannel)\n              .pipe(\n                Stream.runForEach((invocation) =>\n                  handleNodejsInvocation(\n                    fn,\n                    invocation,\n                    workers,\n                    serverScope,\n                    projectRoot,\n                    appSyncClient!,\n                    invocationCounter,\n                    invocationContexts,\n                  ).pipe(\n                    Effect.catchAll((error) =>\n                      Effect.logError(\n                        `[Local] Node.js invocation error: ${error}`,\n                      ),\n                    ),\n                  ),\n                ),\n                Effect.forkDaemon,\n              )\n          }\n        }\n\n        yield* Ref.set(registeredFunctions, currentRegistered)\n\n        // Start file watchers for new Docker functions\n        const newDockerFunctions: WatchedDockerFunction[] = []\n        for (const fn of functions) {\n          if (\n            fn.dockerContextPath &&\n            !watchedDockerFunctions.has(fn.functionName)\n          ) {\n            // Resolve the context path\n            const contextPath = fn.dockerContextPath.startsWith(\"/\")\n              ? fn.dockerContextPath\n              : `${projectRoot}/${fn.dockerContextPath}`\n\n            newDockerFunctions.push({\n              functionId: fn.functionName,\n              dockerContextPath: contextPath,\n            })\n            watchedDockerFunctions.add(fn.functionName)\n          }\n        }\n\n        // Start watching new Docker contexts\n        if (newDockerFunctions.length > 0) {\n          yield* Effect.logDebug(\n            `[Local] Starting file watchers for ${newDockerFunctions.length} Docker function(s)...`,\n          )\n\n          // Fork a daemon fiber to handle file change events with context preserved\n          yield* watchDockerContexts(newDockerFunctions, 500).pipe(\n            Stream.runForEach((event) =>\n              Effect.gen(function* () {\n                yield* Effect.logDebug(\n                  `[Local] File changed in ${event.functionId}: ${event.filePath}`,\n                )\n                yield* rebuildDockerContainer(\n                  event.functionId,\n                  containers,\n                  projectRoot,\n                ).pipe(\n                  Effect.catchAll((error) =>\n                    Effect.logError(\n                      `[Local] Rebuild failed for ${event.functionId}: ${error}`,\n                    ),\n                  ),\n                )\n              }),\n            ),\n            Effect.forkDaemon,\n          )\n        }\n\n        if (!logState.hasLoggedWatching) {\n          logState.hasLoggedWatching = true\n          yield* Effect.logInfo(\"[Local] Ready for invocations\")\n        }\n\n        // Mark that we've completed first discovery\n        logState.hasDiscoveredOnce = true\n      })\n\n      // Handle CDK watch events (stack discovery and deploy completion)\n      yield* Queue.take(cdkEvents).pipe(\n        Effect.flatMap((event) =>\n          Effect.gen(function* () {\n            switch (event._tag) {\n              case \"StackDiscovered\":\n                // Add discovered stack to filter (if not using --stacks)\n                if (\n                  !stacksFromOption &&\n                  !filterState.stacks.includes(event.stackName)\n                ) {\n                  filterState.stacks.push(event.stackName)\n                  yield* Effect.logDebug(\n                    `[Local] Discovered stack: ${event.stackName}`,\n                  )\n                }\n                break\n              case \"DeployComplete\":\n                // Run daemon update on deploy completion\n                yield* startOrUpdateDaemon.pipe(\n                  Effect.catchAll((error) =>\n                    Effect.logError(`Failed to update daemon: ${error}`),\n                  ),\n                )\n                break\n            }\n          }),\n        ),\n        Effect.forever,\n        Effect.fork,\n      )\n\n      // Handle cleanup on exit\n      const cleanup = async () => {\n        await Effect.runPromise(\n          Effect.gen(function* () {\n            yield* Effect.logInfo(\"\\nShutting down...\")\n\n            // Stop CDK watch\n            yield* cdkWatchProcess\n              .kill(\"SIGTERM\")\n              .pipe(Effect.catchAll(() => Effect.void))\n\n            // Stop all Docker containers using the Docker service\n            const docker = yield* Docker\n            const currentContainers = yield* Ref.get(containers)\n            for (const [name, container] of currentContainers) {\n              yield* Effect.logInfo(`Stopping container: ${name}`)\n              yield* docker.stop(container.containerName).pipe(\n                Effect.scoped,\n                Effect.catchAll(() => Effect.void),\n              )\n            }\n\n            // Stop all Node.js workers\n            const currentWorkers = yield* Ref.get(workers)\n            for (const [name, worker] of currentWorkers) {\n              yield* Effect.logInfo(`Stopping worker: ${name}`)\n              yield* Effect.try(() =>\n                worker.workerProcess.kill(\"SIGTERM\"),\n              ).pipe(Effect.catchAll(() => Effect.void))\n            }\n\n            // Close the server scope to clean up Runtime API servers\n            yield* Scope.close(serverScope, Exit.void)\n          }).pipe(\n            Effect.provide(DockerLive),\n            Effect.provide(BunContext.layer),\n            Effect.provide(Logger.pretty),\n            Effect.provide(Logger.minimumLogLevel(logLevel)),\n          ),\n        )\n\n        process.exit(0)\n      }\n\n      process.on(\"SIGINT\", cleanup)\n      process.on(\"SIGTERM\", cleanup)\n\n      yield* Effect.logInfo(\"[Local] Press Ctrl+C to stop\")\n\n      // Keep the process running\n      yield* Effect.never\n    }).pipe(\n      Effect.provide(Logger.pretty),\n      Effect.provide(Logger.minimumLogLevel(logLevel)),\n    )\n  },\n).pipe(\n  Command.withDescription(\n    \"Start local Lambda development with CDK watch and Docker containers\",\n  ),\n)\n"]}