autotel 2.26.3 → 3.0.0

package/dist/{chunk-HPUGKUMZ.js → chunk-DAAJLUTO.js}

@@ -1,640 +1,13 @@
-import { setSpanName } from './chunk-B3ZHLLMP.js';
-import { validateEvent, runInOperationContext } from './chunk-WD4RP6IV.js';
-import { getOrCreateCorrelationId } from './chunk-S4OFEXLA.js';
-import { createTraceContext, getActiveContextWithBaggage, getContextStorage, enterOrRun } from './chunk-BBBWDIYQ.js';
-import { getValidationConfig, isInitialized, warnIfNotInitialized, getConfig as getConfig$1, getEventsConfig, getLogger, getSdk } from './chunk-W35FVJBC.js';
+import { setSpanName } from './chunk-DSMSIVTG.js';
+import { runInOperationContext } from './chunk-SEO6NAQT.js';
+import { createTraceContext, getActiveContextWithBaggage, getContextStorage, getEventQueue, enterOrRun } from './chunk-QG3U5ONP.js';
+import { getConfig as getConfig$1, getSdk } from './chunk-W35FVJBC.js';
 import { AlwaysSampler, AUTOTEL_SAMPLING_TAIL_KEEP, AUTOTEL_SAMPLING_TAIL_EVALUATED } from './chunk-DPSA4QLA.js';
 import { getConfig } from './chunk-J5QENANM.js';
-import { trace, SpanStatusCode, context, propagation } from '@opentelemetry/api';
+import { trace as trace$1, SpanStatusCode, context, propagation } from '@opentelemetry/api';
 import { readFileSync } from 'fs';
 import { fileURLToPath } from 'url';
 
-// src/rate-limiter.ts
-var TokenBucketRateLimiter = class {
-  tokens;
-  maxTokens;
-  refillRate;
-  // tokens per millisecond
-  lastRefill;
-  constructor(config) {
-    this.maxTokens = config.burstCapacity || config.maxEventsPerSecond * 2;
-    this.tokens = this.maxTokens;
-    this.refillRate = config.maxEventsPerSecond / 1e3;
-    this.lastRefill = Date.now();
-  }
-  /**
-   * Try to consume a token (allow an event)
-   * Returns true if allowed, false if rate limit exceeded
-   */
-  tryConsume(count = 1) {
-    this.refill();
-    if (this.tokens >= count) {
-      this.tokens -= count;
-      return true;
-    }
-    return false;
-  }
-  /**
-   * Wait until a token is available (async rate limiting)
-   * Returns a promise that resolves when the event can be processed
-   */
-  async waitForToken(count = 1) {
-    this.refill();
-    if (this.tokens >= count) {
-      this.tokens -= count;
-      return;
-    }
-    const tokensNeeded = count - this.tokens;
-    const waitMs = Math.ceil(tokensNeeded / this.refillRate);
-    await new Promise((resolve) => setTimeout(resolve, waitMs));
-    return this.waitForToken(count);
-  }
-  /**
-   * Refill tokens based on elapsed time
-   */
-  refill() {
-    const now = Date.now();
-    const elapsed = now - this.lastRefill;
-    const tokensToAdd = elapsed * this.refillRate;
-    this.tokens = Math.min(this.maxTokens, this.tokens + tokensToAdd);
-    this.lastRefill = now;
-  }
-  /**
-   * Get current available tokens (for testing/debugging)
-   */
-  getAvailableTokens() {
-    this.refill();
-    return Math.floor(this.tokens);
-  }
-  /**
-   * Reset the rate limiter (for testing)
-   */
-  reset() {
-    this.tokens = this.maxTokens;
-    this.lastRefill = Date.now();
-  }
-};
-
-// src/event-queue.ts
-var DEFAULT_CONFIG = {
-  maxSize: 5e4,
-  batchSize: 100,
-  flushInterval: 1e4,
-  maxRetries: 3,
-  rateLimit: {
-    maxEventsPerSecond: 100,
-    burstCapacity: 200
-  }
-};
-function getSubscriberName(subscriber) {
-  if (subscriber.name) {
-    return subscriber.name.toLowerCase();
-  }
-  const className = subscriber.constructor?.name || "unknown";
-  return className.replace(/Subscriber$/i, "").toLowerCase();
-}
-var EventQueue = class {
-  queue = [];
-  flushTimer = null;
-  config;
-  subscribers;
-  rateLimiter;
-  flushPromise = null;
-  isShuttingDown = false;
-  // Metrics
-  metrics = null;
-  // Observable callback cleanup functions
-  observableCleanups = [];
-  // Subscriber health tracking (for observable gauges)
-  subscriberHealthy = /* @__PURE__ */ new Map();
-  constructor(subscribers, config) {
-    this.subscribers = subscribers;
-    this.config = { ...DEFAULT_CONFIG, ...config };
-    this.rateLimiter = this.config.rateLimit ? new TokenBucketRateLimiter(this.config.rateLimit) : null;
-    for (const subscriber of subscribers) {
-      const name = getSubscriberName(subscriber);
-      this.subscriberHealthy.set(name, true);
-    }
-    this.initMetrics();
-  }
-  /**
-   * Initialize OTel metrics for queue observability
-   */
-  initMetrics() {
-    const runtimeConfig = getConfig();
-    const meter = runtimeConfig.meter;
-    const queueSize = meter.createObservableGauge(
-      "autotel.event_delivery.queue.size",
-      {
-        description: "Current number of events in the delivery queue",
-        unit: "count"
-      }
-    );
-    const queueSizeCallback = (observableResult) => {
-      observableResult.observe(this.queue.length);
-    };
-    queueSize.addCallback(queueSizeCallback);
-    this.observableCleanups.push(
-      () => queueSize.removeCallback(queueSizeCallback)
-    );
-    const oldestAge = meter.createObservableGauge(
-      "autotel.event_delivery.queue.oldest_age_ms",
-      {
-        description: "Age of the oldest event in the queue in milliseconds",
-        unit: "ms"
-      }
-    );
-    const oldestAgeCallback = (observableResult) => {
-      if (this.queue.length > 0) {
-        const oldest = this.queue[0];
-        const ageMs = Date.now() - oldest.timestamp;
-        observableResult.observe(ageMs);
-      } else {
-        observableResult.observe(0);
-      }
-    };
-    oldestAge.addCallback(oldestAgeCallback);
-    this.observableCleanups.push(
-      () => oldestAge.removeCallback(oldestAgeCallback)
-    );
-    const delivered = meter.createCounter(
-      "autotel.event_delivery.queue.delivered",
-      {
-        description: "Number of events successfully delivered to subscribers",
-        unit: "count"
-      }
-    );
-    const failed = meter.createCounter("autotel.event_delivery.queue.failed", {
-      description: "Number of events that failed delivery after all retry attempts",
-      unit: "count"
-    });
-    const dropped = meter.createCounter(
-      "autotel.event_delivery.queue.dropped",
-      {
-        description: "Number of events dropped from the queue",
-        unit: "count"
-      }
-    );
-    const latency = meter.createHistogram(
-      "autotel.event_delivery.queue.latency_ms",
-      {
-        description: "Event delivery latency from enqueue to successful send",
-        unit: "ms"
-      }
-    );
-    const subscriberHealth = meter.createObservableGauge(
-      "autotel.event_delivery.subscriber.health",
-      {
-        description: "Subscriber health status (1=healthy, 0=unhealthy)",
-        unit: "1"
-      }
-    );
-    const subscriberHealthCallback = (observableResult) => {
-      for (const [subscriberName, isHealthy] of this.subscriberHealthy) {
-        observableResult.observe(isHealthy ? 1 : 0, {
-          subscriber: subscriberName
-        });
-      }
-    };
-    subscriberHealth.addCallback(subscriberHealthCallback);
-    this.observableCleanups.push(
-      () => subscriberHealth.removeCallback(subscriberHealthCallback)
-    );
-    this.metrics = {
-      queueSize,
-      oldestAge,
-      delivered,
-      failed,
-      dropped,
-      latency,
-      subscriberHealth
-    };
-  }
-  /**
-   * Record a dropped event with reason and emit debug breadcrumb
-   */
-  recordDropped(reason, event, subscriberName) {
-    const attrs = { reason };
-    if (subscriberName) {
-      attrs.subscriber = subscriberName;
-    }
-    this.metrics?.dropped.add(1, attrs);
-    const logLevel = reason === "payload_invalid" ? "error" : "warn";
-    const logger = getLogger();
-    if (logLevel === "error") {
-      logger.error(
-        {
-          eventName: event?.name,
-          subscriber: subscriberName,
-          reason,
-          correlationId: event?._correlationId,
-          traceId: event?._traceId
-        },
-        `[autotel] Event dropped: ${reason}`
-      );
-    } else {
-      logger.warn(
-        {
-          eventName: event?.name,
-          subscriber: subscriberName,
-          reason,
-          correlationId: event?._correlationId,
-          traceId: event?._traceId
-        },
-        `[autotel] Event dropped: ${reason}`
-      );
-    }
-  }
-  /**
-   * Record permanent delivery failure (after all retries exhausted)
-   * Increments failed counter and logs error
-   */
-  recordFailed(event, subscriberName, error) {
-    this.metrics?.failed.add(1, { subscriber: subscriberName });
-    this.subscriberHealthy.set(subscriberName, false);
-    getLogger().error(
-      {
-        eventName: event.name,
-        subscriber: subscriberName,
-        correlationId: event._correlationId,
-        traceId: event._traceId,
-        err: error
-      },
-      `[autotel] Event delivery failed after all retries`
-    );
-  }
-  /**
-   * Mark subscriber as unhealthy on transient failure (without incrementing failed counter)
-   * Used during retry attempts - only recordFailed should increment the counter
-   */
-  markSubscriberUnhealthy(subscriberName) {
-    this.subscriberHealthy.set(subscriberName, false);
-  }
-  /**
-   * Record successful delivery
-   */
-  recordDelivered(event, subscriberName, startTime) {
-    const latencyMs = Date.now() - startTime;
-    this.metrics?.delivered.add(1, { subscriber: subscriberName });
-    this.metrics?.latency.record(latencyMs, { subscriber: subscriberName });
-    this.subscriberHealthy.set(subscriberName, true);
-  }
-  /**
-   * Enqueue an event for sending
-   *
-   * Backpressure policy:
-   * - Drops oldest event and logs warning if queue is full (same behavior in all environments)
-   */
-  enqueue(event) {
-    if (this.isShuttingDown) {
-      this.recordDropped("shutdown", event);
-      return;
-    }
-    if (this.queue.length >= this.config.maxSize) {
-      const droppedEvent = this.queue.shift();
-      this.recordDropped("rate_limit", droppedEvent);
-      getLogger().warn(
-        {
-          droppedEvent: droppedEvent?.name
-        },
-        `[autotel] Events queue full (${this.config.maxSize} events). Dropping oldest event. Events are being produced faster than they can be sent. Check your subscribers or reduce tracking frequency.`
-      );
-    }
-    const enrichedEvent = {
-      ...event,
-      _correlationId: event._correlationId || getOrCreateCorrelationId()
-    };
-    this.queue.push(enrichedEvent);
-    this.scheduleBatchFlush();
-  }
-  /**
-   * Schedule a batch flush if not already scheduled
-   */
-  scheduleBatchFlush() {
-    if (this.flushTimer || this.flushPromise) return;
-    this.flushTimer = setTimeout(() => {
-      this.flushTimer = null;
-      void this.flushBatch();
-    }, this.config.flushInterval);
-  }
-  /**
-   * Flush a batch of events
-   * Uses promise-based concurrency control to prevent race conditions
-   */
-  async flushBatch() {
-    if (this.queue.length === 0) return;
-    if (this.flushPromise) {
-      await this.flushPromise;
-      return;
-    }
-    this.flushPromise = this.doFlushBatch();
-    try {
-      await this.flushPromise;
-    } finally {
-      this.flushPromise = null;
-      if (this.queue.length > 0) {
-        this.scheduleBatchFlush();
-      }
-    }
-  }
-  /**
-   * Internal flush implementation
-   */
-  async doFlushBatch() {
-    const batch = this.queue.splice(0, this.config.batchSize);
-    await this.sendWithRetry(batch, this.config.maxRetries);
-  }
-  /**
-   * Send events with exponential backoff retry
-   * Tracks per-event, per-subscriber failures so failed counter reflects actual failed deliveries.
-   * On retry, only failed (event, subscriber) pairs are re-sent to avoid double-counting delivered.
-   */
-  async sendWithRetry(events, retriesLeft, subscribersByEventIndex) {
-    const failedDeliveries = await this.sendToSubscribers(
-      events,
-      subscribersByEventIndex
-    );
-    if (failedDeliveries.length > 0) {
-      if (retriesLeft > 0) {
-        const failedEventIndices = new Set(
-          failedDeliveries.map((f) => f.eventIndex)
-        );
-        const failedEventIndicesOrdered = [...failedEventIndices].sort(
-          (a, b) => a - b
-        );
-        const eventsToRetry = failedEventIndicesOrdered.map(
-          (i) => events[i]
-        );
-        const failedSubscribersByRetryIndex = /* @__PURE__ */ new Map();
-        for (let j = 0; j < failedEventIndicesOrdered.length; j++) {
-          const origIndex = failedEventIndicesOrdered[j];
-          const set = /* @__PURE__ */ new Set();
-          for (const { eventIndex, subscriberName } of failedDeliveries) {
-            if (eventIndex === origIndex) set.add(subscriberName);
-          }
-          failedSubscribersByRetryIndex.set(j, set);
-        }
-        const delay = Math.pow(2, this.config.maxRetries - retriesLeft) * 1e3;
-        await new Promise((resolve) => setTimeout(resolve, delay));
-        return this.sendWithRetry(
-          eventsToRetry,
-          retriesLeft - 1,
-          failedSubscribersByRetryIndex
-        );
-      } else {
-        for (const { eventIndex, subscriberName, error } of failedDeliveries) {
-          const event = events[eventIndex];
-          if (event) this.recordFailed(event, subscriberName, error);
-        }
-        const failedSubscriberNames = [
-          ...new Set(failedDeliveries.map((f) => f.subscriberName))
-        ];
-        getLogger().error(
-          {
-            failedSubscribers: failedSubscriberNames,
-            retriesAttempted: this.config.maxRetries
-          },
-          "[autotel] Failed to send events after retries"
-        );
-      }
-    }
-  }
-  /**
-   * Send events to configured subscribers with rate limiting and metrics.
-   * When subscribersByEventIndex is provided (retry path), only those subscribers are tried per event.
-   * Returns per-event, per-subscriber failures (empty if all succeeded).
-   */
-  async sendToSubscribers(events, subscribersByEventIndex) {
-    const failedDeliveries = [];
-    const sendOne = async (event, eventIndex) => {
-      const subscriberNames = subscribersByEventIndex?.get(eventIndex);
-      const failures = await this.sendEventToSubscribers(
-        event,
-        subscriberNames ?? void 0
-      );
-      for (const failure of failures) {
-        failedDeliveries.push({
-          eventIndex,
-          subscriberName: failure.subscriberName,
-          error: failure.error
-        });
-      }
-    };
-    if (!this.rateLimiter) {
-      for (let i = 0; i < events.length; i++) {
-        const event = events[i];
-        if (event) await sendOne(event, i);
-      }
-      return failedDeliveries;
-    }
-    for (let i = 0; i < events.length; i++) {
-      await this.rateLimiter.waitForToken();
-      const event = events[i];
-      if (event) await sendOne(event, i);
-    }
-    return failedDeliveries;
-  }
-  /**
-   * Send a single event to subscribers.
-   * - When subscriberNames is undefined (initial attempt): send to all subscribers.
-   * - When subscriberNames is provided (retry): send only to those subscribers (never re-send to healthy ones).
-   * Returns list of subscribers that failed (empty if all succeeded).
-   */
-  async sendEventToSubscribers(event, subscriberNames) {
-    const startTime = event.timestamp;
-    const failures = [];
-    const subscribersToTry = subscriberNames === void 0 ? this.subscribers : this.subscribers.filter(
-      (s) => subscriberNames.has(getSubscriberName(s))
-    );
-    const results = await Promise.allSettled(
-      subscribersToTry.map(async (subscriber) => {
-        const subscriberName = getSubscriberName(subscriber);
-        try {
-          await subscriber.trackEvent(event.name, event.attributes, {
-            autotel: event.autotel
-          });
-          this.recordDelivered(event, subscriberName, startTime);
-          return { subscriberName, success: true };
-        } catch (error) {
-          this.markSubscriberUnhealthy(subscriberName);
-          return {
-            subscriberName,
-            success: false,
-            error: error instanceof Error ? error : void 0
-          };
-        }
-      })
-    );
-    for (const result of results) {
-      if (result.status === "fulfilled" && !result.value.success) {
-        failures.push({
-          subscriberName: result.value.subscriberName,
-          error: result.value.error
-        });
-      }
-    }
-    return failures;
-  }
-  /**
-   * Flush all remaining events. Queue remains usable after flush (e.g. for
-   * auto-flush at root span end). Use shutdown() when tearing down the queue.
-   */
-  async flush() {
-    if (this.flushTimer) {
-      clearTimeout(this.flushTimer);
-      this.flushTimer = null;
-    }
-    if (this.flushPromise) {
-      await this.flushPromise;
-    }
-    while (this.queue.length > 0) {
-      await this.doFlushBatch();
-    }
-  }
-  /**
-   * Flush remaining events and permanently disable the queue (reject new events).
-   * Use for process/SDK shutdown; use flush() for periodic or span-end drain.
-   */
-  async shutdown() {
-    this.isShuttingDown = true;
-    await this.flush();
-  }
-  /**
-   * Cleanup observable metric callbacks to prevent memory leaks
-   * Call this when destroying the EventQueue instance
-   */
-  cleanup() {
-    for (const cleanupFn of this.observableCleanups) {
-      try {
-        cleanupFn();
-      } catch {
-      }
-    }
-    this.observableCleanups = [];
-  }
-  /**
-   * Get queue size (for testing/debugging)
-   */
-  size() {
-    return this.queue.length;
-  }
-  /**
-   * Get subscriber health status (for testing/debugging)
-   */
-  getSubscriberHealth() {
-    return new Map(this.subscriberHealthy);
-  }
-  /**
-   * Check if a specific subscriber is healthy
-   */
-  isSubscriberHealthy(subscriberName) {
-    return this.subscriberHealthy.get(subscriberName.toLowerCase()) ?? true;
-  }
-  /**
-   * Manually mark a subscriber as healthy or unhealthy
-   * (used for circuit breaker integration)
-   */
-  setSubscriberHealth(subscriberName, healthy) {
-    this.subscriberHealthy.set(subscriberName.toLowerCase(), healthy);
-  }
-};
-
-// src/track.ts
-var eventsQueue = null;
-function buildAutotelContext(span2) {
-  const eventsConfig = getEventsConfig();
-  const config = getConfig$1();
-  const correlationId = getOrCreateCorrelationId();
-  if (!eventsConfig?.includeTraceContext) {
-    return {
-      correlation_id: correlationId
-    };
-  }
-  const autotelContext = {
-    correlation_id: correlationId
-  };
-  const spanContext = span2?.spanContext();
-  if (spanContext) {
-    autotelContext.trace_id = spanContext.traceId;
-    autotelContext.span_id = spanContext.spanId;
-    autotelContext.trace_flags = spanContext.traceFlags.toString(16).padStart(2, "0");
-    const traceState = spanContext.traceState;
-    if (traceState) {
-      try {
-        if (typeof traceState.serialize === "function") {
-          const traceStateStr = traceState.serialize();
-          if (traceStateStr) {
-            autotelContext.trace_state = traceStateStr;
-          }
-        }
-      } catch {
-      }
-    }
-    if (eventsConfig.traceUrl && config) {
-      const traceUrl = eventsConfig.traceUrl({
-        traceId: spanContext.traceId,
-        spanId: spanContext.spanId,
-        correlationId,
-        serviceName: config.service,
-        environment: config.environment
-      });
-      if (traceUrl) {
-        autotelContext.trace_url = traceUrl;
-      }
-    }
-  } else {
-    if (eventsConfig.traceUrl && config) {
-      const traceUrl = eventsConfig.traceUrl({
-        correlationId,
-        serviceName: config.service,
-        environment: config.environment
-      });
-      if (traceUrl) {
-        autotelContext.trace_url = traceUrl;
-      }
-    }
-  }
-  return autotelContext;
-}
-function getOrCreateQueue() {
-  if (!isInitialized()) {
-    warnIfNotInitialized("track()");
-    return null;
-  }
-  if (!eventsQueue) {
-    const config = getConfig$1();
-    if (!config?.subscribers || config.subscribers.length === 0) {
-      return null;
-    }
-    eventsQueue = new EventQueue(config.subscribers);
-  }
-  return eventsQueue;
-}
-function track(event, data) {
-  const queue = getOrCreateQueue();
-  if (!queue) return;
-  const validationConfig = getValidationConfig();
-  const validated = validateEvent(event, data, validationConfig || void 0);
-  const span2 = trace.getActiveSpan();
-  const enrichedData = span2 ? {
-    ...validated.attributes,
-    traceId: span2.spanContext().traceId,
-    spanId: span2.spanContext().spanId
-  } : validated.attributes;
-  const autotelContext = buildAutotelContext(span2);
-  queue.enqueue({
-    name: validated.eventName,
-    attributes: enrichedData,
-    timestamp: Date.now(),
-    autotel: autotelContext
-  });
-}
-function getEventQueue() {
-  return eventsQueue;
-}
-function resetEventQueue() {
-  eventsQueue = null;
-}
 var inferenceCache = /* @__PURE__ */ new Map();
 var MAX_CACHE_SIZE = 50;
 function captureStackTrace() {
@@ -965,7 +338,7 @@ function shouldSkip(key, fn, skip) {
   return false;
 }
 function getCtxValue() {
-  const activeSpan = trace.getActiveSpan();
+  const activeSpan = trace$1.getActiveSpan();
   if (!activeSpan) return null;
   return createTraceContext(activeSpan);
 }
@@ -1031,7 +404,7 @@ function wrapWithTracing(fnFactory, options, variableName) {
       return await fn.call(this, ...args);
     }
     const startTime = performance.now();
-    const isRootSpan = options.startNewRoot || trace.getActiveSpan() === void 0;
+    const isRootSpan = options.startNewRoot || trace$1.getActiveSpan() === void 0;
     const shouldAutoFlush = options.flushOnRootSpanEnd ?? getConfig$1()?.flushOnRootSpanEnd ?? true;
     const shouldAutoFlushSpans = getConfig$1()?.forceFlushOnShutdown ?? false;
     const flushIfNeeded = async () => {
@@ -1226,7 +599,7 @@ function wrapWithTracingSync(fnFactory, options, variableName) {
       return fn.call(this, ...args);
     }
     const startTime = performance.now();
-    const isRootSpan = options.startNewRoot || trace.getActiveSpan() === void 0;
+    const isRootSpan = options.startNewRoot || trace$1.getActiveSpan() === void 0;
     const shouldAutoFlush = options.flushOnRootSpanEnd ?? getConfig$1()?.flushOnRootSpanEnd ?? true;
     const shouldAutoFlushSpans = getConfig$1()?.forceFlushOnShutdown ?? false;
     const flushIfNeeded = () => {
@@ -1403,7 +776,7 @@ function executeImmediately(fn, options) {
     return fn(createDummyCtx());
   }
   const startTime = performance.now();
-  const isRootSpan = options.startNewRoot || trace.getActiveSpan() === void 0;
+  const isRootSpan = options.startNewRoot || trace$1.getActiveSpan() === void 0;
   const shouldAutoFlush = options.flushOnRootSpanEnd ?? getConfig$1()?.flushOnRootSpanEnd ?? true;
   const shouldAutoFlushSpans = getConfig$1()?.forceFlushOnShutdown ?? false;
   const callCounter = options.withMetrics ? meter.createCounter(`${spanName}.calls`, {
@@ -1616,7 +989,7 @@ function executeImmediately(fn, options) {
     }
   );
 }
-function trace2(fnOrNameOrOptions, maybeFn) {
+function trace(fnOrNameOrOptions, maybeFn) {
   if (typeof fnOrNameOrOptions === "function") {
     if (looksLikeTraceFactory(fnOrNameOrOptions) && !isFactoryReturningFunction(
       fnOrNameOrOptions
@@ -1806,6 +1179,6 @@ function withBaggage(options) {
   return result;
 }
 
-export { ctx, getEventQueue, instrument, resetEventQueue, span, trace2 as trace, track, withBaggage, withNewContext, withTracing };
-//# sourceMappingURL=chunk-HPUGKUMZ.js.map
-//# sourceMappingURL=chunk-HPUGKUMZ.js.map
+export { ctx, instrument, span, trace, withBaggage, withNewContext, withTracing };
+//# sourceMappingURL=chunk-DAAJLUTO.js.map
+//# sourceMappingURL=chunk-DAAJLUTO.js.map