@kensio/yulin 1.21.28 → 1.21.30

package/dist/service/lambda/function/code/vm/sdk/sim-sdk-lambda-vm-module-provider.js

@@ -1,7 +1,7 @@
 import { SimSdkModuleClientInterceptor } from "../../../../../../sdk/module/sim-sdk-module-client-interceptor.js";
 import { SimSdkCommandDispatcher } from "../../../../../../sdk/sim-sdk-command-dispatcher.js";
 import { SimLambdaAwsApiOutbound } from "../../../outbound/sim-lambda-aws-api-outbound.js";
-import { isSimLambdaHttpModuleSpecifier, makeSimLambdaHttpModule, simLambdaHttpModuleScheme, } from "../../../outbound/sim-lambda-http-module.js";
+import { isSimLambdaTransportModuleSpecifier, makeSimLambdaTransportModule, } from "../../../outbound/sim-lambda-transport-module.js";
 import { isModuleNotFoundError, requireHostModule, } from "../sim-lambda-host-modules.js";
 import { SimLambdaSdkPackagesNotInstalledError } from "./sim-lambda-sdk-packages-not-installed.error.js";
 import { awsSdkPackagePrefix, } from "./sim-lambda-vm-sdk-module-provider.js";
@@ -37,11 +37,11 @@ export class SimSdkLambdaVmModuleProvider {
         this.requireModule = properties.requireModule ?? requireHostModule;
     }
     /**
-     * Provide an intercepted AWS SDK package or HTTP transport module, or
-     * undefined for other specifiers.
+     * Provide an intercepted AWS SDK package or HTTP or HTTP/2 transport
+     * module, or undefined for other specifiers.
      */
     provideModule(specifier) {
-        const isTransport = isSimLambdaHttpModuleSpecifier(specifier);
+        const isTransport = isSimLambdaTransportModuleSpecifier(specifier);
         if (!isTransport && !specifier.startsWith(awsSdkPackagePrefix)) {
             return undefined;
         }
@@ -51,11 +51,7 @@ export class SimSdkLambdaVmModuleProvider {
         }
         const hostExports = this.hostModuleExports(specifier);
         const module = isTransport
-            ? makeSimLambdaHttpModule({
-                hostModule: hostExports,
-                outbound: this.outboundHttp,
-                scheme: simLambdaHttpModuleScheme(specifier),
-            })
+            ? makeSimLambdaTransportModule(specifier, hostExports, this.outboundHttp)
             : this.interceptor.interceptModule(hostExports);
         this.providedModules.set(specifier, module);
         return module;

package/dist/service/lambda/function/code/vm/sim-lambda-vm-context.d.ts

@@ -29,7 +29,7 @@ export interface SimLambdaVmContextProperties {
 /**
  * Create the sandbox vm context that sim Lambda function code runs in.
  *
- * The context provides the common globals a Node.js Lambda runtime offers,
+ * The context provides the globals a Node.js Lambda runtime offers,
  * including an AWS-like process.env holding the standard runtime variables
  * and any variables declared for the function, and the writable standard
  * streams function code writes its output to. Everything else must be part

package/dist/service/lambda/function/code/vm/sim-lambda-vm-context.js

@@ -6,11 +6,12 @@ import { simLambdaNoOutputSink, } from "../../logging/sim-lambda-output-sink.js"
 import { makeSimLambdaOutboundFetch } from "../../outbound/sim-lambda-outbound-fetch.js";
 import { simLambdaClearInterval, simLambdaClearTimeout, } from "../../invoke/timer/sim-lambda-clear-timer.js";
 import { simLambdaSetInterval, simLambdaSetTimeout, } from "../../invoke/timer/sim-lambda-process-timers.js";
+import { simLambdaVmHostGlobals } from "./sim-lambda-vm-host-globals.js";
 import { SimLambdaVmOutputStream } from "./sim-lambda-vm-output-stream.js";
 /**
  * Create the sandbox vm context that sim Lambda function code runs in.
  *
- * The context provides the common globals a Node.js Lambda runtime offers,
+ * The context provides the globals a Node.js Lambda runtime offers,
  * including an AWS-like process.env holding the standard runtime variables
  * and any variables declared for the function, and the writable standard
  * streams function code writes its output to. Everything else must be part
@@ -33,12 +34,12 @@ export function makeSimLambdaVmContext(properties) {
     // What function code writes reaches the function's log group through here.
     stdout.recordTo(sink);
     stderr.recordTo(sink);
-    return vm.createContext({
+    const context = vm.createContext({
+        ...simLambdaVmHostGlobals(),
         // The sandbox's console is built over those streams, as the real
         // runtime's is, so everything function code prints goes to one place
         // whether it printed through the console or wrote to the stream itself.
         console: new Console({ stdout, stderr }),
-        Buffer,
         process: {
             env: environment.variables(),
             stdout,
@@ -55,25 +56,13 @@ export function makeSimLambdaVmContext(properties) {
         clearTimeout: simLambdaClearTimeout,
         setInterval: simLambdaSetInterval,
         clearInterval: simLambdaClearInterval,
-        setImmediate,
-        queueMicrotask,
-        TextEncoder,
-        TextDecoder,
-        URL,
-        URLSearchParams,
-        structuredClone,
-        crypto,
-        // The Fetch API the Node.js runtime provides, with the client itself
-        // routed into the simulation. The rest are the host's own, so the objects
-        // a handler builds and the ones the simulation answers with are the same
-        // kind of thing.
+        // The Fetch API client, routed into the simulation. The types it works
+        // with are the host's own.
         fetch: makeSimLambdaOutboundFetch(outboundHttp),
-        Headers,
-        Request,
-        Response,
-        FormData,
-        Blob,
-        AbortController,
-        AbortSignal,
     });
+    // Node.js names its global object `global` as well as `globalThis`, and
+    // bundlers emit references to it for older packages. It has to be the
+    // sandbox's own global, which only exists once the context does.
+    vm.runInContext("globalThis.global = globalThis;", context);
+    return context;
 }

package/dist/service/lambda/function/code/vm/sim-lambda-vm-host-globals.d.ts

@@ -0,0 +1,4 @@
+/**
+ * The host's own value for each global the sandbox passes through.
+ */
+export declare function simLambdaVmHostGlobals(): Record<string, unknown>;

package/dist/service/lambda/function/code/vm/sim-lambda-vm-host-globals.js

@@ -0,0 +1,87 @@
+/**
+ * The globals the Node.js runtime provides that the sandbox passes through
+ * from the host as they are.
+ *
+ * Anything here is the host's own object, so what function code builds with
+ * one and what the simulation answers with are the same kind of thing. The
+ * globals the sandbox replaces (the console, `process`, `Date`, the timers
+ * and `fetch`) are built in `makeSimLambdaVmContext` instead.
+ */
+const simLambdaVmHostGlobalNames = [
+    "Buffer",
+    "setImmediate",
+    // The host's, since the sandbox's `setImmediate` is the host's too.
+    "clearImmediate",
+    "queueMicrotask",
+    "structuredClone",
+    "atob",
+    "btoa",
+    "TextEncoder",
+    "TextDecoder",
+    "URL",
+    "URLSearchParams",
+    "URLPattern",
+    "DOMException",
+    // The Fetch API types. The client itself is the sandbox's own.
+    "Headers",
+    "Request",
+    "Response",
+    "FormData",
+    "Blob",
+    "File",
+    "AbortController",
+    "AbortSignal",
+    // WHATWG streams, which bundled SDK clients build their event streams on.
+    "ReadableStream",
+    "ReadableStreamDefaultReader",
+    "ReadableStreamBYOBReader",
+    "ReadableStreamBYOBRequest",
+    "ReadableByteStreamController",
+    "ReadableStreamDefaultController",
+    "WritableStream",
+    "WritableStreamDefaultController",
+    "WritableStreamDefaultWriter",
+    "TransformStream",
+    "TransformStreamDefaultController",
+    "ByteLengthQueuingStrategy",
+    "CountQueuingStrategy",
+    "TextEncoderStream",
+    "TextDecoderStream",
+    "CompressionStream",
+    "DecompressionStream",
+    // Events and messaging.
+    "Event",
+    "EventTarget",
+    "CustomEvent",
+    "MessageEvent",
+    "CloseEvent",
+    "MessageChannel",
+    "MessagePort",
+    "BroadcastChannel",
+    "WebSocket",
+    // Web Crypto.
+    "crypto",
+    "Crypto",
+    "CryptoKey",
+    "SubtleCrypto",
+    // Performance reads host time, while `Date` reads the simulated clock.
+    "performance",
+    "Performance",
+    "PerformanceEntry",
+    "PerformanceMark",
+    "PerformanceMeasure",
+    "PerformanceObserver",
+    "PerformanceObserverEntryList",
+    "PerformanceResourceTiming",
+    "navigator",
+    "Navigator",
+];
+/**
+ * The host's own value for each global the sandbox passes through.
+ */
+export function simLambdaVmHostGlobals() {
+    return Object.fromEntries(simLambdaVmHostGlobalNames.map((name) => [
+        name,
+        Reflect.get(globalThis, name),
+    ]));
+}

package/dist/service/lambda/function/invoke/sim-lambda-outbound-clients.d.ts

@@ -12,5 +12,8 @@ import type { SimLambdaOutboundHttp } from "../outbound/sim-lambda-outbound-http
  * modules export as it was. The built-in modules' named ES module exports are
  * a snapshot of those properties, so they are re-synchronised afterwards for
  * the handler that imported `request` by name rather than the module.
+ *
+ * `node:http2` has `connect` replaced the same way. Bedrock Runtime's SDK
+ * client sends over HTTP/2.
  */
 export declare function installSimLambdaOutboundClients(outbound: SimLambdaOutboundHttp): void;

package/dist/service/lambda/function/invoke/sim-lambda-outbound-clients.js

@@ -1,7 +1,9 @@
 import http from "node:http";
+import http2 from "node:http2";
 import https from "node:https";
 import { syncBuiltinESMExports } from "node:module";
 import { makeSimLambdaHttpModule } from "../outbound/sim-lambda-http-module.js";
+import { makeSimLambdaHttp2Module } from "../outbound/sim-lambda-http2-module.js";
 import { makeSimLambdaOutboundFetch } from "../outbound/sim-lambda-outbound-fetch.js";
 /**
  * The transport modules an in-process handler makes requests through, with the
@@ -24,6 +26,9 @@ const transportModules = [
  * modules export as it was. The built-in modules' named ES module exports are
  * a snapshot of those properties, so they are re-synchronised afterwards for
  * the handler that imported `request` by name rather than the module.
+ *
+ * `node:http2` has `connect` replaced the same way. Bedrock Runtime's SDK
+ * client sends over HTTP/2.
  */
 export function installSimLambdaOutboundClients(outbound) {
     const hostFetch = globalThis.fetch;
@@ -38,5 +43,10 @@ export function installSimLambdaOutboundClients(outbound) {
         patched["request"] = routed["request"];
         patched["get"] = routed["get"];
     }
+    const http2Module = http2;
+    http2Module["connect"] = makeSimLambdaHttp2Module({
+        hostModule: http2Module,
+        outbound,
+    })["connect"];
     syncBuiltinESMExports();
 }

package/dist/service/lambda/function/outbound/sim-lambda-http2-exchanges.d.ts

@@ -0,0 +1,32 @@
+import { AsyncResource } from "node:async_hooks";
+import type http2 from "node:http2";
+/**
+ * A request sent on a simulated session, waiting for its answer.
+ */
+export interface SimLambdaHttp2Exchange {
+    readonly stream: http2.ClientHttp2Stream;
+    /**
+     * The asynchronous context the request was sent from. A pooled session
+     * outlives the invocation that opened it, and each request on it belongs to
+     * whichever invocation sent it.
+     */
+    readonly scope: AsyncResource;
+}
+/**
+ * The requests in flight on one simulated session, each joined to the
+ * asynchronous context it was sent from.
+ */
+export declare class SimLambdaHttp2Exchanges {
+    private readonly exchanges;
+    /**
+     * Tag each request the session sends with the context it was sent from.
+     */
+    track(session: http2.ClientHttp2Session): void;
+    /**
+     * The exchange a request arriving at the session's server belongs to.
+     *
+     * Every request on the session's client is tagged by `track`, and nothing
+     * else can reach its server.
+     */
+    exchangeFor(request: http2.Http2ServerRequest): SimLambdaHttp2Exchange;
+}

package/dist/service/lambda/function/outbound/sim-lambda-http2-exchanges.js

@@ -0,0 +1,39 @@
+import { AsyncResource } from "node:async_hooks";
+import { randomUUID } from "node:crypto";
+import { assertDefined } from "../../../../util/type-guard/defined.js";
+import { simLambdaHttp2ExchangeHeaderName, simLambdaHttp2ExchangeId, } from "./sim-lambda-http2-messages.js";
+/**
+ * The requests in flight on one simulated session, each joined to the
+ * asynchronous context it was sent from.
+ */
+export class SimLambdaHttp2Exchanges {
+    exchanges = new Map();
+    /**
+     * Tag each request the session sends with the context it was sent from.
+     */
+    track(session) {
+        const hostRequest = session.request.bind(session);
+        const request = (headers, options) => {
+            const exchangeId = randomUUID();
+            const stream = hostRequest({ ...headers, [simLambdaHttp2ExchangeHeaderName]: exchangeId }, options);
+            this.exchanges.set(exchangeId, {
+                stream,
+                scope: new AsyncResource("SimLambdaHttp2Request"),
+            });
+            stream.once("close", () => this.exchanges.delete(exchangeId));
+            return stream;
+        };
+        Object.assign(session, { request });
+    }
+    /**
+     * The exchange a request arriving at the session's server belongs to.
+     *
+     * Every request on the session's client is tagged by `track`, and nothing
+     * else can reach its server.
+     */
+    exchangeFor(request) {
+        const exchange = this.exchanges.get(simLambdaHttp2ExchangeId(request));
+        assertDefined(exchange, "sim Lambda HTTP/2 exchange for a request");
+        return exchange;
+    }
+}

package/dist/service/lambda/function/outbound/sim-lambda-http2-messages.d.ts

@@ -0,0 +1,33 @@
+import type http2 from "node:http2";
+import type { SimLambdaOutboundHttp } from "./sim-lambda-outbound-http.js";
+/**
+ * The header a request sent on a simulated session carries to say which
+ * request it is, so the answer runs in the asynchronous context the request
+ * was sent from. The simulation never sees it.
+ */
+export declare const simLambdaHttp2ExchangeHeaderName = "x-yulin-sim-lambda-exchange";
+/**
+ * The headers of a simulated answer that HTTP/2 can carry.
+ */
+export declare function simLambdaHttp2ResponseHeaders(headers: Headers): Record<string, string>;
+/**
+ * The request a stream carried, as the request the simulation is asked to
+ * answer, at the authority the session was connected to.
+ *
+ * A pooled session outlives the invocation that opened it. A request sent on
+ * it once no invocation is running has nothing to answer it, and is refused
+ * saying so.
+ */
+export declare function simLambdaHttp2Request(authority: URL, outbound: SimLambdaOutboundHttp, request: http2.Http2ServerRequest): Promise<Request>;
+/**
+ * The exchange tag a request on a simulated session carries.
+ */
+export declare function simLambdaHttp2ExchangeId(request: http2.Http2ServerRequest): string;
+/**
+ * The options and listener a `connect` call passed after the authority. The
+ * listener comes back as a list of none or one, to pass on as it came.
+ */
+export declare function simLambdaHttp2ConnectArguments(callArguments: readonly unknown[]): {
+    readonly options: object | undefined;
+    readonly listener: unknown[];
+};

package/dist/service/lambda/function/outbound/sim-lambda-http2-messages.js

@@ -0,0 +1,87 @@
+/**
+ * The header a request sent on a simulated session carries to say which
+ * request it is, so the answer runs in the asynchronous context the request
+ * was sent from. The simulation never sees it.
+ */
+export const simLambdaHttp2ExchangeHeaderName = "x-yulin-sim-lambda-exchange";
+/**
+ * The response headers HTTP/2 forbids, which a simulated answer may still
+ * carry from an HTTP/1.1 shape.
+ */
+const connectionHeaderNames = new Set([
+    "connection",
+    "keep-alive",
+    "proxy-connection",
+    "transfer-encoding",
+    "upgrade",
+]);
+/**
+ * The headers of a request, less the HTTP/2 pseudo-headers and the exchange
+ * tag.
+ */
+function requestHeaders(headers) {
+    return Object.fromEntries(Object.entries(headers).flatMap(([name, value]) => value === undefined ||
+        name === simLambdaHttp2ExchangeHeaderName ||
+        name.startsWith(":")
+        ? []
+        : [[name, Array.isArray(value) ? value.join(", ") : value]]));
+}
+/**
+ * The headers of a simulated answer that HTTP/2 can carry.
+ */
+export function simLambdaHttp2ResponseHeaders(headers) {
+    return Object.fromEntries([...headers].filter(([name]) => !connectionHeaderNames.has(name)));
+}
+/**
+ * The request a stream carried, as the request the simulation is asked to
+ * answer, at the authority the session was connected to.
+ *
+ * A pooled session outlives the invocation that opened it. A request sent on
+ * it once no invocation is running has nothing to answer it, and is refused
+ * saying so.
+ */
+export async function simLambdaHttp2Request(authority, outbound, request) {
+    const { hostname, host, protocol } = authority;
+    if (!outbound.serves(hostname)) {
+        throw sessionEndedError(hostname);
+    }
+    const chunks = [];
+    for await (const chunk of request) {
+        chunks.push(chunk);
+    }
+    const body = Buffer.concat(chunks);
+    return new Request(`${protocol}//${host}${request.url}`, {
+        method: request.method,
+        headers: requestHeaders(request.headers),
+        ...(body.length > 0 && { body }),
+    });
+}
+/**
+ * The exchange tag a request on a simulated session carries.
+ */
+export function simLambdaHttp2ExchangeId(request) {
+    // oxlint-disable-next-line security/detect-object-injection -- this module's own fixed header name.
+    return String(request.headers[simLambdaHttp2ExchangeHeaderName]);
+}
+/**
+ * The options and listener a `connect` call passed after the authority. The
+ * listener comes back as a list of none or one, to pass on as it came.
+ */
+export function simLambdaHttp2ConnectArguments(callArguments) {
+    const [, second, third] = callArguments;
+    const listener = typeof second === "function" ? second : third;
+    return {
+        options: typeof second === "object" ? (second ?? undefined) : undefined,
+        listener: listener === undefined ? [] : [listener],
+    };
+}
+/**
+ * Refuse a request on a session a sim Lambda invocation opened, sent once no
+ * invocation is running to answer it.
+ */
+function sessionEndedError(hostname) {
+    return new Error(`Cannot send a request to ${hostname} on an HTTP/2 session a sim ` +
+        "Lambda invocation opened, once no invocation is running. Create " +
+        "the SDK client inside the handler, or send this call from a " +
+        "handler invocation.");
+}

package/dist/service/lambda/function/outbound/sim-lambda-http2-module.d.ts

@@ -0,0 +1,27 @@
+import type { SimLambdaOutboundHttp } from "./sim-lambda-outbound-http.js";
+/**
+ * A `node:http2` module, as far as this needs to know.
+ */
+type NodeHttp2Module = Record<string, unknown>;
+/**
+ * Whether a module specifier names the HTTP/2 module.
+ */
+export declare function isSimLambdaHttp2ModuleSpecifier(specifier: string): boolean;
+interface SimLambdaHttp2ModuleProperties {
+    readonly hostModule: NodeHttp2Module;
+    readonly outbound: SimLambdaOutboundHttp;
+}
+/**
+ * Build the `node:http2` module sim Lambda function code connects through.
+ *
+ * Everything the real module exports is kept, and only `connect` is
+ * replaced. A session to a hostname the simulation serves is a real HTTP/2
+ * session, connected over an in-memory socket pair to a server in this
+ * process that hands each request to the simulation. Every other session is
+ * the host module's, connected exactly as it was asked for.
+ *
+ * Bedrock Runtime's SDK client sends over HTTP/2, so this is where its calls
+ * from function code reach simulated Bedrock.
+ */
+export declare function makeSimLambdaHttp2Module(properties: SimLambdaHttp2ModuleProperties): NodeHttp2Module;
+export {};

package/dist/service/lambda/function/outbound/sim-lambda-http2-module.js

@@ -0,0 +1,53 @@
+import { SimLambdaHttp2Session, } from "./sim-lambda-http2-session.js";
+/**
+ * The specifiers a bundler and a hand-written require may ask for the
+ * HTTP/2 module by.
+ */
+const http2ModuleSpecifiers = new Set([
+    "http2",
+    "node:http2",
+]);
+/**
+ * Whether a module specifier names the HTTP/2 module.
+ */
+export function isSimLambdaHttp2ModuleSpecifier(specifier) {
+    return http2ModuleSpecifiers.has(specifier);
+}
+/**
+ * Build the `node:http2` module sim Lambda function code connects through.
+ *
+ * Everything the real module exports is kept, and only `connect` is
+ * replaced. A session to a hostname the simulation serves is a real HTTP/2
+ * session, connected over an in-memory socket pair to a server in this
+ * process that hands each request to the simulation. Every other session is
+ * the host module's, connected exactly as it was asked for.
+ *
+ * Bedrock Runtime's SDK client sends over HTTP/2, so this is where its calls
+ * from function code reach simulated Bedrock.
+ */
+export function makeSimLambdaHttp2Module(properties) {
+    const { hostModule, outbound } = properties;
+    const hostConnect = hostModule["connect"];
+    return {
+        ...hostModule,
+        connect: (...callArguments) => {
+            const authority = authorityUrl(callArguments[0]);
+            if (authority === undefined || !outbound.serves(authority.hostname)) {
+                return hostConnect(...callArguments);
+            }
+            return new SimLambdaHttp2Session(authority, outbound).connect(hostConnect, callArguments);
+        },
+    };
+}
+/**
+ * The URL `connect` was asked for, as a string or a URL, or undefined for
+ * anything that is not one.
+ */
+function authorityUrl(authority) {
+    if (authority instanceof URL) {
+        return authority;
+    }
+    return typeof authority === "string" && URL.canParse(authority)
+        ? new URL(authority)
+        : undefined;
+}

package/dist/service/lambda/function/outbound/sim-lambda-http2-session.d.ts

@@ -0,0 +1,31 @@
+import http2 from "node:http2";
+import type { SimLambdaOutboundHttp } from "./sim-lambda-outbound-http.js";
+/**
+ * The host module's `connect`.
+ */
+export type SimLambdaHttp2Connect = (...callArguments: unknown[]) => http2.ClientHttp2Session;
+/**
+ * One HTTP/2 session the simulation answers.
+ */
+export declare class SimLambdaHttp2Session {
+    private readonly authority;
+    private readonly outbound;
+    private readonly exchanges;
+    constructor(authority: URL, outbound: SimLambdaOutboundHttp);
+    /**
+     * Connect the host module's client to an in-process server.
+     *
+     * The host client does all the HTTP/2 work, so streams, flow control,
+     * timeouts and resets behave as they do over a network socket. Only the
+     * socket it runs over is supplied.
+     */
+    connect(hostConnect: SimLambdaHttp2Connect, callArguments: readonly unknown[]): http2.ClientHttp2Session;
+    private answer;
+    /**
+     * Answer one request from the simulation.
+     *
+     * A request the simulation cannot answer fails the client's stream with the
+     * error that explains it, which is what the SDK rejects the call with.
+     */
+    private respond;
+}

package/dist/service/lambda/function/outbound/sim-lambda-http2-session.js

@@ -0,0 +1,57 @@
+import http2 from "node:http2";
+import { duplexPair } from "node:stream";
+import { simLambdaHttp2ConnectArguments, simLambdaHttp2Request, simLambdaHttp2ResponseHeaders, } from "./sim-lambda-http2-messages.js";
+import { SimLambdaHttp2Exchanges } from "./sim-lambda-http2-exchanges.js";
+/**
+ * One HTTP/2 session the simulation answers.
+ */
+export class SimLambdaHttp2Session {
+    authority;
+    outbound;
+    exchanges = new SimLambdaHttp2Exchanges();
+    constructor(authority, outbound) {
+        this.authority = authority;
+        this.outbound = outbound;
+    }
+    /**
+     * Connect the host module's client to an in-process server.
+     *
+     * The host client does all the HTTP/2 work, so streams, flow control,
+     * timeouts and resets behave as they do over a network socket. Only the
+     * socket it runs over is supplied.
+     */
+    connect(hostConnect, callArguments) {
+        const { options, listener } = simLambdaHttp2ConnectArguments(callArguments);
+        const server = http2.createServer((request, response) => {
+            this.answer(request, response);
+        });
+        const [clientSocket, serverSocket] = duplexPair();
+        server.emit("connection", serverSocket);
+        const session = hostConnect(this.authority, { ...options, createConnection: () => clientSocket }, ...listener);
+        this.exchanges.track(session);
+        return session;
+    }
+    answer(request, response) {
+        const exchange = this.exchanges.exchangeFor(request);
+        exchange.scope.runInAsyncScope(() => {
+            void this.respond(request, response, exchange.stream);
+        });
+    }
+    /**
+     * Answer one request from the simulation.
+     *
+     * A request the simulation cannot answer fails the client's stream with the
+     * error that explains it, which is what the SDK rejects the call with.
+     */
+    async respond(request, response, clientStream) {
+        try {
+            const answered = await this.outbound.fetch(await simLambdaHttp2Request(this.authority, this.outbound, request));
+            const body = Buffer.from(await answered.arrayBuffer());
+            response.writeHead(answered.status, simLambdaHttp2ResponseHeaders(answered.headers));
+            response.end(body);
+        }
+        catch (error) {
+            clientStream.destroy(error);
+        }
+    }
+}

package/dist/service/lambda/function/outbound/sim-lambda-transport-module.d.ts

@@ -0,0 +1,11 @@
+import type { SimLambdaOutboundHttp } from "./sim-lambda-outbound-http.js";
+/**
+ * Whether a module specifier names one of the transport modules function code
+ * makes requests through: `node:http`, `node:https` or `node:http2`.
+ */
+export declare function isSimLambdaTransportModuleSpecifier(specifier: string): boolean;
+/**
+ * The transport module a specifier names, with its requests to the hostnames
+ * the simulation serves answered by the simulation.
+ */
+export declare function makeSimLambdaTransportModule(specifier: string, hostModule: Record<string, unknown>, outbound: SimLambdaOutboundHttp): Record<string, unknown>;

package/dist/service/lambda/function/outbound/sim-lambda-transport-module.js

@@ -0,0 +1,24 @@
+import { isSimLambdaHttpModuleSpecifier, makeSimLambdaHttpModule, simLambdaHttpModuleScheme, } from "./sim-lambda-http-module.js";
+import { isSimLambdaHttp2ModuleSpecifier, makeSimLambdaHttp2Module, } from "./sim-lambda-http2-module.js";
+/**
+ * Whether a module specifier names one of the transport modules function code
+ * makes requests through: `node:http`, `node:https` or `node:http2`.
+ */
+export function isSimLambdaTransportModuleSpecifier(specifier) {
+    return (isSimLambdaHttpModuleSpecifier(specifier) ||
+        isSimLambdaHttp2ModuleSpecifier(specifier));
+}
+/**
+ * The transport module a specifier names, with its requests to the hostnames
+ * the simulation serves answered by the simulation.
+ */
+export function makeSimLambdaTransportModule(specifier, hostModule, outbound) {
+    if (isSimLambdaHttp2ModuleSpecifier(specifier)) {
+        return makeSimLambdaHttp2Module({ hostModule, outbound });
+    }
+    return makeSimLambdaHttpModule({
+        hostModule,
+        outbound,
+        scheme: simLambdaHttpModuleScheme(specifier),
+    });
+}