cdk-local-lambda 0.0.2

package/lib/cli/runtime-api/server.js

@@ -0,0 +1,396 @@
+/**
+ * Lambda Runtime API HTTP server using Effect HttpServer.
+ *
+ * This server emulates the AWS Lambda Runtime API that Docker containers
+ * use to receive invocations and send responses.
+ *
+ * Each Lambda function gets its own server on an ephemeral port. The server
+ * maintains a queue of pending invocations. When a container polls
+ * /invocation/next, it blocks until an invocation is available.
+ *
+ * @see https://docs.aws.amazon.com/lambda/latest/dg/runtimes-api.html
+ */
+import * as Headers from "@effect/platform/Headers";
+import * as HttpRouter from "@effect/platform/HttpRouter";
+import * as HttpServerRequest from "@effect/platform/HttpServerRequest";
+import * as HttpServerResponse from "@effect/platform/HttpServerResponse";
+import * as BunHttpServer from "@effect/platform-bun/BunHttpServer";
+import { Effect, HashMap, Option, Queue, Ref } from "effect";
+/**
+ * Create a new Runtime API state (queues only, no port).
+ *
+ * @param functionMetadata - Function metadata for extension registration responses
+ */
+export const makeRuntimeApiState = (functionMetadata) => Effect.gen(function* () {
+    const invocationQueue = yield* Queue.unbounded();
+    const responseQueue = yield* Queue.unbounded();
+    const extensions = yield* Ref.make(HashMap.empty());
+    return {
+        invocationQueue,
+        responseQueue,
+        extensions,
+        functionMetadata,
+    };
+});
+/**
+ * Default poll timeout - used when not overridden.
+ *
+ * ## Why containers can't stay warm indefinitely (like AWS Lambda does)
+ *
+ * AWS Lambda keeps containers warm for ~5-15 minutes between invocations.
+ * Their Runtime API implementation can hold HTTP connections open indefinitely
+ * because they control the entire infrastructure end-to-end.
+ *
+ * In local development, we're constrained by HTTP server limitations:
+ * - Bun's maximum `idleTimeout` is 255 seconds (~4.25 minutes)
+ * - This is a practical limit to prevent resource exhaustion in HTTP servers
+ * - When the timeout expires, Bun forcefully closes the connection
+ * - The Lambda RIC interprets this as a fatal "No Response from endpoint" error
+ *
+ * Our solution: timeout slightly before Bun does (240s vs 255s) and return
+ * HTTP 503, which causes the RIC to exit gracefully. The container will be
+ * automatically restarted on the next invocation (~2 seconds for warm images).
+ *
+ * This is an inherent limitation of local Lambda emulation - AWS's purpose-built
+ * infrastructure simply doesn't have the same timeout constraints.
+ */
+const DEFAULT_POLL_TIMEOUT_MS = 240_000; // 4 minutes
+/**
+ * Handle GET /2018-06-01/runtime/invocation/next
+ * Polls for an invocation with a bounded timeout to handle idle containers gracefully.
+ * This ensures that if no invocations arrive within the timeout, the container
+ * exits cleanly rather than being killed by an HTTP timeout.
+ *
+ * When the timeout expires, we return a 503 Service Unavailable which signals
+ * to the Lambda RIC that it should exit. The container will be restarted
+ * automatically when the next invocation arrives.
+ */
+const handleInvocationNext = (state, pollTimeoutMs) => Effect.gen(function* () {
+    yield* Effect.logDebug("Container polling for next invocation");
+    const startTime = Date.now();
+    // Poll with timeout instead of blocking indefinitely
+    // This allows us to detect connection issues and keep the invocation in the queue
+    let invocation = null;
+    while (invocation === null) {
+        // Check if we've exceeded the timeout
+        if (Date.now() - startTime > pollTimeoutMs) {
+            yield* Effect.logDebug("Invocation poll timeout - returning 503 to trigger container exit");
+            // Return 503 Service Unavailable to signal the RIC to exit gracefully
+            // This is expected behavior for idle containers in local development
+            return HttpServerResponse.empty({
+                status: 503,
+                headers: Headers.fromInput({
+                    "Content-Type": "application/json",
+                }),
+            });
+        }
+        // Try to take from queue with a short timeout
+        const result = yield* Queue.poll(state.invocationQueue);
+        if (Option.isSome(result)) {
+            invocation = result.value;
+        }
+        else {
+            // Queue is empty, wait a bit before retrying
+            yield* Effect.sleep("100 millis");
+        }
+    }
+    yield* Effect.logDebug(`Returning invocation ${invocation.requestId} to container`);
+    return yield* HttpServerResponse.json(invocation.event, {
+        status: 200,
+        headers: Headers.fromInput({
+            "Lambda-Runtime-Aws-Request-Id": invocation.requestId,
+            "Lambda-Runtime-Deadline-Ms": String(invocation.deadlineMs),
+            "Lambda-Runtime-Invoked-Function-Arn": invocation.invokedFunctionArn,
+            "Lambda-Runtime-Log-Group-Name": invocation.logGroupName,
+            "Lambda-Runtime-Log-Stream-Name": invocation.logStreamName,
+        }),
+    });
+});
+/**
+ * Handle POST /2018-06-01/runtime/invocation/:requestId/response
+ */
+const handleInvocationResponse = (state) => Effect.gen(function* () {
+    const params = yield* HttpRouter.params;
+    const requestId = params.requestId ?? "";
+    const request = yield* HttpServerRequest.HttpServerRequest;
+    // Body might not be JSON, so gracefully handle parse errors
+    const body = yield* Effect.orElseSucceed(request.json, () => null);
+    const response = {
+        requestId,
+        body,
+    };
+    yield* Effect.logDebug(`Received response for ${requestId}`);
+    yield* Queue.offer(state.responseQueue, response);
+    return HttpServerResponse.empty({ status: 202 });
+});
+/**
+ * Handle POST /2018-06-01/runtime/invocation/:requestId/error
+ */
+const handleInvocationError = (state) => Effect.gen(function* () {
+    const params = yield* HttpRouter.params;
+    const requestId = params.requestId ?? "";
+    const request = yield* HttpServerRequest.HttpServerRequest;
+    // Body might not be JSON, so gracefully handle parse errors
+    const errorBody = yield* Effect.orElseSucceed(request.json, () => ({}));
+    const errorTypeHeader = Headers.get(request.headers, "lambda-runtime-function-error-type");
+    const errorType = Option.getOrElse(errorTypeHeader, () => "Error");
+    const error = {
+        requestId,
+        errorType: String(errorType),
+        errorMessage: errorBody.errorMessage ?? "Unknown error",
+        stackTrace: errorBody.stackTrace,
+    };
+    yield* Effect.logDebug(`Received error for ${requestId}: ${error.errorMessage}`);
+    yield* Queue.offer(state.responseQueue, error);
+    return HttpServerResponse.empty({ status: 202 });
+});
+/**
+ * Handle POST /2018-06-01/runtime/init/error
+ */
+const handleInitError = (state) => Effect.gen(function* () {
+    const request = yield* HttpServerRequest.HttpServerRequest;
+    // Body might not be JSON, so gracefully handle parse errors
+    const errorBody = yield* Effect.orElseSucceed(request.json, () => ({}));
+    const errorTypeHeader = Headers.get(request.headers, "lambda-runtime-function-error-type");
+    const errorType = Option.getOrElse(errorTypeHeader, () => "InitError");
+    const error = {
+        errorType: String(errorType),
+        errorMessage: errorBody.errorMessage ?? "Unknown init error",
+        stackTrace: errorBody.stackTrace,
+    };
+    yield* Effect.logDebug(`Received init error: ${error.errorMessage}`);
+    yield* Queue.offer(state.responseQueue, error);
+    return HttpServerResponse.empty({ status: 202 });
+});
+// ============================================================================
+// Extensions API handlers
+// @see https://docs.aws.amazon.com/lambda/latest/dg/runtimes-extensions-api.html
+// ============================================================================
+/**
+ * Handle POST /2020-01-01/extension/register
+ * Extensions call this to register for lifecycle events.
+ */
+const handleExtensionRegister = (state) => Effect.gen(function* () {
+    const request = yield* HttpServerRequest.HttpServerRequest;
+    // Get extension name from header (required)
+    const extensionNameHeader = Headers.get(request.headers, "lambda-extension-name");
+    const extensionName = Option.getOrElse(extensionNameHeader, () => "unknown-extension");
+    // Parse request body for events to register for
+    const body = yield* Effect.orElseSucceed(request.json, () => ({}));
+    const events = body.events ?? ["INVOKE", "SHUTDOWN"];
+    // Generate unique extension ID
+    const extensionId = crypto.randomUUID();
+    // Create event queue for this extension
+    const eventQueue = yield* Queue.unbounded();
+    const extensionState = {
+        extension: {
+            extensionId,
+            name: extensionName,
+            events,
+        },
+        eventQueue,
+    };
+    // Register the extension
+    yield* Ref.update(state.extensions, (exts) => HashMap.set(exts, extensionId, extensionState));
+    yield* Effect.logDebug(`Extension registered: ${extensionName} (${extensionId}) for events: ${events.join(", ")}`);
+    return yield* HttpServerResponse.json({
+        functionName: state.functionMetadata.functionName,
+        functionVersion: state.functionMetadata.functionVersion,
+        handler: state.functionMetadata.handler,
+    }, {
+        status: 200,
+        headers: Headers.fromInput({
+            "Lambda-Extension-Identifier": extensionId,
+        }),
+    });
+});
+/**
+ * Handle GET /2020-01-01/extension/event/next
+ * Extensions call this to poll for the next lifecycle event.
+ */
+const handleExtensionEventNext = (state, pollTimeoutMs) => Effect.gen(function* () {
+    const request = yield* HttpServerRequest.HttpServerRequest;
+    // Get extension ID from header (required)
+    const extensionIdHeader = Headers.get(request.headers, "lambda-extension-identifier");
+    const extensionId = Option.getOrElse(extensionIdHeader, () => "");
+    if (!extensionId) {
+        return HttpServerResponse.empty({
+            status: 403,
+            headers: Headers.fromInput({
+                "Content-Type": "application/json",
+            }),
+        });
+    }
+    // Find the extension
+    const extensions = yield* Ref.get(state.extensions);
+    const extensionState = HashMap.get(extensions, extensionId);
+    if (Option.isNone(extensionState)) {
+        yield* Effect.logDebug(`Extension not found: ${extensionId}`);
+        return HttpServerResponse.empty({
+            status: 403,
+            headers: Headers.fromInput({
+                "Content-Type": "application/json",
+            }),
+        });
+    }
+    const { eventQueue, extension } = extensionState.value;
+    yield* Effect.logDebug(`Extension ${extension.name} polling for next event`);
+    const startTime = Date.now();
+    // Poll for the next event with timeout
+    let event = null;
+    while (event === null) {
+        if (Date.now() - startTime > pollTimeoutMs) {
+            yield* Effect.logDebug("Extension event poll timeout - returning 503 to trigger exit");
+            return HttpServerResponse.empty({
+                status: 503,
+                headers: Headers.fromInput({
+                    "Content-Type": "application/json",
+                }),
+            });
+        }
+        const result = yield* Queue.poll(eventQueue);
+        if (Option.isSome(result)) {
+            event = result.value;
+        }
+        else {
+            yield* Effect.sleep("100 millis");
+        }
+    }
+    yield* Effect.logDebug(`Returning ${event.eventType} event to extension ${extension.name}`);
+    return yield* HttpServerResponse.json(event, {
+        status: 200,
+        headers: Headers.fromInput({
+            "Lambda-Extension-Event-Identifier": crypto.randomUUID(),
+        }),
+    });
+});
+/**
+ * Handle POST /2020-01-01/extension/init/error
+ * Extensions call this to report initialization errors.
+ */
+const handleExtensionInitError = (state) => Effect.gen(function* () {
+    const request = yield* HttpServerRequest.HttpServerRequest;
+    const extensionIdHeader = Headers.get(request.headers, "lambda-extension-identifier");
+    const extensionId = Option.getOrElse(extensionIdHeader, () => "unknown");
+    const errorBody = yield* Effect.orElseSucceed(request.json, () => ({}));
+    yield* Effect.logDebug(`Extension ${extensionId} init error: ${errorBody.errorMessage ?? "unknown"}`);
+    // Report the error through the response queue
+    const initError = {
+        errorType: errorBody.errorType ?? "Extension.InitError",
+        errorMessage: errorBody.errorMessage ?? "Extension initialization failed",
+    };
+    yield* Queue.offer(state.responseQueue, initError);
+    return HttpServerResponse.empty({ status: 202 });
+});
+/**
+ * Handle POST /2020-01-01/extension/exit/error
+ * Extensions call this to report errors before exiting.
+ */
+const handleExtensionExitError = () => Effect.gen(function* () {
+    const request = yield* HttpServerRequest.HttpServerRequest;
+    const extensionIdHeader = Headers.get(request.headers, "lambda-extension-identifier");
+    const extensionId = Option.getOrElse(extensionIdHeader, () => "unknown");
+    const errorBody = yield* Effect.orElseSucceed(request.json, () => ({}));
+    yield* Effect.logDebug(`Extension ${extensionId} exit error: ${errorBody.errorMessage ?? "unknown"}`);
+    // Just acknowledge - extension is exiting anyway
+    return HttpServerResponse.empty({ status: 202 });
+});
+// ============================================================================
+// Router
+// ============================================================================
+/**
+ * Create the Runtime API router for a given state.
+ */
+const makeRuntimeApiRouter = (state, pollTimeoutMs) => HttpRouter.empty.pipe(
+// Runtime API (2018-06-01)
+HttpRouter.get("/2018-06-01/runtime/invocation/next", handleInvocationNext(state, pollTimeoutMs)), HttpRouter.post("/2018-06-01/runtime/invocation/:requestId/response", handleInvocationResponse(state)), HttpRouter.post("/2018-06-01/runtime/invocation/:requestId/error", handleInvocationError(state)), HttpRouter.post("/2018-06-01/runtime/init/error", handleInitError(state)), 
+// Extensions API (2020-01-01)
+HttpRouter.post("/2020-01-01/extension/register", handleExtensionRegister(state)), HttpRouter.get("/2020-01-01/extension/event/next", handleExtensionEventNext(state, pollTimeoutMs)), HttpRouter.post("/2020-01-01/extension/init/error", handleExtensionInitError(state)), HttpRouter.post("/2020-01-01/extension/exit/error", handleExtensionExitError()));
+const DEFAULT_FUNCTION_METADATA = {
+    functionName: "local-function",
+    functionVersion: "$LATEST",
+    handler: "index.handler",
+};
+/**
+ * Start a Runtime API server on an ephemeral port.
+ * Returns the actual port and state for this server instance.
+ *
+ * The server is scoped - it will be stopped when the scope closes.
+ *
+ * @param options - Server configuration options
+ */
+export const startRuntimeApiServer = (options = {}) => Effect.gen(function* () {
+    const pollTimeoutMs = options.pollTimeoutMs ?? DEFAULT_POLL_TIMEOUT_MS;
+    const functionMetadata = options.functionMetadata ?? DEFAULT_FUNCTION_METADATA;
+    // Create state (queues) for this server
+    const state = yield* makeRuntimeApiState(functionMetadata);
+    // Create router for this state
+    const router = makeRuntimeApiRouter(state, pollTimeoutMs);
+    // Create HTTP server on ephemeral port (port: 0)
+    const server = yield* BunHttpServer.make({
+        port: 0,
+        hostname: "0.0.0.0",
+        idleTimeout: 255, // Max allowed by Bun (4.25 minutes) for long-polling
+    });
+    // Start serving the router
+    yield* server.serve(router);
+    // Get the actual assigned port
+    const address = server.address;
+    if (address._tag !== "TcpAddress") {
+        // This should never happen since we're using TCP
+        throw new Error("Expected TCP address");
+    }
+    yield* Effect.logDebug(`RuntimeAPI server listening on port ${address.port}`);
+    return {
+        port: address.port,
+        state,
+    };
+});
+/**
+ * Queue an invocation for the container to process.
+ */
+export const queueInvocation = (state, invocation) => Queue.offer(state.invocationQueue, invocation);
+/**
+ * Wait for the response to a specific invocation.
+ */
+export const waitForResponse = (state) => Queue.take(state.responseQueue);
+/**
+ * Notify all registered extensions about an invocation.
+ * This sends an INVOKE event to all extensions that registered for it.
+ */
+export const notifyExtensionsInvoke = (state, invocation) => Effect.gen(function* () {
+    const extensions = yield* Ref.get(state.extensions);
+    const invokeEvent = {
+        eventType: "INVOKE",
+        deadlineMs: invocation.deadlineMs,
+        requestId: invocation.requestId,
+        invokedFunctionArn: invocation.invokedFunctionArn,
+    };
+    // Send INVOKE event to all extensions that registered for it
+    for (const [, extState] of extensions) {
+        if (extState.extension.events.includes("INVOKE")) {
+            yield* Queue.offer(extState.eventQueue, invokeEvent);
+            yield* Effect.logDebug(`Sent INVOKE event to extension ${extState.extension.name}`);
+        }
+    }
+});
+/**
+ * Notify all registered extensions about shutdown.
+ * This sends a SHUTDOWN event to all extensions that registered for it.
+ */
+export const notifyExtensionsShutdown = (state, reason = "SPINDOWN") => Effect.gen(function* () {
+    const extensions = yield* Ref.get(state.extensions);
+    const shutdownEvent = {
+        eventType: "SHUTDOWN",
+        shutdownReason: reason,
+        deadlineMs: Date.now() + 2000, // 2 second deadline for shutdown
+    };
+    // Send SHUTDOWN event to all extensions that registered for it
+    for (const [, extState] of extensions) {
+        if (extState.extension.events.includes("SHUTDOWN")) {
+            yield* Queue.offer(extState.eventQueue, shutdownEvent);
+            yield* Effect.logDebug(`Sent SHUTDOWN event to extension ${extState.extension.name}`);
+        }
+    }
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"server.js","sourceRoot":"","sources":["../../../src/cli/runtime-api/server.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Lambda Runtime API HTTP server using Effect HttpServer.\n *\n * This server emulates the AWS Lambda Runtime API that Docker containers\n * use to receive invocations and send responses.\n *\n * Each Lambda function gets its own server on an ephemeral port. The server\n * maintains a queue of pending invocations. When a container polls\n * /invocation/next, it blocks until an invocation is available.\n *\n * @see https://docs.aws.amazon.com/lambda/latest/dg/runtimes-api.html\n */\n\nimport * as Headers from \"@effect/platform/Headers\"\nimport * as HttpRouter from \"@effect/platform/HttpRouter\"\nimport * as HttpServerRequest from \"@effect/platform/HttpServerRequest\"\nimport * as HttpServerResponse from \"@effect/platform/HttpServerResponse\"\nimport * as BunHttpServer from \"@effect/platform-bun/BunHttpServer\"\nimport { Effect, HashMap, Option, Queue, Ref, type Scope } from \"effect\"\nimport type {\n  ExtensionEvent,\n  ExtensionEventType,\n  LambdaError,\n  LambdaInitError,\n  LambdaInvocation,\n  LambdaResponse,\n  RegisteredExtension,\n} from \"./types.js\"\n\n/**\n * State for a registered extension.\n */\ninterface ExtensionState {\n  /** Extension info */\n  extension: RegisteredExtension\n  /** Queue of events for this extension */\n  eventQueue: Queue.Queue<ExtensionEvent>\n}\n\n/**\n * Function metadata for extension registration responses.\n */\nexport interface FunctionMetadata {\n  functionName: string\n  functionVersion: string\n  handler: string\n}\n\n/**\n * State for a Runtime API server session.\n * Supports multiple invocations with a queue-based model.\n */\nexport interface RuntimeApiState {\n  /** Queue of pending invocations waiting to be fetched by the container */\n  invocationQueue: Queue.Queue<LambdaInvocation>\n  /** Queue for responses/errors from the container */\n  responseQueue: Queue.Queue<LambdaResponse | LambdaError | LambdaInitError>\n  /** Registered extensions by extension ID */\n  extensions: Ref.Ref<HashMap.HashMap<string, ExtensionState>>\n  /** Function metadata for extension registration */\n  functionMetadata: FunctionMetadata\n}\n\n/**\n * Result from starting a Runtime API server.\n */\nexport interface RuntimeApiServer {\n  /** The actual port the server is listening on */\n  port: number\n  /** The state containing the invocation and response queues */\n  state: RuntimeApiState\n}\n\n/**\n * Create a new Runtime API state (queues only, no port).\n *\n * @param functionMetadata - Function metadata for extension registration responses\n */\nexport const makeRuntimeApiState = (functionMetadata: FunctionMetadata) =>\n  Effect.gen(function* () {\n    const invocationQueue = yield* Queue.unbounded<LambdaInvocation>()\n    const responseQueue = yield* Queue.unbounded<\n      LambdaResponse | LambdaError | LambdaInitError\n    >()\n    const extensions = yield* Ref.make(HashMap.empty<string, ExtensionState>())\n\n    return {\n      invocationQueue,\n      responseQueue,\n      extensions,\n      functionMetadata,\n    } satisfies RuntimeApiState\n  })\n\n/**\n * Default poll timeout - used when not overridden.\n *\n * ## Why containers can't stay warm indefinitely (like AWS Lambda does)\n *\n * AWS Lambda keeps containers warm for ~5-15 minutes between invocations.\n * Their Runtime API implementation can hold HTTP connections open indefinitely\n * because they control the entire infrastructure end-to-end.\n *\n * In local development, we're constrained by HTTP server limitations:\n * - Bun's maximum `idleTimeout` is 255 seconds (~4.25 minutes)\n * - This is a practical limit to prevent resource exhaustion in HTTP servers\n * - When the timeout expires, Bun forcefully closes the connection\n * - The Lambda RIC interprets this as a fatal \"No Response from endpoint\" error\n *\n * Our solution: timeout slightly before Bun does (240s vs 255s) and return\n * HTTP 503, which causes the RIC to exit gracefully. The container will be\n * automatically restarted on the next invocation (~2 seconds for warm images).\n *\n * This is an inherent limitation of local Lambda emulation - AWS's purpose-built\n * infrastructure simply doesn't have the same timeout constraints.\n */\nconst DEFAULT_POLL_TIMEOUT_MS = 240_000 // 4 minutes\n\n/**\n * Handle GET /2018-06-01/runtime/invocation/next\n * Polls for an invocation with a bounded timeout to handle idle containers gracefully.\n * This ensures that if no invocations arrive within the timeout, the container\n * exits cleanly rather than being killed by an HTTP timeout.\n *\n * When the timeout expires, we return a 503 Service Unavailable which signals\n * to the Lambda RIC that it should exit. The container will be restarted\n * automatically when the next invocation arrives.\n */\nconst handleInvocationNext = (state: RuntimeApiState, pollTimeoutMs: number) =>\n  Effect.gen(function* () {\n    yield* Effect.logDebug(\"Container polling for next invocation\")\n\n    const startTime = Date.now()\n\n    // Poll with timeout instead of blocking indefinitely\n    // This allows us to detect connection issues and keep the invocation in the queue\n    let invocation: LambdaInvocation | null = null\n\n    while (invocation === null) {\n      // Check if we've exceeded the timeout\n      if (Date.now() - startTime > pollTimeoutMs) {\n        yield* Effect.logDebug(\n          \"Invocation poll timeout - returning 503 to trigger container exit\",\n        )\n        // Return 503 Service Unavailable to signal the RIC to exit gracefully\n        // This is expected behavior for idle containers in local development\n        return HttpServerResponse.empty({\n          status: 503,\n          headers: Headers.fromInput({\n            \"Content-Type\": \"application/json\",\n          }),\n        })\n      }\n\n      // Try to take from queue with a short timeout\n      const result = yield* Queue.poll(state.invocationQueue)\n\n      if (Option.isSome(result)) {\n        invocation = result.value\n      } else {\n        // Queue is empty, wait a bit before retrying\n        yield* Effect.sleep(\"100 millis\")\n      }\n    }\n\n    yield* Effect.logDebug(\n      `Returning invocation ${invocation.requestId} to container`,\n    )\n\n    return yield* HttpServerResponse.json(invocation.event, {\n      status: 200,\n      headers: Headers.fromInput({\n        \"Lambda-Runtime-Aws-Request-Id\": invocation.requestId,\n        \"Lambda-Runtime-Deadline-Ms\": String(invocation.deadlineMs),\n        \"Lambda-Runtime-Invoked-Function-Arn\": invocation.invokedFunctionArn,\n        \"Lambda-Runtime-Log-Group-Name\": invocation.logGroupName,\n        \"Lambda-Runtime-Log-Stream-Name\": invocation.logStreamName,\n      }),\n    })\n  })\n\n/**\n * Handle POST /2018-06-01/runtime/invocation/:requestId/response\n */\nconst handleInvocationResponse = (state: RuntimeApiState) =>\n  Effect.gen(function* () {\n    const params = yield* HttpRouter.params\n    const requestId = params.requestId ?? \"\"\n    const request = yield* HttpServerRequest.HttpServerRequest\n\n    // Body might not be JSON, so gracefully handle parse errors\n    const body = yield* Effect.orElseSucceed(request.json, () => null)\n\n    const response: LambdaResponse = {\n      requestId,\n      body,\n    }\n\n    yield* Effect.logDebug(`Received response for ${requestId}`)\n    yield* Queue.offer(state.responseQueue, response)\n\n    return HttpServerResponse.empty({ status: 202 })\n  })\n\n/**\n * Handle POST /2018-06-01/runtime/invocation/:requestId/error\n */\nconst handleInvocationError = (state: RuntimeApiState) =>\n  Effect.gen(function* () {\n    const params = yield* HttpRouter.params\n    const requestId = params.requestId ?? \"\"\n    const request = yield* HttpServerRequest.HttpServerRequest\n\n    // Body might not be JSON, so gracefully handle parse errors\n    const errorBody = yield* Effect.orElseSucceed(\n      request.json as Effect.Effect<\n        { errorMessage?: string; stackTrace?: string[] },\n        unknown\n      >,\n      (): { errorMessage?: string; stackTrace?: string[] } => ({}),\n    )\n\n    const errorTypeHeader = Headers.get(\n      request.headers,\n      \"lambda-runtime-function-error-type\",\n    )\n    const errorType = Option.getOrElse(errorTypeHeader, () => \"Error\")\n\n    const error: LambdaError = {\n      requestId,\n      errorType: String(errorType),\n      errorMessage: errorBody.errorMessage ?? \"Unknown error\",\n      stackTrace: errorBody.stackTrace,\n    }\n\n    yield* Effect.logDebug(\n      `Received error for ${requestId}: ${error.errorMessage}`,\n    )\n    yield* Queue.offer(state.responseQueue, error)\n\n    return HttpServerResponse.empty({ status: 202 })\n  })\n\n/**\n * Handle POST /2018-06-01/runtime/init/error\n */\nconst handleInitError = (state: RuntimeApiState) =>\n  Effect.gen(function* () {\n    const request = yield* HttpServerRequest.HttpServerRequest\n\n    // Body might not be JSON, so gracefully handle parse errors\n    const errorBody = yield* Effect.orElseSucceed(\n      request.json as Effect.Effect<\n        { errorMessage?: string; stackTrace?: string[] },\n        unknown\n      >,\n      (): { errorMessage?: string; stackTrace?: string[] } => ({}),\n    )\n\n    const errorTypeHeader = Headers.get(\n      request.headers,\n      \"lambda-runtime-function-error-type\",\n    )\n    const errorType = Option.getOrElse(errorTypeHeader, () => \"InitError\")\n\n    const error: LambdaInitError = {\n      errorType: String(errorType),\n      errorMessage: errorBody.errorMessage ?? \"Unknown init error\",\n      stackTrace: errorBody.stackTrace,\n    }\n\n    yield* Effect.logDebug(`Received init error: ${error.errorMessage}`)\n    yield* Queue.offer(state.responseQueue, error)\n\n    return HttpServerResponse.empty({ status: 202 })\n  })\n\n// ============================================================================\n// Extensions API handlers\n// @see https://docs.aws.amazon.com/lambda/latest/dg/runtimes-extensions-api.html\n// ============================================================================\n\n/**\n * Handle POST /2020-01-01/extension/register\n * Extensions call this to register for lifecycle events.\n */\nconst handleExtensionRegister = (state: RuntimeApiState) =>\n  Effect.gen(function* () {\n    const request = yield* HttpServerRequest.HttpServerRequest\n\n    // Get extension name from header (required)\n    const extensionNameHeader = Headers.get(\n      request.headers,\n      \"lambda-extension-name\",\n    )\n    const extensionName = Option.getOrElse(\n      extensionNameHeader,\n      () => \"unknown-extension\",\n    )\n\n    // Parse request body for events to register for\n    const body = yield* Effect.orElseSucceed(\n      request.json as Effect.Effect<{ events?: ExtensionEventType[] }, unknown>,\n      (): { events?: ExtensionEventType[] } => ({}),\n    )\n    const events: ExtensionEventType[] = body.events ?? [\"INVOKE\", \"SHUTDOWN\"]\n\n    // Generate unique extension ID\n    const extensionId = crypto.randomUUID()\n\n    // Create event queue for this extension\n    const eventQueue = yield* Queue.unbounded<ExtensionEvent>()\n\n    const extensionState: ExtensionState = {\n      extension: {\n        extensionId,\n        name: extensionName,\n        events,\n      },\n      eventQueue,\n    }\n\n    // Register the extension\n    yield* Ref.update(state.extensions, (exts) =>\n      HashMap.set(exts, extensionId, extensionState),\n    )\n\n    yield* Effect.logDebug(\n      `Extension registered: ${extensionName} (${extensionId}) for events: ${events.join(\", \")}`,\n    )\n\n    return yield* HttpServerResponse.json(\n      {\n        functionName: state.functionMetadata.functionName,\n        functionVersion: state.functionMetadata.functionVersion,\n        handler: state.functionMetadata.handler,\n      },\n      {\n        status: 200,\n        headers: Headers.fromInput({\n          \"Lambda-Extension-Identifier\": extensionId,\n        }),\n      },\n    )\n  })\n\n/**\n * Handle GET /2020-01-01/extension/event/next\n * Extensions call this to poll for the next lifecycle event.\n */\nconst handleExtensionEventNext = (\n  state: RuntimeApiState,\n  pollTimeoutMs: number,\n) =>\n  Effect.gen(function* () {\n    const request = yield* HttpServerRequest.HttpServerRequest\n\n    // Get extension ID from header (required)\n    const extensionIdHeader = Headers.get(\n      request.headers,\n      \"lambda-extension-identifier\",\n    )\n    const extensionId = Option.getOrElse(extensionIdHeader, () => \"\")\n\n    if (!extensionId) {\n      return HttpServerResponse.empty({\n        status: 403,\n        headers: Headers.fromInput({\n          \"Content-Type\": \"application/json\",\n        }),\n      })\n    }\n\n    // Find the extension\n    const extensions = yield* Ref.get(state.extensions)\n    const extensionState = HashMap.get(extensions, extensionId)\n\n    if (Option.isNone(extensionState)) {\n      yield* Effect.logDebug(`Extension not found: ${extensionId}`)\n      return HttpServerResponse.empty({\n        status: 403,\n        headers: Headers.fromInput({\n          \"Content-Type\": \"application/json\",\n        }),\n      })\n    }\n\n    const { eventQueue, extension } = extensionState.value\n\n    yield* Effect.logDebug(`Extension ${extension.name} polling for next event`)\n\n    const startTime = Date.now()\n\n    // Poll for the next event with timeout\n    let event: ExtensionEvent | null = null\n\n    while (event === null) {\n      if (Date.now() - startTime > pollTimeoutMs) {\n        yield* Effect.logDebug(\n          \"Extension event poll timeout - returning 503 to trigger exit\",\n        )\n        return HttpServerResponse.empty({\n          status: 503,\n          headers: Headers.fromInput({\n            \"Content-Type\": \"application/json\",\n          }),\n        })\n      }\n\n      const result = yield* Queue.poll(eventQueue)\n\n      if (Option.isSome(result)) {\n        event = result.value\n      } else {\n        yield* Effect.sleep(\"100 millis\")\n      }\n    }\n\n    yield* Effect.logDebug(\n      `Returning ${event.eventType} event to extension ${extension.name}`,\n    )\n\n    return yield* HttpServerResponse.json(event, {\n      status: 200,\n      headers: Headers.fromInput({\n        \"Lambda-Extension-Event-Identifier\": crypto.randomUUID(),\n      }),\n    })\n  })\n\n/**\n * Handle POST /2020-01-01/extension/init/error\n * Extensions call this to report initialization errors.\n */\nconst handleExtensionInitError = (state: RuntimeApiState) =>\n  Effect.gen(function* () {\n    const request = yield* HttpServerRequest.HttpServerRequest\n\n    const extensionIdHeader = Headers.get(\n      request.headers,\n      \"lambda-extension-identifier\",\n    )\n    const extensionId = Option.getOrElse(extensionIdHeader, () => \"unknown\")\n\n    const errorBody = yield* Effect.orElseSucceed(\n      request.json as Effect.Effect<\n        { errorMessage?: string; errorType?: string },\n        unknown\n      >,\n      (): { errorMessage?: string; errorType?: string } => ({}),\n    )\n\n    yield* Effect.logDebug(\n      `Extension ${extensionId} init error: ${errorBody.errorMessage ?? \"unknown\"}`,\n    )\n\n    // Report the error through the response queue\n    const initError: LambdaInitError = {\n      errorType: errorBody.errorType ?? \"Extension.InitError\",\n      errorMessage: errorBody.errorMessage ?? \"Extension initialization failed\",\n    }\n    yield* Queue.offer(state.responseQueue, initError)\n\n    return HttpServerResponse.empty({ status: 202 })\n  })\n\n/**\n * Handle POST /2020-01-01/extension/exit/error\n * Extensions call this to report errors before exiting.\n */\nconst handleExtensionExitError = () =>\n  Effect.gen(function* () {\n    const request = yield* HttpServerRequest.HttpServerRequest\n\n    const extensionIdHeader = Headers.get(\n      request.headers,\n      \"lambda-extension-identifier\",\n    )\n    const extensionId = Option.getOrElse(extensionIdHeader, () => \"unknown\")\n\n    const errorBody = yield* Effect.orElseSucceed(\n      request.json as Effect.Effect<\n        { errorMessage?: string; errorType?: string },\n        unknown\n      >,\n      (): { errorMessage?: string; errorType?: string } => ({}),\n    )\n\n    yield* Effect.logDebug(\n      `Extension ${extensionId} exit error: ${errorBody.errorMessage ?? \"unknown\"}`,\n    )\n\n    // Just acknowledge - extension is exiting anyway\n    return HttpServerResponse.empty({ status: 202 })\n  })\n\n// ============================================================================\n// Router\n// ============================================================================\n\n/**\n * Create the Runtime API router for a given state.\n */\nconst makeRuntimeApiRouter = (state: RuntimeApiState, pollTimeoutMs: number) =>\n  HttpRouter.empty.pipe(\n    // Runtime API (2018-06-01)\n    HttpRouter.get(\n      \"/2018-06-01/runtime/invocation/next\",\n      handleInvocationNext(state, pollTimeoutMs),\n    ),\n    HttpRouter.post(\n      \"/2018-06-01/runtime/invocation/:requestId/response\",\n      handleInvocationResponse(state),\n    ),\n    HttpRouter.post(\n      \"/2018-06-01/runtime/invocation/:requestId/error\",\n      handleInvocationError(state),\n    ),\n    HttpRouter.post(\"/2018-06-01/runtime/init/error\", handleInitError(state)),\n    // Extensions API (2020-01-01)\n    HttpRouter.post(\n      \"/2020-01-01/extension/register\",\n      handleExtensionRegister(state),\n    ),\n    HttpRouter.get(\n      \"/2020-01-01/extension/event/next\",\n      handleExtensionEventNext(state, pollTimeoutMs),\n    ),\n    HttpRouter.post(\n      \"/2020-01-01/extension/init/error\",\n      handleExtensionInitError(state),\n    ),\n    HttpRouter.post(\n      \"/2020-01-01/extension/exit/error\",\n      handleExtensionExitError(),\n    ),\n  )\n\n/**\n * Options for starting a Runtime API server.\n */\nexport interface RuntimeApiServerOptions {\n  /** How long to wait for an invocation before returning 503 */\n  pollTimeoutMs?: number\n  /** Function metadata for extension registration */\n  functionMetadata?: FunctionMetadata\n}\n\nconst DEFAULT_FUNCTION_METADATA: FunctionMetadata = {\n  functionName: \"local-function\",\n  functionVersion: \"$LATEST\",\n  handler: \"index.handler\",\n}\n\n/**\n * Start a Runtime API server on an ephemeral port.\n * Returns the actual port and state for this server instance.\n *\n * The server is scoped - it will be stopped when the scope closes.\n *\n * @param options - Server configuration options\n */\nexport const startRuntimeApiServer = (\n  options: RuntimeApiServerOptions = {},\n): Effect.Effect<RuntimeApiServer, never, Scope.Scope> =>\n  Effect.gen(function* () {\n    const pollTimeoutMs = options.pollTimeoutMs ?? DEFAULT_POLL_TIMEOUT_MS\n    const functionMetadata =\n      options.functionMetadata ?? DEFAULT_FUNCTION_METADATA\n\n    // Create state (queues) for this server\n    const state = yield* makeRuntimeApiState(functionMetadata)\n\n    // Create router for this state\n    const router = makeRuntimeApiRouter(state, pollTimeoutMs)\n\n    // Create HTTP server on ephemeral port (port: 0)\n    const server = yield* BunHttpServer.make({\n      port: 0,\n      hostname: \"0.0.0.0\",\n      idleTimeout: 255, // Max allowed by Bun (4.25 minutes) for long-polling\n    })\n\n    // Start serving the router\n    yield* server.serve(router)\n\n    // Get the actual assigned port\n    const address = server.address\n    if (address._tag !== \"TcpAddress\") {\n      // This should never happen since we're using TCP\n      throw new Error(\"Expected TCP address\")\n    }\n\n    yield* Effect.logDebug(\n      `RuntimeAPI server listening on port ${address.port}`,\n    )\n\n    return {\n      port: address.port,\n      state,\n    } satisfies RuntimeApiServer\n  })\n\n/**\n * Queue an invocation for the container to process.\n */\nexport const queueInvocation = (\n  state: RuntimeApiState,\n  invocation: LambdaInvocation,\n): Effect.Effect<void> => Queue.offer(state.invocationQueue, invocation)\n\n/**\n * Wait for the response to a specific invocation.\n */\nexport const waitForResponse = (\n  state: RuntimeApiState,\n): Effect.Effect<LambdaResponse | LambdaError | LambdaInitError> =>\n  Queue.take(state.responseQueue)\n\n/**\n * Notify all registered extensions about an invocation.\n * This sends an INVOKE event to all extensions that registered for it.\n */\nexport const notifyExtensionsInvoke = (\n  state: RuntimeApiState,\n  invocation: LambdaInvocation,\n): Effect.Effect<void> =>\n  Effect.gen(function* () {\n    const extensions = yield* Ref.get(state.extensions)\n\n    const invokeEvent: ExtensionEvent = {\n      eventType: \"INVOKE\",\n      deadlineMs: invocation.deadlineMs,\n      requestId: invocation.requestId,\n      invokedFunctionArn: invocation.invokedFunctionArn,\n    }\n\n    // Send INVOKE event to all extensions that registered for it\n    for (const [, extState] of extensions) {\n      if (extState.extension.events.includes(\"INVOKE\")) {\n        yield* Queue.offer(extState.eventQueue, invokeEvent)\n        yield* Effect.logDebug(\n          `Sent INVOKE event to extension ${extState.extension.name}`,\n        )\n      }\n    }\n  })\n\n/**\n * Notify all registered extensions about shutdown.\n * This sends a SHUTDOWN event to all extensions that registered for it.\n */\nexport const notifyExtensionsShutdown = (\n  state: RuntimeApiState,\n  reason: \"SPINDOWN\" | \"TIMEOUT\" | \"FAILURE\" = \"SPINDOWN\",\n): Effect.Effect<void> =>\n  Effect.gen(function* () {\n    const extensions = yield* Ref.get(state.extensions)\n\n    const shutdownEvent: ExtensionEvent = {\n      eventType: \"SHUTDOWN\",\n      shutdownReason: reason,\n      deadlineMs: Date.now() + 2000, // 2 second deadline for shutdown\n    }\n\n    // Send SHUTDOWN event to all extensions that registered for it\n    for (const [, extState] of extensions) {\n      if (extState.extension.events.includes(\"SHUTDOWN\")) {\n        yield* Queue.offer(extState.eventQueue, shutdownEvent)\n        yield* Effect.logDebug(\n          `Sent SHUTDOWN event to extension ${extState.extension.name}`,\n        )\n      }\n    }\n  })\n"]}

package/lib/cli/runtime-api/types.d.ts

@@ -0,0 +1,149 @@
+/**
+ * Types for Lambda Runtime API implementation.
+ *
+ * This implements the AWS Lambda Runtime API that Docker containers use
+ * to communicate with the Lambda runtime environment.
+ *
+ * @see https://docs.aws.amazon.com/lambda/latest/dg/runtimes-api.html
+ */
+/**
+ * Lambda invocation context passed via headers and body
+ */
+export interface LambdaInvocation {
+    /** Unique request ID for this invocation */
+    requestId: string;
+    /** Event payload */
+    event: unknown;
+    /** Function ARN */
+    invokedFunctionArn: string;
+    /** Deadline timestamp in milliseconds since epoch */
+    deadlineMs: number;
+    /** Function name */
+    functionName: string;
+    /** Function version */
+    functionVersion: string;
+    /** Memory limit in MB */
+    memoryLimitMB: number;
+    /** Log group name */
+    logGroupName: string;
+    /** Log stream name */
+    logStreamName: string;
+}
+/**
+ * Response from the Lambda handler
+ */
+export interface LambdaResponse {
+    /** Request ID this response is for */
+    requestId: string;
+    /** Response body (JSON) */
+    body: unknown;
+}
+/**
+ * Error response from the Lambda handler
+ */
+export interface LambdaError {
+    /** Request ID this error is for */
+    requestId: string;
+    /** Error type (e.g., "Runtime.UnhandledPromiseRejection") */
+    errorType: string;
+    /** Error message */
+    errorMessage: string;
+    /** Stack trace lines */
+    stackTrace?: string[];
+}
+/**
+ * Init error (error during handler initialization)
+ */
+export interface LambdaInitError {
+    /** Error type */
+    errorType: string;
+    /** Error message */
+    errorMessage: string;
+    /** Stack trace lines */
+    stackTrace?: string[];
+}
+/**
+ * Runtime API server configuration
+ */
+export interface RuntimeApiConfig {
+    /** Port to listen on (0 for ephemeral) */
+    port: number;
+    /** Host to bind to */
+    host: string;
+}
+/**
+ * State of a pending invocation
+ */
+export type InvocationState = {
+    type: "pending";
+    invocation: LambdaInvocation;
+} | {
+    type: "completed";
+    response: LambdaResponse;
+} | {
+    type: "error";
+    error: LambdaError;
+} | {
+    type: "init-error";
+    error: LambdaInitError;
+};
+/**
+ * Headers returned by GET /invocation/next
+ */
+export interface InvocationNextHeaders {
+    "Lambda-Runtime-Aws-Request-Id": string;
+    "Lambda-Runtime-Deadline-Ms": string;
+    "Lambda-Runtime-Invoked-Function-Arn": string;
+    "Lambda-Runtime-Log-Group-Name"?: string;
+    "Lambda-Runtime-Log-Stream-Name"?: string;
+    "Lambda-Runtime-Trace-Id"?: string;
+}
+/**
+ * Event types that extensions can register for.
+ * @see https://docs.aws.amazon.com/lambda/latest/dg/runtimes-extensions-api.html
+ */
+export type ExtensionEventType = "INVOKE" | "SHUTDOWN";
+/**
+ * Registered extension information.
+ */
+export interface RegisteredExtension {
+    /** Unique identifier for the extension (UUID) */
+    extensionId: string;
+    /** Name of the extension (from Lambda-Extension-Name header) */
+    name: string;
+    /** Events this extension is registered for */
+    events: ExtensionEventType[];
+}
+/**
+ * Extension INVOKE event payload.
+ */
+export interface ExtensionInvokeEvent {
+    eventType: "INVOKE";
+    deadlineMs: number;
+    requestId: string;
+    invokedFunctionArn: string;
+    tracing?: {
+        type: string;
+        value: string;
+    };
+}
+/**
+ * Extension SHUTDOWN event payload.
+ */
+export interface ExtensionShutdownEvent {
+    eventType: "SHUTDOWN";
+    shutdownReason: "SPINDOWN" | "TIMEOUT" | "FAILURE";
+    deadlineMs: number;
+}
+/**
+ * Extension event (either INVOKE or SHUTDOWN).
+ */
+export type ExtensionEvent = ExtensionInvokeEvent | ExtensionShutdownEvent;
+/**
+ * Response body for extension registration.
+ */
+export interface ExtensionRegisterResponse {
+    functionName: string;
+    functionVersion: string;
+    handler: string;
+}

package/lib/cli/runtime-api/types.js

@@ -0,0 +1,10 @@
+/**
+ * Types for Lambda Runtime API implementation.
+ *
+ * This implements the AWS Lambda Runtime API that Docker containers use
+ * to communicate with the Lambda runtime environment.
+ *
+ * @see https://docs.aws.amazon.com/lambda/latest/dg/runtimes-api.html
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvY2xpL3J1bnRpbWUtYXBpL3R5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7O0dBT0ciLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIFR5cGVzIGZvciBMYW1iZGEgUnVudGltZSBBUEkgaW1wbGVtZW50YXRpb24uXG4gKlxuICogVGhpcyBpbXBsZW1lbnRzIHRoZSBBV1MgTGFtYmRhIFJ1bnRpbWUgQVBJIHRoYXQgRG9ja2VyIGNvbnRhaW5lcnMgdXNlXG4gKiB0byBjb21tdW5pY2F0ZSB3aXRoIHRoZSBMYW1iZGEgcnVudGltZSBlbnZpcm9ubWVudC5cbiAqXG4gKiBAc2VlIGh0dHBzOi8vZG9jcy5hd3MuYW1hem9uLmNvbS9sYW1iZGEvbGF0ZXN0L2RnL3J1bnRpbWVzLWFwaS5odG1sXG4gKi9cblxuLyoqXG4gKiBMYW1iZGEgaW52b2NhdGlvbiBjb250ZXh0IHBhc3NlZCB2aWEgaGVhZGVycyBhbmQgYm9keVxuICovXG5leHBvcnQgaW50ZXJmYWNlIExhbWJkYUludm9jYXRpb24ge1xuICAvKiogVW5pcXVlIHJlcXVlc3QgSUQgZm9yIHRoaXMgaW52b2NhdGlvbiAqL1xuICByZXF1ZXN0SWQ6IHN0cmluZ1xuICAvKiogRXZlbnQgcGF5bG9hZCAqL1xuICBldmVudDogdW5rbm93blxuICAvKiogRnVuY3Rpb24gQVJOICovXG4gIGludm9rZWRGdW5jdGlvbkFybjogc3RyaW5nXG4gIC8qKiBEZWFkbGluZSB0aW1lc3RhbXAgaW4gbWlsbGlzZWNvbmRzIHNpbmNlIGVwb2NoICovXG4gIGRlYWRsaW5lTXM6IG51bWJlclxuICAvKiogRnVuY3Rpb24gbmFtZSAqL1xuICBmdW5jdGlvbk5hbWU6IHN0cmluZ1xuICAvKiogRnVuY3Rpb24gdmVyc2lvbiAqL1xuICBmdW5jdGlvblZlcnNpb246IHN0cmluZ1xuICAvKiogTWVtb3J5IGxpbWl0IGluIE1CICovXG4gIG1lbW9yeUxpbWl0TUI6IG51bWJlclxuICAvKiogTG9nIGdyb3VwIG5hbWUgKi9cbiAgbG9nR3JvdXBOYW1lOiBzdHJpbmdcbiAgLyoqIExvZyBzdHJlYW0gbmFtZSAqL1xuICBsb2dTdHJlYW1OYW1lOiBzdHJpbmdcbn1cblxuLyoqXG4gKiBSZXNwb25zZSBmcm9tIHRoZSBMYW1iZGEgaGFuZGxlclxuICovXG5leHBvcnQgaW50ZXJmYWNlIExhbWJkYVJlc3BvbnNlIHtcbiAgLyoqIFJlcXVlc3QgSUQgdGhpcyByZXNwb25zZSBpcyBmb3IgKi9cbiAgcmVxdWVzdElkOiBzdHJpbmdcbiAgLyoqIFJlc3BvbnNlIGJvZHkgKEpTT04pICovXG4gIGJvZHk6IHVua25vd25cbn1cblxuLyoqXG4gKiBFcnJvciByZXNwb25zZSBmcm9tIHRoZSBMYW1iZGEgaGFuZGxlclxuICovXG5leHBvcnQgaW50ZXJmYWNlIExhbWJkYUVycm9yIHtcbiAgLyoqIFJlcXVlc3QgSUQgdGhpcyBlcnJvciBpcyBmb3IgKi9cbiAgcmVxdWVzdElkOiBzdHJpbmdcbiAgLyoqIEVycm9yIHR5cGUgKGUuZy4sIFwiUnVudGltZS5VbmhhbmRsZWRQcm9taXNlUmVqZWN0aW9uXCIpICovXG4gIGVycm9yVHlwZTogc3RyaW5nXG4gIC8qKiBFcnJvciBtZXNzYWdlICovXG4gIGVycm9yTWVzc2FnZTogc3RyaW5nXG4gIC8qKiBTdGFjayB0cmFjZSBsaW5lcyAqL1xuICBzdGFja1RyYWNlPzogc3RyaW5nW11cbn1cblxuLyoqXG4gKiBJbml0IGVycm9yIChlcnJvciBkdXJpbmcgaGFuZGxlciBpbml0aWFsaXphdGlvbilcbiAqL1xuZXhwb3J0IGludGVyZmFjZSBMYW1iZGFJbml0RXJyb3Ige1xuICAvKiogRXJyb3IgdHlwZSAqL1xuICBlcnJvclR5cGU6IHN0cmluZ1xuICAvKiogRXJyb3IgbWVzc2FnZSAqL1xuICBlcnJvck1lc3NhZ2U6IHN0cmluZ1xuICAvKiogU3RhY2sgdHJhY2UgbGluZXMgKi9cbiAgc3RhY2tUcmFjZT86IHN0cmluZ1tdXG59XG5cbi8qKlxuICogUnVudGltZSBBUEkgc2VydmVyIGNvbmZpZ3VyYXRpb25cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBSdW50aW1lQXBpQ29uZmlnIHtcbiAgLyoqIFBvcnQgdG8gbGlzdGVuIG9uICgwIGZvciBlcGhlbWVyYWwpICovXG4gIHBvcnQ6IG51bWJlclxuICAvKiogSG9zdCB0byBiaW5kIHRvICovXG4gIGhvc3Q6IHN0cmluZ1xufVxuXG4vKipcbiAqIFN0YXRlIG9mIGEgcGVuZGluZyBpbnZvY2F0aW9uXG4gKi9cbmV4cG9ydCB0eXBlIEludm9jYXRpb25TdGF0ZSA9XG4gIHwgeyB0eXBlOiBcInBlbmRpbmdcIjsgaW52b2NhdGlvbjogTGFtYmRhSW52b2NhdGlvbiB9XG4gIHwgeyB0eXBlOiBcImNvbXBsZXRlZFwiOyByZXNwb25zZTogTGFtYmRhUmVzcG9uc2UgfVxuICB8IHsgdHlwZTogXCJlcnJvclwiOyBlcnJvcjogTGFtYmRhRXJyb3IgfVxuICB8IHsgdHlwZTogXCJpbml0LWVycm9yXCI7IGVycm9yOiBMYW1iZGFJbml0RXJyb3IgfVxuXG4vKipcbiAqIEhlYWRlcnMgcmV0dXJuZWQgYnkgR0VUIC9pbnZvY2F0aW9uL25leHRcbiAqL1xuZXhwb3J0IGludGVyZmFjZSBJbnZvY2F0aW9uTmV4dEhlYWRlcnMge1xuICBcIkxhbWJkYS1SdW50aW1lLUF3cy1SZXF1ZXN0LUlkXCI6IHN0cmluZ1xuICBcIkxhbWJkYS1SdW50aW1lLURlYWRsaW5lLU1zXCI6IHN0cmluZ1xuICBcIkxhbWJkYS1SdW50aW1lLUludm9rZWQtRnVuY3Rpb24tQXJuXCI6IHN0cmluZ1xuICBcIkxhbWJkYS1SdW50aW1lLUxvZy1Hcm91cC1OYW1lXCI/OiBzdHJpbmdcbiAgXCJMYW1iZGEtUnVudGltZS1Mb2ctU3RyZWFtLU5hbWVcIj86IHN0cmluZ1xuICBcIkxhbWJkYS1SdW50aW1lLVRyYWNlLUlkXCI/OiBzdHJpbmdcbn1cblxuLyoqXG4gKiBFdmVudCB0eXBlcyB0aGF0IGV4dGVuc2lvbnMgY2FuIHJlZ2lzdGVyIGZvci5cbiAqIEBzZWUgaHR0cHM6Ly9kb2NzLmF3cy5hbWF6b24uY29tL2xhbWJkYS9sYXRlc3QvZGcvcnVudGltZXMtZXh0ZW5zaW9ucy1hcGkuaHRtbFxuICovXG5leHBvcnQgdHlwZSBFeHRlbnNpb25FdmVudFR5cGUgPSBcIklOVk9LRVwiIHwgXCJTSFVURE9XTlwiXG5cbi8qKlxuICogUmVnaXN0ZXJlZCBleHRlbnNpb24gaW5mb3JtYXRpb24uXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgUmVnaXN0ZXJlZEV4dGVuc2lvbiB7XG4gIC8qKiBVbmlxdWUgaWRlbnRpZmllciBmb3IgdGhlIGV4dGVuc2lvbiAoVVVJRCkgKi9cbiAgZXh0ZW5zaW9uSWQ6IHN0cmluZ1xuICAvKiogTmFtZSBvZiB0aGUgZXh0ZW5zaW9uIChmcm9tIExhbWJkYS1FeHRlbnNpb24tTmFtZSBoZWFkZXIpICovXG4gIG5hbWU6IHN0cmluZ1xuICAvKiogRXZlbnRzIHRoaXMgZXh0ZW5zaW9uIGlzIHJlZ2lzdGVyZWQgZm9yICovXG4gIGV2ZW50czogRXh0ZW5zaW9uRXZlbnRUeXBlW11cbn1cblxuLyoqXG4gKiBFeHRlbnNpb24gSU5WT0tFIGV2ZW50IHBheWxvYWQuXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgRXh0ZW5zaW9uSW52b2tlRXZlbnQge1xuICBldmVudFR5cGU6IFwiSU5WT0tFXCJcbiAgZGVhZGxpbmVNczogbnVtYmVyXG4gIHJlcXVlc3RJZDogc3RyaW5nXG4gIGludm9rZWRGdW5jdGlvbkFybjogc3RyaW5nXG4gIHRyYWNpbmc/OiB7XG4gICAgdHlwZTogc3RyaW5nXG4gICAgdmFsdWU6IHN0cmluZ1xuICB9XG59XG5cbi8qKlxuICogRXh0ZW5zaW9uIFNIVVRET1dOIGV2ZW50IHBheWxvYWQuXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgRXh0ZW5zaW9uU2h1dGRvd25FdmVudCB7XG4gIGV2ZW50VHlwZTogXCJTSFVURE9XTlwiXG4gIHNodXRkb3duUmVhc29uOiBcIlNQSU5ET1dOXCIgfCBcIlRJTUVPVVRcIiB8IFwiRkFJTFVSRVwiXG4gIGRlYWRsaW5lTXM6IG51bWJlclxufVxuXG4vKipcbiAqIEV4dGVuc2lvbiBldmVudCAoZWl0aGVyIElOVk9LRSBvciBTSFVURE9XTikuXG4gKi9cbmV4cG9ydCB0eXBlIEV4dGVuc2lvbkV2ZW50ID0gRXh0ZW5zaW9uSW52b2tlRXZlbnQgfCBFeHRlbnNpb25TaHV0ZG93bkV2ZW50XG5cbi8qKlxuICogUmVzcG9uc2UgYm9keSBmb3IgZXh0ZW5zaW9uIHJlZ2lzdHJhdGlvbi5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBFeHRlbnNpb25SZWdpc3RlclJlc3BvbnNlIHtcbiAgZnVuY3Rpb25OYW1lOiBzdHJpbmdcbiAgZnVuY3Rpb25WZXJzaW9uOiBzdHJpbmdcbiAgaGFuZGxlcjogc3RyaW5nXG59XG4iXX0=