@foam-ai/node 0.1.0-alpha.1 → 0.1.0-alpha.11

package/dist/network-capture/redact.js

@@ -0,0 +1,401 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSensitiveBodyKey = isSensitiveBodyKey;
+exports.isNdjsonMediaType = isNdjsonMediaType;
+exports.isJsonSequenceMediaType = isJsonSequenceMediaType;
+exports.isTextualBodyMediaType = isTextualBodyMediaType;
+exports.redactBodyText = redactBodyText;
+const constants_js_1 = require("../constants.js");
+const redaction_js_1 = require("../redaction.js");
+const NDJSON_MEDIA_TYPES = new Set([
+    "application/json-stream",
+    "application/jsonl",
+    "application/jsonlines",
+    "application/ndjson",
+    "application/stream+json",
+    "application/x-json-stream",
+    "application/x-jsonlines",
+    "application/x-ldjson",
+    "application/x-ndjson",
+]);
+const JSON_SEQUENCE_MEDIA_TYPES = new Set([
+    "application/json-seq",
+    "application/x-json-seq",
+]);
+const XML_MEDIA_TYPES = new Set([
+    "application/xml",
+    "text/html",
+    "text/xml",
+]);
+const YAML_MEDIA_TYPES = new Set([
+    "application/x-yaml",
+    "application/yaml",
+    "text/x-yaml",
+    "text/yaml",
+]);
+function rawHeader(value) {
+    const first = Array.isArray(value) ? value[0] : value;
+    return typeof first === "string" ? first : "";
+}
+function parseContentType(value) {
+    const raw = rawHeader(value);
+    const media = (raw.split(";", 1)[0] ?? "").trim().toLowerCase();
+    const params = new Map();
+    const pattern = /;\s*([^=;\s]+)\s*=\s*(?:"([^"]*)"|([^;]*))/g;
+    let match;
+    while ((match = pattern.exec(raw)) !== null) {
+        params.set(match[1].toLowerCase(), (match[2] ?? match[3] ?? "").trim());
+    }
+    return { media, params };
+}
+function isSensitiveBodyKey(key) {
+    return (0, redaction_js_1.keyMatch)(key) !== undefined;
+}
+function isNdjsonMediaType(media) {
+    return (NDJSON_MEDIA_TYPES.has(media) ||
+        media.endsWith("+ndjson") ||
+        media.endsWith("/ndjson"));
+}
+function isJsonSequenceMediaType(media) {
+    return JSON_SEQUENCE_MEDIA_TYPES.has(media) || media.endsWith("+json-seq");
+}
+function isTextualBodyMediaType(media) {
+    return (media.startsWith("text/") ||
+        media.startsWith("multipart/") ||
+        media.endsWith("/json") ||
+        media.endsWith("+json") ||
+        media.endsWith("/xml") ||
+        media.endsWith("+xml") ||
+        media.endsWith("/yaml") ||
+        media.endsWith("+yaml") ||
+        isNdjsonMediaType(media) ||
+        isJsonSequenceMediaType(media) ||
+        media === "application/x-www-form-urlencoded");
+}
+function redactNode(node, state) {
+    if (typeof node === "string") {
+        const value = (0, redaction_js_1.redactString)(node);
+        if (value !== node)
+            state.changed = true;
+        return value;
+    }
+    if (Array.isArray(node)) {
+        return node.map((item) => redactNode(item, state));
+    }
+    if (node !== null && typeof node === "object") {
+        const result = {};
+        for (const [key, value] of Object.entries(node)) {
+            const match = (0, redaction_js_1.keyMatch)(key);
+            if (match && value !== null && value !== undefined) {
+                result[key] = (0, redaction_js_1.maskForMatch)(match, value);
+                state.changed = true;
+            }
+            else {
+                result[key] = redactNode(value, state);
+            }
+        }
+        return result;
+    }
+    return node;
+}
+const JSON_PAIR_PATTERN = /"((?:[^"\\]|\\.)*)"(\s*:\s*)("(?:[^"\\]|\\.)*"?|-?\d[\d.eE+-]*|true|false|null)/g;
+function fallbackMask(kind) {
+    return kind === "secret" ? constants_js_1.FULL_MASK : constants_js_1.REDACTED_VALUE;
+}
+function redactJsonFallback(text) {
+    let changed = false;
+    const redacted = text.replace(JSON_PAIR_PATTERN, (match, key, separator) => {
+        const kind = (0, redaction_js_1.keyMatch)(key);
+        if (!kind)
+            return match;
+        changed = true;
+        return `"${key}"${separator}"${fallbackMask(kind)}"`;
+    });
+    return changed ? { text: redacted, changed } : { text, changed: false };
+}
+function redactJson(text) {
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        return redactJsonFallback(text);
+    }
+    const state = { changed: false };
+    const redacted = redactNode(parsed, state);
+    return state.changed
+        ? { text: JSON.stringify(redacted), changed: true }
+        : { text, changed: false };
+}
+function redactByLine(text, redactLine) {
+    let changed = false;
+    const lines = text.split("\n").map((raw) => {
+        const hasCr = raw.endsWith("\r");
+        const line = hasCr ? raw.slice(0, -1) : raw;
+        if (!line)
+            return raw;
+        const result = redactLine(line);
+        if (!result.changed)
+            return raw;
+        changed = true;
+        return hasCr ? `${result.text}\r` : result.text;
+    });
+    return changed
+        ? { text: lines.join("\n"), changed: true }
+        : { text, changed: false };
+}
+function redactNdjson(text) {
+    return redactByLine(text, redactJson);
+}
+function redactJsonSequence(text) {
+    if (!text.includes("\u001e"))
+        return redactJson(text);
+    let changed = false;
+    const segments = text.split("\u001e");
+    const redacted = segments.map((segment, index) => {
+        if (index === 0 || !segment)
+            return segment;
+        const ending = segment.match(/(?:\r\n|\n|\r)$/)?.[0] ?? "";
+        const document = ending ? segment.slice(0, -ending.length) : segment;
+        const result = redactJson(document);
+        if (!result.changed)
+            return segment;
+        changed = true;
+        return `${result.text}${ending}`;
+    });
+    return changed
+        ? { text: redacted.join("\u001e"), changed: true }
+        : { text, changed: false };
+}
+function redactSseBlock(block) {
+    const lineEnding = block.match(/\r\n|\n|\r/)?.[0] ?? "\n";
+    const lines = block.split(/\r\n|\n|\r/);
+    const data = [];
+    lines.forEach((line, index) => {
+        const match = /^(data: ?)(.*)$/.exec(line);
+        if (match) {
+            data.push({ index, prefix: match[1], value: match[2] });
+        }
+    });
+    if (data.length === 0)
+        return { text: block, changed: false };
+    const payload = data.map((entry) => entry.value).join("\n");
+    const json = redactJson(payload);
+    const plain = json.changed ? json : redactPlainText(payload);
+    if (!plain.changed)
+        return { text: block, changed: false };
+    lines[data[0].index] = `${data[0].prefix}${plain.text}`;
+    for (let index = data.length - 1; index >= 1; index -= 1) {
+        lines.splice(data[index].index, 1);
+    }
+    return { text: lines.join(lineEnding), changed: true };
+}
+function redactSse(text) {
+    const separator = /(\r\n\r\n|\n\n|\r\r)/;
+    const parts = text.split(separator);
+    let changed = false;
+    for (let index = 0; index < parts.length; index += 2) {
+        const result = redactSseBlock(parts[index]);
+        if (result.changed) {
+            parts[index] = result.text;
+            changed = true;
+        }
+    }
+    return changed
+        ? { text: parts.join(""), changed: true }
+        : { text, changed: false };
+}
+function redactForm(text) {
+    const params = new URLSearchParams(text);
+    let changed = false;
+    for (const key of new Set(params.keys())) {
+        if (!(0, redaction_js_1.keyMatch)(key) && !(0, redaction_js_1.isSensitiveQueryKey)(key))
+            continue;
+        params.set(key, constants_js_1.REDACTED_VALUE);
+        changed = true;
+    }
+    return changed
+        ? { text: params.toString(), changed: true }
+        : { text, changed: false };
+}
+function localName(name) {
+    const separator = name.lastIndexOf(":");
+    return separator < 0 ? name : name.slice(separator + 1);
+}
+function escapePattern(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function redactXmlElements(text) {
+    let changed = false;
+    let cursor = 0;
+    let output = "";
+    const opening = /<([A-Za-z_][\w:.-]*)(?:\s[^>]*)?>/g;
+    let match;
+    while ((match = opening.exec(text)) !== null) {
+        if (match[0].endsWith("/>"))
+            continue;
+        const kind = (0, redaction_js_1.keyMatch)(localName(match[1]));
+        if (!kind)
+            continue;
+        const closing = new RegExp(`</${escapePattern(match[1])}\\s*>`, "g");
+        closing.lastIndex = opening.lastIndex;
+        const close = closing.exec(text);
+        output += text.slice(cursor, opening.lastIndex);
+        if (!close) {
+            output += fallbackMask(kind);
+            cursor = text.length;
+            changed = true;
+            break;
+        }
+        const value = text.slice(opening.lastIndex, close.index);
+        output += `${value.includes("<") ? fallbackMask(kind) : (0, redaction_js_1.maskForMatch)(kind, value)}${close[0]}`;
+        cursor = closing.lastIndex;
+        opening.lastIndex = cursor;
+        changed = true;
+    }
+    if (!changed)
+        return { text, changed: false };
+    return { text: output + text.slice(cursor), changed: true };
+}
+function redactXml(text) {
+    const elements = redactXmlElements(text);
+    let changed = elements.changed;
+    let output = elements.text;
+    output = output.replace(/(\s)([A-Za-z_:][\w:.-]*)(\s*=\s*)(["'])(.*?)\4/g, (match, spacing, name, separator, quote, value) => {
+        const kind = (0, redaction_js_1.keyMatch)(localName(name));
+        if (!kind)
+            return match;
+        changed = true;
+        return `${spacing}${name}${separator}${quote}${(0, redaction_js_1.maskForMatch)(kind, value)}${quote}`;
+    });
+    output = output.replace(/<input\b[^>]*>/gi, (tag) => {
+        const name = /\bname\s*=\s*(["'])(.*?)\1/i.exec(tag)?.[2];
+        if (!name || (!(0, redaction_js_1.keyMatch)(name) && !(0, redaction_js_1.isSensitiveQueryKey)(name)))
+            return tag;
+        const replaced = tag.replace(/(\bvalue\s*=\s*)(["'])(.*?)\2/i, `$1$2${constants_js_1.REDACTED_VALUE}$2`);
+        if (replaced === tag)
+            return tag;
+        changed = true;
+        return replaced;
+    });
+    return changed ? { text: output, changed: true } : { text, changed: false };
+}
+const YAML_PAIR = /^(\s*(?:-\s*)?)(["']?)([A-Za-z_][\w.-]*)\2(\s*:\s*)(.*)$/;
+function redactYaml(text) {
+    let blockSecret = false;
+    const result = redactByLine(text, (line) => {
+        const match = YAML_PAIR.exec(line);
+        if (!match)
+            return { text: line, changed: false };
+        const kind = (0, redaction_js_1.keyMatch)(match[3]);
+        if (!kind)
+            return { text: line, changed: false };
+        if (/^[>|]/.test(match[5].trim()))
+            blockSecret = true;
+        return {
+            text: `${match[1]}${match[2]}${match[3]}${match[2]}${match[4]}${(0, redaction_js_1.maskForMatch)(kind, match[5].trim().replace(/^(["'])(.*)\1$/, "$2"))}`,
+            changed: true,
+        };
+    });
+    return blockSecret ? { text: constants_js_1.REDACTED_VALUE, changed: true } : result;
+}
+function redactPlainText(text) {
+    const trimmed = text.trimStart();
+    if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+        const json = redactJson(text);
+        if (json.changed)
+            return json;
+    }
+    const yaml = redactYaml(text);
+    if (yaml.changed)
+        return yaml;
+    const redacted = (0, redaction_js_1.redactString)(text);
+    return redacted === text
+        ? { text, changed: false }
+        : { text: redacted, changed: true };
+}
+function contentDispositionName(headers) {
+    const line = headers
+        .split(/\r\n|\n|\r/)
+        .find((header) => /^content-disposition\s*:/i.test(header));
+    return line ? /\bname\s*=\s*(?:"([^"]*)"|([^;\s]*))/i.exec(line)?.slice(1).find(Boolean) : undefined;
+}
+function partContentType(headers) {
+    return headers
+        .split(/\r\n|\n|\r/)
+        .find((header) => /^content-type\s*:/i.test(header))
+        ?.replace(/^[^:]+:\s*/, "");
+}
+function redactMultipart(text, boundary) {
+    if (!boundary || boundary.length > 70)
+        return { text, changed: false };
+    const marker = `--${boundary}`;
+    if (!text.includes(marker))
+        return { text, changed: false };
+    let changed = false;
+    const parts = text.split(marker);
+    for (let index = 1; index < parts.length; index += 1) {
+        const part = parts[index];
+        if (part.startsWith("--"))
+            continue;
+        const leading = part.match(/^(?:\r\n|\n|\r)/)?.[0] ?? "";
+        const content = leading ? part.slice(leading.length) : part;
+        const separator = /\r\n\r\n|\n\n|\r\r/.exec(content);
+        if (!separator?.index)
+            continue;
+        const headers = content.slice(0, separator.index);
+        const bodyWithEnding = content.slice(separator.index + separator[0].length);
+        const ending = bodyWithEnding.match(/(?:\r\n|\n|\r)$/)?.[0] ?? "";
+        const body = ending
+            ? bodyWithEnding.slice(0, -ending.length)
+            : bodyWithEnding;
+        const name = contentDispositionName(headers);
+        let result;
+        if (name && ((0, redaction_js_1.keyMatch)(name) || (0, redaction_js_1.isSensitiveQueryKey)(name))) {
+            result = { text: constants_js_1.REDACTED_VALUE, changed: true };
+        }
+        else if (/\bfilename\s*=/i.test(headers)) {
+            result = { text: body, changed: false };
+        }
+        else {
+            result = redactBodyText(body, partContentType(headers) ?? "text/plain");
+        }
+        if (!result.changed)
+            continue;
+        parts[index] = `${leading}${headers}${separator[0]}${result.text}${ending}`;
+        changed = true;
+    }
+    return changed
+        ? { text: parts.join(marker), changed: true }
+        : { text, changed: false };
+}
+function redactBodyText(text, contentType) {
+    const { media, params } = parseContentType(contentType);
+    if (media === "application/x-www-form-urlencoded")
+        return redactForm(text);
+    if (media === "text/event-stream")
+        return redactSse(text);
+    if (isJsonSequenceMediaType(media))
+        return redactJsonSequence(text);
+    if (isNdjsonMediaType(media))
+        return redactNdjson(text);
+    if (media.endsWith("/json") || media.endsWith("+json"))
+        return redactJson(text);
+    if (media.startsWith("multipart/")) {
+        return redactMultipart(text, params.get("boundary") ?? "");
+    }
+    if (XML_MEDIA_TYPES.has(media) ||
+        media.endsWith("/xml") ||
+        media.endsWith("+xml")) {
+        return redactXml(text);
+    }
+    if (YAML_MEDIA_TYPES.has(media) ||
+        media.endsWith("/yaml") ||
+        media.endsWith("+yaml")) {
+        return redactYaml(text);
+    }
+    if (media.startsWith("text/") || params.has("charset")) {
+        return redactPlainText(text);
+    }
+    return { text, changed: false };
+}

package/dist/network-capture/support.d.ts

@@ -0,0 +1,2 @@
+export declare function isHttpCaptureSupported(nodeVersion?: string | undefined): boolean;
+export declare function isUndiciCaptureSupported(undiciVersion?: string | undefined): boolean;

package/dist/network-capture/support.js

@@ -0,0 +1,38 @@
+"use strict";
+// Foam only wires its network-capture hooks when the runtime is one the OTel
+// instrumentation actually supports; otherwise the instrumentation would never
+// invoke them, so patching objects or subscribing to diagnostics channels
+// would be pointless. Floors come from the instrumentation packages:
+//
+// - @opentelemetry/instrumentation-http: engines "^18.19.0 || >=20.6.0"
+// - @opentelemetry/instrumentation-undici: undici >= 5.12.0, the release that
+//   added the undici:request:* diagnostics channels it (and Foam) rely on.
+//
+// All floors end in .0, so comparing major.minor is enough.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isHttpCaptureSupported = isHttpCaptureSupported;
+exports.isUndiciCaptureSupported = isUndiciCaptureSupported;
+function parseVersion(raw) {
+    const match = raw === undefined ? null : /^v?(\d+)\.(\d+)\./.exec(raw);
+    if (!match)
+        return undefined;
+    return { major: Number(match[1]), minor: Number(match[2]) };
+}
+function isHttpCaptureSupported(nodeVersion = process.versions.node) {
+    const version = parseVersion(nodeVersion);
+    if (!version)
+        return false;
+    if (version.major === 18)
+        return version.minor >= 19;
+    return version.major > 20 || (version.major === 20 && version.minor >= 6);
+}
+// process.versions.undici reports the bundled undici (global fetch) and is
+// present on every Node version Foam supports. It counts even when the app
+// also installed an older undici copy: capture stays useful for fetch, and
+// the old copy simply emits no channel events. Unknown means unsupported.
+function isUndiciCaptureSupported(undiciVersion = process.versions.undici) {
+    const version = parseVersion(undiciVersion);
+    if (!version)
+        return false;
+    return version.major > 5 || (version.major === 5 && version.minor >= 12);
+}

package/dist/network-capture/undici.d.ts

@@ -0,0 +1,5 @@
+import type { RequestHookFunction, ResponseHookFunction } from "@opentelemetry/instrumentation-undici";
+export declare function createUndiciNetworkCaptureHooks(bodyCaptureEnabled?: boolean): {
+    requestHook: RequestHookFunction;
+    responseHook: ResponseHookFunction;
+};

package/dist/network-capture/undici.js

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createUndiciNetworkCaptureHooks = createUndiciNetworkCaptureHooks;
+const api_1 = require("@opentelemetry/api");
+const node_diagnostics_channel_1 = require("node:diagnostics_channel");
+const utils_js_1 = require("../utils.js");
+const collector_js_1 = require("./collector.js");
+const undiciSessions = new WeakMap();
+const legacyWrappedRequests = new WeakSet();
+let undiciBodyChannelsBound = false;
+function appendHeader(headers, rawName, value) {
+    const name = String(rawName).toLowerCase();
+    const existing = headers[name];
+    if (existing === undefined)
+        headers[name] = value;
+    else if (Array.isArray(existing))
+        existing.push(value);
+    else
+        headers[name] = [existing, value];
+}
+function undiciRequestHeaders(value) {
+    const headers = {};
+    if (typeof value === "string") {
+        for (const line of value.split("\r\n")) {
+            const separator = line.indexOf(":");
+            if (separator <= 0)
+                continue;
+            appendHeader(headers, line.slice(0, separator).trim(), line.slice(separator + 1).trim());
+        }
+    }
+    else if (Array.isArray(value)) {
+        for (let index = 0; index + 1 < value.length; index += 2) {
+            appendHeader(headers, value[index], value[index + 1]);
+        }
+    }
+    return headers;
+}
+function undiciResponseHeaders(value) {
+    if (!Array.isArray(value))
+        return {};
+    const headers = {};
+    for (let index = 0; index + 1 < value.length; index += 2) {
+        const name = value[index];
+        const headerValue = value[index + 1];
+        appendHeader(headers, Buffer.isBuffer(name) ? name.toString("latin1") : name, Buffer.isBuffer(headerValue)
+            ? headerValue.toString("latin1")
+            : headerValue);
+    }
+    return headers;
+}
+function undiciRequest(message) {
+    if (!message || typeof message !== "object" || !("request" in message)) {
+        return undefined;
+    }
+    const request = message.request;
+    return request && typeof request === "object"
+        ? request
+        : undefined;
+}
+function undiciCollector(session, direction) {
+    const field = direction === "request" ? "requestBody" : "responseBody";
+    const existing = session[field];
+    if (existing)
+        return existing;
+    const headers = direction === "request" ? session.requestHeaders : session.responseHeaders;
+    if (!headers)
+        return undefined;
+    const created = collector_js_1.BodyCollector.create(session.span, "client", direction, () => headers);
+    if (created)
+        session[field] = created;
+    return created;
+}
+function finishUndici(request, complete) {
+    const session = undiciSessions.get(request);
+    if (!session)
+        return;
+    undiciSessions.delete(request);
+    session.requestBody?.finalize(complete);
+    session.responseBody?.finalize(complete);
+}
+function bindUndiciChannel(name, handle) {
+    (0, node_diagnostics_channel_1.subscribe)(name, (message) => {
+        (0, utils_js_1.safely)(() => {
+            const request = undiciRequest(message);
+            if (!request)
+                return;
+            const session = undiciSessions.get(request);
+            if (!session)
+                return;
+            handle(message, request, session);
+        });
+    });
+}
+function wrapLegacyBodyMethod(request, name, direction) {
+    const target = request;
+    const original = target[name];
+    if (typeof original !== "function")
+        return;
+    target[name] = function (chunk, ...rest) {
+        const result = original.call(this, chunk, ...rest);
+        (0, utils_js_1.safely)(() => {
+            const session = undiciSessions.get(request);
+            if (!session || session.modernBodyChannels)
+                return;
+            undiciCollector(session, direction)?.observe(chunk);
+        });
+        return result;
+    };
+}
+function bindLegacyUndiciBodyMethods(request) {
+    if (legacyWrappedRequests.has(request))
+        return;
+    legacyWrappedRequests.add(request);
+    wrapLegacyBodyMethod(request, "onBodySent", "request");
+    wrapLegacyBodyMethod(request, "onData", "response");
+    wrapLegacyBodyMethod(request, "onResponseData", "response");
+}
+function bindUndiciBodyChannels() {
+    if (undiciBodyChannelsBound)
+        return;
+    undiciBodyChannelsBound = true;
+    (0, node_diagnostics_channel_1.subscribe)("undici:request:create", (message) => {
+        (0, utils_js_1.safely)(() => {
+            const request = undiciRequest(message);
+            if (request)
+                bindLegacyUndiciBodyMethods(request);
+        });
+    });
+    bindUndiciChannel("undici:request:bodyChunkSent", (message, _request, session) => {
+        session.modernBodyChannels = true;
+        undiciCollector(session, "request")?.observe(message.chunk);
+    });
+    bindUndiciChannel("undici:request:bodySent", (_message, _request, session) => {
+        session.requestBody?.finalize(true);
+    });
+    bindUndiciChannel("undici:request:bodyChunkReceived", (message, _request, session) => {
+        session.modernBodyChannels = true;
+        undiciCollector(session, "response")?.observe(message.chunk);
+    });
+    bindUndiciChannel("undici:request:trailers", (_message, request) => {
+        finishUndici(request, true);
+    });
+    bindUndiciChannel("undici:request:error", (_message, request) => {
+        finishUndici(request, false);
+    });
+}
+function createUndiciNetworkCaptureHooks(bodyCaptureEnabled = true) {
+    if (bodyCaptureEnabled)
+        bindUndiciBodyChannels();
+    return {
+        requestHook(span, request) {
+            (0, utils_js_1.safely)(() => {
+                const headers = undiciRequestHeaders(request.headers);
+                (0, collector_js_1.setHeaderAttributes)(span, "request", headers);
+                if (!bodyCaptureEnabled ||
+                    !span.isRecording() ||
+                    (span.spanContext().traceFlags & api_1.TraceFlags.SAMPLED) !==
+                        api_1.TraceFlags.SAMPLED) {
+                    return;
+                }
+                undiciSessions.set(request, { span, requestHeaders: headers });
+                bindLegacyUndiciBodyMethods(request);
+            });
+        },
+        responseHook(span, info) {
+            (0, utils_js_1.safely)(() => {
+                const headers = undiciResponseHeaders(info.response.headers);
+                (0, collector_js_1.setHeaderAttributes)(span, "response", headers);
+                if (!bodyCaptureEnabled || info.request === undefined)
+                    return;
+                const session = undiciSessions.get(info.request);
+                if (session)
+                    session.responseHeaders = headers;
+            });
+        },
+    };
+}

package/dist/otlp.d.ts

@@ -0,0 +1,8 @@
+import type { SeverityNumber } from "@opentelemetry/api-logs";
+export declare function sendOtlpLog({ token, resourceAttributes, scopeName, severityNumber, body, }: {
+    token: string;
+    resourceAttributes: Record<string, string>;
+    scopeName: string;
+    severityNumber: SeverityNumber;
+    body: string;
+}): Promise<void>;

package/dist/otlp.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendOtlpLog = sendOtlpLog;
+const constants_js_1 = require("./constants.js");
+const endpoint_js_1 = require("./endpoint.js");
+// pcga11: Pipeline-independent OTLP log delivery.
+// Use when the SDK's LoggerProvider/exporter never got set up or is
+// broken (diagnostics). Not a client surface: no batching, no resource
+// detectors, no trace correlation, one fetch per record. Client logs go
+// through the Foam LoggerProvider in logs.ts.
+async function sendOtlpLog({ token, resourceAttributes, scopeName, severityNumber, body, }) {
+    try {
+        await fetch(`${endpoint_js_1.endpoint}${constants_js_1.FOAM_OTLP_LOGS_PATH}`, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${token}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                resourceLogs: [
+                    {
+                        resource: {
+                            attributes: Object.entries(resourceAttributes).map(([key, value]) => ({ key, value: { stringValue: value } })),
+                        },
+                        scopeLogs: [
+                            {
+                                scope: { name: scopeName },
+                                logRecords: [
+                                    {
+                                        timeUnixNano: String(BigInt(Date.now()) * 1000000n),
+                                        severityNumber,
+                                        severityText: constants_js_1.SEVERITY_TEXT[severityNumber],
+                                        body: { stringValue: body },
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                ],
+            }),
+        });
+    }
+    catch {
+        // pcga11: do not remove this catch block. Ingest must never throw into application code.
+    }
+}

package/dist/propagation.d.ts

@@ -0,0 +1,5 @@
+import { type Context } from "@opentelemetry/api";
+export declare function injectTraceContext(carrier: Record<string, string>): void;
+export declare function extractTraceContext(carrier: Record<string, string>): Context;
+export declare function setBaggage<T>(key: string, value: string, callback: () => T): T | undefined;
+export declare function getBaggage(key: string): string | undefined;