mercury-composable 4.12.1 → 4.12.15

package/dist/src/otel/index.js

@@ -0,0 +1,65 @@
+import { getLogger } from '../log.js';
+import { DISTRIBUTED_TRACE_FORWARDER } from '../trace.js';
+import { FORWARDING_SWITCH, HEADERS, settingsFromConfig } from './config.js';
+import { Exporter } from './export.js';
+import { hex, spanFromDataset } from './span.js';
+export { DISTRIBUTED_TRACE_FORWARDER } from '../trace.js';
+export { FORWARDING_SWITCH, fixedSettings, parseHeaders, settingsFromConfig } from './config.js';
+export { describeHttpFailure, Exporter, ExportFailure, INSTRUMENTATION_SCOPE } from './export.js';
+export { attribute, parseIso8601Nanos, spanFromDataset } from './span.js';
+export { encodeExportRequest, partialSuccess, ProtoReader, ProtoWriter, SPAN_FLAGS_SAMPLED_LOCAL } from './otlp.js';
+const log = getLogger('mercury.otel');
+/** The engines run the forwarder with two workers. */
+export const FORWARDER_INSTANCES = 2;
+/**
+ * The `distributed.trace.forwarder` function bound to one exporter: map the
+ * dataset to a span and export it, logging - never throwing - a failure.
+ */
+export function forwarder(exporter) {
+    return async (_headers, body) => {
+        // a dataset without W3C-valid ids cannot become a span without forging ids - skipped
+        const span = spanFromDataset(body);
+        if (!span)
+            return;
+        try {
+            await exporter.export(span);
+        }
+        catch (e) {
+            const failure = e;
+            log.warn(`OTLP export failed for span ${hex(span.spanId)} of trace ${hex(span.traceId)} - ` +
+                failure.message);
+        }
+    };
+}
+/** Whether `otel.forwarding` is switched on (the text `true`, case-insensitive). */
+export function enabled(config) {
+    const value = config.getProperty(FORWARDING_SWITCH);
+    return value !== undefined && value.trim().toLowerCase() === 'true';
+}
+/**
+ * Register the built-in forwarder on `distributed.trace.forwarder` when
+ * `otel.forwarding=true` - the host's start-up hook. Returns the exporter, or
+ * undefined when forwarding is off or a function already occupies the route (an
+ * application's own forwarder wins, as in the engines). A misconfigured endpoint
+ * fails the start.
+ */
+export function activate(config, registry) {
+    if (!enabled(config))
+        return undefined;
+    if (registry.exists(DISTRIBUTED_TRACE_FORWARDER)) {
+        log.info(`${DISTRIBUTED_TRACE_FORWARDER} is provided by the application - the built-in ` +
+            'OpenTelemetry forwarder stands down');
+        return undefined;
+    }
+    const exporter = new Exporter(settingsFromConfig(config));
+    const names = exporter.headerNames();
+    log.info(`OpenTelemetry trace forwarder ready - service=${exporter.serviceName}, OTLP ` +
+        `endpoint=${exporter.endpoint}, compression=${exporter.compression}, credential ` +
+        `headers=${JSON.stringify(names)}`);
+    if (!names.length) {
+        log.info(`No OTLP credential header yet (${HEADERS} unset) - it is re-read on every export, ` +
+            'so a credential published later takes effect without a restart');
+    }
+    registry.register(DISTRIBUTED_TRACE_FORWARDER, forwarder(exporter), { instances: FORWARDER_INSTANCES, isPrivate: true });
+    return exporter;
+}

package/dist/src/otel/otlp.d.ts

@@ -0,0 +1,104 @@
+/**
+ * The OTLP wire format - a hand-written protobuf encoder for the one message the
+ * forwarder sends, `ExportTraceServiceRequest`, and a reader for the one it
+ * receives, `ExportTraceServiceResponse` (the Rust port's `otlp.rs`, line for line).
+ *
+ * No protobuf library, no generated code, no OpenTelemetry SDK: the OTLP v1 trace
+ * schema is frozen and the forwarder needs eight message types with scalar fields.
+ * Field numbers are the OTLP trace.proto / common.proto / resource.proto /
+ * trace_service.proto definitions; the encoding rules are
+ * https://protobuf.dev/programming-guides/encoding/
+ *
+ *   ExportTraceServiceRequest { repeated ResourceSpans resource_spans = 1; }
+ *   ResourceSpans   { Resource resource = 1; repeated ScopeSpans scope_spans = 2; }
+ *   Resource        { repeated KeyValue attributes = 1; }
+ *   ScopeSpans      { InstrumentationScope scope = 1; repeated Span spans = 2; }
+ *   InstrumentationScope { string name = 1; string version = 2; }
+ *   KeyValue        { string key = 1; AnyValue value = 2; }
+ *   AnyValue        { oneof value { string string_value = 1; bool bool_value = 2;
+ *                                   int64 int_value = 3; double double_value = 4; } }
+ *   Span            { bytes trace_id = 1; bytes span_id = 2; bytes parent_span_id = 4;
+ *                     string name = 5; SpanKind kind = 6; fixed64 start_time_unix_nano = 7;
+ *                     fixed64 end_time_unix_nano = 8; repeated KeyValue attributes = 9;
+ *                     Status status = 15; fixed32 flags = 16; }
+ *   Status          { string message = 2; StatusCode code = 3; }
+ *   ExportTraceServiceResponse { ExportTracePartialSuccess partial_success = 1; }
+ *   ExportTracePartialSuccess  { int64 rejected_spans = 1; string error_message = 2; }
+ */
+import { Span } from './span.js';
+export declare const WIRE_VARINT = 0;
+export declare const WIRE_FIXED64 = 1;
+export declare const WIRE_LEN = 2;
+export declare const WIRE_FIXED32 = 5;
+export declare const SPAN_FLAGS_SAMPLED_LOCAL = 257;
+/**
+ * A minimal protobuf writer: field tags, varints, fixed-width scalars and
+ * length-delimited payloads. Proto3 default values are omitted, except for
+ * `oneof` members (which have explicit presence) - the `*Always` methods.
+ */
+export declare class ProtoWriter {
+    private chunks;
+    intoBytes(): Uint8Array;
+    /** Base-128 varint: little-endian groups of 7 bits, high bit = more follows. */
+    varint(value: number | bigint): void;
+    private tag;
+    /** `string` - omitted when empty (proto3 default). */
+    string(field: number, value: string): void;
+    /** A `oneof` string member - always written, even when empty. */
+    stringAlways(field: number, value: string): void;
+    /** `bytes` - omitted when empty. */
+    bytes(field: number, value: Uint8Array): void;
+    /** An embedded message - always written (an empty message is meaningful). */
+    message(field: number, body: Uint8Array): void;
+    /** `uint32` / `uint64` / enum - omitted when zero. */
+    uint(field: number, value: number): void;
+    /** A `oneof` `int64` member - always written (two's complement varint). */
+    int64Always(field: number, value: number | bigint): void;
+    /** `fixed64` - omitted when zero. */
+    fixed64(field: number, value: bigint): void;
+    /** A `oneof` `double` member - always written (IEEE-754, little-endian). */
+    doubleAlways(field: number, value: number): void;
+    /** `fixed32` - omitted when zero. */
+    fixed32(field: number, value: number): void;
+}
+/** The OTLP `Span` message for one mapped span. */
+export declare function spanMessage(span: Span): Uint8Array;
+/**
+ * One `ExportTraceServiceRequest` carrying one span under one resource and one
+ * instrumentation scope - the request body of an OTLP/HTTP export.
+ */
+export declare function encodeExportRequest(serviceName: string, scopeName: string, scopeVersion: string, span: Span): Uint8Array;
+/**
+ * A minimal, bounds-checked protobuf reader - enough to walk the OTLP message
+ * tree (the response's `partial_success`, and the test collector's decoding of
+ * what this host sent). Every read returns `undefined` past the end instead of
+ * throwing, so a malformed body is reported, never fatal.
+ */
+export declare class ProtoReader {
+    private readonly buf;
+    private pos;
+    private readonly view;
+    constructor(buf: Uint8Array);
+    hasMore(): boolean;
+    /** The next field tag as `[fieldNumber, wireType]`. */
+    readTag(): [number, number] | undefined;
+    readVarint(): bigint | undefined;
+    readFixed64(): bigint | undefined;
+    readDouble(): number | undefined;
+    readFixed32(): number | undefined;
+    /** A length-delimited chunk: bytes, a string, or an embedded message. */
+    readBytes(): Uint8Array | undefined;
+    readString(): string | undefined;
+    /** Advance past a field whose value is not needed, honouring its wire type. */
+    skip(wire: number): boolean;
+}
+/**
+ * The `partial_success` block of an `ExportTraceServiceResponse`: a backend
+ * that accepted the request but rejected spans says so here.
+ */
+export interface PartialSuccess {
+    rejectedSpans: number;
+    errorMessage: string;
+}
+/** The response's partial-success block when it carries content, else undefined. */
+export declare function partialSuccess(body: Uint8Array): PartialSuccess | undefined;

package/dist/src/otel/otlp.js

@@ -0,0 +1,358 @@
+/**
+ * The OTLP wire format - a hand-written protobuf encoder for the one message the
+ * forwarder sends, `ExportTraceServiceRequest`, and a reader for the one it
+ * receives, `ExportTraceServiceResponse` (the Rust port's `otlp.rs`, line for line).
+ *
+ * No protobuf library, no generated code, no OpenTelemetry SDK: the OTLP v1 trace
+ * schema is frozen and the forwarder needs eight message types with scalar fields.
+ * Field numbers are the OTLP trace.proto / common.proto / resource.proto /
+ * trace_service.proto definitions; the encoding rules are
+ * https://protobuf.dev/programming-guides/encoding/
+ *
+ *   ExportTraceServiceRequest { repeated ResourceSpans resource_spans = 1; }
+ *   ResourceSpans   { Resource resource = 1; repeated ScopeSpans scope_spans = 2; }
+ *   Resource        { repeated KeyValue attributes = 1; }
+ *   ScopeSpans      { InstrumentationScope scope = 1; repeated Span spans = 2; }
+ *   InstrumentationScope { string name = 1; string version = 2; }
+ *   KeyValue        { string key = 1; AnyValue value = 2; }
+ *   AnyValue        { oneof value { string string_value = 1; bool bool_value = 2;
+ *                                   int64 int_value = 3; double double_value = 4; } }
+ *   Span            { bytes trace_id = 1; bytes span_id = 2; bytes parent_span_id = 4;
+ *                     string name = 5; SpanKind kind = 6; fixed64 start_time_unix_nano = 7;
+ *                     fixed64 end_time_unix_nano = 8; repeated KeyValue attributes = 9;
+ *                     Status status = 15; fixed32 flags = 16; }
+ *   Status          { string message = 2; StatusCode code = 3; }
+ *   ExportTraceServiceResponse { ExportTracePartialSuccess partial_success = 1; }
+ *   ExportTracePartialSuccess  { int64 rejected_spans = 1; string error_message = 2; }
+ */
+import { STATUS_UNSET } from './span.js';
+// protobuf wire types (the low 3 bits of a field tag)
+export const WIRE_VARINT = 0;
+export const WIRE_FIXED64 = 1;
+export const WIRE_LEN = 2;
+export const WIRE_FIXED32 = 5;
+// OTLP span flags: bits 0-7 are the W3C trace flags (0x01 = sampled), bit 8 says
+// the is-remote bit is known, bit 9 is the is-remote bit itself. A span this host
+// produced is sampled and local - the value the Java SDK writes.
+export const SPAN_FLAGS_SAMPLED_LOCAL = 0x0101;
+const encoder = new TextEncoder();
+const decoder = new TextDecoder('utf-8');
+const MASK_64 = (1n << 64n) - 1n;
+/**
+ * A minimal protobuf writer: field tags, varints, fixed-width scalars and
+ * length-delimited payloads. Proto3 default values are omitted, except for
+ * `oneof` members (which have explicit presence) - the `*Always` methods.
+ */
+export class ProtoWriter {
+    chunks = [];
+    intoBytes() {
+        return Uint8Array.from(this.chunks);
+    }
+    /** Base-128 varint: little-endian groups of 7 bits, high bit = more follows. */
+    varint(value) {
+        let v = typeof value === 'bigint' ? value : BigInt(Math.trunc(value));
+        if (v < 0n) {
+            v &= MASK_64; // two's complement, 64-bit
+        }
+        for (;;) {
+            const byte = Number(v & 0x7fn);
+            v >>= 7n;
+            if (v === 0n) {
+                this.chunks.push(byte);
+                return;
+            }
+            this.chunks.push(byte | 0x80);
+        }
+    }
+    tag(field, wire) {
+        this.varint((field << 3) | wire);
+    }
+    /** `string` - omitted when empty (proto3 default). */
+    string(field, value) {
+        if (value) {
+            this.bytes(field, encoder.encode(value));
+        }
+    }
+    /** A `oneof` string member - always written, even when empty. */
+    stringAlways(field, value) {
+        const data = encoder.encode(value);
+        this.tag(field, WIRE_LEN);
+        this.varint(data.length);
+        this.chunks.push(...data);
+    }
+    /** `bytes` - omitted when empty. */
+    bytes(field, value) {
+        if (value.length) {
+            this.tag(field, WIRE_LEN);
+            this.varint(value.length);
+            this.chunks.push(...value);
+        }
+    }
+    /** An embedded message - always written (an empty message is meaningful). */
+    message(field, body) {
+        this.tag(field, WIRE_LEN);
+        this.varint(body.length);
+        this.chunks.push(...body);
+    }
+    /** `uint32` / `uint64` / enum - omitted when zero. */
+    uint(field, value) {
+        if (value !== 0) {
+            this.tag(field, WIRE_VARINT);
+            this.varint(value);
+        }
+    }
+    /** A `oneof` `int64` member - always written (two's complement varint). */
+    int64Always(field, value) {
+        this.tag(field, WIRE_VARINT);
+        this.varint(value);
+    }
+    /** `fixed64` - omitted when zero. */
+    fixed64(field, value) {
+        if (value !== 0n) {
+            this.tag(field, WIRE_FIXED64);
+            const buf = new Uint8Array(8);
+            new DataView(buf.buffer).setBigUint64(0, value & MASK_64, true);
+            this.chunks.push(...buf);
+        }
+    }
+    /** A `oneof` `double` member - always written (IEEE-754, little-endian). */
+    doubleAlways(field, value) {
+        this.tag(field, WIRE_FIXED64);
+        const buf = new Uint8Array(8);
+        new DataView(buf.buffer).setFloat64(0, value, true);
+        this.chunks.push(...buf);
+    }
+    /** `fixed32` - omitted when zero. */
+    fixed32(field, value) {
+        if (value !== 0) {
+            this.tag(field, WIRE_FIXED32);
+            const buf = new Uint8Array(4);
+            new DataView(buf.buffer).setUint32(0, value, true);
+            this.chunks.push(...buf);
+        }
+    }
+}
+function anyValue(value) {
+    const w = new ProtoWriter();
+    switch (value.type) {
+        case 'string':
+            w.stringAlways(1, value.value);
+            break;
+        case 'int':
+            w.int64Always(3, value.value);
+            break;
+        case 'double':
+            w.doubleAlways(4, value.value);
+            break;
+    }
+    return w.intoBytes();
+}
+function keyValue(key, value) {
+    const w = new ProtoWriter();
+    w.string(1, key);
+    w.message(2, anyValue(value));
+    return w.intoBytes();
+}
+function resource(serviceName) {
+    const w = new ProtoWriter();
+    w.message(1, keyValue('service.name', { type: 'string', value: serviceName }));
+    return w.intoBytes();
+}
+function instrumentationScope(name, version) {
+    const w = new ProtoWriter();
+    w.string(1, name);
+    w.string(2, version);
+    return w.intoBytes();
+}
+function status(span) {
+    if (span.statusCode === STATUS_UNSET && !span.statusMessage) {
+        return undefined;
+    }
+    const w = new ProtoWriter();
+    w.string(2, span.statusMessage);
+    w.uint(3, span.statusCode);
+    return w.intoBytes();
+}
+/** The OTLP `Span` message for one mapped span. */
+export function spanMessage(span) {
+    const w = new ProtoWriter();
+    w.bytes(1, span.traceId);
+    w.bytes(2, span.spanId);
+    if (span.parentSpanId) {
+        w.bytes(4, span.parentSpanId);
+    }
+    w.string(5, span.name);
+    w.uint(6, span.kind);
+    w.fixed64(7, span.startUnixNano);
+    w.fixed64(8, span.endUnixNano);
+    for (const [key, value] of span.attributes) {
+        w.message(9, keyValue(key, value));
+    }
+    const st = status(span);
+    if (st) {
+        w.message(15, st);
+    }
+    w.fixed32(16, SPAN_FLAGS_SAMPLED_LOCAL);
+    return w.intoBytes();
+}
+/**
+ * One `ExportTraceServiceRequest` carrying one span under one resource and one
+ * instrumentation scope - the request body of an OTLP/HTTP export.
+ */
+export function encodeExportRequest(serviceName, scopeName, scopeVersion, span) {
+    const scopeSpans = new ProtoWriter();
+    scopeSpans.message(1, instrumentationScope(scopeName, scopeVersion));
+    scopeSpans.message(2, spanMessage(span));
+    const resourceSpans = new ProtoWriter();
+    resourceSpans.message(1, resource(serviceName));
+    resourceSpans.message(2, scopeSpans.intoBytes());
+    const request = new ProtoWriter();
+    request.message(1, resourceSpans.intoBytes());
+    return request.intoBytes();
+}
+// ---------------------------------------------------------------------------
+// reading
+// ---------------------------------------------------------------------------
+/**
+ * A minimal, bounds-checked protobuf reader - enough to walk the OTLP message
+ * tree (the response's `partial_success`, and the test collector's decoding of
+ * what this host sent). Every read returns `undefined` past the end instead of
+ * throwing, so a malformed body is reported, never fatal.
+ */
+export class ProtoReader {
+    buf;
+    pos = 0;
+    view;
+    constructor(buf) {
+        this.buf = buf;
+        this.view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+    }
+    hasMore() {
+        return this.pos < this.buf.length;
+    }
+    /** The next field tag as `[fieldNumber, wireType]`. */
+    readTag() {
+        const tag = this.readVarint();
+        if (tag === undefined) {
+            return undefined;
+        }
+        return [Number(tag >> 3n), Number(tag & 0x7n)];
+    }
+    readVarint() {
+        let result = 0n;
+        let shift = 0n;
+        for (;;) {
+            if (this.pos >= this.buf.length) {
+                return undefined;
+            }
+            const byte = this.buf[this.pos++];
+            if (shift > 63n) {
+                return undefined;
+            }
+            result |= BigInt(byte & 0x7f) << shift;
+            if ((byte & 0x80) === 0) {
+                return result;
+            }
+            shift += 7n;
+        }
+    }
+    readFixed64() {
+        if (this.pos + 8 > this.buf.length) {
+            return undefined;
+        }
+        const value = this.view.getBigUint64(this.pos, true);
+        this.pos += 8;
+        return value;
+    }
+    readDouble() {
+        if (this.pos + 8 > this.buf.length) {
+            return undefined;
+        }
+        const value = this.view.getFloat64(this.pos, true);
+        this.pos += 8;
+        return value;
+    }
+    readFixed32() {
+        if (this.pos + 4 > this.buf.length) {
+            return undefined;
+        }
+        const value = this.view.getUint32(this.pos, true);
+        this.pos += 4;
+        return value;
+    }
+    /** A length-delimited chunk: bytes, a string, or an embedded message. */
+    readBytes() {
+        const length = this.readVarint();
+        if (length === undefined) {
+            return undefined;
+        }
+        const n = Number(length);
+        if (this.pos + n > this.buf.length) {
+            return undefined;
+        }
+        const out = this.buf.subarray(this.pos, this.pos + n);
+        this.pos += n;
+        return out;
+    }
+    readString() {
+        const data = this.readBytes();
+        return data === undefined ? undefined : decoder.decode(data);
+    }
+    /** Advance past a field whose value is not needed, honouring its wire type. */
+    skip(wire) {
+        switch (wire) {
+            case WIRE_VARINT: return this.readVarint() !== undefined;
+            case WIRE_FIXED64: return this.readFixed64() !== undefined;
+            case WIRE_LEN: return this.readBytes() !== undefined;
+            case WIRE_FIXED32: return this.readFixed32() !== undefined;
+            default: return false;
+        }
+    }
+}
+/** The response's partial-success block when it carries content, else undefined. */
+export function partialSuccess(body) {
+    const reader = new ProtoReader(body);
+    let result;
+    while (reader.hasMore()) {
+        const tag = reader.readTag();
+        if (!tag)
+            return undefined;
+        const [field, wire] = tag;
+        if (field === 1 && wire === WIRE_LEN) {
+            const block = reader.readBytes();
+            if (!block)
+                return undefined;
+            const inner = new ProtoReader(block);
+            const partial = { rejectedSpans: 0, errorMessage: '' };
+            while (inner.hasMore()) {
+                const innerTag = inner.readTag();
+                if (!innerTag)
+                    return undefined;
+                const [f, w] = innerTag;
+                if (f === 1 && w === WIRE_VARINT) {
+                    const value = inner.readVarint();
+                    if (value === undefined)
+                        return undefined;
+                    partial.rejectedSpans = Number(BigInt.asIntN(64, value));
+                }
+                else if (f === 2 && w === WIRE_LEN) {
+                    const text = inner.readString();
+                    if (text === undefined)
+                        return undefined;
+                    partial.errorMessage = text;
+                }
+                else if (!inner.skip(w)) {
+                    return undefined;
+                }
+            }
+            result = partial;
+        }
+        else if (!reader.skip(wire)) {
+            return undefined;
+        }
+    }
+    if (result && (result.rejectedSpans !== 0 || result.errorMessage)) {
+        return result;
+    }
+    return undefined;
+}

package/dist/src/otel/span.d.ts

@@ -0,0 +1,67 @@
+/**
+ * The telemetry dataset -> OpenTelemetry span mapping (the engines'
+ * `TraceMetricsSpanData` / the Rust port's `span.rs`).
+ *
+ * The host has already produced the W3C-compatible trace id, span id and parent
+ * span id during execution, so the span built here carries those EXACT ids - an
+ * OpenTelemetry tracer would mint new ones and break the lineage. A dataset whose
+ * ids are not W3C-valid (32 / 16 lowercase hex, not all zeros) is skipped rather
+ * than exported with forged ids.
+ *
+ * | Dataset metric | Span |
+ * |----------------|------|
+ * | `id` | trace id |
+ * | `span_id` | span id |
+ * | `parent_span_id` | parent span id (a root span when absent) |
+ * | `service` (route) | span name (`path`, then `task`, when absent) |
+ * | `start` + `exec_time` | start / end timestamps |
+ * | `success` / `status` / `exception` | status OK, or ERROR with a description |
+ * | `service` = `http.request` (the edge's round-trip record) | kind SERVER (every function execution is INTERNAL) |
+ * | `path`, `from`, `origin`, `status`, `exec_time_ms`, `round_trip_ms`, `exception` | attributes |
+ * | `service` | the `route` attribute |
+ * | `annotations` entries | `annotation.<key>` attributes |
+ */
+export declare const KIND_INTERNAL = 1;
+export declare const KIND_SERVER = 2;
+export declare const STATUS_UNSET = 0;
+export declare const STATUS_OK = 1;
+export declare const STATUS_ERROR = 2;
+/** An OTLP AnyValue - the scalar shapes the mapping emits. */
+export type AttributeValue = {
+    type: 'string';
+    value: string;
+} | {
+    type: 'int';
+    value: number;
+} | {
+    type: 'double';
+    value: number;
+};
+/** One completed span, ready for the OTLP encoder. */
+export interface Span {
+    traceId: Uint8Array;
+    spanId: Uint8Array;
+    parentSpanId?: Uint8Array;
+    name: string;
+    kind: number;
+    startUnixNano: bigint;
+    endUnixNano: bigint;
+    attributes: Array<[string, AttributeValue]>;
+    statusCode: number;
+    statusMessage: string;
+}
+export declare function hex(bytes: Uint8Array): string;
+/** The value of a span attribute, as text (numbers rendered the way the collector tests read them). */
+export declare function attribute(span: Span, key: string): string | undefined;
+/**
+ * Map one telemetry dataset (`{trace: {...}, annotations: {...}}`) to a span -
+ * undefined when the dataset has no `trace` block or its trace / span id is
+ * not W3C-valid.
+ */
+export declare function spanFromDataset(dataset: unknown): Span | undefined;
+/**
+ * Parse an ISO-8601 UTC instant (`YYYY-MM-DDTHH:MM:SS[.fraction]Z`, the shape the
+ * engines and this host write) to nanoseconds since the Unix epoch - the inverse of
+ * the envelope formatter, with no date library (days from civil per Howard Hinnant).
+ */
+export declare function parseIso8601Nanos(text: string): bigint | undefined;