@omote/core 0.9.7 → 0.10.5

package/dist/chunk-X5OTUOE6.mjs

@@ -1,927 +0,0 @@
-// 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-X5OTUOE6.mjs.map