@kensio/yulin 1.21.27 → 1.21.29

package/dist/service/cloudformation/template/node/fn/join/sim-cfn-fn-join.js

@@ -1,4 +1,5 @@
 import { SimCfnNode } from "../../sim-cfn-node.js";
+import { isSimCfnUnresolvedExpression } from "../../../value/sim-cfn-unresolved-expression.js";
 /**
  * Simulated CloudFormation `Fn::Join` intrinsic function.
  *
@@ -7,6 +8,12 @@ import { SimCfnNode } from "../../sim-cfn-node.js";
  * {
  *   "Fn::Join": ["-", ["a", "b", { "Ref": "Name" }]]
  * }
+ *
+ * The values may also come from one function that returns the whole list:
+ *
+ * {
+ *   "Fn::Join": [",", { "Fn::GetAtt": ["Zone", "NameServers"] }]
+ * }
  */
 export class SimCfnFnJoin extends SimCfnNode {
     delimiter;
@@ -17,13 +24,13 @@ export class SimCfnFnJoin extends SimCfnNode {
         this.values = values;
     }
     /**
-     * Resolve each value and join them with the delimiter.
+     * Resolve the values and join them with the delimiter.
      *
-     * Joining happens only when every value has resolved to a string. If any
-     * value is still an unresolved expression (for example a Resource `Ref`
-     * during the up-front pass before Resources exist), this node re-emits
-     * itself in template form. A later resolution pass can finish it once the
-     * referenced Resources are available.
+     * Joining happens only when the values have resolved to a list of strings.
+     * If the list, or any value in it, is still an unresolved expression (for
+     * example a Resource `Ref` during the up-front pass before Resources exist),
+     * this node re-emits itself in template form. A later resolution pass can
+     * finish it once the referenced Resources are available.
      *
      * A dynamic reference can be assembled out of the joined values, as CDK
      * writes one whenever the secret it reads sits in the same Stack: the
@@ -33,37 +40,49 @@ export class SimCfnFnJoin extends SimCfnNode {
      * out of its variables.
      */
     resolve(context) {
-        const resolved = this.values.map((value) => this.resolveValue(value, context));
-        if (resolved.every((value) => typeof value === "string")) {
-            const joined = resolved.join(this.delimiter);
+        const values = this.values.resolve(context);
+        if (isSimCfnUnresolvedExpression(values)) {
+            return { "Fn::Join": [this.delimiter, values] };
+        }
+        if (!Array.isArray(values)) {
+            throw new TypeError(`Sim CloudFormation Fn::Join values must resolve to a list, got ${describe(values)}`);
+        }
+        for (const value of values) {
+            this.assertJoinable(value);
+        }
+        if (values.every((value) => typeof value === "string")) {
+            const joined = values.join(this.delimiter);
             return context.dynamicReferences?.substitute(joined) ?? joined;
         }
-        return { "Fn::Join": [this.delimiter, resolved] };
+        return { "Fn::Join": [this.delimiter, values] };
     }
     /**
-     * Collect referenced names from every joined value.
+     * Collect referenced names from the values.
      */
     referencedNames() {
-        return this.values.flatMap((value) => value.referencedNames());
-    }
-    resolveValue(value, context) {
-        const resolved = value.resolve(context);
-        if (typeof resolved === "string") {
-            return resolved;
-        }
-        if (this.isDeferredExpression(resolved)) {
-            return resolved;
-        }
-        throw new TypeError(`Sim CloudFormation Fn::Join values must each resolve to a string, got ${typeof resolved}`);
+        return this.values.referencedNames();
     }
     /**
-     * Whether a resolved value is still an unresolved intrinsic expression.
+     * Refuse a value that can never become a string.
      *
-     * Only object-shaped values (a preserved `Ref` or nested function object)
-     * are treated as deferred. Other non-string primitives such as numbers are
-     * genuine type errors.
+     * A string joins now, and an unresolved expression may join on a later
+     * pass. Anything else (a number, a nested list, a plain object) is a type
+     * error, as CloudFormation joins a list of strings only.
      */
-    isDeferredExpression(value) {
-        return typeof value === "object" && value !== null;
+    assertJoinable(value) {
+        if (typeof value === "string" || isSimCfnUnresolvedExpression(value)) {
+            return;
+        }
+        throw new TypeError(`Sim CloudFormation Fn::Join values must each resolve to a string, got ${describe(value)}`);
+    }
+}
+/**
+ * Name a resolved value's type for an error message, telling a list and a
+ * null apart from an object.
+ */
+function describe(value) {
+    if (Array.isArray(value)) {
+        return "list";
     }
+    return value === null ? "null" : typeof value;
 }

package/dist/service/cloudformation/template/parse/fn/join/sim-cfn-fn-join-parser.d.ts

@@ -10,10 +10,13 @@ import type { SimCfnValueParser } from "../../value/sim-cfn-value-parser.type.js
  *   "Fn::Join": ["-", ["a", { "Ref": "Name" }]]
  * }
  *
- * The parser validates only the Fn::Join envelope: a string delimiter and an
- * array of values. Each joined value is parsed through the recursive value
- * parser, because join entries may themselves be literals, Refs, other
- * intrinsic functions, arrays, or plain objects.
+ * The values argument goes through the recursive value parser. It may be a
+ * literal list, whose entries may themselves be literals, Refs or other
+ * intrinsic functions, or a function that returns a whole list (such as
+ * `Fn::GetAtt` on a hosted zone's `NameServers`, or `Fn::Split`). Whether it
+ * resolves to a list of strings is a resolution-time question, so it belongs
+ * to the node. A string, number or boolean in its place can never become a
+ * list, and is refused here.
  */
 export declare class SimCfnFnJoinParser {
     private readonly valueParser;

package/dist/service/cloudformation/template/parse/fn/join/sim-cfn-fn-join-parser.js

@@ -8,10 +8,13 @@ import { SimCfnFnJoin as SimCfnFunctionJoin } from "../../../node/fn/join/sim-cf
  *   "Fn::Join": ["-", ["a", { "Ref": "Name" }]]
  * }
  *
- * The parser validates only the Fn::Join envelope: a string delimiter and an
- * array of values. Each joined value is parsed through the recursive value
- * parser, because join entries may themselves be literals, Refs, other
- * intrinsic functions, arrays, or plain objects.
+ * The values argument goes through the recursive value parser. It may be a
+ * literal list, whose entries may themselves be literals, Refs or other
+ * intrinsic functions, or a function that returns a whole list (such as
+ * `Fn::GetAtt` on a hosted zone's `NameServers`, or `Fn::Split`). Whether it
+ * resolves to a list of strings is a resolution-time question, so it belongs
+ * to the node. A string, number or boolean in its place can never become a
+ * list, and is refused here.
  */
 export class SimCfnFnJoinParser {
     valueParser;
@@ -29,9 +32,10 @@ export class SimCfnFnJoinParser {
         if (typeof delimiter !== "string") {
             throw new TypeError("Sim CloudFormation Fn::Join delimiter must be a string");
         }
-        if (!Array.isArray(values)) {
-            throw new TypeError("Sim CloudFormation Fn::Join values must be an array");
+        if (typeof values !== "object" || values === null) {
+            throw new TypeError("Sim CloudFormation Fn::Join values must be a list or a function " +
+                "that returns one");
         }
-        return new SimCfnFunctionJoin(delimiter, values.map((item) => this.valueParser.parse(item)));
+        return new SimCfnFunctionJoin(delimiter, this.valueParser.parse(values));
     }
 }

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

@@ -42,8 +42,8 @@ export declare class SimSdkLambdaVmModuleProvider implements SimLambdaVmSdkModul
     private readonly providedModules;
     constructor(properties: SimSdkLambdaVmModuleProviderProperties);
     /**
-     * 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: string): unknown;
     /**

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 {};