@lovrozagar/honey 0.7.2 → 1.0.0-rc.1

package/dist/schema/yup.js

@@ -0,0 +1,57 @@
+/**
+ * Yup → JSON Schema from the schema's own `describe()`: yup publishes no JSON Schema, and core never
+ * imports yup (F2).
+ */
+import { dict } from "../routing/tree.js";
+function object(description) {
+    const fields = description.fields;
+    const keys = Object.keys(fields);
+    if (keys.length === 0)
+        return { type: "object" };
+    const properties = dict();
+    const required = [];
+    for (const key of keys) {
+        const field = fields[key];
+        properties[key] = described(field);
+        if (field.optional !== true)
+            required.push(key);
+    }
+    const json = { properties, type: "object" };
+    if (required.length > 0)
+        json.required = required;
+    return json;
+}
+function base(description) {
+    const inner = description.innerType;
+    switch (description.type) {
+        case "array":
+            return inner === undefined || Array.isArray(inner)
+                ? { type: "array" }
+                : { items: described(inner), type: "array" };
+        case "boolean":
+        case "number":
+        case "string":
+            return { type: description.type };
+        case "date":
+            return { format: "date-time", type: "string" };
+        case "mixed":
+            return description.oneOf !== undefined && description.oneOf.length > 0 ? { enum: description.oneOf } : {};
+        case "object":
+            return object(description);
+        case "tuple": {
+            const items = inner.map(described);
+            return { items: false, maxItems: items.length, minItems: items.length, prefixItems: items, type: "array" };
+        }
+        default:
+            return {};
+    }
+}
+function described(description) {
+    const json = base(description);
+    return description.nullable === true ? { anyOf: [json, { type: "null" }] } : json;
+}
+/** The JSON Schema of the yup schema `schema`; {} for anything without `describe()`. */
+export function yupJsonSchema(schema) {
+    const describe = schema.describe;
+    return typeof describe === "function" ? described(describe.call(schema)) : {};
+}

package/dist/schema/zod.d.ts

@@ -0,0 +1,6 @@
+import type { JsonSchema, SchemaIo } from "./to-json-schema.ts";
+/**
+ * The JSON Schema of the zod schema `schema` on the `io` side. `degraded` hears, once, the node
+ * kinds that came out unconstrained.
+ */
+export declare function zodJsonSchema(schema: unknown, io: SchemaIo, degraded: (nodes: readonly string[]) => void): JsonSchema;

package/dist/schema/zod.js

@@ -0,0 +1,192 @@
+/**
+ * Zod → JSON Schema. Zod 4 publishes Standard JSON Schema, so that runs first, with an override
+ * that gives Date and BigInt their wire shape and records each node JSON Schema has no word for.
+ * zod/mini, and a bundle that dropped the converter, publish none: the walk reads the definition
+ * the schema carries (`_zod.def`). Core never imports zod (F2).
+ */
+import { dict } from "../routing/tree.js";
+import { compareCodeUnits } from "./canonicalize.js";
+/* past this depth a node is unconstrained: a recursive lazy schema would not end */
+const MAX_DEPTH = 32;
+/** Node kinds JSON Schema has no word for: zod writes `{}` for each, and the rest survives. */
+const UNREPRESENTABLE = ["custom", "function", "map", "nan", "promise", "set", "symbol", "transform"];
+/** Node kinds that leave no value constraint: unconstrained by design, not degraded. */
+const OPEN = ["any", "undefined", "unknown", "void"];
+/** `schema`'s zod 4 internals; anything else, a zod 3 schema among them, has none. */
+function internals(schema) {
+    // oxlint-disable-next-line no-underscore-dangle -- zod 4 names its internals `_zod`
+    return schema._zod;
+}
+/** The definition of a schema the walk already holds as zod 4: a child of one. */
+function childDef(schema) {
+    return internals(schema).def;
+}
+/** `json` with the format, bounds and pattern zod recorded for `schema`'s checks. */
+function bagged(schema, json) {
+    const { bag } = internals(schema);
+    if (bag.format === "safeint")
+        json.type = "integer";
+    else if (typeof bag.format === "string" && bag.format !== "regex")
+        json.format = bag.format;
+    if (bag.patterns instanceof Set && bag.patterns.size === 1) {
+        const [pattern] = bag.patterns;
+        json.pattern = pattern.source;
+    }
+    const [min, max] = json.type === "string"
+        ? ["minLength", "maxLength"]
+        : json.type === "array"
+            ? ["minItems", "maxItems"]
+            : ["minimum", "maximum"];
+    if (typeof bag.minimum === "number")
+        json[min] = bag.minimum;
+    if (typeof bag.maximum === "number")
+        json[max] = bag.maximum;
+    if (typeof bag.exclusiveMinimum === "number")
+        json.exclusiveMinimum = bag.exclusiveMinimum;
+    if (typeof bag.exclusiveMaximum === "number")
+        json.exclusiveMaximum = bag.exclusiveMaximum;
+    return json;
+}
+/** Whether an object key may be left out on the `io` side. */
+function optional(def, io) {
+    if (def.type === "optional")
+        return true;
+    /* a default fills the value in: optional going in, always there coming out */
+    if (def.type === "default" || def.type === "prefault")
+        return io === "input" || optional(childDef(def.innerType), io);
+    if (def.type === "nullable" || def.type === "catch" || def.type === "readonly") {
+        return optional(childDef(def.innerType), io);
+    }
+    return false;
+}
+function object(def, walk, io) {
+    const shape = def.shape;
+    const properties = dict();
+    const required = [];
+    for (const key of Object.keys(shape)) {
+        properties[key] = walk(shape[key]);
+        if (!optional(childDef(shape[key]), io))
+            required.push(key);
+    }
+    const json = { properties, type: "object" };
+    if (required.length > 0)
+        json.required = required;
+    const rest = def.catchall;
+    /* a plain object strips unknown keys: none come out, any may go in */
+    if (rest === undefined) {
+        if (io === "output")
+            json.additionalProperties = false;
+    }
+    else
+        json.additionalProperties = childDef(rest).type === "never" ? false : walk(rest);
+    return json;
+}
+function tuple(def, walk) {
+    const items = def.items.map(walk);
+    const json = { minItems: items.length, prefixItems: items, type: "array" };
+    if (def.rest === null || def.rest === undefined) {
+        json.items = false;
+        json.maxItems = items.length;
+    }
+    else
+        json.items = walk(def.rest);
+    return json;
+}
+/** Enum values: a TS numeric enum's reverse mappings left out, typed when they share one. */
+function enumValues(def) {
+    const entries = def.entries;
+    const values = Object.keys(entries)
+        .filter((key) => typeof entries[entries[key]] !== "number")
+        .map((key) => entries[key]);
+    const types = new Set(values.map((value) => typeof value));
+    return types.size === 1 ? { enum: values, type: [...types][0] } : { enum: values };
+}
+function literal(def) {
+    const values = def.values.map((value) => (typeof value === "bigint" ? Number(value) : value));
+    return values.length === 1 ? { const: values[0] } : { enum: values };
+}
+/** The inner schema and its default; zod's `defaultValue` getter calls a default function. */
+function defaulted(def, walk) {
+    return { ...walk(def.innerType), default: def.defaultValue };
+}
+const inner = (def, walk) => walk(def.innerType);
+const binary = () => ({ contentEncoding: "binary", format: "binary", type: "string" });
+/** Each definition type's JSON Schema; one not listed is unconstrained and reported. */
+const BY_TYPE = {
+    array: (def, walk, _io, schema) => bagged(schema, { items: walk(def.element), type: "array" }),
+    bigint: () => ({ format: "int64", type: "integer" }),
+    boolean: () => ({ type: "boolean" }),
+    catch: inner,
+    date: () => ({ format: "date-time", type: "string" }),
+    default: defaulted,
+    enum: enumValues,
+    file: binary,
+    intersection: (def, walk) => ({ allOf: [walk(def.left), walk(def.right)] }),
+    lazy: (def, walk) => walk(def.getter()),
+    literal,
+    nonoptional: inner,
+    null: () => ({ type: "null" }),
+    nullable: (def, walk) => ({ anyOf: [walk(def.innerType), { type: "null" }] }),
+    number: (_def, _walk, _io, schema) => bagged(schema, { type: "number" }),
+    object,
+    optional: inner,
+    /* a pipe validates `in` and hands back `out` */
+    pipe: (def, walk, io) => walk(io === "input" ? def.in : def.out),
+    prefault: defaulted,
+    readonly: (def, walk) => ({ ...walk(def.innerType), readOnly: true }),
+    record: (def, walk) => ({ additionalProperties: walk(def.valueType), type: "object" }),
+    string: (_def, _walk, _io, schema) => bagged(schema, { type: "string" }),
+    tuple,
+    union: (def, walk) => ({ anyOf: def.options.map(walk) }),
+};
+function walkDef(schema, io, degraded, depth) {
+    if (depth > MAX_DEPTH)
+        return {};
+    const def = internals(schema)?.def;
+    if (def === undefined) {
+        degraded.add("unrecognized");
+        return {};
+    }
+    if (Object.hasOwn(BY_TYPE, def.type)) {
+        return BY_TYPE[def.type](def, (child) => walkDef(child, io, degraded, depth + 1), io, schema);
+    }
+    if (!OPEN.includes(def.type))
+        degraded.add(def.type);
+    return {};
+}
+/** Zod's `override`: Date and BigInt as they cross the wire, and each node it could not express recorded. */
+function override(degraded) {
+    return ({ jsonSchema, zodSchema }) => {
+        const kind = childDef(zodSchema).type;
+        if (kind === "date")
+            Object.assign(jsonSchema, { format: "date-time", type: "string" });
+        else if (kind === "bigint")
+            Object.assign(jsonSchema, { format: "int64", type: "integer" });
+        else if (UNREPRESENTABLE.includes(kind) && Object.keys(jsonSchema).length === 0)
+            degraded.add(kind);
+    };
+}
+/** Zod's own converter for `io`: Standard JSON Schema, else the instance method zod 4.0 and 4.1 carry. */
+function converted(schema, io, degraded) {
+    const libraryOptions = { override: override(degraded), unrepresentable: "any" };
+    const standard = schema["~standard"];
+    const fromStandard = standard.jsonSchema?.[io];
+    if (typeof fromStandard === "function") {
+        return fromStandard({ libraryOptions, target: "draft-2020-12" });
+    }
+    const method = schema.toJSONSchema;
+    if (typeof method === "function")
+        return method.call(schema, { ...libraryOptions, io });
+    return undefined;
+}
+/**
+ * The JSON Schema of the zod schema `schema` on the `io` side. `degraded` hears, once, the node
+ * kinds that came out unconstrained.
+ */
+export function zodJsonSchema(schema, io, degraded) {
+    const nodes = new Set();
+    const json = converted(schema, io, nodes) ?? walkDef(schema, io, nodes, 0);
+    if (nodes.size > 0)
+        degraded([...nodes].sort(compareCodeUnits));
+    return json;
+}

package/dist/security/crypto.d.ts

@@ -0,0 +1,7 @@
+/**
+ * `timingSafeEqual(a, b)`: constant-time equality for secrets (an API key, a token), on WebCrypto
+ * alone, so it runs on Node, Bun and Workers. Both sides are MACed under a key drawn fresh for the
+ * call and the MACs compared by `crypto.subtle.verify`, so neither the content nor the length of
+ * either side leaks through timing, and no key outlives the comparison (no module state, H23).
+ */
+export declare function timingSafeEqual(a: string | Uint8Array, b: string | Uint8Array): Promise<boolean>;

package/dist/security/crypto.js

@@ -0,0 +1,30 @@
+/**
+ * `timingSafeEqual(a, b)`: constant-time equality for secrets (an API key, a token), on WebCrypto
+ * alone, so it runs on Node, Bun and Workers. Both sides are MACed under a key drawn fresh for the
+ * call and the MACs compared by `crypto.subtle.verify`, so neither the content nor the length of
+ * either side leaks through timing, and no key outlives the comparison (no module state, H23).
+ */
+/**
+ * Strings compare by UTF-16 code unit, not by their UTF-8 encoding: UTF-8 turns every lone
+ * surrogate into U+FFFD, so two different strings would compare equal.
+ */
+function toBytes(value) {
+    if (typeof value !== "string")
+        return new Uint8Array(value);
+    const bytes = new Uint8Array(value.length * 2);
+    for (let i = 0; i < value.length; i++) {
+        const unit = value.charCodeAt(i);
+        bytes[i * 2] = unit >> 8;
+        bytes[i * 2 + 1] = unit & 0xff;
+    }
+    return bytes;
+}
+export async function timingSafeEqual(a, b) {
+    /* a string never equals bytes: "ab" and its code units differ */
+    if ((typeof a === "string") !== (typeof b === "string"))
+        return false;
+    const raw = crypto.getRandomValues(new Uint8Array(32));
+    const key = await crypto.subtle.importKey("raw", raw, { hash: "SHA-256", name: "HMAC" }, false, ["sign", "verify"]);
+    const mac = await crypto.subtle.sign("HMAC", key, toBytes(a));
+    return crypto.subtle.verify("HMAC", key, mac, toBytes(b));
+}

package/dist/streaming/producer-stream.d.ts

@@ -0,0 +1,45 @@
+/**
+ * The one streaming primitive behind `ctx.res.sse()`, `stream()` and `generate()`.
+ *
+ * - The producer starts on the first read, so a body nobody reads (HEAD, a middleware that swaps
+ *   the response, a client gone before the headers) never runs it.
+ * - It ends exactly once: the producer finished, the reader cancelled (client disconnect), or the
+ *   request signal aborted (`ctx.signal`). Cleanups registered with `onEnd` run there, once.
+ * - A write resolves when the reader asks for more, so a producer that awaits its writes never
+ *   queues more than one chunk past demand. A write after the end rejects, marked handled, so an
+ *   unawaited one never surfaces as an unhandled rejection.
+ * - A producer failure that is not the stream's own abort breaks the body, so the client sees an
+ *   aborted transfer instead of a clean end, and goes to `report`.
+ */
+export type ProducerSink = {
+    /** Aborts when the stream ends any way other than the producer finishing. */
+    readonly signal: AbortSignal;
+    /** True once the stream ended. */
+    readonly closed: boolean;
+    /** End the body cleanly. Idempotent. */
+    close(): void;
+    /** End the body as broken. Idempotent. */
+    error(error: unknown): void;
+    /** Run `fn` once when the stream ends, or now if it already has. */
+    onEnd(fn: () => void): void;
+    /** Queue a chunk. Resolves when the reader is ready for more; rejects after the end. */
+    write(chunk: Uint8Array): Promise<void>;
+};
+export type ProducerOptions = {
+    /** A producer failure that is not the stream's own abort. Wired to the logger at bit 07. */
+    report?: (error: unknown) => void;
+    /** The request's signal (`ctx.signal`), read when the producer starts. */
+    signal?: () => AbortSignal | undefined;
+};
+type Generated = AsyncGenerator<string | Uint8Array, void, unknown> | Generator<string | Uint8Array, void, unknown>;
+/**
+ * A body driven by a push producer (`sse`, `stream`). `start` runs on the first read with a
+ * sink; when its promise settles the body ends, cleanly or broken if it rejected.
+ */
+export declare function producerStream(start: (sink: ProducerSink) => void | Promise<void>, options?: ProducerOptions): ReadableStream<Uint8Array>;
+/**
+ * A body pulled from a generator, one value per read. Cancel, or the request signal aborting,
+ * calls `generator.return()` so its `finally` runs; a throw breaks the body.
+ */
+export declare function generatorStream(generator: Generated, options?: ProducerOptions): ReadableStream<Uint8Array>;
+export {};

package/dist/streaming/producer-stream.js

@@ -0,0 +1,251 @@
+/**
+ * The one streaming primitive behind `ctx.res.sse()`, `stream()` and `generate()`.
+ *
+ * - The producer starts on the first read, so a body nobody reads (HEAD, a middleware that swaps
+ *   the response, a client gone before the headers) never runs it.
+ * - It ends exactly once: the producer finished, the reader cancelled (client disconnect), or the
+ *   request signal aborted (`ctx.signal`). Cleanups registered with `onEnd` run there, once.
+ * - A write resolves when the reader asks for more, so a producer that awaits its writes never
+ *   queues more than one chunk past demand. A write after the end rejects, marked handled, so an
+ *   unawaited one never surfaces as an unhandled rejection.
+ * - A producer failure that is not the stream's own abort breaks the body, so the client sees an
+ *   aborted transfer instead of a clean end, and goes to `report`.
+ */
+class StreamEnded extends Error {
+    name = "AbortError";
+}
+function swallow() { }
+/** A rejection marked handled: awaiting it still throws, leaving it unawaited never surfaces. */
+function handledRejection(reason) {
+    const rejected = Promise.reject(reason);
+    /* handled, not hidden: the caller who awaits it still gets the rejection */
+    rejected.catch(swallow);
+    return rejected;
+}
+/** The reason the stream aborted with, or an AbortError thrown in answer to it. */
+function isAbortOf(error, signal) {
+    return signal.aborted && (error === signal.reason || (error instanceof Error && error.name === "AbortError"));
+}
+/** Listen for the request ending; the returned function stops listening. */
+function onRequestAbort(request, end) {
+    request.addEventListener("abort", end, { once: true });
+    return () => request.removeEventListener("abort", end);
+}
+function closeQuietly(controller) {
+    try {
+        controller.close();
+    }
+    catch {
+        /* the reader already cancelled */
+    }
+}
+/** The state of one push-driven body: its end, the writers waiting on demand, its cleanups. */
+class Producer {
+    #abort = new AbortController();
+    #cleanups = [];
+    #controller;
+    #ended = false;
+    #waiting = [];
+    #detach = swallow;
+    get signal() {
+        return this.#abort.signal;
+    }
+    get closed() {
+        return this.#ended;
+    }
+    attach(controller) {
+        this.#controller = controller;
+    }
+    close() {
+        if (this.#ended)
+            return;
+        this.#ended = true;
+        closeQuietly(this.#controller);
+        this.#release();
+    }
+    error(error) {
+        if (this.#ended)
+            return;
+        this.#ended = true;
+        this.#controller.error(error);
+        this.#release();
+    }
+    onEnd(fn) {
+        if (this.#ended)
+            fn();
+        else
+            this.#cleanups.push(fn);
+    }
+    write(chunk) {
+        if (this.#ended) {
+            return handledRejection(this.signal.aborted ? this.signal.reason : new StreamEnded("stream closed"));
+        }
+        /* the queue holds nothing ahead of demand (high-water mark 0): every write waits for the next read */
+        this.#controller.enqueue(chunk);
+        const waiter = Promise.withResolvers();
+        /* handled, not hidden: a writer that awaits it still gets the rejection */
+        waiter.promise.catch(swallow);
+        this.#waiting.push(waiter);
+        return waiter.promise;
+    }
+    /** The reader cancelled, or the request ended: abort the producer, then clean up. */
+    cancel(reason) {
+        this.#ended = true;
+        this.#abort.abort(reason ?? new StreamEnded("stream cancelled"));
+        const waiting = this.#waiting;
+        this.#waiting = [];
+        for (const waiter of waiting)
+            waiter.reject(this.signal.reason);
+        this.#release();
+    }
+    /** The reader asked for more: every waiting writer may go on. */
+    demand() {
+        if (this.#waiting.length === 0)
+            return;
+        const waiting = this.#waiting;
+        this.#waiting = [];
+        for (const waiter of waiting)
+            waiter.resolve();
+    }
+    run(start, options) {
+        const request = options?.signal?.();
+        if (request?.aborted === true) {
+            /* the client left before the first read: end without running the producer */
+            this.cancel(request.reason);
+            closeQuietly(this.#controller);
+            return;
+        }
+        if (request !== undefined) {
+            this.#detach = onRequestAbort(request, () => {
+                this.cancel(request.reason);
+                closeQuietly(this.#controller);
+            });
+        }
+        let result;
+        try {
+            result = start(this);
+        }
+        catch (error) {
+            result = Promise.reject(error);
+        }
+        Promise.resolve(result).then(() => this.close(), (error) => {
+            if (isAbortOf(error, this.signal))
+                return;
+            options?.report?.(error);
+            this.error(error);
+        });
+    }
+    #release() {
+        this.demand();
+        this.#detach();
+        this.#detach = swallow;
+        const cleanups = this.#cleanups;
+        this.#cleanups = [];
+        for (const fn of cleanups) {
+            try {
+                fn();
+            }
+            catch {
+                /* one cleanup failing must not keep the others from running */
+            }
+        }
+    }
+}
+/**
+ * A body driven by a push producer (`sse`, `stream`). `start` runs on the first read with a
+ * sink; when its promise settles the body ends, cleanly or broken if it rejected.
+ */
+export function producerStream(start, options) {
+    const producer = new Producer();
+    let started = false;
+    return new ReadableStream({
+        cancel: (reason) => producer.cancel(reason),
+        pull: () => {
+            if (started)
+                return producer.demand();
+            started = true;
+            producer.run(start, options);
+        },
+        start: (controller) => producer.attach(controller),
+    }, { highWaterMark: 0 });
+}
+/** One generator-backed body: a value per read; cancel or the request ending runs its `finally`. */
+class GeneratorPull {
+    #encoder = new TextEncoder();
+    #generator;
+    #options;
+    #controller;
+    #ended = false;
+    #attached = false;
+    #detach = swallow;
+    constructor(generator, options) {
+        this.#generator = generator;
+        this.#options = options;
+    }
+    attach(controller) {
+        this.#controller = controller;
+    }
+    /** End without another value: detach, then let the generator run its `finally`. */
+    stop() {
+        this.#end();
+        /* `return()` on an async generator waits for a pending `next()`, then runs `finally` */
+        Promise.resolve()
+            .then(() => this.#generator.return(undefined))
+            .catch((error) => this.#options?.report?.(error));
+    }
+    async pull() {
+        if (!this.#attached && !this.#listen()) {
+            this.stop();
+            return this.#controller.close();
+        }
+        let step;
+        try {
+            step = await this.#generator.next();
+        }
+        catch (error) {
+            if (this.#ended)
+                return;
+            this.#end();
+            this.#options?.report?.(error);
+            return this.#controller.error(error);
+        }
+        if (this.#ended)
+            return;
+        if (step.done === true) {
+            this.#end();
+            return this.#controller.close();
+        }
+        this.#controller.enqueue(typeof step.value === "string" ? this.#encoder.encode(step.value) : step.value);
+    }
+    /** Follow the request signal from the first read; false when it already aborted. */
+    #listen() {
+        this.#attached = true;
+        const request = this.#options?.signal?.();
+        if (request === undefined)
+            return true;
+        if (request.aborted)
+            return false;
+        this.#detach = onRequestAbort(request, () => {
+            this.stop();
+            closeQuietly(this.#controller);
+        });
+        return true;
+    }
+    #end() {
+        this.#ended = true;
+        this.#detach();
+        this.#detach = swallow;
+    }
+}
+/**
+ * A body pulled from a generator, one value per read. Cancel, or the request signal aborting,
+ * calls `generator.return()` so its `finally` runs; a throw breaks the body.
+ */
+export function generatorStream(generator, options) {
+    const pull = new GeneratorPull(generator, options);
+    return new ReadableStream({
+        cancel: () => pull.stop(),
+        pull: () => pull.pull(),
+        start: (controller) => pull.attach(controller),
+    }, { highWaterMark: 0 });
+}

package/dist/telemetry/fields.d.ts

@@ -0,0 +1,43 @@
+/**
+ * The privacy-safe field catalog (H17): what a log line or a span may say about a request. Paths
+ * go without their query or fragment; cookies, credentials and bodies never appear at all.
+ */
+/** One request-log line's fields (the catalog below), as `requestLog({ skip })` sees them. */
+export type RequestLogEntry = {
+    /** body bytes sent, when the body was counted */
+    readonly bytes?: number;
+    readonly durationMs: number;
+    /** what the body is: json, text, binary, stream, sse, generate or empty */
+    readonly kind: string;
+    readonly method: string;
+    /** without its query */
+    readonly path: string;
+    readonly requestId?: string;
+    /** the route that served it; empty for a request no route served */
+    readonly routeId: string;
+    readonly runtime: string;
+    /** the status sent, or "aborted" when the client left before the body ended */
+    readonly status: number | "aborted";
+};
+/** Every field a request-log line carries; nothing outside it is ever written. */
+export declare const REQUEST_LOG_FIELDS: readonly string[];
+/**
+ * A header whose value is a credential, a cookie or a session: never logged, never a span
+ * attribute. One definition for the request log, spans and curlLogger's redaction.
+ */
+export declare function isSensitiveHeader(name: string): boolean;
+/** The path of `target` (a URL or a path) without its query or fragment; `/` when empty. */
+export declare function pathOf(target: string): string;
+/** The ids a request may carry: its request id, and its trace's ids when it is traced. */
+export type RequestIds = {
+    readonly requestId?: string | undefined;
+    readonly trace?: {
+        readonly spanId: string;
+        readonly traceId: string;
+    } | null;
+};
+/**
+ * What a per-request logger binds: method, the path without its query, the route id, the request
+ * id when set, and the trace's ids when the request is traced (so a line joins its trace).
+ */
+export declare function requestBindings(method: string, path: string, routeId: string, { requestId, trace }?: RequestIds): Record<string, string>;