@kensio/yulin 1.12.1 → 1.14.0

package/dist/service/elbv2/serve/sim-elbv2-action-performer.js

@@ -0,0 +1,44 @@
+import { SimElbV2FixedResponse } from "./sim-elbv2-fixed-response.js";
+import { SimElbV2ForwardTarget } from "./sim-elbv2-forward-target.js";
+import { SimElbV2RedirectResponse } from "./sim-elbv2-redirect-response.js";
+/**
+ * Carries out the action a listener or a rule answers a request with.
+ *
+ * Two of the three need no target at all: a fixed response and a redirect are
+ * written by the load balancer itself, which is why a listener holding one can
+ * serve with nothing registered behind it. A forward is the one that goes on to
+ * a target group.
+ */
+export class SimElbV2ActionPerformer {
+    invocations;
+    fixedResponse = new SimElbV2FixedResponse();
+    redirect = new SimElbV2RedirectResponse();
+    constructor(invocations) {
+        this.invocations = invocations;
+    }
+    /**
+     * Answer one request with one matched action.
+     */
+    async perform(input) {
+        const { action } = input.matched;
+        if (action.type === "fixed-response") {
+            return this.fixedResponse.respond(action);
+        }
+        if (action.type === "redirect") {
+            return this.redirect.respond({
+                action,
+                listener: input.listener,
+                request: input.request,
+            });
+        }
+        return await this.forward(input);
+    }
+    async forward(input) {
+        return await this.invocations.invoke({
+            listener: input.listener,
+            targetGroup: new SimElbV2ForwardTarget(input.elbV2).resolve(input.matched),
+            request: input.request,
+        });
+    }
+}
+//# sourceMappingURL=sim-elbv2-action-performer.js.map

package/dist/service/elbv2/serve/sim-elbv2-action-performer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-elbv2-action-performer.js","sourceRoot":"","sources":["../../../../src/service/elbv2/serve/sim-elbv2-action-performer.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AACtE,OAAO,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AAEtE,OAAO,EAAE,wBAAwB,EAAE,MAAM,kCAAkC,CAAC;AAU5E;;;;;;;GAOG;AACH,MAAM,OAAO,uBAAuB;IAIL,WAAW;IAHvB,aAAa,GAAG,IAAI,qBAAqB,EAAE,CAAC;IAC5C,QAAQ,GAAG,IAAI,wBAAwB,EAAE,CAAC;IAE3D,YAA6B,WAAsC;2BAAtC,WAAW;IAA8B,CAAC;IAEvE;;OAEG;IACH,KAAK,CAAC,OAAO,CAAC,KAAmC;QAC/C,MAAM,EAAE,MAAM,EAAE,GAAG,KAAK,CAAC,OAAO,CAAC;QAEjC,IAAI,MAAM,CAAC,IAAI,KAAK,gBAAgB,EAAE,CAAC;YACrC,OAAO,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;QAC5C,CAAC;QAED,IAAI,MAAM,CAAC,IAAI,KAAK,UAAU,EAAE,CAAC;YAC/B,OAAO,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC;gBAC3B,MAAM;gBACN,QAAQ,EAAE,KAAK,CAAC,QAAQ;gBACxB,OAAO,EAAE,KAAK,CAAC,OAAO;aACvB,CAAC,CAAC;QACL,CAAC;QAED,OAAO,MAAM,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;IACnC,CAAC;IAEO,KAAK,CAAC,OAAO,CACnB,KAAmC;QAEnC,OAAO,MAAM,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC;YACnC,QAAQ,EAAE,KAAK,CAAC,QAAQ;YACxB,WAAW,EAAE,IAAI,qBAAqB,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,OAAO,CACzD,KAAK,CAAC,OAAO,CACd;YACD,OAAO,EAAE,KAAK,CAAC,OAAO;SACvB,CAAC,CAAC;IACL,CAAC;CACF"}

package/dist/service/elbv2/serve/sim-elbv2-body-encoding.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Decides how a request or response body crosses the boundary between HTTP
+ * bytes and the string an ALB invocation event carries.
+ *
+ * A body with a `content-encoding` header is always base64, whatever its
+ * content type, because the bytes are compressed rather than text. Without one,
+ * the content type decides, and the handler is told which happened with
+ * `isBase64Encoded`.
+ */
+export declare class SimElbV2BodyEncoding {
+    /**
+     * Whether a body is passed to the handler as text.
+     *
+     * An absent content type is treated as binary, as ELB does, because nothing
+     * says the bytes are decodable text.
+     */
+    isText(contentType: string | null, contentEncoding: string | null): boolean;
+    /**
+     * Encode request body bytes for the handler event.
+     *
+     * A text body that is not valid UTF-8 throws rather than being decoded into
+     * replacement characters. Real ELB fails the invocation for the same reason,
+     * with `LambdaBadRequest` in its logs and a 502 for the client, so a handler
+     * never sees a body silently rewritten on its way in.
+     */
+    encode(bytes: Uint8Array, contentType: string | null, contentEncoding: string | null): string;
+    /**
+     * Decode a handler's response body into the bytes sent to the client.
+     */
+    decode(body: string, isBase64Encoded: boolean): Uint8Array | string;
+}
+//# sourceMappingURL=sim-elbv2-body-encoding.d.ts.map

package/dist/service/elbv2/serve/sim-elbv2-body-encoding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-elbv2-body-encoding.d.ts","sourceRoot":"","sources":["../../../../src/service/elbv2/serve/sim-elbv2-body-encoding.ts"],"names":[],"mappings":"AAeA;;;;;;;;GAQG;AACH,qBAAa,oBAAoB;IAC/B;;;;;OAKG;IACH,MAAM,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,EAAE,eAAe,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO,CAgB1E;IAED;;;;;;;OAOG;IACH,MAAM,CACJ,KAAK,EAAE,UAAU,EACjB,WAAW,EAAE,MAAM,GAAG,IAAI,EAC1B,eAAe,EAAE,MAAM,GAAG,IAAI,GAC7B,MAAM,CAMR;IAED;;OAEG;IACH,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,eAAe,EAAE,OAAO,GAAG,UAAU,GAAG,MAAM,CAMlE;CACF"}

package/dist/service/elbv2/serve/sim-elbv2-body-encoding.js

@@ -0,0 +1,68 @@
+/**
+ * The media types an Application Load Balancer passes to a Lambda target as
+ * text.
+ *
+ * This list is ELB's own and is shorter than the one API Gateway uses. A form
+ * post is the difference worth knowing about:
+ * `application/x-www-form-urlencoded` is text to API Gateway and base64 to a
+ * load balancer.
+ */
+const textMediaTypes = new Set([
+    "application/json",
+    "application/javascript",
+    "application/xml",
+]);
+/**
+ * Decides how a request or response body crosses the boundary between HTTP
+ * bytes and the string an ALB invocation event carries.
+ *
+ * A body with a `content-encoding` header is always base64, whatever its
+ * content type, because the bytes are compressed rather than text. Without one,
+ * the content type decides, and the handler is told which happened with
+ * `isBase64Encoded`.
+ */
+export class SimElbV2BodyEncoding {
+    /**
+     * Whether a body is passed to the handler as text.
+     *
+     * An absent content type is treated as binary, as ELB does, because nothing
+     * says the bytes are decodable text.
+     */
+    isText(contentType, contentEncoding) {
+        if (contentEncoding !== null) {
+            return false;
+        }
+        if (contentType === null) {
+            return false;
+        }
+        const mediaType = contentType.split(";", 1)[0]?.trim().toLowerCase() ?? "";
+        if (mediaType.startsWith("text/")) {
+            return true;
+        }
+        return textMediaTypes.has(mediaType);
+    }
+    /**
+     * Encode request body bytes for the handler event.
+     *
+     * A text body that is not valid UTF-8 throws rather than being decoded into
+     * replacement characters. Real ELB fails the invocation for the same reason,
+     * with `LambdaBadRequest` in its logs and a 502 for the client, so a handler
+     * never sees a body silently rewritten on its way in.
+     */
+    encode(bytes, contentType, contentEncoding) {
+        if (this.isText(contentType, contentEncoding)) {
+            return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+        }
+        return Buffer.from(bytes).toString("base64");
+    }
+    /**
+     * Decode a handler's response body into the bytes sent to the client.
+     */
+    decode(body, isBase64Encoded) {
+        if (isBase64Encoded) {
+            return new Uint8Array(Buffer.from(body, "base64"));
+        }
+        return body;
+    }
+}
+//# sourceMappingURL=sim-elbv2-body-encoding.js.map

package/dist/service/elbv2/serve/sim-elbv2-body-encoding.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-elbv2-body-encoding.js","sourceRoot":"","sources":["../../../../src/service/elbv2/serve/sim-elbv2-body-encoding.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,MAAM,cAAc,GAAwB,IAAI,GAAG,CAAC;IAClD,kBAAkB;IAClB,wBAAwB;IACxB,iBAAiB;CAClB,CAAC,CAAC;AAEH;;;;;;;;GAQG;AACH,MAAM,OAAO,oBAAoB;IAC/B;;;;;OAKG;IACH,MAAM,CAAC,WAA0B,EAAE,eAA8B;QAC/D,IAAI,eAAe,KAAK,IAAI,EAAE,CAAC;YAC7B,OAAO,KAAK,CAAC;QACf,CAAC;QAED,IAAI,WAAW,KAAK,IAAI,EAAE,CAAC;YACzB,OAAO,KAAK,CAAC;QACf,CAAC;QAED,MAAM,SAAS,GAAG,WAAW,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,WAAW,EAAE,IAAI,EAAE,CAAC;QAE3E,IAAI,SAAS,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE,CAAC;YAClC,OAAO,IAAI,CAAC;QACd,CAAC;QAED,OAAO,cAAc,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;IACvC,CAAC;IAED;;;;;;;OAOG;IACH,MAAM,CACJ,KAAiB,EACjB,WAA0B,EAC1B,eAA8B;QAE9B,IAAI,IAAI,CAAC,MAAM,CAAC,WAAW,EAAE,eAAe,CAAC,EAAE,CAAC;YAC9C,OAAO,IAAI,WAAW,CAAC,OAAO,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QACjE,CAAC;QAED,OAAO,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;IAC/C,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,IAAY,EAAE,eAAwB;QAC3C,IAAI,eAAe,EAAE,CAAC;YACpB,OAAO,IAAI,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC;QACrD,CAAC;QAED,OAAO,IAAI,CAAC;IACd,CAAC;CACF"}

package/dist/service/elbv2/serve/sim-elbv2-container-target-invocation.d.ts

@@ -0,0 +1,45 @@
+import type { SimClock } from "../../../util/clock/sim-clock.js";
+import type { SimElbV2Router } from "./sim-elbv2-router.js";
+import type { SimElbV2TargetInvocation, SimElbV2TargetInvocationInput } from "./sim-elbv2-target-invocation.js";
+interface SimElbV2ContainerTargetInvocationProperties {
+    readonly router: SimElbV2Router;
+    /** Clock the forwarded request's trace id is stamped with. */
+    readonly clock: SimClock;
+}
+/**
+ * Carries a request to the container of the simulated ECS service registered
+ * into an address target group.
+ *
+ * There are three ways for this to have nothing to send the request to, and all
+ * three are the same 503 real ELB answers when no target is in service. A group
+ * with nothing registered has no target at all. A group whose registered
+ * service has no container bound to an HTTP handler has a target with nothing
+ * behind it, which is what a real load balancer sees when a task's container is
+ * not answering. An address registered by hand is the same case: nothing in
+ * this simulation listens on an address, so only a service registration puts
+ * something behind one.
+ *
+ * A container that throws is a 502, as a Lambda target that throws is. The
+ * error goes no further than the load balancer, which is also where it goes on
+ * real AWS: what the client sees is the status.
+ */
+export declare class SimElbV2ContainerTargetInvocation implements SimElbV2TargetInvocation {
+    private readonly router;
+    private readonly forwardedRequest;
+    private readonly errorResponse;
+    constructor(properties: SimElbV2ContainerTargetInvocationProperties);
+    /**
+     * Send one request to the target group's container.
+     */
+    invoke(input: SimElbV2TargetInvocationInput): Promise<Response>;
+    /**
+     * What the container answered, where it answered with a response at all.
+     *
+     * A handler that returns something else is the same 502 a Lambda target's
+     * unusable result is. The binding's type says a response, so this is for a
+     * handler written in JavaScript, where nothing checked.
+     */
+    private answered;
+}
+export {};
+//# sourceMappingURL=sim-elbv2-container-target-invocation.d.ts.map

package/dist/service/elbv2/serve/sim-elbv2-container-target-invocation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-elbv2-container-target-invocation.d.ts","sourceRoot":"","sources":["../../../../src/service/elbv2/serve/sim-elbv2-container-target-invocation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kCAAkC,CAAC;AAGjE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,KAAK,EACV,wBAAwB,EACxB,6BAA6B,EAC9B,MAAM,kCAAkC,CAAC;AAE1C,UAAU,2CAA2C;IACnD,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC;IAChC,8DAA8D;IAC9D,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC;CAC1B;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,iCAAkC,YAAW,wBAAwB;IAChF,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAiB;IACxC,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAA2B;IAC5D,OAAO,CAAC,QAAQ,CAAC,aAAa,CAA+B;IAE7D,YAAY,UAAU,EAAE,2CAA2C,EAKlE;IAED;;OAEG;IACG,MAAM,CAAC,KAAK,EAAE,6BAA6B,GAAG,OAAO,CAAC,QAAQ,CAAC,CAoBpE;IAED;;;;;;OAMG;IACH,OAAO,CAAC,QAAQ;CAOjB"}

package/dist/service/elbv2/serve/sim-elbv2-container-target-invocation.js

@@ -0,0 +1,63 @@
+import { SimElbV2ErrorResponse } from "./sim-elbv2-error-response.js";
+import { SimElbV2ForwardedRequest } from "./sim-elbv2-forwarded-request.js";
+/**
+ * Carries a request to the container of the simulated ECS service registered
+ * into an address target group.
+ *
+ * There are three ways for this to have nothing to send the request to, and all
+ * three are the same 503 real ELB answers when no target is in service. A group
+ * with nothing registered has no target at all. A group whose registered
+ * service has no container bound to an HTTP handler has a target with nothing
+ * behind it, which is what a real load balancer sees when a task's container is
+ * not answering. An address registered by hand is the same case: nothing in
+ * this simulation listens on an address, so only a service registration puts
+ * something behind one.
+ *
+ * A container that throws is a 502, as a Lambda target that throws is. The
+ * error goes no further than the load balancer, which is also where it goes on
+ * real AWS: what the client sees is the status.
+ */
+export class SimElbV2ContainerTargetInvocation {
+    router;
+    forwardedRequest;
+    errorResponse = new SimElbV2ErrorResponse();
+    constructor(properties) {
+        this.router = properties.router;
+        this.forwardedRequest = new SimElbV2ForwardedRequest({
+            clock: properties.clock,
+        });
+    }
+    /**
+     * Send one request to the target group's container.
+     */
+    async invoke(input) {
+        const { targetGroup } = input;
+        if (targetGroup.registeredTargets.length === 0) {
+            return this.errorResponse.serviceUnavailable();
+        }
+        const container = this.router.containerFor(targetGroup);
+        if (container === undefined) {
+            return this.errorResponse.serviceUnavailable();
+        }
+        try {
+            return this.answered(await container.handle(this.forwardedRequest.build(input)));
+        }
+        catch {
+            return this.errorResponse.badGateway();
+        }
+    }
+    /**
+     * What the container answered, where it answered with a response at all.
+     *
+     * A handler that returns something else is the same 502 a Lambda target's
+     * unusable result is. The binding's type says a response, so this is for a
+     * handler written in JavaScript, where nothing checked.
+     */
+    answered(answer) {
+        if (answer instanceof Response) {
+            return answer;
+        }
+        return this.errorResponse.badGateway();
+    }
+}
+//# sourceMappingURL=sim-elbv2-container-target-invocation.js.map

package/dist/service/elbv2/serve/sim-elbv2-container-target-invocation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-elbv2-container-target-invocation.js","sourceRoot":"","sources":["../../../../src/service/elbv2/serve/sim-elbv2-container-target-invocation.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AACtE,OAAO,EAAE,wBAAwB,EAAE,MAAM,kCAAkC,CAAC;AAa5E;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,OAAO,iCAAiC;IAC3B,MAAM,CAAiB;IACvB,gBAAgB,CAA2B;IAC3C,aAAa,GAAG,IAAI,qBAAqB,EAAE,CAAC;IAE7D,YAAY,UAAuD;QACjE,IAAI,CAAC,MAAM,GAAG,UAAU,CAAC,MAAM,CAAC;QAChC,IAAI,CAAC,gBAAgB,GAAG,IAAI,wBAAwB,CAAC;YACnD,KAAK,EAAE,UAAU,CAAC,KAAK;SACxB,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,MAAM,CAAC,KAAoC;QAC/C,MAAM,EAAE,WAAW,EAAE,GAAG,KAAK,CAAC;QAE9B,IAAI,WAAW,CAAC,iBAAiB,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC/C,OAAO,IAAI,CAAC,aAAa,CAAC,kBAAkB,EAAE,CAAC;QACjD,CAAC;QAED,MAAM,SAAS,GAAG,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,WAAW,CAAC,CAAC;QAExD,IAAI,SAAS,KAAK,SAAS,EAAE,CAAC;YAC5B,OAAO,IAAI,CAAC,aAAa,CAAC,kBAAkB,EAAE,CAAC;QACjD,CAAC;QAED,IAAI,CAAC;YACH,OAAO,IAAI,CAAC,QAAQ,CAClB,MAAM,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAC3D,CAAC;QACJ,CAAC;QAAC,MAAM,CAAC;YACP,OAAO,IAAI,CAAC,aAAa,CAAC,UAAU,EAAE,CAAC;QACzC,CAAC;IACH,CAAC;IAED;;;;;;OAMG;IACK,QAAQ,CAAC,MAAgB;QAC/B,IAAI,MAAM,YAAY,QAAQ,EAAE,CAAC;YAC/B,OAAO,MAAM,CAAC;QAChB,CAAC;QAED,OAAO,IAAI,CAAC,aAAa,CAAC,UAAU,EAAE,CAAC;IACzC,CAAC;CACF"}

package/dist/service/elbv2/serve/sim-elbv2-controller.d.ts

@@ -0,0 +1,27 @@
+import type { SimAwsServiceController, SimAwsServiceRequest } from "../../../serve/controller/sim-service-controller.js";
+import { SimAws } from "../../aws/sim-aws.js";
+import { SimElbV2Router } from "./sim-elbv2-router.js";
+interface SimElbV2ServiceControllerProperties {
+    readonly simAws?: SimAws;
+    readonly router?: SimElbV2Router;
+}
+/**
+ * HTTP controller for simulated Application Load Balancers.
+ *
+ * A request reaching a load balancer's DNS name is matched to a listener by the
+ * port it arrived on. That listener's rules are then evaluated in priority
+ * order, and the first one claiming the request says what happens to it. A
+ * request no rule claims is answered by the listener's default action.
+ */
+export declare class SimElbV2ServiceController implements SimAwsServiceController {
+    private readonly router;
+    private readonly actions;
+    constructor(properties?: SimElbV2ServiceControllerProperties);
+    /**
+     * Handle an HTTP request routed to a simulated load balancer.
+     */
+    handleRequest(serviceRequest: SimAwsServiceRequest): Promise<Response>;
+    private answer;
+}
+export {};
+//# sourceMappingURL=sim-elbv2-controller.d.ts.map

package/dist/service/elbv2/serve/sim-elbv2-controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-elbv2-controller.d.ts","sourceRoot":"","sources":["../../../../src/service/elbv2/serve/sim-elbv2-controller.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,uBAAuB,EACvB,oBAAoB,EACrB,MAAM,qDAAqD,CAAC;AAC7D,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAK9C,OAAO,EAEL,cAAc,EACf,MAAM,uBAAuB,CAAC;AAG/B,UAAU,mCAAmC;IAC3C,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,MAAM,CAAC,EAAE,cAAc,CAAC;CAClC;AAED;;;;;;;GAOG;AACH,qBAAa,yBAA0B,YAAW,uBAAuB;IACvE,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAiB;IACxC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA0B;IAElD,YAAY,UAAU,GAAE,mCAAwC,EAY/D;IAED;;OAEG;IACG,aAAa,CAAC,cAAc,EAAE,oBAAoB,GAAG,OAAO,CAAC,QAAQ,CAAC,CAW3E;YAEa,MAAM;CAcrB"}

package/dist/service/elbv2/serve/sim-elbv2-controller.js

@@ -0,0 +1,52 @@
+import { SimAws } from "../../aws/sim-aws.js";
+import { SimElbV2ConnectionRefusedError } from "../error/sim-elbv2.error.js";
+import { SimElbV2ActionPerformer } from "./sim-elbv2-action-performer.js";
+import { SimElbV2TargetInvocations } from "./sim-elbv2-target-invocations.js";
+import { requireSimElbV2Listener } from "./sim-elbv2-listener-match.js";
+import { SimElbV2Router, } from "./sim-elbv2-router.js";
+import { SimElbV2RuleEvaluation } from "./sim-elbv2-rule-evaluation.js";
+/**
+ * HTTP controller for simulated Application Load Balancers.
+ *
+ * A request reaching a load balancer's DNS name is matched to a listener by the
+ * port it arrived on. That listener's rules are then evaluated in priority
+ * order, and the first one claiming the request says what happens to it. A
+ * request no rule claims is answered by the listener's default action.
+ */
+export class SimElbV2ServiceController {
+    router;
+    actions;
+    constructor(properties = {}) {
+        const { simAws = new SimAws() } = properties;
+        this.router = properties.router ?? new SimElbV2Router({ simAws });
+        // The clock is taken from the router rather than from properties, so a
+        // supplied router and the forwarded timestamps belong to the same
+        // simulation.
+        this.actions = new SimElbV2ActionPerformer(new SimElbV2TargetInvocations({
+            router: this.router,
+            clock: this.router.simAws,
+        }));
+    }
+    /**
+     * Handle an HTTP request routed to a simulated load balancer.
+     */
+    async handleRequest(serviceRequest) {
+        const route = this.router.route(serviceRequest.target);
+        if (route === undefined) {
+            throw new SimElbV2ConnectionRefusedError(`No simulated load balancer answers on ` +
+                `'${serviceRequest.target.resourceName}'`);
+        }
+        return await this.answer(route, serviceRequest.request);
+    }
+    async answer(route, request) {
+        const { elbV2 } = route;
+        const listener = requireSimElbV2Listener(route, request);
+        return await this.actions.perform({
+            matched: new SimElbV2RuleEvaluation(elbV2).actionFor(listener, request),
+            listener,
+            elbV2,
+            request,
+        });
+    }
+}
+//# sourceMappingURL=sim-elbv2-controller.js.map

package/dist/service/elbv2/serve/sim-elbv2-controller.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-elbv2-controller.js","sourceRoot":"","sources":["../../../../src/service/elbv2/serve/sim-elbv2-controller.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAC9C,OAAO,EAAE,8BAA8B,EAAE,MAAM,6BAA6B,CAAC;AAC7E,OAAO,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAC;AAC1E,OAAO,EAAE,yBAAyB,EAAE,MAAM,mCAAmC,CAAC;AAC9E,OAAO,EAAE,uBAAuB,EAAE,MAAM,+BAA+B,CAAC;AACxE,OAAO,EAEL,cAAc,GACf,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAC;AAOxE;;;;;;;GAOG;AACH,MAAM,OAAO,yBAAyB;IACnB,MAAM,CAAiB;IACvB,OAAO,CAA0B;IAElD,YAAY,UAAU,GAAwC,EAAE;QAC9D,MAAM,EAAE,MAAM,GAAG,IAAI,MAAM,EAAE,EAAE,GAAG,UAAU,CAAC;QAC7C,IAAI,CAAC,MAAM,GAAG,UAAU,CAAC,MAAM,IAAI,IAAI,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC;QAClE,uEAAuE;QACvE,kEAAkE;QAClE,cAAc;QACd,IAAI,CAAC,OAAO,GAAG,IAAI,uBAAuB,CACxC,IAAI,yBAAyB,CAAC;YAC5B,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC,MAAM;SAC1B,CAAC,CACH,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,aAAa,CAAC,cAAoC;QACtD,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;QAEvD,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;YACxB,MAAM,IAAI,8BAA8B,CACtC,wCAAwC;gBACtC,IAAI,cAAc,CAAC,MAAM,CAAC,YAAY,GAAG,CAC5C,CAAC;QACJ,CAAC;QAED,OAAO,MAAM,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,cAAc,CAAC,OAAO,CAAC,CAAC;IAC1D,CAAC;IAEO,KAAK,CAAC,MAAM,CAClB,KAAgC,EAChC,OAAgB;QAEhB,MAAM,EAAE,KAAK,EAAE,GAAG,KAAK,CAAC;QACxB,MAAM,QAAQ,GAAG,uBAAuB,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;QAEzD,OAAO,MAAM,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC;YAChC,OAAO,EAAE,IAAI,sBAAsB,CAAC,KAAK,CAAC,CAAC,SAAS,CAAC,QAAQ,EAAE,OAAO,CAAC;YACvE,QAAQ;YACR,KAAK;YACL,OAAO;SACR,CAAC,CAAC;IACL,CAAC;CACF"}

package/dist/service/elbv2/serve/sim-elbv2-error-response.d.ts

@@ -0,0 +1,33 @@
+/**
+ * The responses a load balancer generates itself, rather than getting from a
+ * target.
+ *
+ * Real ELB answers these with a short HTML page naming the status, which is
+ * what a browser shows when a target is missing or broken. The status code is
+ * the part worth asserting on: the page is reproduced so that a response looks
+ * like one a load balancer sent, not so that anything reads it.
+ */
+export declare class SimElbV2ErrorResponse {
+    /**
+     * The target could not be invoked, or answered with something that is not a
+     * response.
+     *
+     * This is what a Lambda target produces when the load balancer may not
+     * invoke it, when the function is not there, when the handler throws, and
+     * when what the handler returns has no usable status code.
+     */
+    badGateway(): Response;
+    /**
+     * There was no target to send the request to.
+     *
+     * Real ELB answers this when a target group has no registered targets, or
+     * none of them is in service.
+     */
+    serviceUnavailable(): Response;
+    /**
+     * The request body is larger than a Lambda target takes.
+     */
+    payloadTooLarge(): Response;
+    private build;
+}
+//# sourceMappingURL=sim-elbv2-error-response.d.ts.map

package/dist/service/elbv2/serve/sim-elbv2-error-response.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-elbv2-error-response.d.ts","sourceRoot":"","sources":["../../../../src/service/elbv2/serve/sim-elbv2-error-response.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,qBAAa,qBAAqB;IAChC;;;;;;;OAOG;IACH,UAAU,IAAI,QAAQ,CAErB;IAED;;;;;OAKG;IACH,kBAAkB,IAAI,QAAQ,CAE7B;IAED;;OAEG;IACH,eAAe,IAAI,QAAQ,CAE1B;IAED,OAAO,CAAC,KAAK;CAad"}

package/dist/service/elbv2/serve/sim-elbv2-error-response.js

@@ -0,0 +1,47 @@
+/**
+ * The responses a load balancer generates itself, rather than getting from a
+ * target.
+ *
+ * Real ELB answers these with a short HTML page naming the status, which is
+ * what a browser shows when a target is missing or broken. The status code is
+ * the part worth asserting on: the page is reproduced so that a response looks
+ * like one a load balancer sent, not so that anything reads it.
+ */
+export class SimElbV2ErrorResponse {
+    /**
+     * The target could not be invoked, or answered with something that is not a
+     * response.
+     *
+     * This is what a Lambda target produces when the load balancer may not
+     * invoke it, when the function is not there, when the handler throws, and
+     * when what the handler returns has no usable status code.
+     */
+    badGateway() {
+        return this.build(502, "Bad Gateway");
+    }
+    /**
+     * There was no target to send the request to.
+     *
+     * Real ELB answers this when a target group has no registered targets, or
+     * none of them is in service.
+     */
+    serviceUnavailable() {
+        return this.build(503, "Service Unavailable");
+    }
+    /**
+     * The request body is larger than a Lambda target takes.
+     */
+    payloadTooLarge() {
+        return this.build(413, "Payload Too Large");
+    }
+    build(status, reason) {
+        const title = `${String(status)} ${reason}`;
+        return new Response(`<html>\n<head><title>${title}</title></head>\n` +
+            `<body>\n<center><h1>${title}</h1></center>\n</body>\n</html>\n`, {
+            status,
+            statusText: reason,
+            headers: { "content-type": "text/html" },
+        });
+    }
+}
+//# sourceMappingURL=sim-elbv2-error-response.js.map

package/dist/service/elbv2/serve/sim-elbv2-error-response.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-elbv2-error-response.js","sourceRoot":"","sources":["../../../../src/service/elbv2/serve/sim-elbv2-error-response.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,MAAM,OAAO,qBAAqB;IAChC;;;;;;;OAOG;IACH,UAAU;QACR,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,EAAE,aAAa,CAAC,CAAC;IACxC,CAAC;IAED;;;;;OAKG;IACH,kBAAkB;QAChB,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,EAAE,qBAAqB,CAAC,CAAC;IAChD,CAAC;IAED;;OAEG;IACH,eAAe;QACb,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,EAAE,mBAAmB,CAAC,CAAC;IAC9C,CAAC;IAEO,KAAK,CAAC,MAAc,EAAE,MAAc;QAC1C,MAAM,KAAK,GAAG,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,MAAM,EAAE,CAAC;QAE5C,OAAO,IAAI,QAAQ,CACjB,wBAAwB,KAAK,mBAAmB;YAC9C,uBAAuB,KAAK,oCAAoC,EAClE;YACE,MAAM;YACN,UAAU,EAAE,MAAM;YAClB,OAAO,EAAE,EAAE,cAAc,EAAE,WAAW,EAAE;SACzC,CACF,CAAC;IACJ,CAAC;CACF"}

package/dist/service/elbv2/serve/sim-elbv2-event-builder.d.ts

@@ -0,0 +1,40 @@
+import type { SimClock } from "../../../util/clock/sim-clock.js";
+import type { SimElbV2Event } from "./sim-elbv2-event.type.js";
+interface SimElbV2EventBuilderProperties {
+    /**
+     * Clock stamping the trace id, so a handler sees the same "now" as the rest
+     * of the simulation.
+     */
+    readonly clock: SimClock;
+}
+interface SimElbV2EventInput {
+    readonly request: Request;
+    /** The request body, already read, because its size is checked first. */
+    readonly bytes: Uint8Array;
+    /** The target group the listener forwarded to. */
+    readonly targetGroupArn: string;
+    /** The port the listener taking the request answers on. */
+    readonly port: number;
+    /** The protocol that listener speaks. */
+    readonly protocol: string;
+}
+/**
+ * Builds the event an Application Load Balancer passes to a Lambda target.
+ *
+ * Every field is always present, which is what tells this apart from the API
+ * Gateway payload formats: a request with no query string carries an empty
+ * `queryStringParameters` map rather than none, and one with no body carries an
+ * empty `body` rather than leaving the field out.
+ */
+export declare class SimElbV2EventBuilder {
+    private readonly bodyEncoding;
+    private readonly requestParts;
+    private readonly clock;
+    constructor(properties: SimElbV2EventBuilderProperties);
+    /**
+     * Build the invocation event for one request forwarded to a target group.
+     */
+    build(input: SimElbV2EventInput): SimElbV2Event;
+}
+export {};
+//# sourceMappingURL=sim-elbv2-event-builder.d.ts.map

package/dist/service/elbv2/serve/sim-elbv2-event-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-elbv2-event-builder.d.ts","sourceRoot":"","sources":["../../../../src/service/elbv2/serve/sim-elbv2-event-builder.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kCAAkC,CAAC;AAEjE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAG/D,UAAU,8BAA8B;IACtC;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC;CAC1B;AAED,UAAU,kBAAkB;IAC1B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,yEAAyE;IACzE,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;IAC3B,kDAAkD;IAClD,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,2DAA2D;IAC3D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,yCAAyC;IACzC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;;;GAOG;AACH,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,QAAQ,CAAC,YAAY,CAA8B;IAC3D,OAAO,CAAC,QAAQ,CAAC,YAAY,CAA8B;IAC3D,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAW;IAEjC,YAAY,UAAU,EAAE,8BAA8B,EAErD;IAED;;OAEG;IACH,KAAK,CAAC,KAAK,EAAE,kBAAkB,GAAG,aAAa,CAyB9C;CACF"}

package/dist/service/elbv2/serve/sim-elbv2-event-builder.js

@@ -0,0 +1,47 @@
+import { simAwsProxiedSourceIp, simAwsProxiedTraceId, } from "../../../serve/http/sim-aws-proxied-connection.js";
+import { SimElbV2BodyEncoding } from "./sim-elbv2-body-encoding.js";
+import { SimElbV2RequestParts } from "./sim-elbv2-request-parts.js";
+/**
+ * Builds the event an Application Load Balancer passes to a Lambda target.
+ *
+ * Every field is always present, which is what tells this apart from the API
+ * Gateway payload formats: a request with no query string carries an empty
+ * `queryStringParameters` map rather than none, and one with no body carries an
+ * empty `body` rather than leaving the field out.
+ */
+export class SimElbV2EventBuilder {
+    bodyEncoding = new SimElbV2BodyEncoding();
+    requestParts = new SimElbV2RequestParts();
+    clock;
+    constructor(properties) {
+        this.clock = properties.clock;
+    }
+    /**
+     * Build the invocation event for one request forwarded to a target group.
+     */
+    build(input) {
+        const { request, bytes } = input;
+        const url = new URL(request.url);
+        const contentType = request.headers.get("content-type");
+        const contentEncoding = request.headers.get("content-encoding");
+        return {
+            requestContext: { elb: { targetGroupArn: input.targetGroupArn } },
+            httpMethod: request.method,
+            path: url.pathname,
+            queryStringParameters: this.requestParts.queryStringParameters(url),
+            headers: this.requestParts.headers({
+                request,
+                port: input.port,
+                protocol: input.protocol,
+                traceId: simAwsProxiedTraceId(this.clock.now()),
+                sourceIp: simAwsProxiedSourceIp,
+            }),
+            body: this.bodyEncoding.encode(bytes, contentType, contentEncoding),
+            // An empty body is text rather than empty base64, which is what real ELB
+            // reports for a GET carrying nothing.
+            isBase64Encoded: bytes.length > 0 &&
+                !this.bodyEncoding.isText(contentType, contentEncoding),
+        };
+    }
+}
+//# sourceMappingURL=sim-elbv2-event-builder.js.map

package/dist/service/elbv2/serve/sim-elbv2-event-builder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-elbv2-event-builder.js","sourceRoot":"","sources":["../../../../src/service/elbv2/serve/sim-elbv2-event-builder.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,qBAAqB,EACrB,oBAAoB,GACrB,MAAM,mDAAmD,CAAC;AAE3D,OAAO,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AAEpE,OAAO,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AAsBpE;;;;;;;GAOG;AACH,MAAM,OAAO,oBAAoB;IACd,YAAY,GAAG,IAAI,oBAAoB,EAAE,CAAC;IAC1C,YAAY,GAAG,IAAI,oBAAoB,EAAE,CAAC;IAC1C,KAAK,CAAW;IAEjC,YAAY,UAA0C;QACpD,IAAI,CAAC,KAAK,GAAG,UAAU,CAAC,KAAK,CAAC;IAChC,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,KAAyB;QAC7B,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,GAAG,KAAK,CAAC;QACjC,MAAM,GAAG,GAAG,IAAI,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QACjC,MAAM,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC;QACxD,MAAM,eAAe,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAAC;QAEhE,OAAO;YACL,cAAc,EAAE,EAAE,GAAG,EAAE,EAAE,cAAc,EAAE,KAAK,CAAC,cAAc,EAAE,EAAE;YACjE,UAAU,EAAE,OAAO,CAAC,MAAM;YAC1B,IAAI,EAAE,GAAG,CAAC,QAAQ;YAClB,qBAAqB,EAAE,IAAI,CAAC,YAAY,CAAC,qBAAqB,CAAC,GAAG,CAAC;YACnE,OAAO,EAAE,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC;gBACjC,OAAO;gBACP,IAAI,EAAE,KAAK,CAAC,IAAI;gBAChB,QAAQ,EAAE,KAAK,CAAC,QAAQ;gBACxB,OAAO,EAAE,oBAAoB,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC;gBAC/C,QAAQ,EAAE,qBAAqB;aAChC,CAAC;YACF,IAAI,EAAE,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,KAAK,EAAE,WAAW,EAAE,eAAe,CAAC;YACnE,yEAAyE;YACzE,sCAAsC;YACtC,eAAe,EACb,KAAK,CAAC,MAAM,GAAG,CAAC;gBAChB,CAAC,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,WAAW,EAAE,eAAe,CAAC;SAC1D,CAAC;IACJ,CAAC;CACF"}

package/dist/service/elbv2/serve/sim-elbv2-event.type.d.ts

@@ -0,0 +1,45 @@
+/**
+ * What an ALB invocation event says about where the request came from.
+ *
+ * The `elb` block is the whole of it, and it carries the target group ARN
+ * rather than the load balancer's. That is what a handler reads to tell an ALB
+ * event apart from an API Gateway one, which has a `requestContext` of a
+ * completely different shape.
+ */
+export interface SimElbV2EventRequestContext {
+    readonly elb: {
+        readonly targetGroupArn: string;
+    };
+}
+/**
+ * The event an Application Load Balancer passes to a Lambda target.
+ *
+ * This is ALB's own shape rather than either API Gateway payload format:
+ * `httpMethod` and `path` rather than a `requestContext.http` block, headers
+ * and query string parameters as flat single-value maps, and a body that is
+ * always present even when it is empty.
+ */
+export interface SimElbV2Event {
+    readonly requestContext: SimElbV2EventRequestContext;
+    readonly httpMethod: string;
+    readonly path: string;
+    readonly queryStringParameters: Readonly<Record<string, string>>;
+    readonly headers: Readonly<Record<string, string>>;
+    readonly body: string;
+    readonly isBase64Encoded: boolean;
+}
+/**
+ * The response an Application Load Balancer accepts from a Lambda target.
+ *
+ * Only `statusCode` is load bearing. A result without a numeric one is not a
+ * response ALB can send, and the load balancer answers 502 rather than passing
+ * the handler's shape on to the client.
+ */
+export interface SimElbV2Result {
+    readonly statusCode?: number;
+    readonly statusDescription?: string;
+    readonly headers?: Readonly<Record<string, string>>;
+    readonly body?: string;
+    readonly isBase64Encoded?: boolean;
+}
+//# sourceMappingURL=sim-elbv2-event.type.d.ts.map

package/dist/service/elbv2/serve/sim-elbv2-event.type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-elbv2-event.type.d.ts","sourceRoot":"","sources":["../../../../src/service/elbv2/serve/sim-elbv2-event.type.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,GAAG,EAAE;QACZ,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;KACjC,CAAC;CACH;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,cAAc,EAAE,2BAA2B,CAAC;IACrD,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,qBAAqB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACjE,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACnD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAC;CACnC;AAED;;;;;;GAMG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,iBAAiB,CAAC,EAAE,MAAM,CAAC;IACpC,QAAQ,CAAC,OAAO,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACpD,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,eAAe,CAAC,EAAE,OAAO,CAAC;CACpC"}

package/dist/service/elbv2/serve/sim-elbv2-event.type.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=sim-elbv2-event.type.js.map

package/dist/service/elbv2/serve/sim-elbv2-event.type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-elbv2-event.type.js","sourceRoot":"","sources":["../../../../src/service/elbv2/serve/sim-elbv2-event.type.ts"],"names":[],"mappings":""}

package/dist/service/elbv2/serve/sim-elbv2-fetch.d.ts

@@ -0,0 +1,16 @@
+import type { SimAws } from "../../aws/sim-aws.js";
+/**
+ * Send an HTTP request to whichever simulated load balancer its host name
+ * names.
+ *
+ * This is the in-process way to reach a load balancer, taking the same
+ * arguments as `fetch`. The host name of the URL is the load balancer's DNS
+ * name and the port is the listener's, which is what a client writes on real
+ * AWS too. Nothing is sent over a socket.
+ *
+ * A host name no load balancer answers on, and a port no listener holds, both
+ * throw rather than answering: on real AWS neither reaches a load balancer at
+ * all, so there is no status for either.
+ */
+export declare function simElbV2Fetch(simAws: SimAws, input: Request | string, init?: RequestInit): Promise<Response>;
+//# sourceMappingURL=sim-elbv2-fetch.d.ts.map

package/dist/service/elbv2/serve/sim-elbv2-fetch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-elbv2-fetch.d.ts","sourceRoot":"","sources":["../../../../src/service/elbv2/serve/sim-elbv2-fetch.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAGnD;;;;;;;;;;;;GAYG;AACH,wBAAsB,aAAa,CACjC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,OAAO,GAAG,MAAM,EACvB,IAAI,CAAC,EAAE,WAAW,GACjB,OAAO,CAAC,QAAQ,CAAC,CAYnB"}