@dunx/http 3.7.0 → 3.8.1

package/README.md

@@ -108,8 +108,8 @@ from, and it may change in any release.
   `grpc-status` in an HTTP trailer and `Bun.serve` sends no trailers, so a request
   with `content-type: application/grpc` gets a 415 that says so.
   `@connectrpc/connect` and `@bufbuild/protobuf` are optional peers, and the
-  `.proto` toolchain stays yours. `ThrottleGuard` does not cover an RPC: it skips
-  every unmatched path, and an RPC path is in no route table.
+  `.proto` toolchain stays yours. `ThrottleGuard` covers an RPC: it skips an
+  unmatched path nobody claims, and an RPC path is claimed.
 
 ## License
 

package/dist/chunk-cx4btdwe.js

@@ -0,0 +1,56 @@
+// @bun
+// src/server/trace-context.ts
+import {
+  DEFAULT_TRACE_FLAGS,
+  formatTraceparent,
+  isSampled,
+  mintSpanId,
+  mintTraceId,
+  parseTraceparent,
+  TRACEPARENT_HEADER as TRACEPARENT_HEADER2,
+  TRACESTATE_HEADER as TRACESTATE_HEADER2
+} from "@dunx/core";
+var TRACERESPONSE_HEADER2 = "traceresponse";
+var TRACE = Symbol.for("dunx.http.trace");
+var EXPOSE = Symbol.for("dunx.http.trace.expose");
+
+class TraceContext2 {
+  static adopt(req, expose = true) {
+    const inbound = parseTraceparent(req.headers.get(TRACEPARENT_HEADER2));
+    const state = req.headers.get(TRACESTATE_HEADER2);
+    const trace = inbound === undefined ? {
+      traceId: mintTraceId(),
+      spanId: mintSpanId(),
+      flags: DEFAULT_TRACE_FLAGS
+    } : {
+      traceId: inbound.traceId,
+      spanId: mintSpanId(),
+      parentSpanId: inbound.spanId,
+      flags: inbound.flags,
+      ...state === null ? {} : { state }
+    };
+    req[TRACE] = trace;
+    if (expose)
+      req[EXPOSE] = true;
+    return trace;
+  }
+  static of(req) {
+    return req[TRACE];
+  }
+  static header(trace) {
+    return formatTraceparent(trace);
+  }
+  static stamp(response, req) {
+    const traced = req;
+    const trace = traced[TRACE];
+    if (trace !== undefined && traced[EXPOSE] === true) {
+      response.headers.set(TRACERESPONSE_HEADER2, TraceContext2.header(trace));
+    }
+    return response;
+  }
+  static sampled(trace) {
+    return isSampled(trace);
+  }
+}
+
+export { TRACEPARENT_HEADER2, TRACESTATE_HEADER2, TRACERESPONSE_HEADER2, TraceContext2 };

package/dist/client/sse.d.ts

@@ -13,9 +13,10 @@ export interface SseMessage {
  * Every event of a server-sent-events body, in order, ending with the stream or
  * with `[DONE]`. One still being read when the body ends is dropped, per spec.
  *
- * Async iteration rather than `getReader()`, which releases the reader on
- * completion, on a consumer `break` and on the `[DONE]` return. Hand-rolled:
- * Bun exposes no `EventSource` global and no SSE parser, measured not assumed.
+ * `getReader()` rather than async iteration, so the last read is told apart from
+ * a chunk boundary: a trailing `\r` is half a `\r\n` in one and a line ending in
+ * the other. `releaseLock` in a `finally` covers a `break` and `[DONE]`.
+ * Hand-rolled: Bun exposes no `EventSource` and no SSE parser, measured.
  */
 export declare function sseMessages(body: ReadableStream<Uint8Array>): AsyncGenerator<SseMessage>;
 /**

package/dist/client.js

@@ -6,7 +6,7 @@ import {
   TRACEPARENT_HEADER2,
   TRACESTATE_HEADER2,
   TraceContext2
-} from "./chunk-gmtwad7f.js";
+} from "./chunk-cx4btdwe.js";
 
 // src/client/errors.ts
 import { AppError } from "@dunx/core";
@@ -174,44 +174,61 @@ async function* sseMessages(body) {
   let event;
   let id;
   let retry;
-  for await (const chunk of body) {
-    buffer += decoder.decode(chunk, { stream: true });
-    let end = LINE.exec(buffer);
-    while (end !== null) {
-      const line = buffer.slice(0, end.index);
-      buffer = buffer.slice(end.index + end[0].length);
-      end = LINE.exec(buffer);
-      if (line === "") {
-        const payload = data.join(`
+  const reader = body.getReader();
+  let done = false;
+  try {
+    for (;; ) {
+      let end = LINE.exec(buffer);
+      while (end !== null) {
+        if (!done && end[0] === "\r" && end.index + 1 === buffer.length)
+          break;
+        const line = buffer.slice(0, end.index);
+        buffer = buffer.slice(end.index + end[0].length);
+        end = LINE.exec(buffer);
+        if (line === "") {
+          const seen = data.length > 0;
+          const payload = data.join(`
 `);
-        data = [];
-        if (payload === "") {
+          data = [];
+          if (!seen) {
+            event = undefined;
+            continue;
+          }
+          if (payload === "[DONE]")
+            return;
+          yield {
+            data: payload,
+            ...event === undefined ? {} : { event },
+            ...id === undefined ? {} : { id },
+            ...retry === undefined ? {} : { retry }
+          };
           event = undefined;
           continue;
         }
-        if (payload === "[DONE]")
-          return;
-        yield {
-          data: payload,
-          ...event === undefined ? {} : { event },
-          ...id === undefined ? {} : { id },
-          ...retry === undefined ? {} : { retry }
-        };
-        event = undefined;
-        continue;
+        if (line.startsWith(":"))
+          continue;
+        const [field, value] = split(line);
+        if (field === "data")
+          data.push(value);
+        else if (field === "event")
+          event = value;
+        else if (field === "id" && !value.includes("\x00"))
+          id = value;
+        else if (field === "retry" && /^\d+$/.test(value))
+          retry = Number(value);
       }
-      if (line.startsWith(":"))
+      if (done)
+        return;
+      const next = await reader.read();
+      if (next.done) {
+        buffer += decoder.decode();
+        done = true;
         continue;
-      const [field, value] = split(line);
-      if (field === "data")
-        data.push(value);
-      else if (field === "event")
-        event = value;
-      else if (field === "id" && !value.includes("\x00"))
-        id = value;
-      else if (field === "retry" && /^\d+$/.test(value))
-        retry = Number(value);
+      }
+      buffer += decoder.decode(next.value, { stream: true });
     }
+  } finally {
+    reader.releaseLock();
   }
 }
 class ConnectDeadline {

package/dist/connect/middleware.d.ts

@@ -12,14 +12,15 @@ import { ConnectRegistry } from './registry.js';
  * first is what leaves a matched route paying nothing. Anything outside the
  * registered paths falls through untouched.
  *
- * `ThrottleGuard` is the one that does **not** cover an RPC: it returns early on
- * every unmatched path so a burst of 404s cannot spend a caller's budget, and an
- * RPC is unmatched. See docs/guide/27-rpc.md.
+ * `ThrottleGuard` covers an RPC: its early return is for an unmatched path
+ * nobody claims, and a claimed path is served. See docs/guide/27-rpc.md.
  */
 export declare class ConnectMiddleware implements Middleware, ClaimsPaths {
     #private;
     constructor(registry: ConnectRegistry);
     /** Every mounted RPC path, so a controller cannot shadow one unnoticed. */
     claimedPaths(): readonly string[];
+    /** Connect and gRPC-Web both POST. Connect's GET form is not served here. */
+    claimedMethods(): readonly string[];
     handle(req: BunRequest, ctx: RouteContext, next: Next): Promise<Response>;
 }

package/dist/connect/options.d.ts

@@ -1,6 +1,6 @@
 import type { DescService } from '@bufbuild/protobuf';
 import type { ConnectRouterOptions, ServiceImpl } from '@connectrpc/connect';
-import type { Ctor, ModuleRef } from '@dunx/core';
+import { type Ctor, type ModuleRef } from '@dunx/core';
 /**
  * Everything `createConnectRouter` takes except the protocol switches and
  * `shutdownSignal`, which the container owns. `interceptors`, `contextValues`,
@@ -43,9 +43,8 @@ export interface ConnectOptionsInit extends ConnectRouterSettings {
      * the deadline for the whole call, which is the default because a gap between
      * messages is the protocol rather than a symptom.
      *
-     * Worth setting on a public mount: `ThrottleGuard` returns early on every
-     * unmatched path and an RPC is unmatched, so nothing else here bounds how long
-     * or how many streams one caller holds open.
+     * Worth setting on a public mount: `ThrottleGuard` limits the calls, and this
+     * limits how long one that is already streaming may idle.
      *
      * @default 0
      */

package/dist/connect.js

@@ -16,12 +16,14 @@ import {
 } from "./chunk-08k9vq31.js";
 
 // src/connect/registry.ts
+import { AppError as AppError2 } from "@dunx/core";
 import {
   createConnectRouter
 } from "@connectrpc/connect";
 import { createFetchHandler } from "@connectrpc/connect/protocol";
 
 // src/connect/options.ts
+import { AppError } from "@dunx/core";
 var connectService = (service, useClass) => ({ service, useClass });
 
 class ConnectOptions {
@@ -48,14 +50,14 @@ class ConnectOptions {
     this.grpcWeb = grpcWeb ?? true;
     this.streamTimeout = streamTimeout ?? 0;
     if (!Number.isFinite(this.streamTimeout) || this.streamTimeout < 0) {
-      throw new Error(`ConnectModule streamTimeout must be a non-negative number of seconds, got ${String(streamTimeout)}.`);
+      throw new AppError(`ConnectModule streamTimeout must be a non-negative number of seconds, got ${String(streamTimeout)}.`);
     }
     this.router = router;
     if (!this.connect && !this.grpcWeb) {
-      throw new Error("ConnectModule needs at least one protocol, and both connect and " + "grpcWeb are false. Native gRPC is not a third option here: it " + "carries grpc-status in an HTTP trailer and Bun.serve sends none.");
+      throw new AppError("ConnectModule needs at least one protocol, and both connect and " + "grpcWeb are false. Native gRPC is not a third option here: it " + "carries grpc-status in an HTTP trailer and Bun.serve sends none.");
     }
     if (services.length === 0) {
-      throw new Error("ConnectModule.forRoot was given no services. Pass at least one " + "connectService(Desc, Impl), or drop the module.");
+      throw new AppError("ConnectModule.forRoot was given no services. Pass at least one " + "connectService(Desc, Impl), or drop the module.");
     }
   }
 }
@@ -82,7 +84,7 @@ class ConnectRegistry {
     options.services.forEach((registration, index) => {
       const implementation = implementations[index];
       if (implementation === undefined) {
-        throw new Error(`No instance was resolved for ${registration.useClass.name}, which ` + `serves ${registration.service.typeName}.`);
+        throw new AppError2(`No instance was resolved for ${registration.useClass.name}, which ` + `serves ${registration.service.typeName}.`);
       }
       router.service(registration.service, implementation);
     });
@@ -131,6 +133,9 @@ class ConnectMiddleware {
   claimedPaths() {
     return this.#registry.paths;
   }
+  claimedMethods() {
+    return ["POST"];
+  }
   handle(req, ctx, next) {
     if (ctx.get(UNMATCHED2) !== true)
       return next();

package/dist/index.js

@@ -37,7 +37,7 @@ import {
   TRACESTATE_HEADER2,
   TRACERESPONSE_HEADER2,
   TraceContext2
-} from "./chunk-gmtwad7f.js";
+} from "./chunk-cx4btdwe.js";
 import {
   __privateGet,
   __privateAdd,
@@ -189,16 +189,21 @@ var seriesFor = (route, method) => ({
 class RequestMetrics {
   #series = new Map;
   #unmatched = new Map;
+  #claimed = new Map;
+  #claimedPaths = new Set;
   #since = new Date;
   #server;
   observe(ctx, status, durationNs, traceId) {
     let series = this.#series.get(ctx);
     if (series === undefined) {
       if (ctx.get(UNMATCHED2) === true) {
-        series = this.#unmatched.get(ctx.method);
+        const claimed = this.#claimedPaths.has(ctx.path);
+        const key = claimed ? `${ctx.method} ${ctx.path}` : ctx.method;
+        const bucket = claimed ? this.#claimed : this.#unmatched;
+        series = bucket.get(key);
         if (series === undefined) {
-          series = seriesFor(UNMATCHED_ROUTE, ctx.method);
-          this.#unmatched.set(ctx.method, series);
+          series = seriesFor(claimed ? ctx.path : UNMATCHED_ROUTE, ctx.method);
+          bucket.set(key, series);
         }
       } else {
         series = seriesFor(ctx.path, ctx.method);
@@ -218,6 +223,7 @@ class RequestMetrics {
     const routes = [];
     for (const series of [
       ...this.#series.values(),
+      ...this.#claimed.values(),
       ...this.#unmatched.values()
     ]) {
       routes.push({
@@ -238,9 +244,13 @@ class RequestMetrics {
   }
   reset() {
     this.#series.clear();
+    this.#claimed.clear();
     this.#unmatched.clear();
     this.#since = new Date;
   }
+  claim(paths) {
+    this.#claimedPaths = new Set(paths);
+  }
   attach(server) {
     this.#server = server;
   }
@@ -1366,7 +1376,22 @@ var buildFallback = (middleware = [], onError = defaultErrorMapper, cors, notFou
   const miss = () => {
     throw new HttpError(HttpStatusCode2.NOT_FOUND, "NOT_FOUND");
   };
+  const claimedPreflight = new Map;
+  if (cors) {
+    for (const entry of middleware) {
+      if (!hasClaimedPaths(entry))
+        continue;
+      const answer = preflight(cors, entry.claimedMethods());
+      for (const path of entry.claimedPaths())
+        claimedPreflight.set(path, answer);
+    }
+  }
   const run = async (req, server) => {
+    if (req.method === "OPTIONS") {
+      const answer = claimedPreflight.get(new URL(req.url).pathname);
+      if (answer !== undefined)
+        return answer(req);
+    }
     try {
       return await compose(middleware, unmatchedContext(req, notFound === "public", server), miss)(req);
     } catch (error) {
@@ -1645,7 +1670,9 @@ class HttpApplication extends ShutdownAware {
     if (ws && !this.#split)
       assertNoGatewayCollisions(prefixed, ws.paths);
     assertNoShadowedClaims(prefixed, middleware);
-    this.#app.get(ClaimedRoutes).attach(middleware.flatMap((entry) => hasClaimedPaths(entry) ? [...entry.claimedPaths()] : []));
+    const claimed = middleware.flatMap((entry) => hasClaimedPaths(entry) ? [...entry.claimedPaths()] : []);
+    this.#app.get(ClaimedRoutes).attach(claimed);
+    this.#app.get(RequestMetrics).claim(claimed);
     const fetch = buildFallback(middleware, this.#onError, this.#cors, this.#notFound);
     const bound = this.#binding.bind({ port, routes, fetch, websocket: ws });
     attachAddressSource(this.#app.get(ClientAddress), {
@@ -2240,6 +2267,8 @@ var frameEvent = (event) => {
     const data = typeof event.data === "string" ? event.data : JSON.stringify(event.data);
     for (const line of lines(data ?? ""))
       fields.push(`data: ${line}`);
+  } else if (event.event !== undefined || event.id !== undefined) {
+    fields.push("data: ");
   }
   return `${fields.join(`
 `)}
@@ -2266,11 +2295,17 @@ class SseStream {
   #timer;
   #lastEventId;
   #closed = false;
+  #gone = new AbortController;
+  #drained;
   constructor(options = {}) {
     this.#body = new ReadableStream({
       start: (controller) => {
         this.#controller = controller;
       },
+      pull: () => {
+        this.#drained?.();
+        this.#drained = undefined;
+      },
       cancel: () => {
         this.#stop();
       }
@@ -2292,6 +2327,7 @@ class SseStream {
           if (stream.#closed)
             break;
           stream.send(event);
+          await stream.#backpressure();
         }
         stream.close();
       } catch (error) {
@@ -2300,6 +2336,9 @@ class SseStream {
     })();
     return stream;
   }
+  get signal() {
+    return this.#gone.signal;
+  }
   get lastEventId() {
     return this.#lastEventId;
   }
@@ -2321,9 +2360,11 @@ class SseStream {
     this.#controller?.close();
   }
   toResponse(headers = {}) {
-    return new Response(this.#body, {
-      headers: { ...headers, ...SSE_HEADERS }
-    });
+    const merged = new Headers(headers);
+    for (const [name, value] of Object.entries(SSE_HEADERS)) {
+      merged.set(name, value);
+    }
+    return new Response(this.#body, { headers: merged });
   }
   #write(text) {
     if (this.#closed)
@@ -2336,8 +2377,20 @@ class SseStream {
     this.#stop();
     this.#controller?.error(error);
   }
+  #backpressure() {
+    const wanted = this.#controller?.desiredSize;
+    if (this.#closed || wanted === undefined || wanted === null || wanted > 0) {
+      return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+      this.#drained = resolve;
+    });
+  }
   #stop() {
     this.#closed = true;
+    this.#gone.abort();
+    this.#drained?.();
+    this.#drained = undefined;
     if (this.#timer !== undefined)
       clearInterval(this.#timer);
     this.#timer = undefined;
@@ -2512,7 +2565,8 @@ class ThrottleGuard {
   }
   #key(req, ctx) {
     const subject = (this.options.subject ?? ((request) => this.address.of(request)))(req, ctx) ?? "anonymous";
-    return `${this.options.prefix}:throttle:${ctx.controller}:${ctx.handler}:${subject}`;
+    const scope = ctx.get(UNMATCHED2) === true ? ctx.path : `${ctx.controller}:${ctx.handler}`;
+    return `${this.options.prefix}:throttle:${scope}:${subject}`;
   }
   async#hit(key, windowSeconds) {
     try {

package/dist/server/metrics.d.ts

@@ -54,6 +54,8 @@ export declare class RequestMetrics {
      * reflecting a deploy three days ago; who calls this is the app's decision.
      */
     reset(): void;
+    /** Internal: the paths a middleware answers off the fallback. */
+    claim(paths: Iterable<string>): void;
     /**
      * Internal: `listen()` hands the bound server's counters to the resolved
      * singleton. Structural, so an app serving from two ports can hand over the

package/dist/server/middleware.d.ts

@@ -28,5 +28,10 @@ export declare const compose: (middleware: readonly Middleware[], ctx: RouteCont
  */
 export interface ClaimsPaths {
     claimedPaths(): readonly string[];
+    /**
+     * The methods those paths answer. `preflight` is mounted over the route table,
+     * which a claimed path is not in, so an `OPTIONS` would reach the 404.
+     */
+    claimedMethods(): readonly string[];
 }
 export declare const hasClaimedPaths: (value: object) => value is ClaimsPaths;

package/dist/server/trace-context.d.ts

@@ -1,5 +1,5 @@
-export declare const TRACEPARENT_HEADER = "traceparent";
-export declare const TRACESTATE_HEADER = "tracestate";
+import { TRACEPARENT_HEADER, TRACESTATE_HEADER, type TraceIds } from '@dunx/core';
+export { TRACEPARENT_HEADER, TRACESTATE_HEADER };
 /**
  * The span that answered, sent back so a caller can record which of the callee's
  * spans its own span points at. Same four fields as `traceparent`, and the
@@ -12,15 +12,14 @@ export declare const TRACESTATE_HEADER = "tracestate";
  * and adoption is thin, so treat a caller reading it as a bonus.
  */
 export declare const TRACERESPONSE_HEADER = "traceresponse";
-export interface Trace {
-    /** 32 hex digits, shared by every span in the trace. */
-    readonly traceId: string;
-    /** 16 hex digits identifying this server's work on this request. */
-    readonly spanId: string;
+/**
+ * This server's view of a trace: the {@link TraceIds} on the wire plus the
+ * caller's span and any vendor `tracestate`, neither of which a `traceparent`
+ * carries on its own.
+ */
+export interface Trace extends TraceIds {
     /** The caller's span, when one arrived in `traceparent`. */
     readonly parentSpanId?: string;
-    /** Two hex digits. Bit 0 is `sampled`. */
-    readonly flags: string;
     /** `tracestate` verbatim, when one arrived. Vendor data this server does not read. */
     readonly state?: string;
 }
@@ -41,7 +40,6 @@ export interface Trace {
  * request carries no correlation id at all.
  */
 export declare class TraceContext {
-    #private;
     /**
      * The inbound `traceparent`, or a fresh trace. A malformed header is discarded
      * rather than repaired, as the standard requires. Version `ff` is invalid; a
@@ -63,7 +61,7 @@ export declare class TraceContext {
      * The `traceparent` to send upstream. This server's span becomes the callee's
      * parent, so the two link without inventing a span nothing logged.
      */
-    static header(trace: Pick<Trace, 'traceId' | 'spanId' | 'flags'>): string;
+    static header(trace: TraceIds): string;
     /**
      * The response, carrying `traceresponse` if this request adopted a trace.
      *

package/dist/sse/event.d.ts

@@ -1,6 +1,7 @@
 /**
  * One server-sent event. Every field is optional: `retry` alone changes the
- * reconnection delay, `event` alone fires a named event with no payload.
+ * reconnection delay, and `event` or `id` alone carries an empty `data:` so it
+ * dispatches, which a frame with no data field at all does not.
  */
 export interface SseEvent {
     /** A string as it is, anything else through `JSON.stringify`. Each line of it

package/dist/sse/stream.d.ts

@@ -20,6 +20,9 @@ export declare class SseStream {
      * terminal chunk and an `EventSource` reconnects.
      */
     static from(events: AsyncIterable<SseEvent>, options?: SseStreamOptions): SseStream;
+    /** Aborts when the client goes away, for a handler that waits between events
+     * to race: `for await` only sees a disconnect between yields. */
+    get signal(): AbortSignal;
     /** The `id` of the last event sent, or `undefined` if none carried one. */
     get lastEventId(): string | undefined;
     get closed(): boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dunx/http",
-  "version": "3.7.0",
+  "version": "3.8.1",
   "description": "Bun.serve adapter for the dunx framework: controllers, middleware and WebSocket gateways",
   "keywords": [
     "bun",
@@ -76,7 +76,7 @@
   "peerDependencies": {
     "@bufbuild/protobuf": "^2.15.0",
     "@connectrpc/connect": "^2.2.0",
-    "@dunx/core": "^3.7.0",
+    "@dunx/core": "^3.8.1",
     "@types/bun": ">=1.4.1"
   },
   "peerDependenciesMeta": {

package/dist/chunk-gmtwad7f.js

@@ -1,71 +0,0 @@
-// @bun
-// src/server/trace-context.ts
-var TRACEPARENT_HEADER2 = "traceparent";
-var TRACESTATE_HEADER2 = "tracestate";
-var TRACERESPONSE_HEADER2 = "traceresponse";
-var HEX_32 = /^[0-9a-f]{32}$/;
-var HEX_16 = /^[0-9a-f]{16}$/;
-var HEX_2 = /^[0-9a-f]{2}$/;
-var ZERO_TRACE = "0".repeat(32);
-var ZERO_SPAN = "0".repeat(16);
-var SAMPLED = 1;
-var DEFAULT_FLAGS = "01";
-var TRACE = Symbol.for("dunx.http.trace");
-var EXPOSE = Symbol.for("dunx.http.trace.expose");
-var mint = (bytes) => crypto.getRandomValues(new Uint8Array(bytes)).toHex();
-
-class TraceContext2 {
-  static adopt(req, expose = true) {
-    const inbound = TraceContext2.#parse(req.headers.get(TRACEPARENT_HEADER2));
-    const state = req.headers.get(TRACESTATE_HEADER2);
-    const trace = inbound === undefined ? { traceId: mint(16), spanId: mint(8), flags: DEFAULT_FLAGS } : {
-      traceId: inbound.traceId,
-      spanId: mint(8),
-      parentSpanId: inbound.spanId,
-      flags: inbound.flags,
-      ...state === null ? {} : { state }
-    };
-    req[TRACE] = trace;
-    if (expose)
-      req[EXPOSE] = true;
-    return trace;
-  }
-  static of(req) {
-    return req[TRACE];
-  }
-  static header(trace) {
-    return `00-${trace.traceId}-${trace.spanId}-${trace.flags}`;
-  }
-  static stamp(response, req) {
-    const traced = req;
-    const trace = traced[TRACE];
-    if (trace !== undefined && traced[EXPOSE] === true) {
-      response.headers.set(TRACERESPONSE_HEADER2, TraceContext2.header(trace));
-    }
-    return response;
-  }
-  static sampled(trace) {
-    return (Number.parseInt(trace.flags, 16) & SAMPLED) === SAMPLED;
-  }
-  static #parse(header) {
-    if (header === null)
-      return;
-    const parts = header.split("-");
-    if (parts.length < 4)
-      return;
-    const [version, traceId, spanId, flags] = parts;
-    if (!HEX_2.test(version) || version === "ff")
-      return;
-    if (version === "00" && parts.length !== 4)
-      return;
-    if (!HEX_32.test(traceId) || traceId === ZERO_TRACE)
-      return;
-    if (!HEX_16.test(spanId) || spanId === ZERO_SPAN)
-      return;
-    if (!HEX_2.test(flags))
-      return;
-    return { traceId, spanId, flags };
-  }
-}
-
-export { TRACEPARENT_HEADER2, TRACESTATE_HEADER2, TRACERESPONSE_HEADER2, TraceContext2 };