@fluojs/http 2.0.1 → 3.0.0

package/dist/connection.js

@@ -0,0 +1,480 @@
+/**
+ * Function that decides whether one proxy hop is trusted.
+ *
+ * @param address Proxy address being considered, starting with the direct transport peer.
+ * @param index Zero-based distance from the direct transport peer.
+ * @returns Whether the proxy hop may supply forwarding metadata.
+ */
+
+/**
+ * Explicit policy that permits forwarding metadata from known proxy hops.
+ *
+ * `false` disables proxy trust, a number trusts that many nearest hops, an
+ * address/CIDR list matches nearest hops, and a predicate receives each hop
+ * from nearest to furthest.
+ */
+
+/**
+ * Options used to derive a trusted connection snapshot.
+ */
+
+/**
+ * Immutable, runtime-neutral view of the connection identity selected for a request.
+ */
+
+function readHeader(headers, name) {
+  const values = [];
+  let present = false;
+  for (const [key, value] of Object.entries(headers)) {
+    if (key.toLowerCase() !== name) {
+      continue;
+    }
+    present = true;
+    if (typeof value === 'string') {
+      values.push(value);
+    } else if (Array.isArray(value)) {
+      values.push(...value);
+    }
+  }
+  const joined = values.join(',').trim();
+  return {
+    present,
+    value: joined || undefined
+  };
+}
+function normalizeAddress(value) {
+  if (!value) {
+    return undefined;
+  }
+  const trimmed = value.trim();
+  if (!trimmed || trimmed.toLowerCase() === 'unknown' || trimmed.startsWith('_')) {
+    return undefined;
+  }
+  let address = trimmed;
+  if (trimmed.startsWith('[')) {
+    const bracketed = trimmed.match(/^\[([^\]]+)\](?::(\d+))?$/);
+    if (!bracketed) {
+      return undefined;
+    }
+    if (bracketed[2] !== undefined && !isValidPort(bracketed[2])) {
+      return undefined;
+    }
+    address = bracketed[1];
+  } else {
+    const ipv4WithPort = trimmed.match(/^((?:\d{1,3}\.){3}\d{1,3}):(\d+)$/);
+    if (ipv4WithPort) {
+      if (!isValidPort(ipv4WithPort[2])) {
+        return undefined;
+      }
+      address = ipv4WithPort[1];
+    }
+  }
+  const parsed = parseAddress(address);
+  if (!parsed) {
+    return undefined;
+  }
+  if (parsed.kind === 'ipv4') {
+    return formatIpv4(parsed.value);
+  }
+  const mappedIpv4 = ipv4FromMappedIpv6(parsed.value);
+  return mappedIpv4 === undefined ? address.toLowerCase() : formatIpv4(mappedIpv4);
+}
+function splitOutsideQuotes(value, separator) {
+  const parts = [];
+  let current = '';
+  let quoted = false;
+  let escaped = false;
+  for (const character of value) {
+    if (escaped) {
+      current += character;
+      escaped = false;
+      continue;
+    }
+    if (quoted && character === '\\') {
+      current += character;
+      escaped = true;
+      continue;
+    }
+    if (character === '"') {
+      quoted = !quoted;
+      current += character;
+      continue;
+    }
+    if (!quoted && character === separator) {
+      parts.push(current.trim());
+      current = '';
+      continue;
+    }
+    current += character;
+  }
+  if (quoted || escaped) {
+    return undefined;
+  }
+  parts.push(current.trim());
+  return parts;
+}
+function unquoteForwardedValue(value) {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return undefined;
+  }
+  if (!trimmed.startsWith('"')) {
+    return trimmed.includes('"') ? undefined : trimmed;
+  }
+  if (!trimmed.endsWith('"') || trimmed.length < 2) {
+    return undefined;
+  }
+  let unquoted = '';
+  let escaped = false;
+  for (const character of trimmed.slice(1, -1)) {
+    if (escaped) {
+      unquoted += character;
+      escaped = false;
+    } else if (character === '\\') {
+      escaped = true;
+    } else {
+      unquoted += character;
+    }
+  }
+  return escaped ? undefined : unquoted;
+}
+function parseForwarded(value) {
+  if (!value) {
+    return undefined;
+  }
+  const elements = splitOutsideQuotes(value, ',');
+  if (!elements || elements.some(element => !element)) {
+    return undefined;
+  }
+  const parsed = [];
+  for (const element of elements) {
+    const parameters = splitOutsideQuotes(element, ';');
+    if (!parameters || parameters.some(parameter => !parameter)) {
+      return undefined;
+    }
+    let address;
+    let host;
+    let protocol;
+    const keys = new Set();
+    for (const parameter of parameters) {
+      const separator = parameter.indexOf('=');
+      if (separator <= 0) {
+        return undefined;
+      }
+      const key = parameter.slice(0, separator).trim().toLowerCase();
+      const rawParameterValue = parameter.slice(separator + 1);
+      const parameterValue = unquoteForwardedValue(rawParameterValue);
+      if (!key || !parameterValue || keys.has(key)) {
+        return undefined;
+      }
+      keys.add(key);
+      if (key === 'for') {
+        const isUnquotedIpv4WithPort = /^(?:\d{1,3}\.){3}\d{1,3}:\d+$/.test(parameterValue);
+        if (!rawParameterValue.trim().startsWith('"') && parameterValue.includes(':') && !isUnquotedIpv4WithPort) {
+          return undefined;
+        }
+        address = normalizeAddress(parameterValue);
+      } else if (key === 'host') {
+        host = parameterValue.trim() || undefined;
+      } else if (key === 'proto') {
+        protocol = parameterValue.trim().toLowerCase();
+      }
+    }
+    if (!address) {
+      return undefined;
+    }
+    parsed.push({
+      address,
+      host,
+      protocol
+    });
+  }
+  return parsed;
+}
+function parseForwardedFor(value) {
+  if (!value) {
+    return undefined;
+  }
+  const values = value.split(',');
+  if (values.length === 0) {
+    return undefined;
+  }
+  const addresses = [];
+  for (const value of values) {
+    const address = normalizeAddress(value);
+    if (!address) {
+      return undefined;
+    }
+    addresses.push(address);
+  }
+  return addresses;
+}
+function parseIpv4(value) {
+  const parts = value.split('.');
+  if (parts.length !== 4) {
+    return undefined;
+  }
+  let result = 0n;
+  for (const part of parts) {
+    if (!/^\d{1,3}$/.test(part)) {
+      return undefined;
+    }
+    const octet = Number(part);
+    if (octet > 255) {
+      return undefined;
+    }
+    result = (result << 8n) + BigInt(octet);
+  }
+  return result;
+}
+function parseIpv6(value) {
+  const normalized = value.toLowerCase();
+  const ipv4Separator = normalized.lastIndexOf(':');
+  const ipv4Candidate = ipv4Separator === -1 ? undefined : normalized.slice(ipv4Separator + 1);
+  const ipv4 = ipv4Candidate?.includes('.') ? parseIpv4(ipv4Candidate) : undefined;
+  const ipv6Value = ipv4 !== undefined ? `${normalized.slice(0, ipv4Separator)}:${(ipv4 >> 16n & 0xffffn).toString(16)}:${(ipv4 & 0xffffn).toString(16)}` : normalized;
+  const doubleColon = ipv6Value.indexOf('::');
+  if (doubleColon !== -1 && doubleColon !== ipv6Value.lastIndexOf('::')) {
+    return undefined;
+  }
+  const [head, tail] = doubleColon === -1 ? [ipv6Value, ''] : [ipv6Value.slice(0, doubleColon), ipv6Value.slice(doubleColon + 2)];
+  const headParts = head ? head.split(':') : [];
+  const tailParts = tail ? tail.split(':') : [];
+  if (headParts.some(part => !/^[\da-f]{1,4}$/.test(part)) || tailParts.some(part => !/^[\da-f]{1,4}$/.test(part))) {
+    return undefined;
+  }
+  const missingParts = 8 - headParts.length - tailParts.length;
+  if (doubleColon === -1 && missingParts !== 0 || doubleColon !== -1 && missingParts < 1) {
+    return undefined;
+  }
+  const parts = [...headParts, ...Array.from({
+    length: missingParts
+  }, () => '0'), ...tailParts];
+  let result = 0n;
+  for (const part of parts) {
+    result = (result << 16n) + BigInt(`0x${part}`);
+  }
+  return result;
+}
+function parseAddress(value) {
+  const ipv4 = parseIpv4(value);
+  if (ipv4 !== undefined) {
+    return {
+      kind: 'ipv4',
+      value: ipv4
+    };
+  }
+  const ipv6 = parseIpv6(value);
+  return ipv6 === undefined ? undefined : {
+    kind: 'ipv6',
+    value: ipv6
+  };
+}
+function formatIpv4(value) {
+  return [Number(value >> 24n & 0xffn), Number(value >> 16n & 0xffn), Number(value >> 8n & 0xffn), Number(value & 0xffn)].join('.');
+}
+function ipv4FromMappedIpv6(value) {
+  return value >> 32n === 0xffffn ? value & 0xffffffffn : undefined;
+}
+function isValidPort(value) {
+  if (!/^\d+$/.test(value)) {
+    return false;
+  }
+  const port = Number(value);
+  return Number.isInteger(port) && port >= 0 && port <= 65_535;
+}
+function matchesAddressOrCidr(address, rule) {
+  const [network, prefixText, ...extra] = rule.trim().split('/');
+  if (!network || extra.length > 0) {
+    return false;
+  }
+  const candidate = parseAddress(address);
+  let target = parseAddress(network);
+  if (!candidate || !target) {
+    return false;
+  }
+  if (prefixText !== undefined && !/^\d+$/.test(prefixText)) {
+    return false;
+  }
+  let prefix = prefixText === undefined ? undefined : Number(prefixText);
+  const targetBits = target.kind === 'ipv4' ? 32 : 128;
+  if (prefix !== undefined && (prefix < 0 || prefix > targetBits)) {
+    return false;
+  }
+  if (target.kind === 'ipv6') {
+    const mappedIpv4 = ipv4FromMappedIpv6(target.value);
+    if (mappedIpv4 !== undefined) {
+      if (prefix !== undefined && prefix < 96) {
+        return false;
+      }
+      target = {
+        kind: 'ipv4',
+        value: mappedIpv4
+      };
+      prefix = prefix === undefined ? undefined : prefix - 96;
+    }
+  }
+  if (candidate.kind !== target.kind) {
+    return false;
+  }
+  if (prefix === undefined) {
+    return candidate.value === target.value;
+  }
+  const bits = candidate.kind === 'ipv4' ? 32 : 128;
+  if (prefix === 0) {
+    return true;
+  }
+  const shift = BigInt(bits - prefix);
+  return candidate.value >> shift === target.value >> shift;
+}
+function isTrustedProxy(policy, address, index) {
+  if (policy === false) {
+    return false;
+  }
+  if (typeof policy === 'number') {
+    return Number.isInteger(policy) && policy > index;
+  }
+  if (typeof policy === 'function') {
+    return policy(address, index);
+  }
+  return policy.some(rule => matchesAddressOrCidr(address, rule));
+}
+function resolveRemoteAddress(request) {
+  if (request.connection?.remoteAddress) {
+    return normalizeAddress(request.connection.remoteAddress);
+  }
+  if (!request.raw || typeof request.raw !== 'object') {
+    return undefined;
+  }
+  const socket = request.raw.socket;
+  return typeof socket?.remoteAddress === 'string' ? normalizeAddress(socket.remoteAddress) : undefined;
+}
+function resolveTransportProtocol(request) {
+  if (request.connection?.protocol) {
+    return request.connection.protocol;
+  }
+  if (!request.raw || typeof request.raw !== 'object') {
+    return 'http';
+  }
+  const socket = request.raw.socket;
+  return socket?.encrypted === true ? 'https' : 'http';
+}
+function parseHost(value) {
+  const host = value?.trim() || undefined;
+  if (!host || host.includes(',')) {
+    return {
+      host: undefined,
+      hostname: undefined,
+      port: undefined
+    };
+  }
+  if (host.startsWith('[')) {
+    const bracketed = host.match(/^\[([^\]]+)\](?::(\d+))?$/);
+    if (!bracketed || parseAddress(bracketed[1])?.kind !== 'ipv6' || bracketed[2] !== undefined && !isValidPort(bracketed[2])) {
+      return {
+        host: undefined,
+        hostname: undefined,
+        port: undefined
+      };
+    }
+    const hostname = bracketed[1].toLowerCase();
+    const port = bracketed[2] === undefined ? undefined : Number(bracketed[2]);
+    return {
+      host,
+      hostname,
+      port
+    };
+  }
+  const authority = host.match(/^([A-Za-z0-9](?:[A-Za-z0-9.-]*[A-Za-z0-9])?)(?::(\d+))?$/);
+  if (!authority || authority[2] !== undefined && !isValidPort(authority[2])) {
+    return {
+      host: undefined,
+      hostname: undefined,
+      port: undefined
+    };
+  }
+  return {
+    host,
+    hostname: authority[1].toLowerCase(),
+    port: authority[2] === undefined ? undefined : Number(authority[2])
+  };
+}
+function resolveForwardingSource(headers) {
+  const forwardedHeader = readHeader(headers, 'forwarded');
+  if (forwardedHeader.present) {
+    const elements = parseForwarded(forwardedHeader.value);
+    return elements ? {
+      addresses: elements.map(element => element.address),
+      elements,
+      kind: 'forwarded'
+    } : undefined;
+  }
+  const xForwardedForHeader = readHeader(headers, 'x-forwarded-for');
+  if (xForwardedForHeader.present) {
+    const addresses = parseForwardedFor(xForwardedForHeader.value);
+    return addresses ? {
+      addresses,
+      kind: 'x-forwarded-for'
+    } : undefined;
+  }
+  const xRealIpHeader = readHeader(headers, 'x-real-ip');
+  if (!xRealIpHeader.present) {
+    return undefined;
+  }
+  const address = normalizeAddress(xRealIpHeader.value);
+  return address ? {
+    addresses: [address],
+    kind: 'x-real-ip'
+  } : undefined;
+}
+function readIndexedForwardingMetadata(headers, name, index, expectedLength) {
+  const header = readHeader(headers, name);
+  if (!header.value) {
+    return undefined;
+  }
+  const values = header.value.split(',').map(value => value.trim());
+  return values.length === expectedLength && !values.some(value => !value) ? values[index] : undefined;
+}
+
+/**
+ * Resolve an immutable connection snapshot using a direct transport identity
+ * and only proxy metadata allowed by the explicit trust policy.
+ *
+ * Malformed forwarding input is ignored as a whole, preserving the direct
+ * transport identity. Adapters without a socket address produce an undefined
+ * identity rather than trusting a forwarding header by default.
+ *
+ * @param request Adapter-normalized request whose headers and raw transport are inspected.
+ * @param options Explicit proxy trust policy for the current deployment.
+ * @returns Immutable connection identity, protocol, host, and trusted proxy chain.
+ */
+export function resolveHttpConnection(request, options = {}) {
+  const remoteAddress = resolveRemoteAddress(request);
+  const trustProxy = options.trustProxy ?? false;
+  const forwarding = resolveForwardingSource(request.headers);
+  const headerAddresses = forwarding?.addresses;
+  const chain = remoteAddress && headerAddresses && trustProxy !== false ? [...headerAddresses, remoteAddress] : !remoteAddress && options.allowForwardedWithoutPeer && headerAddresses && trustProxy !== false ? [...headerAddresses] : remoteAddress ? [remoteAddress] : [];
+  let clientIndex = chain.length - 1;
+  while (clientIndex > 0 && isTrustedProxy(trustProxy, chain[clientIndex], chain.length - 1 - clientIndex)) {
+    clientIndex--;
+  }
+  const proxyChain = Object.freeze(chain.slice(clientIndex + 1));
+  const usesTrustedForwarding = forwarding !== undefined && clientIndex < forwarding.addresses.length && (proxyChain.length > 0 || !remoteAddress && options.allowForwardedWithoutPeer === true);
+  const forwardedElement = usesTrustedForwarding && forwarding?.kind === 'forwarded' ? forwarding.elements[clientIndex] : undefined;
+  const legacyHost = usesTrustedForwarding && forwarding?.kind !== 'forwarded' ? readIndexedForwardingMetadata(request.headers, 'x-forwarded-host', clientIndex, forwarding.addresses.length) : undefined;
+  const legacyProtocol = usesTrustedForwarding && forwarding?.kind !== 'forwarded' ? readIndexedForwardingMetadata(request.headers, 'x-forwarded-proto', clientIndex, forwarding.addresses.length) : undefined;
+  const protocolCandidate = forwardedElement?.protocol ?? legacyProtocol?.toLowerCase();
+  const protocol = protocolCandidate === 'https' ? 'https' : protocolCandidate === 'http' ? 'http' : resolveTransportProtocol(request);
+  const forwardingHost = parseHost(forwardedElement?.host ?? legacyHost);
+  const host = forwardingHost.host ? forwardingHost : parseHost(readHeader(request.headers, 'host').value);
+  return Object.freeze({
+    clientAddress: chain[clientIndex],
+    host: host.host,
+    hostname: host.hostname,
+    port: host.port,
+    protocol,
+    proxyChain,
+    remoteAddress,
+    secure: protocol === 'https'
+  });
+}

package/dist/context/request-context-node-store.d.ts

@@ -13,6 +13,12 @@ type AsyncLocalStorageResolutionHost = {
     };
 };
 type NodeAsyncHooksLoader = () => Promise<NodeAsyncHooksModule>;
+/**
+ * Registers a host-provided constructor that can be used without an asynchronous module lookup.
+ *
+ * @param AsyncLocalStorage Constructor supplied by a runtime-specific package entrypoint.
+ */
+export declare function registerImmediateAsyncLocalStorageConstructor(AsyncLocalStorage: AsyncLocalStorageConstructor): void;
 /**
  * Resolves host-provided `AsyncLocalStorage` without async imports or throwing host probes.
  *

package/dist/context/request-context-node-store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"request-context-node-store.d.ts","sourceRoot":"","sources":["../../src/context/request-context-node-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAEtE,KAAK,4BAA4B,GAAG,UAAU,mBAAmB,CAAC;AAElE,KAAK,oBAAoB,GAAG;IAC1B,iBAAiB,CAAC,EAAE,4BAA4B,CAAC;CAClD,CAAC;AAEF,KAAK,+BAA+B,GAAG;IACrC,iBAAiB,CAAC,EAAE,4BAA4B,CAAC;IACjD,OAAO,CAAC,EAAE;QACR,gBAAgB,CAAC,CAAC,EAAE,EAAE,kBAAkB,GAAG,oBAAoB,CAAC;QAChE,QAAQ,CAAC,EAAE;YACT,IAAI,CAAC,EAAE,MAAM,CAAC;SACf,CAAC;KACH,CAAC;CACH,CAAC;AAEF,KAAK,oBAAoB,GAAG,MAAM,OAAO,CAAC,oBAAoB,CAAC,CAAC;AAEhE;;;;;GAKG;AACH,wBAAgB,4CAA4C,CAC1D,IAAI,GAAE,+BAA4C,GACjD,4BAA4B,GAAG,SAAS,CAsB1C;AAED;;;;;;GAMG;AACH,wBAAsB,mCAAmC,CACvD,IAAI,GAAE,+BAA4C,EAClD,kBAAkB,GAAE,oBAA2C,GAC9D,OAAO,CAAC,4BAA4B,GAAG,SAAS,CAAC,CAkBnD;AAED;;;;;GAKG;AACH,wBAAgB,sCAAsC,CACpD,IAAI,GAAE,+BAA4C,GACjD,OAAO,CAET"}
+{"version":3,"file":"request-context-node-store.d.ts","sourceRoot":"","sources":["../../src/context/request-context-node-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAEtE,KAAK,4BAA4B,GAAG,UAAU,mBAAmB,CAAC;AAElE,KAAK,oBAAoB,GAAG;IAC1B,iBAAiB,CAAC,EAAE,4BAA4B,CAAC;CAClD,CAAC;AAEF,KAAK,+BAA+B,GAAG;IACrC,iBAAiB,CAAC,EAAE,4BAA4B,CAAC;IACjD,OAAO,CAAC,EAAE;QACR,gBAAgB,CAAC,CAAC,EAAE,EAAE,kBAAkB,GAAG,oBAAoB,CAAC;QAChE,QAAQ,CAAC,EAAE;YACT,IAAI,CAAC,EAAE,MAAM,CAAC;SACf,CAAC;KACH,CAAC;CACH,CAAC;AAEF,KAAK,oBAAoB,GAAG,MAAM,OAAO,CAAC,oBAAoB,CAAC,CAAC;AAIhE;;;;GAIG;AACH,wBAAgB,6CAA6C,CAC3D,iBAAiB,EAAE,4BAA4B,GAC9C,IAAI,CAEN;AAED;;;;;GAKG;AACH,wBAAgB,4CAA4C,CAC1D,IAAI,GAAE,+BAA4C,GACjD,4BAA4B,GAAG,SAAS,CA0B1C;AAED;;;;;;GAMG;AACH,wBAAsB,mCAAmC,CACvD,IAAI,GAAE,+BAA4C,EAClD,kBAAkB,GAAE,oBAA2C,GAC9D,OAAO,CAAC,4BAA4B,GAAG,SAAS,CAAC,CAkBnD;AAED;;;;;GAKG;AACH,wBAAgB,sCAAsC,CACpD,IAAI,GAAE,+BAA4C,GACjD,OAAO,CAET"}

package/dist/context/request-context-node-store.js

@@ -1,3 +1,14 @@
+let registeredAsyncLocalStorageConstructor;
+
+/**
+ * Registers a host-provided constructor that can be used without an asynchronous module lookup.
+ *
+ * @param AsyncLocalStorage Constructor supplied by a runtime-specific package entrypoint.
+ */
+export function registerImmediateAsyncLocalStorageConstructor(AsyncLocalStorage) {
+  registeredAsyncLocalStorageConstructor = AsyncLocalStorage;
+}
+
 /**
  * Resolves host-provided `AsyncLocalStorage` without async imports or throwing host probes.
  *
@@ -5,6 +16,9 @@
  * @returns The resolved `AsyncLocalStorage` constructor, or `undefined` when unavailable.
  */
 export function resolveImmediateAsyncLocalStorageConstructor(host = globalThis) {
+  if (registeredAsyncLocalStorageConstructor) {
+    return registeredAsyncLocalStorageConstructor;
+  }
   if (typeof host.AsyncLocalStorage === 'function') {
     return host.AsyncLocalStorage;
   }

package/dist/context/request-context.d.ts

@@ -2,11 +2,11 @@ import type { ContextKey, RequestContext } from '../types.js';
 /**
  * Runs a callback inside the request-scoped async context.
  *
- * Hosts with `AsyncLocalStorage` preserve the context across awaited work. During lazy
- * `AsyncLocalStorage` resolution, promise continuations registered before the store resolves keep
- * their request context until the returned promise settles. Hosts without an async context primitive
- * use a stack fallback that keeps the context only for the synchronous callback frame and clears it
- * before awaited continuations resume.
+ * Hosts with `AsyncLocalStorage` preserve the context across awaited work. Runtime-specific package
+ * entrypoints register an immediately available constructor before exposing this helper, so
+ * non-async callbacks retain synchronous return and throw behavior while returned promise
+ * continuations remain request-local. Hosts without an async context primitive use a synchronous-only
+ * fallback that clears the context before awaited work resumes.
  *
  * @param context Request context snapshot to bind to the current async execution chain.
  * @param callback Callback executed with `context` available through request-context helpers.

package/dist/context/request-context.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"request-context.d.ts","sourceRoot":"","sources":["../../src/context/request-context.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAoB9D;;;;;;;;;;;;GAYG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,OAAO,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,CAAC,GAAG,CAAC,CAgBtF;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,IAAI,cAAc,GAAG,SAAS,CAErE;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,IAAI,cAAc,CAUrD;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,cAAc,GAAG,cAAc,CAK5E;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,WAAW,EAAE,MAAM,GAAG,UAAU,CAAC,CAAC,CAAC,CAKtE;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,OAAO,EAAE,cAAc,EAAE,GAAG,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,SAAS,CAE7F;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,OAAO,EAAE,cAAc,EAAE,GAAG,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI,CAE9F"}
+{"version":3,"file":"request-context.d.ts","sourceRoot":"","sources":["../../src/context/request-context.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAa9D;;;;;;;;;;;;GAYG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,OAAO,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,CAAC,GAAG,CAAC,CAgBtF;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,IAAI,cAAc,GAAG,SAAS,CAErE;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,IAAI,cAAc,CAUrD;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,cAAc,GAAG,cAAc,CAK5E;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,WAAW,EAAE,MAAM,GAAG,UAAU,CAAC,CAAC,CAAC,CAKtE;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,OAAO,EAAE,cAAc,EAAE,GAAG,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,SAAS,CAE7F;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,OAAO,EAAE,cAAc,EAAE,GAAG,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI,CAE9F"}

package/dist/context/request-context.js

@@ -4,17 +4,15 @@ import { createStackRequestContextStore } from './request-context-stack-store.js
 let requestContextStore;
 let requestContextStoreResolution;
 let fallbackRequestContextStore;
-let originalPromiseThen;
-let promiseThenPatchDepth = 0;
-const dynamicResolutionFallbackStack = [];
+
 /**
  * Runs a callback inside the request-scoped async context.
  *
- * Hosts with `AsyncLocalStorage` preserve the context across awaited work. During lazy
- * `AsyncLocalStorage` resolution, promise continuations registered before the store resolves keep
- * their request context until the returned promise settles. Hosts without an async context primitive
- * use a stack fallback that keeps the context only for the synchronous callback frame and clears it
- * before awaited continuations resume.
+ * Hosts with `AsyncLocalStorage` preserve the context across awaited work. Runtime-specific package
+ * entrypoints register an immediately available constructor before exposing this helper, so
+ * non-async callbacks retain synchronous return and throw behavior while returned promise
+ * continuations remain request-local. Hosts without an async context primitive use a synchronous-only
+ * fallback that clears the context before awaited work resumes.
  *
  * @param context Request context snapshot to bind to the current async execution chain.
  * @param callback Callback executed with `context` available through request-context helpers.
@@ -29,7 +27,7 @@ export function runWithRequestContext(context, callback) {
     return getFallbackRequestContextStore().run(context, callback);
   }
   if (!isAsyncCallback(callback)) {
-    return runWithDynamicResolutionFallbackContext(context, callback);
+    return getFallbackRequestContextStore().run(context, callback);
   }
   return runWithResolvedRequestContextStore(context, callback);
 }
@@ -40,7 +38,7 @@ export function runWithRequestContext(context, callback) {
  * @returns The active request context, or `undefined` when no request scope is bound.
  */
 export function getCurrentRequestContext() {
-  return getRequestContextStore().getStore() ?? getDynamicResolutionFallbackContext();
+  return getRequestContextStore().getStore();
 }
 
 /**
@@ -144,79 +142,6 @@ function getFallbackRequestContextStore() {
   fallbackRequestContextStore ??= createStackRequestContextStore();
   return fallbackRequestContextStore;
 }
-function runWithDynamicResolutionFallbackContext(context, callback) {
-  dynamicResolutionFallbackStack.push(context);
-  installPromiseThenContextBridge();
-  let cleanedUp = false;
-  const cleanup = () => {
-    if (cleanedUp) {
-      return;
-    }
-    cleanedUp = true;
-    removeDynamicResolutionFallbackContext(context);
-    restorePromiseThenContextBridge();
-    void resolveRequestContextStore();
-  };
-  try {
-    const result = callback();
-    if (isPromise(result)) {
-      const then = originalPromiseThen ?? Promise.prototype.then;
-      void then.call(result, cleanup, cleanup);
-      return result;
-    }
-    cleanup();
-    return result;
-  } catch (error) {
-    cleanup();
-    throw error;
-  }
-}
-function getDynamicResolutionFallbackContext() {
-  return dynamicResolutionFallbackStack.at(-1);
-}
-function removeDynamicResolutionFallbackContext(context) {
-  const index = dynamicResolutionFallbackStack.lastIndexOf(context);
-  if (index >= 0) {
-    dynamicResolutionFallbackStack.splice(index, 1);
-  }
-}
-function installPromiseThenContextBridge() {
-  if (promiseThenPatchDepth === 0) {
-    originalPromiseThen = Promise.prototype.then;
-    Object.defineProperty(Promise.prototype, 'then', {
-      configurable: true,
-      value: createContextBridgePromiseThen(originalPromiseThen),
-      writable: true
-    });
-  }
-  promiseThenPatchDepth += 1;
-}
-function restorePromiseThenContextBridge() {
-  promiseThenPatchDepth -= 1;
-  if (promiseThenPatchDepth === 0 && originalPromiseThen) {
-    Object.defineProperty(Promise.prototype, 'then', {
-      configurable: true,
-      value: originalPromiseThen,
-      writable: true
-    });
-    originalPromiseThen = undefined;
-  }
-}
-function createContextBridgePromiseThen(originalThen) {
-  return function contextBridgePromiseThen(onfulfilled, onrejected) {
-    const context = getDynamicResolutionFallbackContext();
-    return originalThen.call(this, wrapPromiseCallback(context, onfulfilled), wrapPromiseCallback(context, onrejected));
-  };
-}
-function wrapPromiseCallback(context, callback) {
-  if (!context || typeof callback !== 'function') {
-    return callback;
-  }
-  return value => runWithDynamicResolutionFallbackContext(context, () => callback(value));
-}
-function isPromise(value) {
-  return value instanceof Promise;
-}
 function isAsyncCallback(callback) {
   return callback.constructor.name === 'AsyncFunction';
 }

package/dist/context/request-id.d.ts

@@ -0,0 +1,10 @@
+import type { FrameworkRequest } from '../types.js';
+/**
+ * Resolves the request identity before dispatcher observers begin.
+ *
+ * @param request Adapter-normalized request carrying inbound correlation headers.
+ * @param generate Whether to generate an ID when neither supported inbound header is present.
+ * @returns The adopted request or legacy correlation ID, or a newly generated ID.
+ */
+export declare function resolveRequestId(request: FrameworkRequest, generate?: boolean): string | undefined;
+//# sourceMappingURL=request-id.d.ts.map

package/dist/context/request-id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-id.d.ts","sourceRoot":"","sources":["../../src/context/request-id.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAuBpD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,gBAAgB,EAAE,QAAQ,UAAO,GAAG,MAAM,GAAG,SAAS,CAI/F"}