@omote/core 0.9.1 → 0.9.2

package/dist/chunk-Y3DTP5P3.mjs

@@ -0,0 +1,927 @@
+// src/logging/types.ts
+var LOG_LEVEL_PRIORITY = {
+  error: 0,
+  warn: 1,
+  info: 2,
+  debug: 3,
+  trace: 4,
+  verbose: 5
+};
+var DEFAULT_LOGGING_CONFIG = {
+  level: "info",
+  enabled: true,
+  format: "pretty",
+  timestamps: true,
+  includeModule: true
+};
+
+// src/logging/formatters.ts
+var COLORS = {
+  reset: "\x1B[0m",
+  red: "\x1B[31m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  cyan: "\x1B[36m",
+  gray: "\x1B[90m",
+  white: "\x1B[37m",
+  magenta: "\x1B[35m"
+};
+var LEVEL_COLORS = {
+  error: COLORS.red,
+  warn: COLORS.yellow,
+  info: COLORS.blue,
+  debug: COLORS.cyan,
+  trace: COLORS.magenta,
+  verbose: COLORS.gray
+};
+var LEVEL_NAMES = {
+  error: "ERROR  ",
+  warn: "WARN   ",
+  info: "INFO   ",
+  debug: "DEBUG  ",
+  trace: "TRACE  ",
+  verbose: "VERBOSE"
+};
+var isBrowser = typeof window !== "undefined";
+function formatTimestamp(timestamp) {
+  const date = new Date(timestamp);
+  return date.toISOString().substring(11, 23);
+}
+function safeStringify(data) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  return JSON.stringify(data, (key, value) => {
+    if (typeof value === "object" && value !== null) {
+      if (seen.has(value)) {
+        return "[Circular]";
+      }
+      seen.add(value);
+    }
+    if (value instanceof Error) {
+      return {
+        name: value.name,
+        message: value.message,
+        stack: value.stack
+      };
+    }
+    if (value instanceof Float32Array || value instanceof Int16Array) {
+      return `${value.constructor.name}(${value.length})`;
+    }
+    if (ArrayBuffer.isView(value)) {
+      return `${value.constructor.name}(${value.byteLength})`;
+    }
+    return value;
+  });
+}
+var jsonFormatter = (entry) => {
+  const output = {
+    timestamp: entry.timestamp,
+    level: entry.level,
+    module: entry.module,
+    message: entry.message
+  };
+  if (entry.data && Object.keys(entry.data).length > 0) {
+    output.data = entry.data;
+  }
+  if (entry.error) {
+    output.error = {
+      name: entry.error.name,
+      message: entry.error.message,
+      stack: entry.error.stack
+    };
+  }
+  return safeStringify(output);
+};
+var prettyFormatter = (entry) => {
+  const time = formatTimestamp(entry.timestamp);
+  const level = LEVEL_NAMES[entry.level];
+  const module = entry.module;
+  const message = entry.message;
+  let output;
+  if (isBrowser) {
+    output = `${time} ${level} [${module}] ${message}`;
+  } else {
+    const color = LEVEL_COLORS[entry.level];
+    output = `${COLORS.gray}${time}${COLORS.reset} ${color}${level}${COLORS.reset} ${COLORS.cyan}[${module}]${COLORS.reset} ${message}`;
+  }
+  if (entry.data && Object.keys(entry.data).length > 0) {
+    const dataStr = safeStringify(entry.data);
+    if (dataStr.length > 80) {
+      output += "\n  " + JSON.stringify(entry.data, null, 2).replace(/\n/g, "\n  ");
+    } else {
+      output += " " + dataStr;
+    }
+  }
+  if (entry.error) {
+    output += `
+  ${entry.error.name}: ${entry.error.message}`;
+    if (entry.error.stack) {
+      const stackLines = entry.error.stack.split("\n").slice(1, 4);
+      output += "\n  " + stackLines.join("\n  ");
+    }
+  }
+  return output;
+};
+function getFormatter(format) {
+  return format === "json" ? jsonFormatter : prettyFormatter;
+}
+function createBrowserConsoleArgs(entry) {
+  const time = formatTimestamp(entry.timestamp);
+  const level = entry.level.toUpperCase().padEnd(7);
+  const module = entry.module;
+  const message = entry.message;
+  const styles = {
+    time: "color: gray;",
+    error: "color: red; font-weight: bold;",
+    warn: "color: orange; font-weight: bold;",
+    info: "color: blue;",
+    debug: "color: cyan;",
+    trace: "color: magenta;",
+    verbose: "color: gray;",
+    module: "color: teal; font-weight: bold;",
+    message: "color: inherit;"
+  };
+  let formatStr = "%c%s %c%s %c[%s]%c %s";
+  const args = [
+    styles.time,
+    time,
+    styles[entry.level],
+    level,
+    styles.module,
+    module,
+    styles.message,
+    message
+  ];
+  if (entry.data && Object.keys(entry.data).length > 0) {
+    formatStr += " %o";
+    args.push(entry.data);
+  }
+  return [formatStr, ...args];
+}
+
+// src/telemetry/exporters/console.ts
+var ConsoleExporter = class {
+  constructor(options = {}) {
+    this.enabled = options.enabled ?? true;
+    this.prefix = options.prefix ?? "[Omote Telemetry]";
+  }
+  exportSpan(span) {
+    if (!this.enabled) return;
+    const statusIcon = span.status === "ok" ? "\u2713" : "\u2717";
+    const statusColor = span.status === "ok" ? "color: green" : "color: red";
+    console.groupCollapsed(
+      `%c${this.prefix} %c${statusIcon} ${span.name} %c(${span.durationMs.toFixed(2)}ms)`,
+      "color: gray",
+      statusColor,
+      "color: gray"
+    );
+    console.log("Trace ID:", span.traceId);
+    console.log("Span ID:", span.spanId);
+    if (span.parentSpanId) {
+      console.log("Parent Span ID:", span.parentSpanId);
+    }
+    console.log("Duration:", `${span.durationMs.toFixed(2)}ms`);
+    console.log("Status:", span.status);
+    if (Object.keys(span.attributes).length > 0) {
+      console.log("Attributes:", span.attributes);
+    }
+    if (span.error) {
+      console.error("Error:", span.error);
+    }
+    console.groupEnd();
+  }
+  exportMetric(metric) {
+    if (!this.enabled) return;
+    const typeIcon = metric.type === "counter" ? "\u2191" : "\u{1F4CA}";
+    console.log(
+      `%c${this.prefix} %c${typeIcon} ${metric.name}: %c${metric.value}`,
+      "color: gray",
+      "color: blue",
+      "color: black; font-weight: bold",
+      metric.attributes
+    );
+  }
+  async flush() {
+  }
+  async shutdown() {
+    this.enabled = false;
+  }
+};
+
+// src/telemetry/exporters/otlp.ts
+var StatusCode = {
+  UNSET: 0,
+  OK: 1,
+  ERROR: 2
+};
+function spanToOTLP(span, serviceName, serviceVersion) {
+  const attributes = Object.entries(span.attributes).filter(([, v]) => v !== void 0).map(([key, value]) => ({
+    key,
+    value: typeof value === "string" ? { stringValue: value } : typeof value === "number" ? Number.isInteger(value) ? { intValue: value } : { doubleValue: value } : { boolValue: value }
+  }));
+  return {
+    resourceSpans: [{
+      resource: {
+        attributes: [
+          { key: "service.name", value: { stringValue: serviceName } },
+          { key: "service.version", value: { stringValue: serviceVersion } },
+          { key: "telemetry.sdk.name", value: { stringValue: "omote-sdk" } },
+          { key: "telemetry.sdk.language", value: { stringValue: "javascript" } }
+        ]
+      },
+      scopeSpans: [{
+        scope: {
+          name: "omote-sdk",
+          version: serviceVersion
+        },
+        spans: [{
+          traceId: span.traceId,
+          spanId: span.spanId,
+          parentSpanId: span.parentSpanId || "",
+          name: span.name,
+          kind: 1,
+          // INTERNAL
+          startTimeUnixNano: String(span.startTime * 1e6),
+          endTimeUnixNano: String(span.endTime * 1e6),
+          attributes,
+          status: {
+            code: span.status === "ok" ? StatusCode.OK : StatusCode.ERROR,
+            message: span.error?.message || ""
+          }
+        }]
+      }]
+    }]
+  };
+}
+function metricToOTLP(metric, serviceName, serviceVersion) {
+  const attributes = Object.entries(metric.attributes).filter(([, v]) => v !== void 0).map(([key, value]) => ({
+    key,
+    value: typeof value === "string" ? { stringValue: value } : typeof value === "number" ? Number.isInteger(value) ? { intValue: value } : { doubleValue: value } : { boolValue: value }
+  }));
+  const dataPoint = {
+    attributes,
+    timeUnixNano: String(metric.timestamp * 1e6),
+    ...metric.type === "counter" ? { asInt: metric.value } : { asDouble: metric.value }
+  };
+  return {
+    resourceMetrics: [{
+      resource: {
+        attributes: [
+          { key: "service.name", value: { stringValue: serviceName } },
+          { key: "service.version", value: { stringValue: serviceVersion } }
+        ]
+      },
+      scopeMetrics: [{
+        scope: {
+          name: "omote-sdk",
+          version: serviceVersion
+        },
+        metrics: [{
+          name: metric.name,
+          ...metric.type === "counter" ? {
+            sum: {
+              dataPoints: [dataPoint],
+              aggregationTemporality: 2,
+              // CUMULATIVE
+              isMonotonic: true
+            }
+          } : {
+            gauge: {
+              dataPoints: [dataPoint]
+            }
+          }
+        }]
+      }]
+    }]
+  };
+}
+var OTLPExporter = class {
+  constructor(config, serviceName = "omote-sdk", serviceVersion = "0.1.0") {
+    this.spanBuffer = [];
+    this.metricBuffer = [];
+    this.flushIntervalId = null;
+    this.BUFFER_SIZE = 100;
+    this.FLUSH_INTERVAL_MS = 5e3;
+    this.isShutdown = false;
+    const parsed = new URL(config.endpoint);
+    if (parsed.protocol !== "https:") {
+      const isLocalhost = parsed.hostname === "localhost" || parsed.hostname === "127.0.0.1" || parsed.hostname === "[::1]";
+      if (!isLocalhost) {
+        throw new Error("OTLP endpoint must use HTTPS (or localhost for development)");
+      }
+    }
+    this.config = {
+      endpoint: config.endpoint,
+      timeoutMs: config.timeoutMs ?? 1e4,
+      headers: config.headers ? { ...config.headers } : {}
+    };
+    this.serviceName = serviceName;
+    this.serviceVersion = serviceVersion;
+    this.flushIntervalId = setInterval(() => {
+      this.flush().catch(console.error);
+    }, this.FLUSH_INTERVAL_MS);
+  }
+  exportSpan(span) {
+    if (this.isShutdown) return;
+    this.spanBuffer.push(span);
+    if (this.spanBuffer.length >= this.BUFFER_SIZE) {
+      this.flush().catch(console.error);
+    }
+  }
+  exportMetric(metric) {
+    if (this.isShutdown) return;
+    this.metricBuffer.push(metric);
+    if (this.metricBuffer.length >= this.BUFFER_SIZE) {
+      this.flush().catch(console.error);
+    }
+  }
+  async flush() {
+    if (this.isShutdown) return;
+    const spans = this.spanBuffer.splice(0);
+    const metrics = this.metricBuffer.splice(0);
+    const promises = [];
+    if (spans.length > 0) {
+      promises.push(this.exportSpans(spans));
+    }
+    if (metrics.length > 0) {
+      promises.push(this.exportMetrics(metrics));
+    }
+    await Promise.all(promises);
+  }
+  async shutdown() {
+    if (this.flushIntervalId) {
+      clearInterval(this.flushIntervalId);
+      this.flushIntervalId = null;
+    }
+    await this.flush();
+    this.isShutdown = true;
+  }
+  async exportSpans(spans) {
+    const resourceSpans = spans.map(
+      (span) => spanToOTLP(span, this.serviceName, this.serviceVersion).resourceSpans[0]
+    );
+    const body = { resourceSpans };
+    const endpoint = this.config.endpoint.replace(/\/$/, "") + "/v1/traces";
+    await this.sendRequest(endpoint, body);
+  }
+  async exportMetrics(metrics) {
+    const resourceMetrics = metrics.map(
+      (metric) => metricToOTLP(metric, this.serviceName, this.serviceVersion).resourceMetrics[0]
+    );
+    const body = { resourceMetrics };
+    const endpoint = this.config.endpoint.replace(/\/$/, "") + "/v1/metrics";
+    await this.sendRequest(endpoint, body);
+  }
+  async sendRequest(endpoint, body) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.config.timeoutMs);
+    try {
+      const response = await fetch(endpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...this.config.headers
+        },
+        body: JSON.stringify(body),
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        console.warn(`[OTLP] Export failed: ${response.status} ${response.statusText}`);
+      }
+    } catch (error) {
+      if (error.name === "AbortError") {
+        console.warn("[OTLP] Export timed out");
+      } else {
+        console.warn("[OTLP] Export error:", error);
+      }
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+};
+
+// src/logging/Clock.ts
+var defaultClock = {
+  now: () => performance.now(),
+  timestamp: () => Date.now()
+};
+var activeClock = defaultClock;
+function configureClock(clock) {
+  activeClock = clock;
+}
+function getClock() {
+  return activeClock;
+}
+
+// src/telemetry/OmoteTelemetry.ts
+function generateId(length = 16) {
+  const bytes = new Uint8Array(length);
+  crypto.getRandomValues(bytes);
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+var globalTelemetry = null;
+function configureTelemetry(config) {
+  if (globalTelemetry) {
+    globalTelemetry.shutdown();
+  }
+  globalTelemetry = new OmoteTelemetry(config);
+  return globalTelemetry;
+}
+function getTelemetry() {
+  return globalTelemetry;
+}
+var OmoteTelemetry = class {
+  constructor(config) {
+    this.exporter = null;
+    this.activeTraceId = null;
+    this.metricsIntervalId = null;
+    // Span stack for log-to-span correlation
+    this.spanStack = [];
+    // Metric accumulators
+    this.counters = /* @__PURE__ */ new Map();
+    this.histograms = /* @__PURE__ */ new Map();
+    this.config = {
+      enabled: config.enabled ?? false,
+      serviceName: config.serviceName ?? "omote-sdk",
+      serviceVersion: config.serviceVersion ?? "0.1.0",
+      exporter: config.exporter ?? "none",
+      exporterConfig: config.exporterConfig,
+      sampling: config.sampling ?? { ratio: 1, alwaysSampleErrors: true },
+      metricsEnabled: config.metricsEnabled ?? true,
+      metricsIntervalMs: config.metricsIntervalMs ?? 6e4
+    };
+    if (this.config.enabled) {
+      this.initExporter();
+      this.startMetricsCollection();
+    }
+  }
+  /**
+   * Initialize the configured exporter
+   */
+  initExporter() {
+    switch (this.config.exporter) {
+      case "console":
+        this.exporter = new ConsoleExporter({ enabled: true });
+        break;
+      case "otlp":
+        if (!this.config.exporterConfig) {
+          console.warn("[Telemetry] OTLP exporter requires exporterConfig with endpoint");
+          return;
+        }
+        this.exporter = new OTLPExporter(
+          this.config.exporterConfig,
+          this.config.serviceName,
+          this.config.serviceVersion
+        );
+        break;
+      case "none":
+      default:
+        this.exporter = null;
+    }
+  }
+  /**
+   * Start periodic metrics collection
+   */
+  startMetricsCollection() {
+    if (!this.config.metricsEnabled || !this.exporter) return;
+    this.metricsIntervalId = setInterval(() => {
+      this.flushMetrics();
+    }, this.config.metricsIntervalMs);
+  }
+  /**
+   * Check if this operation should be sampled
+   */
+  shouldSample(isError = false) {
+    if (!this.config.enabled) return false;
+    const sampling = this.config.sampling;
+    if (isError && sampling.alwaysSampleErrors) return true;
+    const ratio = sampling.ratio ?? 1;
+    return Math.random() < ratio;
+  }
+  /**
+   * Start a new span
+   *
+   * @example
+   * ```typescript
+   * const span = telemetry.startSpan('Wav2Vec2.infer', {
+   *   'inference.input_samples': samples.length,
+   *   'model.backend': 'webgpu',
+   * });
+   *
+   * try {
+   *   const result = await doInference();
+   *   span.setAttributes({ 'inference.output_frames': result.frames });
+   *   span.end();
+   * } catch (error) {
+   *   span.endWithError(error);
+   * }
+   * ```
+   */
+  startSpan(name, attributes = {}, parentContext) {
+    const traceId = parentContext?.traceId ?? this.activeTraceId ?? generateId(16);
+    const spanId = generateId(8);
+    const parentSpanId = parentContext?.spanId;
+    const startTime = getClock().now();
+    if (!parentContext && !this.activeTraceId) {
+      this.activeTraceId = traceId;
+    }
+    let spanAttributes = { ...attributes };
+    let ended = false;
+    let sampled = this.shouldSample();
+    const context = { traceId, spanId, parentSpanId };
+    this.spanStack.push({ traceId, spanId });
+    const endSpan = (status, error) => {
+      if (ended) return;
+      ended = true;
+      const idx = this.spanStack.findIndex((s) => s.spanId === spanId);
+      if (idx !== -1) this.spanStack.splice(idx, 1);
+      const endTime = getClock().now();
+      const durationMs = endTime - startTime;
+      if (status === "error" && !sampled) {
+        sampled = this.shouldSample(true);
+      }
+      if (!sampled || !this.exporter) return;
+      const spanData = {
+        name,
+        traceId,
+        spanId,
+        parentSpanId,
+        startTime,
+        endTime,
+        durationMs,
+        status,
+        attributes: spanAttributes,
+        error
+      };
+      this.exporter.exportSpan(spanData);
+      if (!parentSpanId && this.activeTraceId === traceId) {
+        this.activeTraceId = null;
+      }
+    };
+    return {
+      end: () => endSpan("ok"),
+      endWithError: (error) => endSpan("error", error),
+      setAttributes: (attrs) => {
+        spanAttributes = { ...spanAttributes, ...attrs };
+      },
+      getContext: () => context
+    };
+  }
+  /**
+   * Wrap an async function with a span
+   *
+   * @example
+   * ```typescript
+   * const result = await telemetry.withSpan('Model.load', async (span) => {
+   *   const model = await loadModel();
+   *   span.setAttributes({ 'model.size_bytes': model.size });
+   *   return model;
+   * });
+   * ```
+   */
+  async withSpan(name, fn, attributes = {}, parentContext) {
+    const span = this.startSpan(name, attributes, parentContext);
+    try {
+      const result = await fn(span);
+      span.end();
+      return result;
+    } catch (error) {
+      span.endWithError(error);
+      throw error;
+    }
+  }
+  /**
+   * Increment a counter metric
+   *
+   * @example
+   * ```typescript
+   * telemetry.incrementCounter('omote.inference.total', 1, {
+   *   model: 'wav2vec2',
+   *   backend: 'webgpu',
+   *   status: 'success',
+   * });
+   * ```
+   */
+  incrementCounter(name, value = 1, attributes = {}) {
+    if (!this.config.enabled || !this.config.metricsEnabled) return;
+    const key = this.getMetricKey(name, attributes);
+    const existing = this.counters.get(key);
+    if (existing) {
+      existing.value += value;
+    } else {
+      this.counters.set(key, { value, attributes });
+    }
+  }
+  /**
+   * Record a histogram value
+   *
+   * @example
+   * ```typescript
+   * telemetry.recordHistogram('omote.inference.latency', durationMs, {
+   *   model: 'wav2vec2',
+   *   backend: 'webgpu',
+   * });
+   * ```
+   */
+  recordHistogram(name, value, attributes = {}) {
+    if (!this.config.enabled || !this.config.metricsEnabled) return;
+    const key = this.getMetricKey(name, attributes);
+    const existing = this.histograms.get(key);
+    if (existing) {
+      existing.count++;
+      existing.sum += value;
+      if (value < existing.min) existing.min = value;
+      if (value > existing.max) existing.max = value;
+    } else {
+      this.histograms.set(key, { count: 1, sum: value, min: value, max: value, attributes });
+    }
+  }
+  /**
+   * Generate unique key for metric with attributes
+   */
+  getMetricKey(name, attributes) {
+    const keys = Object.keys(attributes);
+    if (keys.length === 0) return name;
+    const sortedAttrs = Object.entries(attributes).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => `${k}=${v}`).join(",");
+    return `${name}|${sortedAttrs}`;
+  }
+  /**
+   * Flush accumulated metrics to exporter
+   */
+  flushMetrics() {
+    if (!this.exporter) return;
+    const timestamp = getClock().now();
+    for (const [key, data] of this.counters) {
+      if (data.value === 0) continue;
+      const name = key.split("|")[0];
+      const metric = {
+        name,
+        type: "counter",
+        value: data.value,
+        attributes: data.attributes,
+        timestamp
+      };
+      this.exporter.exportMetric(metric);
+      data.value = 0;
+    }
+    for (const [key, data] of this.histograms) {
+      const name = key.split("|")[0];
+      if (data.count === 0) continue;
+      const avg = data.sum / data.count;
+      const metric = {
+        name,
+        type: "histogram",
+        value: avg,
+        attributes: {
+          ...data.attributes,
+          count: data.count,
+          sum: data.sum,
+          min: data.min,
+          max: data.max
+        },
+        timestamp
+      };
+      this.exporter.exportMetric(metric);
+      data.count = 0;
+      data.sum = 0;
+      data.min = Infinity;
+      data.max = -Infinity;
+    }
+  }
+  /**
+   * Force flush all pending data
+   */
+  async flush() {
+    this.flushMetrics();
+    await this.exporter?.flush();
+  }
+  /**
+   * Shutdown telemetry
+   */
+  async shutdown() {
+    if (this.metricsIntervalId) {
+      clearInterval(this.metricsIntervalId);
+      this.metricsIntervalId = null;
+    }
+    await this.flush();
+    await this.exporter?.shutdown();
+    this.exporter = null;
+  }
+  /**
+   * Check if telemetry is enabled
+   */
+  isEnabled() {
+    return this.config.enabled;
+  }
+  /**
+   * Get current configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Get the active span context for log-to-span correlation.
+   * Returns the most recent (top of stack) active span, or null if none.
+   */
+  getActiveContext() {
+    return this.spanStack.length > 0 ? this.spanStack[this.spanStack.length - 1] : null;
+  }
+};
+
+// src/logging/Logger.ts
+var isBrowser2 = typeof window !== "undefined";
+var globalConfig = { ...DEFAULT_LOGGING_CONFIG };
+function configureLogging(config) {
+  globalConfig = { ...globalConfig, ...config };
+}
+function getLoggingConfig() {
+  return { ...globalConfig };
+}
+function resetLoggingConfig() {
+  globalConfig = { ...DEFAULT_LOGGING_CONFIG };
+}
+function setLogLevel(level) {
+  globalConfig.level = level;
+}
+function setLoggingEnabled(enabled) {
+  globalConfig.enabled = enabled;
+}
+var consoleSink = (entry) => {
+  const consoleMethod = entry.level === "error" ? "error" : entry.level === "warn" ? "warn" : "log";
+  if (globalConfig.format === "pretty" && isBrowser2) {
+    const args = createBrowserConsoleArgs(entry);
+    console[consoleMethod](...args);
+  } else {
+    const formatter = getFormatter(globalConfig.format);
+    const formatted = formatter(entry);
+    console[consoleMethod](formatted);
+  }
+};
+function getActiveSink() {
+  return globalConfig.sink || consoleSink;
+}
+function shouldLog(level) {
+  if (!globalConfig.enabled) return false;
+  return LOG_LEVEL_PRIORITY[level] <= LOG_LEVEL_PRIORITY[globalConfig.level];
+}
+var Logger = class _Logger {
+  constructor(module) {
+    this.module = module;
+  }
+  log(level, message, data) {
+    if (!shouldLog(level)) return;
+    const entry = {
+      timestamp: getClock().timestamp(),
+      level,
+      module: this.module,
+      message,
+      data
+    };
+    const ctx = getTelemetry()?.getActiveContext();
+    if (ctx) {
+      entry.traceId = ctx.traceId;
+      entry.spanId = ctx.spanId;
+    }
+    if (data?.error instanceof Error) {
+      entry.error = data.error;
+      const { error, ...rest } = data;
+      entry.data = Object.keys(rest).length > 0 ? rest : void 0;
+    }
+    getActiveSink()(entry);
+  }
+  error(message, data) {
+    this.log("error", message, data);
+  }
+  warn(message, data) {
+    this.log("warn", message, data);
+  }
+  info(message, data) {
+    this.log("info", message, data);
+  }
+  debug(message, data) {
+    this.log("debug", message, data);
+  }
+  trace(message, data) {
+    this.log("trace", message, data);
+  }
+  verbose(message, data) {
+    this.log("verbose", message, data);
+  }
+  child(subModule) {
+    return new _Logger(`${this.module}.${subModule}`);
+  }
+};
+var loggerCache = /* @__PURE__ */ new Map();
+function createLogger(module) {
+  let logger = loggerCache.get(module);
+  if (!logger) {
+    logger = new Logger(module);
+    loggerCache.set(module, logger);
+  }
+  return logger;
+}
+function clearLoggerCache() {
+  loggerCache.clear();
+}
+var noopLogger = {
+  module: "noop",
+  error: () => {
+  },
+  warn: () => {
+  },
+  info: () => {
+  },
+  debug: () => {
+  },
+  trace: () => {
+  },
+  verbose: () => {
+  },
+  child: () => noopLogger
+};
+function getNoopLogger() {
+  return noopLogger;
+}
+
+// src/logging/ErrorCodes.ts
+var ErrorCodes = {
+  // ── Inference ──────────────────────────────────────────────────────────
+  /** Model failed to load (file not found, corrupted, unsupported format) */
+  INF_LOAD_FAILED: "OMOTE_INF_001",
+  /** ORT session poisoned after WebGPU device loss — must reload tab */
+  INF_SESSION_POISON: "OMOTE_INF_002",
+  /** Inference exceeded timeout threshold */
+  INF_TIMEOUT: "OMOTE_INF_003",
+  /** Out-of-memory during inference or model loading */
+  INF_OOM: "OMOTE_INF_004",
+  /** WebGPU unavailable, fell back to WASM */
+  INF_WEBGPU_FALLBACK: "OMOTE_INF_005",
+  /** Input tensor shape does not match model expectations */
+  INF_SHAPE_MISMATCH: "OMOTE_INF_006",
+  // ── Audio ──────────────────────────────────────────────────────────────
+  /** AudioContext creation or resume failed */
+  AUD_CONTEXT_FAILED: "OMOTE_AUD_001",
+  /** Gap detected in audio scheduling (buffer underrun) */
+  AUD_SCHEDULE_GAP: "OMOTE_AUD_002",
+  /** Audio buffer decoding failed */
+  AUD_DECODE_FAILED: "OMOTE_AUD_003",
+  // ── Speech ─────────────────────────────────────────────────────────────
+  /** Voice activity detection error */
+  SPH_VAD_ERROR: "OMOTE_SPH_001",
+  /** Automatic speech recognition error */
+  SPH_ASR_ERROR: "OMOTE_SPH_002",
+  /** Microphone access denied or unavailable */
+  SPH_MIC_DENIED: "OMOTE_SPH_003",
+  // ── TTS ────────────────────────────────────────────────────────────────
+  /** TTS synthesis failed */
+  TTS_SYNTH_FAILED: "OMOTE_TTS_001",
+  /** TTS streaming error (chunk delivery failure) */
+  TTS_STREAM_ERROR: "OMOTE_TTS_002",
+  /** Phonemizer (eSpeak-NG WASM) ran out of memory */
+  TTS_PHONEMIZER_OOM: "OMOTE_TTS_003",
+  // ── Pipeline ───────────────────────────────────────────────────────────
+  /** Invalid state transition in pipeline state machine */
+  PIP_STATE_ERROR: "OMOTE_PIP_001",
+  /** Pipeline operation aborted (user interrupt or signal) */
+  PIP_ABORT: "OMOTE_PIP_002",
+  // ── Cache ──────────────────────────────────────────────────────────────
+  /** IndexedDB storage quota exceeded */
+  CAC_QUOTA_EXCEEDED: "OMOTE_CAC_001",
+  /** Cache entry evicted (LRU or manual) */
+  CAC_EVICTION: "OMOTE_CAC_002",
+  /** Cached model is stale (version mismatch) */
+  CAC_STALE: "OMOTE_CAC_003",
+  // ── Network ────────────────────────────────────────────────────────────
+  /** HTTP fetch failed (model download, CDN) */
+  NET_FETCH_FAILED: "OMOTE_NET_001",
+  /** Network request timed out */
+  NET_TIMEOUT: "OMOTE_NET_002",
+  /** WebSocket connection error */
+  NET_WEBSOCKET_ERROR: "OMOTE_NET_003"
+};
+
+export {
+  LOG_LEVEL_PRIORITY,
+  DEFAULT_LOGGING_CONFIG,
+  jsonFormatter,
+  prettyFormatter,
+  getFormatter,
+  ConsoleExporter,
+  OTLPExporter,
+  defaultClock,
+  configureClock,
+  getClock,
+  configureTelemetry,
+  getTelemetry,
+  OmoteTelemetry,
+  configureLogging,
+  getLoggingConfig,
+  resetLoggingConfig,
+  setLogLevel,
+  setLoggingEnabled,
+  createLogger,
+  clearLoggerCache,
+  noopLogger,
+  getNoopLogger,
+  ErrorCodes
+};
+//# sourceMappingURL=chunk-Y3DTP5P3.mjs.map