@telorun/kernel 0.49.0 → 0.50.0

package/src/logging/console-sink.ts

@@ -0,0 +1,86 @@
+import type { LogRecord } from "@telorun/sdk";
+import { decideColor, type ColorSetting } from "./color-precedence.js";
+import { encodeJsonLine, type BytesEncoder } from "./encode-json.js";
+import { encodePrettyLine } from "./encode-pretty.js";
+import type { LogSinkInstance } from "./log-sink.js";
+
+/**
+ * `Telo.ConsoleSink` — a kernel built-in (§10.2).
+ *
+ * Console and file are built-ins rather than standard-library modules because
+ * §16 already requires every conforming runtime to implement both, along with
+ * the `pretty` and `json` encodings, byte-identically. Mandatory runtime
+ * behaviour belongs in the runtime; shipping it as an installable module would
+ * make conformance depend on whether that module happened to be installed.
+ *
+ * Synchronous by default: a developer-facing stream that silently reorders or
+ * drops is worse than a slow one, and `on_full` does not apply to a sink with no
+ * buffer to saturate.
+ */
+
+export type ConsoleEncoding = "auto" | "pretty" | "json";
+export type ConsoleDestination = "stderr" | "stdout";
+
+export interface ConsoleSinkOptions {
+  sinkId: string;
+  level: number;
+  destination?: ConsoleDestination;
+  encoding?: ConsoleEncoding;
+  color?: ColorSetting;
+  /** The host environment — capability signals only, never a config channel. */
+  env: Record<string, string | undefined>;
+  stdout: NodeJS.WritableStream;
+  stderr: NodeJS.WritableStream;
+  encodeBytes?: BytesEncoder;
+}
+
+export class ConsoleSink implements LogSinkInstance {
+  readonly sinkId: string;
+  readonly level: number;
+  /** A file-descriptor write blocks until the bytes are handed to the OS, so a
+   *  `fatal` record is durable by the time `log()` returns (§10.5). */
+  readonly syncFlushable = true;
+
+  readonly #stream: NodeJS.WritableStream;
+  readonly #pretty: boolean;
+  readonly #color: boolean;
+  readonly #encodeBytes: BytesEncoder | undefined;
+
+  constructor(options: ConsoleSinkOptions) {
+    this.sinkId = options.sinkId;
+    this.level = options.level;
+    const destination = options.destination ?? "stderr";
+    this.#stream = destination === "stdout" ? options.stdout : options.stderr;
+
+    // `auto` is evaluated against *this sink's* destination descriptor, not the
+    // process's: a console sink on stdout and another on stderr can resolve
+    // differently, and that is correct.
+    const isTTY = Boolean((this.#stream as { isTTY?: boolean }).isTTY);
+    const encoding = options.encoding ?? "auto";
+    this.#pretty = encoding === "pretty" || (encoding === "auto" && isTTY);
+    this.#color = this.#pretty
+      ? decideColor({ setting: options.color ?? "auto", env: options.env, isTTY })
+      : false;
+    this.#encodeBytes = options.encodeBytes;
+  }
+
+  write(record: LogRecord): void {
+    this.#stream.write(
+      this.#pretty
+        ? encodePrettyLine(record, { color: this.#color })
+        : encodeJsonLine(record, { encodeBytes: this.#encodeBytes }),
+    );
+  }
+
+  async flush(): Promise<void> {
+    // Nothing is held: every record is handed to the descriptor on write.
+  }
+
+  flushSync(): void {
+    // Same — the write already reached the OS.
+  }
+
+  async close(): Promise<void> {
+    // The process owns stdout/stderr; a sink never closes them.
+  }
+}

package/src/logging/debug-wire-sink.ts

@@ -0,0 +1,85 @@
+import type { LogRecord } from "@telorun/sdk";
+import { toJsonProfile, type BytesEncoder } from "./encode-json.js";
+import type { LogSinkInstance } from "./log-sink.js";
+
+/**
+ * The `debug-wire` sink — `kernel/specs/logging.md` §10.2 and §11.4.
+ *
+ * **Not declarable.** It is host-attached when a debug consumer connects
+ * (`--debug` / `--inspect`) and detached on disconnect, which makes it tooling
+ * attachment rather than application configuration — the same category as TTY
+ * detection, not a violation of D6.
+ *
+ * Not sync-flushable: delivery crosses an SSE/stream boundary owned by the host,
+ * so a `fatal` record's flush here is initiated but never awaited (§10.5).
+ */
+
+export const DEBUG_WIRE_SINK_ID = "<debug-wire>";
+
+export class DebugWireSink implements LogSinkInstance {
+  readonly sinkId = DEBUG_WIRE_SINK_ID;
+  readonly level: number;
+  readonly syncFlushable = false;
+
+  readonly #emit: (frame: { kind: "record"; timestamp: string; record: Record<string, unknown> }) => void;
+  readonly #encodeBytes: BytesEncoder | undefined;
+
+  constructor(options: {
+    level: number;
+    /** Hands a §11.4 `record` frame to the host's wire writer. */
+    emit: (frame: { kind: "record"; timestamp: string; record: Record<string, unknown> }) => void;
+    /** Offloads `bytes` attributes to the host's blob store when it has one —
+     *  the debug wire does. Raw bytes are never inlined (§6.1). */
+    encodeBytes?: BytesEncoder;
+  }) {
+    this.level = options.level;
+    this.#emit = options.emit;
+    this.#encodeBytes = options.encodeBytes;
+  }
+
+  write(record: LogRecord): void {
+    const profile = toJsonProfile(record);
+    if (this.#encodeBytes) offloadBytes(profile, this.#encodeBytes);
+    this.#emit({
+      kind: "record",
+      timestamp: new Date(Number(record.timestamp / 1_000_000n)).toISOString(),
+      record: profile,
+    });
+  }
+
+  async flush(): Promise<void> {
+    // Frames are handed to the host synchronously; the host owns delivery.
+  }
+
+  flushSync(): void {
+    // Never synchronously drainable — see the class doc.
+  }
+
+  async close(): Promise<void> {}
+}
+
+/** Replace `Uint8Array` leaves with the host's pointer form, bounded by the
+ *  attribute limits already applied upstream. */
+function offloadBytes(value: unknown, encodeBytes: BytesEncoder): void {
+  const stack: unknown[] = [value];
+  let guard = 0;
+  while (stack.length > 0 && guard < 10_000) {
+    guard += 1;
+    const current = stack.pop();
+    if (!current || typeof current !== "object") continue;
+    if (Array.isArray(current)) {
+      for (let i = 0; i < current.length; i += 1) {
+        const item = current[i];
+        if (item instanceof Uint8Array) current[i] = encodeBytes(item);
+        else stack.push(item);
+      }
+      continue;
+    }
+    const record = current as Record<string, unknown>;
+    for (const key of Object.keys(record)) {
+      const item = record[key];
+      if (item instanceof Uint8Array) record[key] = encodeBytes(item);
+      else stack.push(item);
+    }
+  }
+}

package/src/logging/drop-accounting.ts

@@ -0,0 +1,108 @@
+import type { DropCause } from "./log-sink.js";
+
+/**
+ * Drop accounting — `kernel/specs/logging.md` §10.4.
+ *
+ * A runtime maintains a monotonic counter of records dropped per sink, per
+ * cause. When drops occur and then cease, it emits exactly one `warn` record
+ * reporting the count and the cause. **Dropping without accounting is
+ * non-conformant** — "nothing is silently lost" is a design principle, not a
+ * nice-to-have, so every drop, truncation, and sink failure is counted and
+ * surfaced.
+ */
+
+/** Sampling drops happen before fan-out, so they are not attributable to any one
+ *  sink and are counted against the pipeline itself. */
+export const PIPELINE_SINK_ID = "<pipeline>";
+
+/** How long a cause must go quiet before its recovery warning is emitted. */
+const QUIESCE_MS = 1000;
+
+interface Counter {
+  /** Monotonic across the process lifetime; never reset. */
+  total: number;
+  /** Total as of the last emitted recovery warning. */
+  reported: number;
+  timer: ReturnType<typeof setTimeout> | undefined;
+}
+
+export interface DropReport {
+  sinkId: string;
+  cause: DropCause;
+  /** Records dropped since the previous report. */
+  count: number;
+  /** Monotonic lifetime total for this (sink, cause) pair. */
+  total: number;
+}
+
+export class DropRegistry {
+  readonly #counters = new Map<string, Counter>();
+  readonly #onRecovered: (report: DropReport) => void;
+  /** Guards against a recovery warning that itself drops, which would otherwise
+   *  re-arm the timer forever. */
+  #reporting = false;
+
+  constructor(onRecovered: (report: DropReport) => void) {
+    this.#onRecovered = onRecovered;
+  }
+
+  record(sinkId: string, cause: DropCause, count = 1): void {
+    const key = `${sinkId}\x00${cause}`;
+    let counter = this.#counters.get(key);
+    if (!counter) {
+      counter = { total: 0, reported: 0, timer: undefined };
+      this.#counters.set(key, counter);
+    }
+    // Always count — a drop caused by emitting the recovery warning itself is
+    // still a drop, and undercounting it is exactly the silent loss this class
+    // exists to prevent.
+    counter.total += count;
+
+    // The only thing suppressed while a recovery warning is in flight is the
+    // timer re-arm: re-arming here would loop forever (the warning's own drop
+    // re-arms the timer, which fires and drops again). The increment above keeps
+    // the total honest; the next ordinary drop — or `reportPending` at
+    // shutdown — surfaces it, since `total !== reported`.
+    if (this.#reporting) return;
+
+    if (counter.timer) clearTimeout(counter.timer);
+    counter.timer = setTimeout(() => this.#report(sinkId, cause, counter!), QUIESCE_MS);
+    // A pending drop report must never be the reason a process stays alive.
+    (counter.timer as { unref?: () => void }).unref?.();
+  }
+
+  /** Lifetime total for a (sink, cause) pair. */
+  total(sinkId: string, cause: DropCause): number {
+    return this.#counters.get(`${sinkId}\x00${cause}`)?.total ?? 0;
+  }
+
+  /** Emit any outstanding reports immediately — used at shutdown so a run that
+   *  ends while still dropping does not lose its final accounting. */
+  reportPending(): void {
+    for (const [key, counter] of this.#counters) {
+      if (counter.total === counter.reported) continue;
+      const [sinkId, cause] = key.split("\x00") as [string, DropCause];
+      this.#report(sinkId, cause, counter);
+    }
+  }
+
+  dispose(): void {
+    for (const counter of this.#counters.values()) {
+      if (counter.timer) clearTimeout(counter.timer);
+      counter.timer = undefined;
+    }
+  }
+
+  #report(sinkId: string, cause: DropCause, counter: Counter): void {
+    counter.timer = undefined;
+    const count = counter.total - counter.reported;
+    if (count <= 0) return;
+    counter.reported = counter.total;
+    this.#reporting = true;
+    try {
+      this.#onRecovered({ sinkId, cause, count, total: counter.total });
+    } finally {
+      this.#reporting = false;
+    }
+  }
+}

package/src/logging/encode-json.ts

@@ -0,0 +1,98 @@
+import { formatUnixNano, type AnyValue, type ErrorValue, type LogRecord } from "@telorun/sdk";
+
+/**
+ * The `json` encoding — `kernel/specs/logging.md` §11.1. One JSON object per
+ * line, UTF-8, newline-terminated.
+ *
+ * No de-facto cross-ecosystem standard exists for key names, so Telo defines its
+ * own profile and keeps OTLP as a separate one. Keys are emitted in the §11.1
+ * order for diffability, and extension data belongs in `attributes` — unknown
+ * top-level keys are never emitted.
+ */
+
+/** How a `bytes` attribute is rendered. Raw bytes are never inlined into a text
+ *  encoding: a sink with a blob store offloads them to a pointer, and every
+ *  other sink base64-encodes (§6.1). */
+export type BytesEncoder = (bytes: Uint8Array) => AnyValue;
+
+export const base64Bytes: BytesEncoder = (bytes) => Buffer.from(bytes).toString("base64");
+
+export interface JsonEncodeOptions {
+  encodeBytes?: BytesEncoder;
+}
+
+/** Encode one record as a newline-terminated JSON line. */
+export function encodeJsonLine(record: LogRecord, options: JsonEncodeOptions = {}): string {
+  return `${encodeJson(record, options)}\n`;
+}
+
+/** Encode one record as a JSON object, without the trailing newline — the shape
+ *  the debug wire nests inside its `record` frame (§11.4). */
+export function encodeJson(record: LogRecord, options: JsonEncodeOptions = {}): string {
+  return JSON.stringify(toJsonProfile(record), makeReplacer(options.encodeBytes ?? base64Bytes));
+}
+
+/** The §11.1 key profile as a plain object, in the recommended order. Exposed
+ *  separately because the debug wire embeds the same profile rather than
+ *  re-deriving it. */
+export function toJsonProfile(record: LogRecord): Record<string, unknown> {
+  const out: Record<string, unknown> = {
+    time: formatUnixNano(record.timestamp),
+    level: record.severityText.toUpperCase(),
+    severity: record.severityNumber,
+    msg: record.message,
+  };
+
+  // `observed_timestamp` is deliberately NOT emitted: §11.1 defines a closed key
+  // set and forbids extra top-level keys, and §17's schema is
+  // `additionalProperties: false`. The field survives on the record model and in
+  // the `otlp` profile, which has a real `observedTimeUnixNano` slot for it.
+  if (record.traceId !== undefined) out["trace_id"] = record.traceId;
+  if (record.spanId !== undefined) out["span_id"] = record.spanId;
+  if (record.traceFlags !== undefined) out["trace_flags"] = record.traceFlags;
+  if (record.resource !== undefined) out["resource"] = record.resource;
+  if (record.module !== undefined) out["module"] = record.module;
+  if (record.scope !== undefined) out["scope"] = record.scope;
+  // Nested, never flattened — flattening risks collision with reserved keys.
+  // Emitted with keys in sorted (code-point) order so the `json` encoding is
+  // byte-identical across runtimes (§16 vector 18): attribute keys are arbitrary
+  // user data with no natural order, and sorted is the only order both this
+  // runtime and a Rust `BTreeMap`-backed one produce without extra config.
+  if (record.attributes !== undefined) out["attributes"] = sortKeysDeep(record.attributes);
+  if (record.error !== undefined) out["err"] = record.error satisfies ErrorValue;
+  if (record.eventName !== undefined) out["event_name"] = record.eventName;
+  if (record.droppedAttributesCount) {
+    out["dropped_attributes_count"] = record.droppedAttributesCount;
+  }
+
+  return out;
+}
+
+/** Rebuild an attribute value with every nested object's keys in sorted order.
+ *  `JSON.stringify` emits string keys in insertion order, so reconstructing the
+ *  object with sorted insertion is what pins the byte order. Arrays keep their
+ *  index order; `Uint8Array` is a leaf. The attributes are already normalized
+ *  (§6.3), so depth and breadth are bounded and this cannot diverge. */
+function sortKeysDeep(value: AnyValue): AnyValue {
+  if (value === null || typeof value !== "object") return value;
+  if (value instanceof Uint8Array) return value;
+  if (Array.isArray(value)) return value.map(sortKeysDeep);
+  const sorted: Record<string, AnyValue> = {};
+  for (const key of Object.keys(value).sort()) sorted[key] = sortKeysDeep(value[key]!);
+  return sorted;
+}
+
+function makeReplacer(encodeBytes: BytesEncoder) {
+  return function replacer(this: unknown, _key: string, value: unknown): unknown {
+    if (typeof value === "bigint") {
+      // Values beyond 2^53 lose precision in a JS receiver, so they degrade to a
+      // decimal string rather than to a wrong number — the same reasoning OTLP
+      // gives for quoting its 64-bit fields.
+      return value >= BigInt(Number.MIN_SAFE_INTEGER) && value <= BigInt(Number.MAX_SAFE_INTEGER)
+        ? Number(value)
+        : value.toString();
+    }
+    if (value instanceof Uint8Array) return encodeBytes(value);
+    return value;
+  };
+}

package/src/logging/encode-pretty.ts

@@ -0,0 +1,117 @@
+import { severityFloor, type AnyValue, type ErrorValue, type LogRecord } from "@telorun/sdk";
+
+/**
+ * The `pretty` encoding — `kernel/specs/logging.md` §11.2. For humans on a
+ * terminal:
+ *
+ *     12:34:56.789 INFO  Http.Server.api  listening  net.host.port=8080
+ *
+ * The color table is a modal synthesis across pino-pretty, zap, tint,
+ * tracing-subscriber, consola, and winston, which do not fully agree — zap alone
+ * uses magenta for DEBUG and blue for INFO, and TRACE has no consensus. It is a
+ * deliberate choice, not a standard.
+ */
+
+const RESET = "\u001b[0m";
+
+const LEVEL_COLOR: Readonly<Record<number, string>> = {
+  1: "\u001b[2m", // TRACE — dim
+  5: "\u001b[34m", // DEBUG — blue
+  9: "\u001b[32m", // INFO — green
+  13: "\u001b[33m", // WARN — yellow
+  17: "\u001b[31m", // ERROR — red
+  21: "\u001b[1;41m", // FATAL — bold, red background
+};
+
+const DIM = "\u001b[2m";
+
+export interface PrettyEncodeOptions {
+  color: boolean;
+}
+
+export function encodePrettyLine(record: LogRecord, options: PrettyEncodeOptions): string {
+  return `${encodePretty(record, options)}\n`;
+}
+
+export function encodePretty(record: LogRecord, options: PrettyEncodeOptions): string {
+  const paint = options.color
+    ? (code: string, text: string) => `${code}${text}${RESET}`
+    : (_code: string, text: string) => text;
+
+  const parts: string[] = [
+    formatLocalTime(record.timestamp),
+    paint(LEVEL_COLOR[severityFloor(record.severityNumber)]!, record.severityText.padEnd(5)),
+  ];
+
+  if (record.resource) parts.push(`${record.resource.kind}.${record.resource.name}`);
+
+  // The message itself is never colored by level — only the level token is.
+  parts.push(record.message);
+
+  const attributes = record.attributes;
+  if (attributes) {
+    for (const [key, value] of Object.entries(attributes)) {
+      parts.push(`${paint(DIM, key)}=${formatAttributeValue(value)}`);
+    }
+  }
+
+  if (record.droppedAttributesCount) {
+    parts.push(`${paint(DIM, "dropped_attributes_count")}=${record.droppedAttributesCount}`);
+  }
+
+  let line = parts.join("  ");
+
+  if (record.error) line += `\n${formatError(record.error, paint)}`;
+
+  return line;
+}
+
+/** `HH:MM:ss.SSS`, local timezone. Millisecond resolution: the sub-millisecond
+ *  digits of the record's nanosecond timestamp are noise on a console line. */
+function formatLocalTime(timestamp: bigint): string {
+  const date = new Date(Number(timestamp / 1_000_000n));
+  const hh = String(date.getHours()).padStart(2, "0");
+  const mm = String(date.getMinutes()).padStart(2, "0");
+  const ss = String(date.getSeconds()).padStart(2, "0");
+  const ms = String(date.getMilliseconds()).padStart(3, "0");
+  return `${hh}:${mm}:${ss}.${ms}`;
+}
+
+function formatAttributeValue(value: AnyValue): string {
+  if (value === null) return "null";
+  if (value instanceof Uint8Array) return `<${value.byteLength} bytes>`;
+  if (typeof value === "object") return quoteIfNeeded(JSON.stringify(value, jsonSafe));
+  return quoteIfNeeded(String(value));
+}
+
+/** Values containing whitespace, `"`, or `=` must be quoted so the `key=value`
+ *  stream stays unambiguously parseable by eye. */
+function quoteIfNeeded(text: string): string {
+  return /[\s"=]/.test(text) ? JSON.stringify(text) : text;
+}
+
+function jsonSafe(_key: string, value: unknown): unknown {
+  if (typeof value === "bigint") return value.toString();
+  if (value instanceof Uint8Array) return `<${value.byteLength} bytes>`;
+  return value;
+}
+
+/** Errors render after the message; the stack goes on following lines,
+ *  indented, unmodified. The `cause` chain follows, already bounded by §6.3. */
+function formatError(error: ErrorValue, paint: (code: string, text: string) => string): string {
+  const lines: string[] = [`  ${paint(LEVEL_COLOR[17]!, error.type)}: ${error.message}`];
+  if (error.stack) {
+    for (const line of error.stack.split("\n")) lines.push(`    ${line}`);
+  }
+  let cause = error.cause;
+  let guard = 0;
+  while (cause && guard < 16) {
+    lines.push(`  ${paint(DIM, "caused by")} ${cause.type}: ${cause.message}`);
+    if (cause.stack) {
+      for (const line of cause.stack.split("\n")) lines.push(`    ${line}`);
+    }
+    cause = cause.cause;
+    guard += 1;
+  }
+  return lines.join("\n");
+}

package/src/logging/file-sink.ts

@@ -0,0 +1,87 @@
+import { closeSync, openSync, writeSync } from "node:fs";
+import type { LogRecord } from "@telorun/sdk";
+import { encodeJsonLine, type BytesEncoder } from "./encode-json.js";
+import { encodePrettyLine } from "./encode-pretty.js";
+import { DEFAULT_BUFFER_POLICY, type LogSinkInstance, type SinkBufferPolicy } from "./log-sink.js";
+import { RecordBuffer } from "./record-buffer.js";
+
+/**
+ * `Telo.FileSink` — a kernel built-in (§10.2). Asynchronous, `json` by default.
+ *
+ * Sync-flushable: a positional write is available on every target platform, so a
+ * `fatal` record is durable by the time `log()` returns. That is what makes the
+ * file sink a legitimate audit destination while an OTLP sink is not — delivery
+ * there is a network round-trip that cannot complete without yielding.
+ */
+
+export type FileEncoding = "json" | "pretty";
+
+export interface FileSinkOptions {
+  sinkId: string;
+  level: number;
+  destination: string;
+  encoding?: FileEncoding;
+  policy?: SinkBufferPolicy;
+  onDrop: () => void;
+  encodeBytes?: BytesEncoder;
+}
+
+export class FileSink implements LogSinkInstance {
+  readonly sinkId: string;
+  readonly level: number;
+  readonly syncFlushable = true;
+
+  readonly #buffer: RecordBuffer;
+  readonly #encode: (record: LogRecord) => string;
+  readonly #fd: number;
+  #timer: ReturnType<typeof setInterval> | undefined;
+  #closed = false;
+
+  constructor(options: FileSinkOptions) {
+    this.sinkId = options.sinkId;
+    this.level = options.level;
+    const policy = options.policy ?? DEFAULT_BUFFER_POLICY;
+    this.#buffer = new RecordBuffer(policy, options.onDrop);
+    const encoding = options.encoding ?? "json";
+    this.#encode =
+      encoding === "pretty"
+        ? (record) => encodePrettyLine(record, { color: false })
+        : (record) => encodeJsonLine(record, { encodeBytes: options.encodeBytes });
+
+    this.#fd = openSync(options.destination, "a");
+
+    this.#timer = setInterval(() => this.flushSync(), policy.flushIntervalMs);
+    // A pending flush tick must never be the reason a process stays alive; the
+    // shutdown flush is what guarantees the tail is written.
+    (this.#timer as { unref?: () => void }).unref?.();
+  }
+
+  write(record: LogRecord): void {
+    if (this.#closed) return;
+    this.#buffer.push(record);
+  }
+
+  async flush(): Promise<void> {
+    this.flushSync();
+  }
+
+  flushSync(): void {
+    if (this.#closed) return;
+    const records = this.#buffer.drain();
+    if (records.length === 0) return;
+    let payload = "";
+    for (const record of records) payload += this.#encode(record);
+    writeSync(this.#fd, payload);
+  }
+
+  async close(): Promise<void> {
+    if (this.#closed) return;
+    this.flushSync();
+    this.#closed = true;
+    if (this.#timer) {
+      clearInterval(this.#timer);
+      this.#timer = undefined;
+    }
+    closeSync(this.#fd);
+  }
+}

package/src/logging/index.ts

@@ -0,0 +1,65 @@
+/**
+ * Structured logging — the Node.js implementation of `kernel/specs/logging.md`.
+ *
+ * The record model, severity scale, and `Logger` surface live in `@telorun/sdk`
+ * because module authors consume them; everything here is the runtime half —
+ * the pipeline, the encodings, the sinks, and the policies that gate emission.
+ * The redaction path grammar lives in `@telorun/analyzer` so `telo check` and
+ * the runtime share one parser rather than two that can drift.
+ */
+
+export { BOOTSTRAP_SINK_ID, createBootstrapWriter } from "./bootstrap-writer.js";
+export { decideColor } from "./color-precedence.js";
+export type { ColorDecisionInput, ColorSetting } from "./color-precedence.js";
+export { ConsoleSink } from "./console-sink.js";
+export { DEBUG_WIRE_SINK_ID, DebugWireSink } from "./debug-wire-sink.js";
+export type { ConsoleDestination, ConsoleEncoding, ConsoleSinkOptions } from "./console-sink.js";
+export { DropRegistry, PIPELINE_SINK_ID } from "./drop-accounting.js";
+export type { DropReport } from "./drop-accounting.js";
+export { base64Bytes, encodeJson, encodeJsonLine, toJsonProfile } from "./encode-json.js";
+export type { BytesEncoder, JsonEncodeOptions } from "./encode-json.js";
+export { encodePretty, encodePrettyLine } from "./encode-pretty.js";
+export type { PrettyEncodeOptions } from "./encode-pretty.js";
+export { FileSink } from "./file-sink.js";
+export type { FileEncoding, FileSinkOptions } from "./file-sink.js";
+export {
+  BLOCK_UNSUPPORTED,
+  blockUnsupportedMessage,
+  DEFAULT_BUFFER_POLICY,
+} from "./log-sink.js";
+export type { DropCause, LogSinkInstance, OnFull, SinkBufferPolicy } from "./log-sink.js";
+export { LoggingPipeline, ROOT_SCOPE_CONFIG } from "./logging-pipeline.js";
+export type { PipelineOptions, ScopeConfig, TraceContextProvider } from "./logging-pipeline.js";
+export {
+  DEFAULT_ATTRIBUTE_LIMITS,
+  normalizeAttributes,
+} from "./normalize-attributes.js";
+export type { AttributeLimits, NormalizedAttributes, NormalizeOptions } from "./normalize-attributes.js";
+export {
+  compileRedactionPolicy,
+  DEFAULT_CENSOR,
+  EMPTY_REDACTION_POLICY,
+  redactAttributes,
+  redactError,
+} from "./redact-attributes.js";
+export type { CompiledRedactionPath, RedactionPolicy } from "./redact-attributes.js";
+export { RecordBuffer } from "./record-buffer.js";
+export { Sampler } from "./sampler.js";
+export type { SamplingConfig } from "./sampler.js";
+export {
+  formatSpanCounter,
+  formatSpanId,
+  newTraceId,
+  normalizeSpanId,
+  normalizeTraceId,
+  saltSpanId,
+} from "./span-id.js";
+export { toErrorValue } from "./to-error-value.js";
+export {
+  formatTraceParent,
+  parseTraceParent,
+  parseTraceState,
+  TRACE_FLAG_RANDOM,
+  TRACE_FLAG_SAMPLED,
+} from "./trace-parent.js";
+export type { TraceContext } from "./trace-parent.js";