@vohongtho.infotech/code-intel 0.3.0 → 0.3.1

package/dist/cli/main.js

@@ -1,18 +1,14 @@
 #!/usr/bin/env node
-import { SpanStatusCode, trace, context, diag, baggageEntryMetadataFromString } from '@opentelemetry/api';
-import { inspect } from 'util';
-import * as zlib from 'zlib';
-import { Readable } from 'stream';
-import * as fs25 from 'fs';
-import fs25__default, { readFileSync, existsSync } from 'fs';
-import * as path28 from 'path';
-import path28__default, { dirname, join } from 'path';
 import { NodeSDK } from '@opentelemetry/sdk-node';
 import { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node';
+import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
 import { resourceFromAttributes } from '@opentelemetry/resources';
 import { SEMRESATTRS_DEPLOYMENT_ENVIRONMENT, SEMRESATTRS_SERVICE_NAME } from '@opentelemetry/semantic-conventions';
+import { SpanStatusCode, trace, context } from '@opentelemetry/api';
 import winston from 'winston';
 import DailyRotateFile from 'winston-daily-rotate-file';
+import fs24, { readFileSync, existsSync } from 'fs';
+import path27, { dirname, join } from 'path';
 import os12 from 'os';
 import { createRequire } from 'module';
 import { fileURLToPath } from 'url';
@@ -49,1227 +45,6 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// ../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/OTLPExporterBase.js
-var OTLPExporterBase;
-var init_OTLPExporterBase = __esm({
-  "../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/OTLPExporterBase.js"() {
-    OTLPExporterBase = class {
-      _delegate;
-      constructor(delegate) {
-        this._delegate = delegate;
-      }
-      /**
-       * Export items.
-       * @param items
-       * @param resultCallback
-       */
-      export(items, resultCallback) {
-        this._delegate.export(items, resultCallback);
-      }
-      forceFlush() {
-        return this._delegate.forceFlush();
-      }
-      shutdown() {
-        return this._delegate.shutdown();
-      }
-    };
-  }
-});
-
-// ../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/types.js
-var OTLPExporterError;
-var init_types = __esm({
-  "../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/types.js"() {
-    OTLPExporterError = class extends Error {
-      code;
-      name = "OTLPExporterError";
-      data;
-      constructor(message, code, data) {
-        super(message);
-        this.data = data;
-        this.code = code;
-      }
-    };
-  }
-});
-
-// ../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/shared-configuration.js
-function validateTimeoutMillis(timeoutMillis) {
-  if (Number.isFinite(timeoutMillis) && timeoutMillis > 0) {
-    return timeoutMillis;
-  }
-  throw new Error(`Configuration: timeoutMillis is invalid, expected number greater than 0 (actual: '${timeoutMillis}')`);
-}
-function wrapStaticHeadersInFunction(headers) {
-  if (headers == null) {
-    return void 0;
-  }
-  return async () => headers;
-}
-function mergeOtlpSharedConfigurationWithDefaults(userProvidedConfiguration, fallbackConfiguration, defaultConfiguration) {
-  return {
-    timeoutMillis: validateTimeoutMillis(userProvidedConfiguration.timeoutMillis ?? fallbackConfiguration.timeoutMillis ?? defaultConfiguration.timeoutMillis),
-    concurrencyLimit: userProvidedConfiguration.concurrencyLimit ?? fallbackConfiguration.concurrencyLimit ?? defaultConfiguration.concurrencyLimit,
-    compression: userProvidedConfiguration.compression ?? fallbackConfiguration.compression ?? defaultConfiguration.compression
-  };
-}
-function getSharedConfigurationDefaults() {
-  return {
-    timeoutMillis: 1e4,
-    concurrencyLimit: 30,
-    compression: "none"
-  };
-}
-var init_shared_configuration = __esm({
-  "../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/shared-configuration.js"() {
-  }
-});
-
-// ../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/bounded-queue-export-promise-handler.js
-function createBoundedQueueExportPromiseHandler(options) {
-  return new BoundedQueueExportPromiseHandler(options.concurrencyLimit);
-}
-var BoundedQueueExportPromiseHandler;
-var init_bounded_queue_export_promise_handler = __esm({
-  "../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/bounded-queue-export-promise-handler.js"() {
-    BoundedQueueExportPromiseHandler = class {
-      _concurrencyLimit;
-      _sendingPromises = [];
-      /**
-       * @param concurrencyLimit maximum promises allowed in a queue at the same time.
-       */
-      constructor(concurrencyLimit) {
-        this._concurrencyLimit = concurrencyLimit;
-      }
-      pushPromise(promise) {
-        if (this.hasReachedLimit()) {
-          throw new Error("Concurrency Limit reached");
-        }
-        this._sendingPromises.push(promise);
-        const popPromise = () => {
-          const index = this._sendingPromises.indexOf(promise);
-          void this._sendingPromises.splice(index, 1);
-        };
-        promise.then(popPromise, popPromise);
-      }
-      hasReachedLimit() {
-        return this._sendingPromises.length >= this._concurrencyLimit;
-      }
-      async awaitAll() {
-        await Promise.all(this._sendingPromises);
-      }
-    };
-  }
-});
-
-// ../../node_modules/@opentelemetry/core/build/esm/baggage/constants.js
-var BAGGAGE_KEY_PAIR_SEPARATOR, BAGGAGE_PROPERTIES_SEPARATOR, BAGGAGE_ITEMS_SEPARATOR;
-var init_constants = __esm({
-  "../../node_modules/@opentelemetry/core/build/esm/baggage/constants.js"() {
-    BAGGAGE_KEY_PAIR_SEPARATOR = "=";
-    BAGGAGE_PROPERTIES_SEPARATOR = ";";
-    BAGGAGE_ITEMS_SEPARATOR = ",";
-  }
-});
-function parsePairKeyValue(entry) {
-  if (!entry)
-    return;
-  const metadataSeparatorIndex = entry.indexOf(BAGGAGE_PROPERTIES_SEPARATOR);
-  const keyPairPart = metadataSeparatorIndex === -1 ? entry : entry.substring(0, metadataSeparatorIndex);
-  const separatorIndex = keyPairPart.indexOf(BAGGAGE_KEY_PAIR_SEPARATOR);
-  if (separatorIndex <= 0)
-    return;
-  const rawKey = keyPairPart.substring(0, separatorIndex).trim();
-  const rawValue = keyPairPart.substring(separatorIndex + 1).trim();
-  if (!rawKey || !rawValue)
-    return;
-  let key;
-  let value;
-  try {
-    key = decodeURIComponent(rawKey);
-    value = decodeURIComponent(rawValue);
-  } catch {
-    return;
-  }
-  let metadata;
-  if (metadataSeparatorIndex !== -1 && metadataSeparatorIndex < entry.length - 1) {
-    const metadataString = entry.substring(metadataSeparatorIndex + 1);
-    metadata = baggageEntryMetadataFromString(metadataString);
-  }
-  return { key, value, metadata };
-}
-function parseKeyPairsIntoRecord(value) {
-  const result = {};
-  if (typeof value === "string" && value.length > 0) {
-    value.split(BAGGAGE_ITEMS_SEPARATOR).forEach((entry) => {
-      const keyPair = parsePairKeyValue(entry);
-      if (keyPair !== void 0 && keyPair.value.length > 0) {
-        result[keyPair.key] = keyPair.value;
-      }
-    });
-  }
-  return result;
-}
-var init_utils = __esm({
-  "../../node_modules/@opentelemetry/core/build/esm/baggage/utils.js"() {
-    init_constants();
-  }
-});
-function getNumberFromEnv(key) {
-  const raw = process.env[key];
-  if (raw == null || raw.trim() === "") {
-    return void 0;
-  }
-  const value = Number(raw);
-  if (isNaN(value)) {
-    diag.warn(`Unknown value ${inspect(raw)} for ${key}, expected a number, using defaults`);
-    return void 0;
-  }
-  return value;
-}
-function getStringFromEnv(key) {
-  const raw = process.env[key];
-  if (raw == null || raw.trim() === "") {
-    return void 0;
-  }
-  return raw;
-}
-var init_environment = __esm({
-  "../../node_modules/@opentelemetry/core/build/esm/platform/node/environment.js"() {
-  }
-});
-
-// ../../node_modules/@opentelemetry/core/build/esm/platform/node/index.js
-var init_node = __esm({
-  "../../node_modules/@opentelemetry/core/build/esm/platform/node/index.js"() {
-    init_environment();
-  }
-});
-
-// ../../node_modules/@opentelemetry/core/build/esm/platform/index.js
-var init_platform = __esm({
-  "../../node_modules/@opentelemetry/core/build/esm/platform/index.js"() {
-    init_node();
-  }
-});
-
-// ../../node_modules/@opentelemetry/core/build/esm/common/time.js
-function hrTimeToNanoseconds(time) {
-  return time[0] * SECOND_TO_NANOSECONDS + time[1];
-}
-var NANOSECOND_DIGITS, SECOND_TO_NANOSECONDS;
-var init_time = __esm({
-  "../../node_modules/@opentelemetry/core/build/esm/common/time.js"() {
-    NANOSECOND_DIGITS = 9;
-    SECOND_TO_NANOSECONDS = Math.pow(10, NANOSECOND_DIGITS);
-  }
-});
-
-// ../../node_modules/@opentelemetry/core/build/esm/ExportResult.js
-var ExportResultCode;
-var init_ExportResult = __esm({
-  "../../node_modules/@opentelemetry/core/build/esm/ExportResult.js"() {
-    (function(ExportResultCode2) {
-      ExportResultCode2[ExportResultCode2["SUCCESS"] = 0] = "SUCCESS";
-      ExportResultCode2[ExportResultCode2["FAILED"] = 1] = "FAILED";
-    })(ExportResultCode || (ExportResultCode = {}));
-  }
-});
-
-// ../../node_modules/@opentelemetry/core/build/esm/index.js
-var init_esm = __esm({
-  "../../node_modules/@opentelemetry/core/build/esm/index.js"() {
-    init_time();
-    init_ExportResult();
-    init_utils();
-    init_platform();
-  }
-});
-function isPartialSuccessResponse(response) {
-  return Object.prototype.hasOwnProperty.call(response, "partialSuccess");
-}
-function createLoggingPartialSuccessResponseHandler() {
-  return {
-    handleResponse(response) {
-      if (response == null || !isPartialSuccessResponse(response) || response.partialSuccess == null || Object.keys(response.partialSuccess).length === 0) {
-        return;
-      }
-      diag.warn("Received Partial Success response:", JSON.stringify(response.partialSuccess));
-    }
-  };
-}
-var init_logging_response_handler = __esm({
-  "../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/logging-response-handler.js"() {
-  }
-});
-function createOtlpExportDelegate(components, settings) {
-  return new OTLPExportDelegate(components.transport, components.serializer, createLoggingPartialSuccessResponseHandler(), components.promiseHandler, settings.timeout);
-}
-var OTLPExportDelegate;
-var init_otlp_export_delegate = __esm({
-  "../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/otlp-export-delegate.js"() {
-    init_esm();
-    init_types();
-    init_logging_response_handler();
-    OTLPExportDelegate = class {
-      _diagLogger;
-      _transport;
-      _serializer;
-      _responseHandler;
-      _promiseQueue;
-      _timeout;
-      constructor(transport, serializer, responseHandler, promiseQueue, timeout) {
-        this._transport = transport;
-        this._serializer = serializer;
-        this._responseHandler = responseHandler;
-        this._promiseQueue = promiseQueue;
-        this._timeout = timeout;
-        this._diagLogger = diag.createComponentLogger({
-          namespace: "OTLPExportDelegate"
-        });
-      }
-      export(internalRepresentation, resultCallback) {
-        this._diagLogger.debug("items to be sent", internalRepresentation);
-        if (this._promiseQueue.hasReachedLimit()) {
-          resultCallback({
-            code: ExportResultCode.FAILED,
-            error: new Error("Concurrent export limit reached")
-          });
-          return;
-        }
-        const serializedRequest = this._serializer.serializeRequest(internalRepresentation);
-        if (serializedRequest == null) {
-          resultCallback({
-            code: ExportResultCode.FAILED,
-            error: new Error("Nothing to send")
-          });
-          return;
-        }
-        this._promiseQueue.pushPromise(this._transport.send(serializedRequest, this._timeout).then((response) => {
-          if (response.status === "success") {
-            if (response.data != null) {
-              try {
-                this._responseHandler.handleResponse(this._serializer.deserializeResponse(response.data));
-              } catch (e) {
-                this._diagLogger.warn("Export succeeded but could not deserialize response - is the response specification compliant?", e, response.data);
-              }
-            }
-            resultCallback({
-              code: ExportResultCode.SUCCESS
-            });
-            return;
-          } else if (response.status === "failure" && response.error) {
-            resultCallback({
-              code: ExportResultCode.FAILED,
-              error: response.error
-            });
-            return;
-          } else if (response.status === "retryable") {
-            resultCallback({
-              code: ExportResultCode.FAILED,
-              error: response.error ?? new OTLPExporterError("Export failed with retryable status")
-            });
-          } else {
-            resultCallback({
-              code: ExportResultCode.FAILED,
-              error: new OTLPExporterError("Export failed with unknown error")
-            });
-          }
-        }, (reason) => resultCallback({
-          code: ExportResultCode.FAILED,
-          error: reason
-        })));
-      }
-      forceFlush() {
-        return this._promiseQueue.awaitAll();
-      }
-      async shutdown() {
-        this._diagLogger.debug("shutdown started");
-        await this.forceFlush();
-        this._transport.shutdown();
-      }
-    };
-  }
-});
-
-// ../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/index.js
-var init_esm2 = __esm({
-  "../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/index.js"() {
-    init_OTLPExporterBase();
-  }
-});
-
-// ../../node_modules/@opentelemetry/otlp-transformer/build/esm/common/internal.js
-function createResource(resource, encoder) {
-  const result = {
-    attributes: toAttributes(resource.attributes, encoder),
-    droppedAttributesCount: 0
-  };
-  const schemaUrl = resource.schemaUrl;
-  if (schemaUrl && schemaUrl !== "")
-    result.schemaUrl = schemaUrl;
-  return result;
-}
-function createInstrumentationScope(scope) {
-  return {
-    name: scope.name,
-    version: scope.version
-  };
-}
-function toAttributes(attributes, encoder) {
-  return Object.keys(attributes).map((key) => toKeyValue(key, attributes[key], encoder));
-}
-function toKeyValue(key, value, encoder) {
-  return {
-    key,
-    value: toAnyValue(value, encoder)
-  };
-}
-function toAnyValue(value, encoder) {
-  const t = typeof value;
-  if (t === "string")
-    return { stringValue: value };
-  if (t === "number") {
-    if (!Number.isInteger(value))
-      return { doubleValue: value };
-    return { intValue: value };
-  }
-  if (t === "boolean")
-    return { boolValue: value };
-  if (value instanceof Uint8Array)
-    return { bytesValue: encoder.encodeUint8Array(value) };
-  if (Array.isArray(value)) {
-    const values = new Array(value.length);
-    for (let i = 0; i < value.length; i++) {
-      values[i] = toAnyValue(value[i], encoder);
-    }
-    return { arrayValue: { values } };
-  }
-  if (t === "object" && value != null) {
-    const keys = Object.keys(value);
-    const values = new Array(keys.length);
-    for (let i = 0; i < keys.length; i++) {
-      values[i] = {
-        key: keys[i],
-        value: toAnyValue(value[keys[i]], encoder)
-      };
-    }
-    return { kvlistValue: { values } };
-  }
-  return {};
-}
-var init_internal = __esm({
-  "../../node_modules/@opentelemetry/otlp-transformer/build/esm/common/internal.js"() {
-  }
-});
-
-// ../../node_modules/@opentelemetry/otlp-transformer/build/esm/common/utils.js
-function hrTimeToNanos(hrTime2) {
-  const NANOSECONDS = BigInt(1e9);
-  return BigInt(Math.trunc(hrTime2[0])) * NANOSECONDS + BigInt(Math.trunc(hrTime2[1]));
-}
-function encodeAsString(hrTime2) {
-  const nanos = hrTimeToNanos(hrTime2);
-  return nanos.toString();
-}
-function identity(value) {
-  return value;
-}
-var encodeTimestamp, JSON_ENCODER;
-var init_utils2 = __esm({
-  "../../node_modules/@opentelemetry/otlp-transformer/build/esm/common/utils.js"() {
-    init_esm();
-    encodeTimestamp = typeof BigInt !== "undefined" ? encodeAsString : hrTimeToNanoseconds;
-    JSON_ENCODER = {
-      encodeHrTime: encodeTimestamp,
-      encodeSpanContext: identity,
-      encodeOptionalSpanContext: identity,
-      encodeUint8Array: (bytes) => {
-        if (typeof Buffer !== "undefined") {
-          return Buffer.from(bytes).toString("base64");
-        }
-        const chars = new Array(bytes.length);
-        for (let i = 0; i < bytes.length; i++) {
-          chars[i] = String.fromCharCode(bytes[i]);
-        }
-        return btoa(chars.join(""));
-      }
-    };
-  }
-});
-
-// ../../node_modules/@opentelemetry/otlp-transformer/build/esm/trace/internal.js
-function buildSpanFlagsFrom(traceFlags, isRemote) {
-  let flags = traceFlags & 255 | SPAN_FLAGS_CONTEXT_HAS_IS_REMOTE_MASK;
-  if (isRemote) {
-    flags |= SPAN_FLAGS_CONTEXT_IS_REMOTE_MASK;
-  }
-  return flags;
-}
-function sdkSpanToOtlpSpan(span, encoder) {
-  const ctx = span.spanContext();
-  const status = span.status;
-  const parentSpanId = span.parentSpanContext?.spanId ? encoder.encodeSpanContext(span.parentSpanContext?.spanId) : void 0;
-  return {
-    traceId: encoder.encodeSpanContext(ctx.traceId),
-    spanId: encoder.encodeSpanContext(ctx.spanId),
-    parentSpanId,
-    traceState: ctx.traceState?.serialize(),
-    name: span.name,
-    // Span kind is offset by 1 because the API does not define a value for unset
-    kind: span.kind == null ? 0 : span.kind + 1,
-    startTimeUnixNano: encoder.encodeHrTime(span.startTime),
-    endTimeUnixNano: encoder.encodeHrTime(span.endTime),
-    attributes: toAttributes(span.attributes, encoder),
-    droppedAttributesCount: span.droppedAttributesCount,
-    events: span.events.map((event) => toOtlpSpanEvent(event, encoder)),
-    droppedEventsCount: span.droppedEventsCount,
-    status: {
-      // API and proto enums share the same values
-      code: status.code,
-      message: status.message
-    },
-    links: span.links.map((link) => toOtlpLink(link, encoder)),
-    droppedLinksCount: span.droppedLinksCount,
-    flags: buildSpanFlagsFrom(ctx.traceFlags, span.parentSpanContext?.isRemote)
-  };
-}
-function toOtlpLink(link, encoder) {
-  return {
-    attributes: link.attributes ? toAttributes(link.attributes, encoder) : [],
-    spanId: encoder.encodeSpanContext(link.context.spanId),
-    traceId: encoder.encodeSpanContext(link.context.traceId),
-    traceState: link.context.traceState?.serialize(),
-    droppedAttributesCount: link.droppedAttributesCount || 0,
-    flags: buildSpanFlagsFrom(link.context.traceFlags, link.context.isRemote)
-  };
-}
-function toOtlpSpanEvent(timedEvent, encoder) {
-  return {
-    attributes: timedEvent.attributes ? toAttributes(timedEvent.attributes, encoder) : [],
-    name: timedEvent.name,
-    timeUnixNano: encoder.encodeHrTime(timedEvent.time),
-    droppedAttributesCount: timedEvent.droppedAttributesCount || 0
-  };
-}
-function createExportTraceServiceRequest(spans, encoder) {
-  return {
-    resourceSpans: spanRecordsToResourceSpans(spans, encoder)
-  };
-}
-function createResourceMap(readableSpans) {
-  const resourceMap = /* @__PURE__ */ new Map();
-  for (const record of readableSpans) {
-    let ilsMap = resourceMap.get(record.resource);
-    if (!ilsMap) {
-      ilsMap = /* @__PURE__ */ new Map();
-      resourceMap.set(record.resource, ilsMap);
-    }
-    const instrumentationScopeKey = `${record.instrumentationScope.name}@${record.instrumentationScope.version || ""}:${record.instrumentationScope.schemaUrl || ""}`;
-    let records = ilsMap.get(instrumentationScopeKey);
-    if (!records) {
-      records = [];
-      ilsMap.set(instrumentationScopeKey, records);
-    }
-    records.push(record);
-  }
-  return resourceMap;
-}
-function spanRecordsToResourceSpans(readableSpans, encoder) {
-  const resourceMap = createResourceMap(readableSpans);
-  const out = [];
-  const entryIterator = resourceMap.entries();
-  let entry = entryIterator.next();
-  while (!entry.done) {
-    const [resource, ilmMap] = entry.value;
-    const scopeResourceSpans = [];
-    const ilmIterator = ilmMap.values();
-    let ilmEntry = ilmIterator.next();
-    while (!ilmEntry.done) {
-      const scopeSpans = ilmEntry.value;
-      if (scopeSpans.length > 0) {
-        const spans = scopeSpans.map((readableSpan) => sdkSpanToOtlpSpan(readableSpan, encoder));
-        scopeResourceSpans.push({
-          scope: createInstrumentationScope(scopeSpans[0].instrumentationScope),
-          spans,
-          schemaUrl: scopeSpans[0].instrumentationScope.schemaUrl
-        });
-      }
-      ilmEntry = ilmIterator.next();
-    }
-    const processedResource = createResource(resource, encoder);
-    const transformedSpans = {
-      resource: processedResource,
-      scopeSpans: scopeResourceSpans,
-      schemaUrl: processedResource.schemaUrl
-    };
-    out.push(transformedSpans);
-    entry = entryIterator.next();
-  }
-  return out;
-}
-var SPAN_FLAGS_CONTEXT_HAS_IS_REMOTE_MASK, SPAN_FLAGS_CONTEXT_IS_REMOTE_MASK;
-var init_internal2 = __esm({
-  "../../node_modules/@opentelemetry/otlp-transformer/build/esm/trace/internal.js"() {
-    init_internal();
-    SPAN_FLAGS_CONTEXT_HAS_IS_REMOTE_MASK = 256;
-    SPAN_FLAGS_CONTEXT_IS_REMOTE_MASK = 512;
-  }
-});
-var JsonTraceSerializer;
-var init_trace = __esm({
-  "../../node_modules/@opentelemetry/otlp-transformer/build/esm/trace/json/trace.js"() {
-    init_internal2();
-    init_utils2();
-    JsonTraceSerializer = {
-      serializeRequest: (arg) => {
-        const request = createExportTraceServiceRequest(arg, JSON_ENCODER);
-        const encoder = new TextEncoder();
-        return encoder.encode(JSON.stringify(request));
-      },
-      deserializeResponse: (arg) => {
-        if (arg.length === 0) {
-          return {};
-        }
-        const decoder = new TextDecoder();
-        try {
-          return JSON.parse(decoder.decode(arg));
-        } catch (err) {
-          diag.warn(`Failed to parse trace export response: ${err.message}. Returning empty response`);
-          return {};
-        }
-      }
-    };
-  }
-});
-
-// ../../node_modules/@opentelemetry/otlp-transformer/build/esm/trace/json/index.js
-var init_json = __esm({
-  "../../node_modules/@opentelemetry/otlp-transformer/build/esm/trace/json/index.js"() {
-    init_trace();
-  }
-});
-
-// ../../node_modules/@opentelemetry/otlp-transformer/build/esm/index.js
-var init_esm3 = __esm({
-  "../../node_modules/@opentelemetry/otlp-transformer/build/esm/index.js"() {
-    init_json();
-  }
-});
-function validateAndNormalizeHeaders(partialHeaders) {
-  const headers = {};
-  Object.entries(partialHeaders ?? {}).forEach(([key, value]) => {
-    if (typeof value !== "undefined") {
-      headers[key] = String(value);
-    } else {
-      diag.warn(`Header "${key}" has invalid value (${value}) and will be ignored`);
-    }
-  });
-  return headers;
-}
-var init_util = __esm({
-  "../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/util.js"() {
-  }
-});
-
-// ../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/otlp-http-configuration.js
-function mergeHeaders(userProvidedHeaders, fallbackHeaders, defaultHeaders) {
-  return async () => {
-    const requiredHeaders = {
-      ...await defaultHeaders()
-    };
-    const headers = {};
-    if (fallbackHeaders != null) {
-      Object.assign(headers, await fallbackHeaders());
-    }
-    if (userProvidedHeaders != null) {
-      Object.assign(headers, validateAndNormalizeHeaders(await userProvidedHeaders()));
-    }
-    return Object.assign(headers, requiredHeaders);
-  };
-}
-function validateUserProvidedUrl(url) {
-  if (url == null) {
-    return void 0;
-  }
-  try {
-    const base = globalThis.location?.href;
-    return new URL(url, base).href;
-  } catch {
-    throw new Error(`Configuration: Could not parse user-provided export URL: '${url}'`);
-  }
-}
-function mergeOtlpHttpConfigurationWithDefaults(userProvidedConfiguration, fallbackConfiguration, defaultConfiguration) {
-  return {
-    ...mergeOtlpSharedConfigurationWithDefaults(userProvidedConfiguration, fallbackConfiguration, defaultConfiguration),
-    headers: mergeHeaders(userProvidedConfiguration.headers, fallbackConfiguration.headers, defaultConfiguration.headers),
-    url: validateUserProvidedUrl(userProvidedConfiguration.url) ?? fallbackConfiguration.url ?? defaultConfiguration.url
-  };
-}
-function getHttpConfigurationDefaults(requiredHeaders, signalResourcePath) {
-  return {
-    ...getSharedConfigurationDefaults(),
-    headers: async () => requiredHeaders,
-    url: "http://localhost:4318/" + signalResourcePath
-  };
-}
-var init_otlp_http_configuration = __esm({
-  "../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/otlp-http-configuration.js"() {
-    init_shared_configuration();
-    init_util();
-  }
-});
-
-// ../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/otlp-node-http-configuration.js
-function httpAgentFactoryFromOptions(options) {
-  return async (protocol) => {
-    const isInsecure = protocol === "http:";
-    const module = isInsecure ? import('http') : import('https');
-    const { Agent } = await module;
-    if (isInsecure) {
-      const { ca, cert, key, ...insecureOptions } = options;
-      return new Agent(insecureOptions);
-    }
-    return new Agent(options);
-  };
-}
-function mergeOtlpNodeHttpConfigurationWithDefaults(userProvidedConfiguration, fallbackConfiguration, defaultConfiguration) {
-  return {
-    ...mergeOtlpHttpConfigurationWithDefaults(userProvidedConfiguration, fallbackConfiguration, defaultConfiguration),
-    agentFactory: userProvidedConfiguration.agentFactory ?? fallbackConfiguration.agentFactory ?? defaultConfiguration.agentFactory,
-    userAgent: userProvidedConfiguration.userAgent
-  };
-}
-function getNodeHttpConfigurationDefaults(requiredHeaders, signalResourcePath) {
-  return {
-    ...getHttpConfigurationDefaults(requiredHeaders, signalResourcePath),
-    agentFactory: httpAgentFactoryFromOptions({ keepAlive: true })
-  };
-}
-var init_otlp_node_http_configuration = __esm({
-  "../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/otlp-node-http-configuration.js"() {
-    init_otlp_http_configuration();
-  }
-});
-
-// ../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/is-export-retryable.js
-function isExportHTTPErrorRetryable(statusCode) {
-  return statusCode === 429 || statusCode === 502 || statusCode === 503 || statusCode === 504;
-}
-function parseRetryAfterToMills(retryAfter) {
-  if (retryAfter == null) {
-    return void 0;
-  }
-  const seconds = Number.parseInt(retryAfter, 10);
-  if (Number.isInteger(seconds)) {
-    return seconds > 0 ? seconds * 1e3 : -1;
-  }
-  const delay = new Date(retryAfter).getTime() - Date.now();
-  if (delay >= 0) {
-    return delay;
-  }
-  return 0;
-}
-var init_is_export_retryable = __esm({
-  "../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/is-export-retryable.js"() {
-  }
-});
-
-// ../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/version.js
-var VERSION;
-var init_version = __esm({
-  "../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/version.js"() {
-    VERSION = "0.215.0";
-  }
-});
-function sendWithHttp(request, url, headers, compression, userAgent, agent, data, timeoutMillis) {
-  return new Promise((resolve2) => {
-    const parsedUrl = new URL(url);
-    if (userAgent) {
-      headers["User-Agent"] = `${userAgent} ${DEFAULT_USER_AGENT}`;
-    } else {
-      headers["User-Agent"] = DEFAULT_USER_AGENT;
-    }
-    const options = {
-      hostname: parsedUrl.hostname,
-      port: parsedUrl.port,
-      path: parsedUrl.pathname,
-      method: "POST",
-      headers,
-      agent
-    };
-    const req = request(options, (res) => {
-      const responseData = [];
-      let responseSize = 0;
-      res.on("data", (chunk) => {
-        responseSize += chunk.length;
-        if (responseSize > MAX_RESPONSE_BODY_SIZE) {
-          const sizeError = new Error(`OTLP export response body exceeded size limit of ${MAX_RESPONSE_BODY_SIZE} bytes`);
-          resolve2({ status: "failure", error: sizeError });
-          res.destroy();
-          return;
-        }
-        responseData.push(chunk);
-      });
-      res.on("end", () => {
-        if (res.statusCode && res.statusCode <= 299) {
-          resolve2({
-            status: "success",
-            data: Buffer.concat(responseData)
-          });
-        } else if (res.statusCode && isExportHTTPErrorRetryable(res.statusCode)) {
-          resolve2({
-            status: "retryable",
-            retryInMillis: parseRetryAfterToMills(res.headers["retry-after"])
-          });
-        } else {
-          const error = new OTLPExporterError(res.statusMessage, res.statusCode, Buffer.concat(responseData).toString());
-          resolve2({
-            status: "failure",
-            error
-          });
-        }
-      });
-      res.on("error", (error) => {
-        if (res.statusCode && res.statusCode <= 299) {
-          resolve2({
-            status: "success"
-          });
-        } else if (res.statusCode && isExportHTTPErrorRetryable(res.statusCode)) {
-          resolve2({
-            status: "retryable",
-            error,
-            retryInMillis: parseRetryAfterToMills(res.headers["retry-after"])
-          });
-        } else {
-          resolve2({
-            status: "failure",
-            error
-          });
-        }
-      });
-    });
-    req.setTimeout(timeoutMillis, () => {
-      req.destroy();
-      resolve2({
-        status: "retryable",
-        error: new Error("Request timed out")
-      });
-    });
-    req.on("error", (error) => {
-      if (isHttpTransportNetworkErrorRetryable(error)) {
-        resolve2({
-          status: "retryable",
-          error
-        });
-      } else {
-        resolve2({
-          status: "failure",
-          error
-        });
-      }
-    });
-    compressAndSend(req, compression, data, (error) => {
-      resolve2({
-        status: "failure",
-        error
-      });
-    });
-  });
-}
-function compressAndSend(req, compression, data, onError) {
-  let dataStream = readableFromUint8Array(data);
-  if (compression === "gzip") {
-    req.setHeader("Content-Encoding", "gzip");
-    dataStream = dataStream.on("error", onError).pipe(zlib.createGzip()).on("error", onError);
-  }
-  dataStream.pipe(req).on("error", onError);
-}
-function readableFromUint8Array(buff) {
-  const readable = new Readable();
-  readable.push(buff);
-  readable.push(null);
-  return readable;
-}
-function isHttpTransportNetworkErrorRetryable(error) {
-  const RETRYABLE_NETWORK_ERROR_CODES = /* @__PURE__ */ new Set([
-    "ECONNRESET",
-    "ECONNREFUSED",
-    "EPIPE",
-    "ETIMEDOUT",
-    "EAI_AGAIN",
-    "ENOTFOUND",
-    "ENETUNREACH",
-    "EHOSTUNREACH"
-  ]);
-  if ("code" in error && typeof error.code === "string") {
-    return RETRYABLE_NETWORK_ERROR_CODES.has(error.code);
-  }
-  return false;
-}
-var DEFAULT_USER_AGENT, MAX_RESPONSE_BODY_SIZE;
-var init_http_transport_utils = __esm({
-  "../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/transport/http-transport-utils.js"() {
-    init_is_export_retryable();
-    init_types();
-    init_version();
-    DEFAULT_USER_AGENT = `OTel-OTLP-Exporter-JavaScript/${VERSION}`;
-    MAX_RESPONSE_BODY_SIZE = 4 * 1024 * 1024;
-  }
-});
-
-// ../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/transport/http-exporter-transport.js
-async function requestFunctionFactory(protocol) {
-  const module = protocol === "http:" ? import('http') : import('https');
-  const { request } = await module;
-  return request;
-}
-function createHttpExporterTransport(parameters) {
-  return new HttpExporterTransport(parameters);
-}
-var HttpExporterTransport;
-var init_http_exporter_transport = __esm({
-  "../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/transport/http-exporter-transport.js"() {
-    init_http_transport_utils();
-    HttpExporterTransport = class {
-      _utils = null;
-      _parameters;
-      constructor(parameters) {
-        this._parameters = parameters;
-      }
-      async send(data, timeoutMillis) {
-        const { agent, request } = await this._loadUtils();
-        const headers = await this._parameters.headers();
-        return sendWithHttp(request, this._parameters.url, headers, this._parameters.compression, this._parameters.userAgent, agent, data, timeoutMillis);
-      }
-      shutdown() {
-      }
-      async _loadUtils() {
-        let utils = this._utils;
-        if (utils === null) {
-          const protocol = new URL(this._parameters.url).protocol;
-          const [agent, request] = await Promise.all([
-            this._parameters.agentFactory(protocol),
-            requestFunctionFactory(protocol)
-          ]);
-          utils = this._utils = { agent, request };
-        }
-        return utils;
-      }
-    };
-  }
-});
-function getJitter() {
-  return Math.random() * (2 * JITTER) - JITTER;
-}
-function createRetryingTransport(options) {
-  return new RetryingTransport(options.transport);
-}
-var MAX_ATTEMPTS, INITIAL_BACKOFF, MAX_BACKOFF, BACKOFF_MULTIPLIER, JITTER, RetryingTransport;
-var init_retrying_transport = __esm({
-  "../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/retrying-transport.js"() {
-    MAX_ATTEMPTS = 5;
-    INITIAL_BACKOFF = 1e3;
-    MAX_BACKOFF = 5e3;
-    BACKOFF_MULTIPLIER = 1.5;
-    JITTER = 0.2;
-    RetryingTransport = class {
-      _transport;
-      constructor(transport) {
-        this._transport = transport;
-      }
-      retry(data, timeoutMillis, inMillis) {
-        return new Promise((resolve2, reject) => {
-          setTimeout(() => {
-            this._transport.send(data, timeoutMillis).then(resolve2, reject);
-          }, inMillis);
-        });
-      }
-      async send(data, timeoutMillis) {
-        let attempts = MAX_ATTEMPTS;
-        let nextBackoff = INITIAL_BACKOFF;
-        const deadline = Date.now() + timeoutMillis;
-        let result = await this._transport.send(data, timeoutMillis);
-        while (result.status === "retryable" && attempts > 0) {
-          attempts--;
-          const backoff = Math.max(Math.min(nextBackoff * (1 + getJitter()), MAX_BACKOFF), 0);
-          nextBackoff = nextBackoff * BACKOFF_MULTIPLIER;
-          const retryInMillis = result.retryInMillis ?? backoff;
-          const remainingTimeoutMillis = deadline - Date.now();
-          if (retryInMillis > remainingTimeoutMillis) {
-            diag.info(`Export retry time ${Math.round(retryInMillis)}ms exceeds remaining timeout ${Math.round(remainingTimeoutMillis)}ms, not retrying further.`);
-            return result;
-          }
-          diag.verbose(`Scheduling export retry in ${Math.round(retryInMillis)}ms`);
-          result = await this.retry(data, remainingTimeoutMillis, retryInMillis);
-        }
-        if (result.status === "success") {
-          diag.verbose(`Export succeeded after ${MAX_ATTEMPTS - attempts} retry attempts.`);
-        } else if (result.status === "retryable") {
-          diag.info(`Export failed after maximum retry attempts (${MAX_ATTEMPTS}).`);
-        } else {
-          diag.info(`Export failed with non-retryable error: ${result.error}`);
-        }
-        return result;
-      }
-      shutdown() {
-        return this._transport.shutdown();
-      }
-    };
-  }
-});
-
-// ../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/otlp-http-export-delegate.js
-function createOtlpHttpExportDelegate(options, serializer) {
-  return createOtlpExportDelegate({
-    transport: createRetryingTransport({
-      transport: createHttpExporterTransport(options)
-    }),
-    serializer,
-    promiseHandler: createBoundedQueueExportPromiseHandler(options)
-  }, { timeout: options.timeoutMillis });
-}
-var init_otlp_http_export_delegate = __esm({
-  "../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/otlp-http-export-delegate.js"() {
-    init_otlp_export_delegate();
-    init_http_exporter_transport();
-    init_bounded_queue_export_promise_handler();
-    init_retrying_transport();
-  }
-});
-function parseAndValidateTimeoutFromEnv(timeoutEnvVar) {
-  const envTimeout = getNumberFromEnv(timeoutEnvVar);
-  if (envTimeout != null) {
-    if (Number.isFinite(envTimeout) && envTimeout > 0) {
-      return envTimeout;
-    }
-    diag.warn(`Configuration: ${timeoutEnvVar} is invalid, expected number greater than 0 (actual: ${envTimeout})`);
-  }
-  return void 0;
-}
-function getTimeoutFromEnv(signalIdentifier) {
-  const specificTimeout = parseAndValidateTimeoutFromEnv(`OTEL_EXPORTER_OTLP_${signalIdentifier}_TIMEOUT`);
-  const nonSpecificTimeout = parseAndValidateTimeoutFromEnv("OTEL_EXPORTER_OTLP_TIMEOUT");
-  return specificTimeout ?? nonSpecificTimeout;
-}
-function parseAndValidateCompressionFromEnv(compressionEnvVar) {
-  const compression = getStringFromEnv(compressionEnvVar)?.trim();
-  if (compression == null || compression === "none" || compression === "gzip") {
-    return compression;
-  }
-  diag.warn(`Configuration: ${compressionEnvVar} is invalid, expected 'none' or 'gzip' (actual: '${compression}')`);
-  return void 0;
-}
-function getCompressionFromEnv(signalIdentifier) {
-  const specificCompression = parseAndValidateCompressionFromEnv(`OTEL_EXPORTER_OTLP_${signalIdentifier}_COMPRESSION`);
-  const nonSpecificCompression = parseAndValidateCompressionFromEnv("OTEL_EXPORTER_OTLP_COMPRESSION");
-  return specificCompression ?? nonSpecificCompression;
-}
-function getSharedConfigurationFromEnvironment(signalIdentifier) {
-  return {
-    timeoutMillis: getTimeoutFromEnv(signalIdentifier),
-    compression: getCompressionFromEnv(signalIdentifier)
-  };
-}
-var init_shared_env_configuration = __esm({
-  "../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/shared-env-configuration.js"() {
-    init_esm();
-  }
-});
-function getStaticHeadersFromEnv(signalIdentifier) {
-  const signalSpecificRawHeaders = getStringFromEnv(`OTEL_EXPORTER_OTLP_${signalIdentifier}_HEADERS`);
-  const nonSignalSpecificRawHeaders = getStringFromEnv("OTEL_EXPORTER_OTLP_HEADERS");
-  const signalSpecificHeaders = parseKeyPairsIntoRecord(signalSpecificRawHeaders);
-  const nonSignalSpecificHeaders = parseKeyPairsIntoRecord(nonSignalSpecificRawHeaders);
-  if (Object.keys(signalSpecificHeaders).length === 0 && Object.keys(nonSignalSpecificHeaders).length === 0) {
-    return void 0;
-  }
-  return Object.assign({}, parseKeyPairsIntoRecord(nonSignalSpecificRawHeaders), parseKeyPairsIntoRecord(signalSpecificRawHeaders));
-}
-function appendRootPathToUrlIfNeeded(url) {
-  try {
-    const parsedUrl = new URL(url);
-    return parsedUrl.toString();
-  } catch {
-    diag.warn(`Configuration: Could not parse environment-provided export URL: '${url}', falling back to undefined`);
-    return void 0;
-  }
-}
-function appendResourcePathToUrl(url, path29) {
-  try {
-    new URL(url);
-  } catch {
-    diag.warn(`Configuration: Could not parse environment-provided export URL: '${url}', falling back to undefined`);
-    return void 0;
-  }
-  if (!url.endsWith("/")) {
-    url = url + "/";
-  }
-  url += path29;
-  try {
-    new URL(url);
-  } catch {
-    diag.warn(`Configuration: Provided URL appended with '${path29}' is not a valid URL, using 'undefined' instead of '${url}'`);
-    return void 0;
-  }
-  return url;
-}
-function getNonSpecificUrlFromEnv(signalResourcePath) {
-  const envUrl = getStringFromEnv("OTEL_EXPORTER_OTLP_ENDPOINT");
-  if (envUrl === void 0) {
-    return void 0;
-  }
-  return appendResourcePathToUrl(envUrl, signalResourcePath);
-}
-function getSpecificUrlFromEnv(signalIdentifier) {
-  const envUrl = getStringFromEnv(`OTEL_EXPORTER_OTLP_${signalIdentifier}_ENDPOINT`);
-  if (envUrl === void 0) {
-    return void 0;
-  }
-  return appendRootPathToUrlIfNeeded(envUrl);
-}
-function readFileFromEnv(signalSpecificEnvVar, nonSignalSpecificEnvVar, warningMessage) {
-  const signalSpecificPath = getStringFromEnv(signalSpecificEnvVar);
-  const nonSignalSpecificPath = getStringFromEnv(nonSignalSpecificEnvVar);
-  const filePath = signalSpecificPath ?? nonSignalSpecificPath;
-  if (filePath != null) {
-    try {
-      return fs25.readFileSync(path28.resolve(process.cwd(), filePath));
-    } catch {
-      diag.warn(warningMessage);
-      return void 0;
-    }
-  } else {
-    return void 0;
-  }
-}
-function getClientCertificateFromEnv(signalIdentifier) {
-  return readFileFromEnv(`OTEL_EXPORTER_OTLP_${signalIdentifier}_CLIENT_CERTIFICATE`, "OTEL_EXPORTER_OTLP_CLIENT_CERTIFICATE", "Failed to read client certificate chain file");
-}
-function getClientKeyFromEnv(signalIdentifier) {
-  return readFileFromEnv(`OTEL_EXPORTER_OTLP_${signalIdentifier}_CLIENT_KEY`, "OTEL_EXPORTER_OTLP_CLIENT_KEY", "Failed to read client certificate private key file");
-}
-function getRootCertificateFromEnv(signalIdentifier) {
-  return readFileFromEnv(`OTEL_EXPORTER_OTLP_${signalIdentifier}_CERTIFICATE`, "OTEL_EXPORTER_OTLP_CERTIFICATE", "Failed to read root certificate file");
-}
-function getNodeHttpConfigurationFromEnvironment(signalIdentifier, signalResourcePath) {
-  return {
-    ...getSharedConfigurationFromEnvironment(signalIdentifier),
-    url: getSpecificUrlFromEnv(signalIdentifier) ?? getNonSpecificUrlFromEnv(signalResourcePath),
-    headers: wrapStaticHeadersInFunction(getStaticHeadersFromEnv(signalIdentifier)),
-    agentFactory: httpAgentFactoryFromOptions({
-      keepAlive: true,
-      ca: getRootCertificateFromEnv(signalIdentifier),
-      cert: getClientCertificateFromEnv(signalIdentifier),
-      key: getClientKeyFromEnv(signalIdentifier)
-    })
-  };
-}
-var init_otlp_node_http_env_configuration = __esm({
-  "../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/otlp-node-http-env-configuration.js"() {
-    init_esm();
-    init_shared_env_configuration();
-    init_shared_configuration();
-    init_otlp_node_http_configuration();
-  }
-});
-
-// ../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/convert-legacy-http-options.js
-function convertLegacyHeaders(config) {
-  if (typeof config.headers === "function") {
-    return config.headers;
-  }
-  return wrapStaticHeadersInFunction(config.headers);
-}
-var init_convert_legacy_http_options = __esm({
-  "../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/convert-legacy-http-options.js"() {
-    init_shared_configuration();
-  }
-});
-function convertLegacyAgentOptions(config) {
-  if (typeof config.httpAgentOptions === "function") {
-    return config.httpAgentOptions;
-  }
-  let legacy = config.httpAgentOptions;
-  if (config.keepAlive != null) {
-    legacy = { keepAlive: config.keepAlive, ...legacy };
-  }
-  if (legacy != null) {
-    return httpAgentFactoryFromOptions(legacy);
-  } else {
-    return void 0;
-  }
-}
-function convertLegacyHttpOptions(config, signalIdentifier, signalResourcePath, requiredHeaders) {
-  if (config.metadata) {
-    diag.warn("Metadata cannot be set when using http");
-  }
-  return mergeOtlpNodeHttpConfigurationWithDefaults({
-    url: config.url,
-    headers: convertLegacyHeaders(config),
-    concurrencyLimit: config.concurrencyLimit,
-    timeoutMillis: config.timeoutMillis,
-    compression: config.compression,
-    agentFactory: convertLegacyAgentOptions(config),
-    userAgent: config.userAgent
-  }, getNodeHttpConfigurationFromEnvironment(signalIdentifier, signalResourcePath), getNodeHttpConfigurationDefaults(requiredHeaders, signalResourcePath));
-}
-var init_convert_legacy_node_http_options = __esm({
-  "../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/convert-legacy-node-http-options.js"() {
-    init_otlp_node_http_configuration();
-    init_index_node_http();
-    init_otlp_node_http_env_configuration();
-    init_convert_legacy_http_options();
-  }
-});
-
-// ../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/index-node-http.js
-var init_index_node_http = __esm({
-  "../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/index-node-http.js"() {
-    init_otlp_node_http_configuration();
-    init_otlp_http_export_delegate();
-    init_convert_legacy_node_http_options();
-  }
-});
-
-// ../../node_modules/@opentelemetry/exporter-trace-otlp-http/build/esm/platform/node/OTLPTraceExporter.js
-var OTLPTraceExporter;
-var init_OTLPTraceExporter = __esm({
-  "../../node_modules/@opentelemetry/exporter-trace-otlp-http/build/esm/platform/node/OTLPTraceExporter.js"() {
-    init_esm2();
-    init_esm3();
-    init_index_node_http();
-    OTLPTraceExporter = class extends OTLPExporterBase {
-      constructor(config = {}) {
-        super(createOtlpHttpExportDelegate(convertLegacyHttpOptions(config, "TRACES", "v1/traces", {
-          "Content-Type": "application/json"
-        }), JsonTraceSerializer));
-      }
-    };
-  }
-});
-
-// ../../node_modules/@opentelemetry/exporter-trace-otlp-http/build/esm/platform/node/index.js
-var init_node2 = __esm({
-  "../../node_modules/@opentelemetry/exporter-trace-otlp-http/build/esm/platform/node/index.js"() {
-    init_OTLPTraceExporter();
-  }
-});
-
-// ../../node_modules/@opentelemetry/exporter-trace-otlp-http/build/esm/platform/index.js
-var init_platform2 = __esm({
-  "../../node_modules/@opentelemetry/exporter-trace-otlp-http/build/esm/platform/index.js"() {
-    init_node2();
-  }
-});
-
-// ../../node_modules/@opentelemetry/exporter-trace-otlp-http/build/esm/index.js
-var init_esm4 = __esm({
-  "../../node_modules/@opentelemetry/exporter-trace-otlp-http/build/esm/index.js"() {
-    init_platform2();
-  }
-});
-
 // src/observability/tracing.ts
 var tracing_exports = {};
 __export(tracing_exports, {
@@ -1353,7 +128,6 @@ function getActiveTraceContext() {
 var _sdk, TRACER_NAME, BLOCKED_ATTR_KEYS;
 var init_tracing = __esm({
   "src/observability/tracing.ts"() {
-    init_esm4();
     _sdk = null;
     TRACER_NAME = "code-intel";
     BLOCKED_ATTR_KEYS = /secret|password|token|key|auth|credential/i;
@@ -1538,7 +312,7 @@ var init_logger = __esm({
         };
       }
       /** Global log directory: ~/.code-intel/logs */
-      static LOG_DIR = path28__default.join(os12.homedir(), ".code-intel", "logs");
+      static LOG_DIR = path27.join(os12.homedir(), ".code-intel", "logs");
       static getLogger() {
         if (!_Logger.instance) {
           const isProduction = process.env.NODE_ENV === "production";
@@ -1547,12 +321,12 @@ var init_logger = __esm({
           transports.push(new winston.transports.Console());
           if (!isProduction) {
             try {
-              if (!fs25__default.existsSync(_Logger.LOG_DIR)) {
-                fs25__default.mkdirSync(_Logger.LOG_DIR, { recursive: true });
+              if (!fs24.existsSync(_Logger.LOG_DIR)) {
+                fs24.mkdirSync(_Logger.LOG_DIR, { recursive: true });
               }
               transports.push(
                 new DailyRotateFile({
-                  filename: path28__default.join(_Logger.LOG_DIR, "%DATE%-code-intel.log"),
+                  filename: path27.join(_Logger.LOG_DIR, "%DATE%-code-intel.log"),
                   datePattern: "YYYY-MM-DD",
                   maxSize: "20m",
                   maxFiles: "14d"
@@ -1674,11 +448,11 @@ var init_id_generator = __esm({
   }
 });
 function findBundledWasmDir() {
-  const fileDir = path28__default.dirname(fileURLToPath(import.meta.url));
+  const fileDir = path27.dirname(fileURLToPath(import.meta.url));
   const candidates = [
-    path28__default.join(fileDir, "wasm"),
+    path27.join(fileDir, "wasm"),
     // dist/index.js → dist/wasm/
-    path28__default.join(fileDir, "../wasm")
+    path27.join(fileDir, "../wasm")
     // dist/cli/main.js → dist/wasm/
   ];
   for (const candidate of candidates) {
@@ -1719,7 +493,7 @@ function wasmPath(lang) {
   }
   const bundled = BUNDLED_WASM_MAP[lang];
   if (bundled) {
-    const bundledPath = path28__default.join(_bundledWasmDir, bundled);
+    const bundledPath = path27.join(_bundledWasmDir, bundled);
     if (existsSync(bundledPath)) return bundledPath;
   }
   return null;
@@ -1732,14 +506,14 @@ async function initParser() {
 }
 async function getLanguage(lang) {
   if (languageCache.has(lang)) return languageCache.get(lang);
-  const path29 = wasmPath(lang);
-  if (!path29) {
+  const path28 = wasmPath(lang);
+  if (!path28) {
     languageCache.set(lang, null);
     return null;
   }
   try {
     await initParser();
-    const language = await Language.load(path29);
+    const language = await Language.load(path28);
     languageCache.set(lang, language);
     return language;
   } catch {
@@ -3164,7 +1938,7 @@ var init_parse_phase = __esm({
           const batch = filePaths.slice(i, i + CONCURRENCY);
           await Promise.all(batch.map(async (filePath) => {
             try {
-              const source = await fs25__default.promises.readFile(filePath, "utf-8");
+              const source = await fs24.promises.readFile(filePath, "utf-8");
               context2.fileCache.set(filePath, source);
             } catch {
             }
@@ -3177,14 +1951,14 @@ var init_parse_phase = __esm({
           const lang = detectLanguage(filePath);
           if (!lang) {
             if (context2.verbose) {
-              const relativePath2 = path28__default.relative(context2.workspaceRoot, filePath);
+              const relativePath2 = path27.relative(context2.workspaceRoot, filePath);
               logger_default.info(`  [parse] skipped (no parser): ${relativePath2}`);
             }
             continue;
           }
           const source = context2.fileCache.get(filePath);
           if (!source) continue;
-          const relativePath = path28__default.relative(context2.workspaceRoot, filePath);
+          const relativePath = path27.relative(context2.workspaceRoot, filePath);
           const fileNodeId = generateNodeId("file", relativePath, relativePath);
           const fileNode = context2.graph.getNode(fileNodeId);
           if (fileNode) {
@@ -3430,11 +2204,11 @@ var init_resolve_phase = __esm({
         let heritageEdges = 0;
         const fileIndex = /* @__PURE__ */ new Map();
         for (const fp of filePaths) {
-          const rel = path28__default.relative(workspaceRoot, fp);
+          const rel = path27.relative(workspaceRoot, fp);
           fileIndex.set(rel, fp);
           const noExt = rel.replace(/\.\w+$/, "");
           if (!fileIndex.has(noExt)) fileIndex.set(noExt, fp);
-          const base = path28__default.basename(rel, path28__default.extname(rel));
+          const base = path27.basename(rel, path27.extname(rel));
           if (!fileIndex.has(base)) fileIndex.set(base, fp);
         }
         const symbolIndex = /* @__PURE__ */ new Map();
@@ -3465,7 +2239,7 @@ var init_resolve_phase = __esm({
         for (const filePath of filePaths) {
           const lang = detectLanguage(filePath);
           if (!lang) continue;
-          const relativePath = path28__default.relative(workspaceRoot, filePath);
+          const relativePath = path27.relative(workspaceRoot, filePath);
           const fileNodeId = generateNodeId("file", relativePath, relativePath);
           const source = fileCache.get(filePath);
           if (!source) continue;
@@ -3478,13 +2252,13 @@ var init_resolve_phase = __esm({
             let resolvedRelPath = null;
             if (cleaned.startsWith(".")) {
               const cleanedNoJs = cleaned.replace(/\.(js|jsx)$/, "");
-              const fromDir = path28__default.dirname(relativePath);
+              const fromDir = path27.dirname(relativePath);
               for (const ext of ["", ".ts", ".tsx", ".js", ".jsx", ".py", ".java", ".go", "/index.ts", "/index.js"]) {
-                const candidate = path28__default.join(fromDir, cleanedNoJs + ext);
-                const normalized = path28__default.normalize(candidate);
+                const candidate = path27.join(fromDir, cleanedNoJs + ext);
+                const normalized = path27.normalize(candidate);
                 if (fileIndex.has(normalized)) {
                   const absPath = fileIndex.get(normalized);
-                  resolvedRelPath = path28__default.relative(workspaceRoot, absPath);
+                  resolvedRelPath = path27.relative(workspaceRoot, absPath);
                   break;
                 }
               }
@@ -3612,7 +2386,7 @@ var init_db_manager = __esm({
         this.dbPath = dbPath;
       }
       async init() {
-        fs25__default.mkdirSync(path28__default.dirname(this.dbPath), { recursive: true });
+        fs24.mkdirSync(path27.dirname(this.dbPath), { recursive: true });
         this.db = new Database(this.dbPath);
         await this.db.init();
         this.conn = new Connection(this.db);
@@ -3708,7 +2482,7 @@ var init_schema = __esm({
   }
 });
 function writeNodeCSVs(graph, outputDir) {
-  fs25__default.mkdirSync(outputDir, { recursive: true });
+  fs24.mkdirSync(outputDir, { recursive: true });
   const header = "id,name,file_path,start_line,end_line,exported,content,metadata\n";
   const tableBuffers = /* @__PURE__ */ new Map();
   const tableFilePaths = /* @__PURE__ */ new Map();
@@ -3716,7 +2490,7 @@ function writeNodeCSVs(graph, outputDir) {
     const table = NODE_TABLE_MAP[node.kind];
     if (!tableBuffers.has(table)) {
       tableBuffers.set(table, [header]);
-      tableFilePaths.set(table, path28__default.join(outputDir, `${table}.csv`));
+      tableFilePaths.set(table, path27.join(outputDir, `${table}.csv`));
     }
     tableBuffers.get(table).push(
       csvRow([
@@ -3736,12 +2510,12 @@ function writeNodeCSVs(graph, outputDir) {
     );
   }
   for (const [table, lines] of tableBuffers) {
-    fs25__default.writeFileSync(tableFilePaths.get(table), lines.join(""), "utf-8");
+    fs24.writeFileSync(tableFilePaths.get(table), lines.join(""), "utf-8");
   }
   return tableFilePaths;
 }
 function writeEdgeCSV(graph, outputDir) {
-  fs25__default.mkdirSync(outputDir, { recursive: true });
+  fs24.mkdirSync(outputDir, { recursive: true });
   const header = "from_id,to_id,kind,weight,label\n";
   const groups = /* @__PURE__ */ new Map();
   for (const edge of graph.allEdges()) {
@@ -3752,7 +2526,7 @@ function writeEdgeCSV(graph, outputDir) {
     const toTable = NODE_TABLE_MAP[targetNode.kind];
     const key = `${fromTable}->${toTable}`;
     if (!groups.has(key)) {
-      const filePath = path28__default.join(outputDir, `edges_${fromTable}_${toTable}.csv`);
+      const filePath = path27.join(outputDir, `edges_${fromTable}_${toTable}.csv`);
       groups.set(key, { lines: [header], from: fromTable, to: toTable, filePath });
     }
     groups.get(key).lines.push(
@@ -3767,7 +2541,7 @@ function writeEdgeCSV(graph, outputDir) {
   }
   const result = [];
   for (const group of groups.values()) {
-    fs25__default.writeFileSync(group.filePath, group.lines.join(""), "utf-8");
+    fs24.writeFileSync(group.filePath, group.lines.join(""), "utf-8");
     result.push({ fromTable: group.from, toTable: group.to, filePath: group.filePath });
   }
   return result;
@@ -3810,7 +2584,7 @@ async function loadGraphToDB(graph, dbManager) {
     } catch {
     }
   }
-  const tmpDir = fs25__default.mkdtempSync(path28__default.join(os12.tmpdir(), "code-intel-csv-"));
+  const tmpDir = fs24.mkdtempSync(path27.join(os12.tmpdir(), "code-intel-csv-"));
   try {
     const nodeTableFiles = writeNodeCSVs(graph, tmpDir);
     const edgeGroups = writeEdgeCSV(graph, tmpDir);
@@ -3829,8 +2603,8 @@ async function loadGraphToDB(graph, dbManager) {
     }
     let nodeCount = 0;
     for (const [table, csvPath] of nodeTableFiles) {
-      if (!fs25__default.existsSync(csvPath)) continue;
-      const stat = fs25__default.statSync(csvPath);
+      if (!fs24.existsSync(csvPath)) continue;
+      const stat = fs24.statSync(csvPath);
       if (stat.size < 50) continue;
       try {
         await dbManager.execute(
@@ -3843,8 +2617,8 @@ async function loadGraphToDB(graph, dbManager) {
     }
     let edgeCount = 0;
     for (const group of edgeGroups) {
-      if (!fs25__default.existsSync(group.filePath)) continue;
-      const stat = fs25__default.statSync(group.filePath);
+      if (!fs24.existsSync(group.filePath)) continue;
+      const stat = fs24.statSync(group.filePath);
       if (stat.size < 50) continue;
       try {
         await dbManager.execute(
@@ -3858,7 +2632,7 @@ async function loadGraphToDB(graph, dbManager) {
     return { nodeCount, edgeCount };
   } finally {
     try {
-      fs25__default.rmSync(tmpDir, { recursive: true, force: true });
+      fs24.rmSync(tmpDir, { recursive: true, force: true });
     } catch {
     }
   }
@@ -3960,15 +2734,15 @@ var init_graph_loader = __esm({
 });
 function loadRegistry() {
   try {
-    const data = fs25__default.readFileSync(REPOS_FILE, "utf-8");
+    const data = fs24.readFileSync(REPOS_FILE, "utf-8");
     return JSON.parse(data);
   } catch {
     return [];
   }
 }
 function saveRegistry(entries) {
-  fs25__default.mkdirSync(GLOBAL_DIR, { recursive: true });
-  fs25__default.writeFileSync(REPOS_FILE, JSON.stringify(entries, null, 2));
+  fs24.mkdirSync(GLOBAL_DIR, { recursive: true });
+  fs24.writeFileSync(REPOS_FILE, JSON.stringify(entries, null, 2));
 }
 function upsertRepo(entry) {
   const entries = loadRegistry();
@@ -3987,28 +2761,28 @@ function removeRepo(repoPath) {
 var GLOBAL_DIR, REPOS_FILE;
 var init_repo_registry = __esm({
   "src/storage/repo-registry.ts"() {
-    GLOBAL_DIR = path28__default.join(os12.homedir(), ".code-intel");
-    REPOS_FILE = path28__default.join(GLOBAL_DIR, "repos.json");
+    GLOBAL_DIR = path27.join(os12.homedir(), ".code-intel");
+    REPOS_FILE = path27.join(GLOBAL_DIR, "repos.json");
   }
 });
 function saveMetadata(repoDir, metadata) {
-  const metaDir = path28__default.join(repoDir, ".code-intel");
-  fs25__default.mkdirSync(metaDir, { recursive: true });
-  fs25__default.writeFileSync(path28__default.join(metaDir, "meta.json"), JSON.stringify(metadata, null, 2));
+  const metaDir = path27.join(repoDir, ".code-intel");
+  fs24.mkdirSync(metaDir, { recursive: true });
+  fs24.writeFileSync(path27.join(metaDir, "meta.json"), JSON.stringify(metadata, null, 2));
 }
 function loadMetadata(repoDir) {
   try {
-    const data = fs25__default.readFileSync(path28__default.join(repoDir, ".code-intel", "meta.json"), "utf-8");
+    const data = fs24.readFileSync(path27.join(repoDir, ".code-intel", "meta.json"), "utf-8");
     return JSON.parse(data);
   } catch {
     return null;
   }
 }
 function getDbPath(repoDir) {
-  return path28__default.join(repoDir, ".code-intel", "graph.db");
+  return path27.join(repoDir, ".code-intel", "graph.db");
 }
 function getVectorDbPath(repoDir) {
-  return path28__default.join(repoDir, ".code-intel", "vector.db");
+  return path27.join(repoDir, ".code-intel", "vector.db");
 }
 var init_metadata = __esm({
   "src/storage/metadata.ts"() {
@@ -4144,27 +2918,27 @@ __export(group_registry_exports, {
   saveSyncResult: () => saveSyncResult
 });
 function groupFile(name) {
-  return path28__default.join(GROUPS_DIR, `${name}.json`);
+  return path27.join(GROUPS_DIR, `${name}.json`);
 }
 function loadGroup(name) {
   try {
-    return JSON.parse(fs25__default.readFileSync(groupFile(name), "utf-8"));
+    return JSON.parse(fs24.readFileSync(groupFile(name), "utf-8"));
   } catch {
     return null;
   }
 }
 function saveGroup(group) {
-  fs25__default.mkdirSync(GROUPS_DIR, { recursive: true });
-  fs25__default.writeFileSync(groupFile(group.name), JSON.stringify(group, null, 2) + "\n");
+  fs24.mkdirSync(GROUPS_DIR, { recursive: true });
+  fs24.writeFileSync(groupFile(group.name), JSON.stringify(group, null, 2) + "\n");
 }
 function listGroups() {
   const groups = [];
   try {
-    for (const file of fs25__default.readdirSync(GROUPS_DIR)) {
+    for (const file of fs24.readdirSync(GROUPS_DIR)) {
       if (!file.endsWith(".json") || file.endsWith(".sync.json")) continue;
       try {
         const g = JSON.parse(
-          fs25__default.readFileSync(path28__default.join(GROUPS_DIR, file), "utf-8")
+          fs24.readFileSync(path27.join(GROUPS_DIR, file), "utf-8")
         );
         groups.push(g);
       } catch {
@@ -4176,16 +2950,16 @@ function listGroups() {
 }
 function deleteGroup(name) {
   try {
-    fs25__default.unlinkSync(groupFile(name));
+    fs24.unlinkSync(groupFile(name));
   } catch {
   }
   try {
-    fs25__default.unlinkSync(path28__default.join(GROUPS_DIR, `${name}.sync.json`));
+    fs24.unlinkSync(path27.join(GROUPS_DIR, `${name}.sync.json`));
   } catch {
   }
 }
 function groupExists(name) {
-  return fs25__default.existsSync(groupFile(name));
+  return fs24.existsSync(groupFile(name));
 }
 function addMember(groupName, member) {
   const group = loadGroup(groupName);
@@ -4211,16 +2985,16 @@ function removeMember(groupName, groupPath) {
   return group;
 }
 function saveSyncResult(result) {
-  fs25__default.mkdirSync(GROUPS_DIR, { recursive: true });
-  fs25__default.writeFileSync(
-    path28__default.join(GROUPS_DIR, `${result.groupName}.sync.json`),
+  fs24.mkdirSync(GROUPS_DIR, { recursive: true });
+  fs24.writeFileSync(
+    path27.join(GROUPS_DIR, `${result.groupName}.sync.json`),
     JSON.stringify(result, null, 2) + "\n"
   );
 }
 function loadSyncResult(groupName) {
   try {
     return JSON.parse(
-      fs25__default.readFileSync(path28__default.join(GROUPS_DIR, `${groupName}.sync.json`), "utf-8")
+      fs24.readFileSync(path27.join(GROUPS_DIR, `${groupName}.sync.json`), "utf-8")
     );
   } catch {
     return null;
@@ -4229,7 +3003,7 @@ function loadSyncResult(groupName) {
 var GROUPS_DIR;
 var init_group_registry = __esm({
   "src/multi-repo/group-registry.ts"() {
-    GROUPS_DIR = path28__default.join(os12.homedir(), ".code-intel", "groups");
+    GROUPS_DIR = path27.join(os12.homedir(), ".code-intel", "groups");
   }
 });
 
@@ -4635,25 +3409,25 @@ function validateDAG(phases) {
   const visiting = /* @__PURE__ */ new Set();
   const visited = /* @__PURE__ */ new Set();
   const phaseMap = new Map(phases.map((p) => [p.name, p]));
-  function dfs(name, path29) {
+  function dfs(name, path28) {
     if (visiting.has(name)) {
-      const cycleStart = path29.indexOf(name);
-      const cycle = path29.slice(cycleStart).concat(name);
+      const cycleStart = path28.indexOf(name);
+      const cycle = path28.slice(cycleStart).concat(name);
       errors.push({ type: "cycle", message: `Cycle detected: ${cycle.join(" \u2192 ")}` });
       return true;
     }
     if (visited.has(name)) return false;
     visiting.add(name);
-    path29.push(name);
+    path28.push(name);
     const phase = phaseMap.get(name);
     if (phase) {
       for (const dep of phase.dependencies) {
-        if (dfs(dep, path29)) return true;
+        if (dfs(dep, path28)) return true;
       }
     }
     visiting.delete(name);
     visited.add(name);
-    path29.pop();
+    path28.pop();
     return false;
   }
   for (const phase of phases) {
@@ -4866,7 +3640,7 @@ var IGNORED_DIRS = /* @__PURE__ */ new Set([
 ]);
 function loadIgnorePatterns(workspaceRoot) {
   try {
-    const raw = fs25__default.readFileSync(path28__default.join(workspaceRoot, ".codeintelignore"), "utf-8");
+    const raw = fs24.readFileSync(path27.join(workspaceRoot, ".codeintelignore"), "utf-8");
     const extras = /* @__PURE__ */ new Set();
     for (const line of raw.split("\n")) {
       const trimmed = line.trim();
@@ -4890,7 +3664,7 @@ var scanPhase = {
     function walk2(dir) {
       let entries;
       try {
-        entries = fs25__default.readdirSync(dir, { withFileTypes: true });
+        entries = fs24.readdirSync(dir, { withFileTypes: true });
       } catch {
         return;
       }
@@ -4899,15 +3673,15 @@ var scanPhase = {
           if (entry.name.startsWith(".")) continue;
           if (IGNORED_DIRS.has(entry.name)) continue;
           if (extraIgnore.has(entry.name)) continue;
-          walk2(path28__default.join(dir, entry.name));
+          walk2(path27.join(dir, entry.name));
         } else if (entry.isFile()) {
           const name = entry.name;
           if (IGNORED_FILE_SUFFIXES.some((s) => name.endsWith(s))) continue;
-          const ext = path28__default.extname(name);
+          const ext = path27.extname(name);
           if (!extensions.has(ext)) continue;
-          const fullPath = path28__default.join(dir, name);
+          const fullPath = path27.join(dir, name);
           try {
-            const stat = fs25__default.statSync(fullPath);
+            const stat = fs24.statSync(fullPath);
             if (stat.size > MAX_FILE_SIZE_BYTES) continue;
           } catch {
             continue;
@@ -4934,20 +3708,20 @@ var structurePhase = {
     const dirs = /* @__PURE__ */ new Set();
     let structDone = 0;
     for (const filePath of context2.filePaths) {
-      const relativePath = path28__default.relative(context2.workspaceRoot, filePath);
+      const relativePath = path27.relative(context2.workspaceRoot, filePath);
       const lang = detectLanguage(filePath);
       context2.graph.addNode({
         id: generateNodeId("file", relativePath, relativePath),
         kind: "file",
-        name: path28__default.basename(filePath),
+        name: path27.basename(filePath),
         filePath: relativePath,
         metadata: lang ? { language: lang } : void 0
       });
-      let dir = path28__default.dirname(relativePath);
+      let dir = path27.dirname(relativePath);
       while (dir && dir !== "." && dir !== "") {
         if (dirs.has(dir)) break;
         dirs.add(dir);
-        dir = path28__default.dirname(dir);
+        dir = path27.dirname(dir);
       }
       structDone++;
       context2.onPhaseProgress?.("structure", structDone, context2.filePaths.length);
@@ -4956,7 +3730,7 @@ var structurePhase = {
       context2.graph.addNode({
         id: generateNodeId("directory", dir, dir),
         kind: "directory",
-        name: path28__default.basename(dir),
+        name: path27.basename(dir),
         filePath: dir
       });
     }
@@ -5067,22 +3841,22 @@ var flowPhase = {
       const queue = [{ nodeId: ep.id, path: [ep.id] }];
       const visited = /* @__PURE__ */ new Set();
       while (queue.length > 0 && flowCount < maxFlows) {
-        const { nodeId, path: path29 } = queue.shift();
-        if (path29.length > maxDepth) continue;
+        const { nodeId, path: path28 } = queue.shift();
+        if (path28.length > maxDepth) continue;
         const callEdges = [...graph.findEdgesFrom(nodeId)].filter((e) => e.kind === "calls").slice(0, maxBranching);
-        if (callEdges.length === 0 && path29.length >= 3) {
+        if (callEdges.length === 0 && path28.length >= 3) {
           const flowId = generateNodeId("flow", ep.filePath, `flow-${flowCount}`);
           graph.addNode({
             id: flowId,
             kind: "flow",
             name: `${ep.name} flow ${flowCount}`,
             filePath: ep.filePath,
-            metadata: { steps: path29, entryPoint: ep.name }
+            metadata: { steps: path28, entryPoint: ep.name }
           });
-          for (let i = 0; i < path29.length; i++) {
+          for (let i = 0; i < path28.length; i++) {
             graph.addEdge({
-              id: generateEdgeId(path29[i], flowId, `step_of_${i}`),
-              source: path29[i],
+              id: generateEdgeId(path28[i], flowId, `step_of_${i}`),
+              source: path28[i],
               target: flowId,
               kind: "step_of",
               weight: 1,
@@ -5095,7 +3869,7 @@ var flowPhase = {
         for (const edge of callEdges) {
           if (visited.has(edge.target)) continue;
           visited.add(edge.target);
-          queue.push({ nodeId: edge.target, path: [...path29, edge.target] });
+          queue.push({ nodeId: edge.target, path: [...path28, edge.target] });
         }
       }
     }
@@ -5182,8 +3956,8 @@ var WorkerPool = class extends EventEmitter {
   /** Submit a task. Resolves with the worker result or rejects on error. */
   run(input) {
     if (this.closed) return Promise.reject(new Error("WorkerPool is closed"));
-    return new Promise((resolve2, reject) => {
-      const task = { id: input.taskId, input, resolve: resolve2, reject, retries: 0 };
+    return new Promise((resolve, reject) => {
+      const task = { id: input.taskId, input, resolve, reject, retries: 0 };
       this.queue.push(task);
       if (this.queue.length > this.maxQueueSize) {
         this.emit("backpressure", this.queue.length);
@@ -5236,7 +4010,7 @@ var LANG_QUERIES2 = {
 };
 function workerScriptPath() {
   const thisFile = fileURLToPath(import.meta.url);
-  return path28__default.join(path28__default.dirname(thisFile), "parse-worker.js");
+  return path27.join(path27.dirname(thisFile), "parse-worker.js");
 }
 var parsePhaseParallel = {
   name: "parse",
@@ -5252,14 +4026,14 @@ var parsePhaseParallel = {
       const batch = filePaths.slice(i, i + CONCURRENCY);
       await Promise.all(batch.map(async (filePath) => {
         try {
-          const source = await fs25__default.promises.readFile(filePath, "utf-8");
+          const source = await fs24.promises.readFile(filePath, "utf-8");
           context2.fileCache.set(filePath, source);
         } catch {
         }
       }));
     }
     const workerScript = workerScriptPath();
-    const workerScriptExists = fs25__default.existsSync(workerScript);
+    const workerScriptExists = fs24.existsSync(workerScript);
     if (!workerScriptExists || workerCount === 1) {
       logger_default.info(`[parse-parallel] falling back to sequential (workerCount=${workerCount}, scriptExists=${workerScriptExists})`);
       const { parsePhase: parsePhase2 } = await Promise.resolve().then(() => (init_parse_phase(), parse_phase_exports));
@@ -5271,7 +4045,7 @@ var parsePhaseParallel = {
       if (!lang) continue;
       const source = context2.fileCache.get(filePath);
       if (!source) continue;
-      const relativePath = path28__default.relative(context2.workspaceRoot, filePath);
+      const relativePath = path27.relative(context2.workspaceRoot, filePath);
       const fileNodeId = generateNodeId("file", relativePath, relativePath);
       const fileNode = context2.graph.getNode(fileNodeId);
       if (fileNode) fileNode.content = source.slice(0, 2e3);
@@ -5314,7 +4088,7 @@ var parsePhaseParallel = {
         symbolCount += res.nodes.length;
         if (res.usedTreeSitter) treeSitterCount++;
         else regexCount++;
-        const relativePath = path28__default.relative(context2.workspaceRoot, res.taskId);
+        const relativePath = path27.relative(context2.workspaceRoot, res.taskId);
         const funcs = res.nodes.filter((n) => n.kind === "function" || n.kind === "method").map((n) => ({ id: n.id, startLine: n.startLine ?? 0, endLine: n.endLine })).sort((a, b) => a.startLine - b.startLine);
         if (funcs.length > 0) context2.fileFunctionIndex.set(relativePath, funcs);
         parseDone++;
@@ -5341,7 +4115,7 @@ init_id_generator();
 init_logger();
 function workerScriptPath2() {
   const thisFile = fileURLToPath(import.meta.url);
-  return path28__default.join(path28__default.dirname(thisFile), "resolve-worker.js");
+  return path27.join(path27.dirname(thisFile), "resolve-worker.js");
 }
 var resolvePhaseParallel = {
   name: "resolve",
@@ -5353,11 +4127,11 @@ var resolvePhaseParallel = {
     const fileFunctionIndex = context2.fileFunctionIndex ?? /* @__PURE__ */ new Map();
     const fileIndex = {};
     for (const fp of filePaths) {
-      const rel = path28__default.relative(workspaceRoot, fp);
+      const rel = path27.relative(workspaceRoot, fp);
       fileIndex[rel] = fp;
       const noExt = rel.replace(/\.\w+$/, "");
       if (!fileIndex[noExt]) fileIndex[noExt] = fp;
-      const base = path28__default.basename(rel, path28__default.extname(rel));
+      const base = path27.basename(rel, path27.extname(rel));
       if (!fileIndex[base]) fileIndex[base] = fp;
     }
     const symbolIndex = {};
@@ -5371,7 +4145,7 @@ var resolvePhaseParallel = {
     }
     const snapshot = { symbolIndex, fileSymbolIndex, fileIndex, workspaceRoot };
     const workerScript = workerScriptPath2();
-    const workerScriptExists = fs25__default.existsSync(workerScript);
+    const workerScriptExists = fs24.existsSync(workerScript);
     const workerCount = parseInt(process.env["PARSE_WORKERS"] ?? "", 10) || Math.max(1, os12.cpus().length - 1);
     if (!workerScriptExists || workerCount === 1) {
       logger_default.info(`[resolve-parallel] falling back to sequential`);
@@ -5384,7 +4158,7 @@ var resolvePhaseParallel = {
       if (!lang) continue;
       const source = fileCache.get(filePath);
       if (!source) continue;
-      const relativePath = path28__default.relative(workspaceRoot, filePath);
+      const relativePath = path27.relative(workspaceRoot, filePath);
       const fileNodeId = generateNodeId("file", relativePath, relativePath);
       const funcList = fileFunctionIndex.get(relativePath) ?? [];
       tasks.push({ taskId: filePath, filePath, relativePath, fileNodeId, source, funcList });
@@ -5401,18 +4175,18 @@ var resolvePhaseParallel = {
     const pendingResolvers = /* @__PURE__ */ new Map();
     for (const { w } of workers) {
       w.on("message", (result) => {
-        const resolve2 = pendingResolvers.get(result.taskId);
-        if (resolve2) {
+        const resolve = pendingResolvers.get(result.taskId);
+        if (resolve) {
           pendingResolvers.delete(result.taskId);
-          resolve2(result);
+          resolve(result);
         }
       });
       w.on("error", (err) => logger_default.warn(`[resolve-worker] error: ${err.message}`));
     }
     let workerIdx = 0;
     function runTask(task) {
-      return new Promise((resolve2) => {
-        pendingResolvers.set(task.taskId, resolve2);
+      return new Promise((resolve) => {
+        pendingResolvers.set(task.taskId, resolve);
         const { w } = workers[workerIdx % workers.length];
         workerIdx++;
         w.postMessage(task);
@@ -5707,8 +4481,8 @@ async function syncGroup(group) {
       logger_default.warn(`  \u26A0 Registry entry "${member.registryName}" not found \u2014 skipping ${member.groupPath}`);
       continue;
     }
-    const dbPath = path28__default.join(regEntry.path, ".code-intel", "graph.db");
-    if (!fs25__default.existsSync(dbPath)) {
+    const dbPath = path27.join(regEntry.path, ".code-intel", "graph.db");
+    if (!fs24.existsSync(dbPath)) {
       logger_default.warn(`  \u26A0 No index at ${dbPath} \u2014 run \`code-intel analyze ${regEntry.path}\` first`);
       continue;
     }
@@ -5745,8 +4519,8 @@ async function queryGroup(group, query, limit = 20) {
   for (const member of group.members) {
     const regEntry = registry.find((r) => r.name === member.registryName);
     if (!regEntry) continue;
-    const dbPath = path28__default.join(regEntry.path, ".code-intel", "graph.db");
-    if (!fs25__default.existsSync(dbPath)) continue;
+    const dbPath = path27.join(regEntry.path, ".code-intel", "graph.db");
+    if (!fs24.existsSync(dbPath)) continue;
     const graph = createKnowledgeGraph();
     const db = new DbManager(dbPath);
     try {
@@ -5805,10 +4579,10 @@ var AppError = class extends Error {
 var SECURE_DIR_MODE = 448;
 var SECURE_FILE_MODE = 384;
 function secureMkdir(dir) {
-  fs25__default.mkdirSync(dir, { recursive: true, mode: SECURE_DIR_MODE });
+  fs24.mkdirSync(dir, { recursive: true, mode: SECURE_DIR_MODE });
   if (process.platform !== "win32") {
     try {
-      fs25__default.chmodSync(dir, SECURE_DIR_MODE);
+      fs24.chmodSync(dir, SECURE_DIR_MODE);
     } catch {
     }
   }
@@ -5816,22 +4590,22 @@ function secureMkdir(dir) {
 function secureChmodFile(file) {
   if (process.platform === "win32") return;
   try {
-    fs25__default.chmodSync(file, SECURE_FILE_MODE);
+    fs24.chmodSync(file, SECURE_FILE_MODE);
   } catch {
   }
 }
 function secureWriteFile(file, data) {
-  secureMkdir(path28__default.dirname(file));
-  fs25__default.writeFileSync(file, data, { mode: SECURE_FILE_MODE });
+  secureMkdir(path27.dirname(file));
+  fs24.writeFileSync(file, data, { mode: SECURE_FILE_MODE });
   secureChmodFile(file);
 }
 function tightenDbFiles(dir) {
   if (process.platform === "win32") return;
-  if (!fs25__default.existsSync(dir)) return;
-  for (const name of fs25__default.readdirSync(dir)) {
+  if (!fs24.existsSync(dir)) return;
+  for (const name of fs24.readdirSync(dir)) {
     if (name.endsWith(".db") || name.endsWith(".db-wal") || name.endsWith(".db-shm")) {
       try {
-        fs25__default.chmodSync(path28__default.join(dir, name), SECURE_FILE_MODE);
+        fs24.chmodSync(path27.join(dir, name), SECURE_FILE_MODE);
       } catch {
       }
     }
@@ -5843,7 +4617,7 @@ var BCRYPT_ROUNDS = 12;
 var UsersDB = class {
   db;
   constructor(dbPath) {
-    const dir = path28__default.dirname(dbPath);
+    const dir = path27.dirname(dbPath);
     secureMkdir(dir);
     this.db = new Database2(dbPath);
     this.db.pragma("journal_mode = WAL");
@@ -6113,7 +4887,7 @@ var UsersDB = class {
   }
 };
 function getUsersDBPath() {
-  return process.env["CODE_INTEL_USERS_DB_PATH"] ?? path28__default.join(os12.homedir(), ".code-intel", "users.db");
+  return process.env["CODE_INTEL_USERS_DB_PATH"] ?? path27.join(os12.homedir(), ".code-intel", "users.db");
 }
 var _usersDB = null;
 function getOrCreateUsersDB() {
@@ -6132,7 +4906,7 @@ function getScryptN() {
   return Number.isInteger(v) && v >= 1024 ? v : 1 << 14;
 }
 function getSecretsPath() {
-  return process.env["CODE_INTEL_SECRETS_PATH"] ?? path28__default.join(os12.homedir(), ".code-intel", ".secrets");
+  return process.env["CODE_INTEL_SECRETS_PATH"] ?? path27.join(os12.homedir(), ".code-intel", ".secrets");
 }
 function getMasterPassword() {
   const fromEnv = process.env["CODE_INTEL_SECRET_KEY"];
@@ -6174,12 +4948,12 @@ function decryptSecrets(encrypted) {
   return JSON.parse(plaintext.toString("utf8"));
 }
 function loadSecrets(secretsPath = getSecretsPath()) {
-  if (!fs25__default.existsSync(secretsPath)) return {};
-  const blob = fs25__default.readFileSync(secretsPath);
+  if (!fs24.existsSync(secretsPath)) return {};
+  const blob = fs24.readFileSync(secretsPath);
   return decryptSecrets(blob);
 }
 function saveSecrets(blob, secretsPath = getSecretsPath()) {
-  secureMkdir(path28__default.dirname(secretsPath));
+  secureMkdir(path27.dirname(secretsPath));
   const encrypted = encryptSecrets(blob);
   secureWriteFile(secretsPath, encrypted);
   secureChmodFile(secretsPath);
@@ -6430,12 +5204,12 @@ async function verifyPassword(plain, hash) {
   return bcrypt.compare(plain, hash);
 }
 var RETRY_DELAYS_SECONDS = [5, 30, 120];
-var MAX_ATTEMPTS2 = 3;
+var MAX_ATTEMPTS = 3;
 var STUCK_THRESHOLD_MINUTES = 30;
 var JobsDB = class {
   db;
   constructor(dbPath) {
-    fs25__default.mkdirSync(path28__default.dirname(dbPath), { recursive: true });
+    fs24.mkdirSync(path27.dirname(dbPath), { recursive: true });
     this.db = new Database2(dbPath);
     this.db.pragma("journal_mode = WAL");
     this.db.pragma("foreign_keys = ON");
@@ -6451,7 +5225,7 @@ var JobsDB = class {
         repoPath TEXT NOT NULL,
         params TEXT NOT NULL DEFAULT '{}',
         attempts INTEGER NOT NULL DEFAULT 0,
-        maxAttempts INTEGER NOT NULL DEFAULT ${MAX_ATTEMPTS2},
+        maxAttempts INTEGER NOT NULL DEFAULT ${MAX_ATTEMPTS},
         createdAt TEXT NOT NULL,
         startedAt TEXT NULL,
         finishedAt TEXT NULL,
@@ -6477,7 +5251,7 @@ var JobsDB = class {
     this.db.prepare(
       `INSERT INTO jobs (id, kind, status, repoPath, params, attempts, maxAttempts, createdAt, idempotencyKey)
          VALUES (?, ?, 'pending', ?, ?, 0, ?, ?, ?)`
-    ).run(id, kind, repoPath, JSON.stringify(params), MAX_ATTEMPTS2, createdAt, idempotencyKey ?? null);
+    ).run(id, kind, repoPath, JSON.stringify(params), MAX_ATTEMPTS, createdAt, idempotencyKey ?? null);
     return this.getJob(id);
   }
   getJob(id) {
@@ -6577,7 +5351,7 @@ var JobsDB = class {
   }
 };
 function getJobsDBPath() {
-  return path28__default.join(os12.homedir(), ".code-intel", "jobs.db");
+  return path27.join(os12.homedir(), ".code-intel", "jobs.db");
 }
 var _jobsDB = null;
 function getOrCreateJobsDB() {
@@ -6591,7 +5365,7 @@ var LLMGovernanceLogger = class {
   }
   /** Path to the JSONL log file. */
   getLogPath() {
-    return process.env["CODE_INTEL_GOVERNANCE_LOG_PATH"] ?? path28__default.join(os12.homedir(), ".code-intel", "llm-governance.jsonl");
+    return process.env["CODE_INTEL_GOVERNANCE_LOG_PATH"] ?? path27.join(os12.homedir(), ".code-intel", "llm-governance.jsonl");
   }
   /**
    * Append an entry to the governance log.
@@ -6607,8 +5381,8 @@ var LLMGovernanceLogger = class {
         ...entry
       };
       const logPath = this.getLogPath();
-      fs25__default.mkdirSync(path28__default.dirname(logPath), { recursive: true });
-      fs25__default.appendFileSync(logPath, JSON.stringify(full) + "\n", "utf-8");
+      fs24.mkdirSync(path27.dirname(logPath), { recursive: true });
+      fs24.appendFileSync(logPath, JSON.stringify(full) + "\n", "utf-8");
     } catch {
     }
   }
@@ -6618,7 +5392,7 @@ var LLMGovernanceLogger = class {
    */
   readLog(limit = 100) {
     try {
-      const raw = fs25__default.readFileSync(this.getLogPath(), "utf-8");
+      const raw = fs24.readFileSync(this.getLogPath(), "utf-8");
       const lines = raw.split("\n").filter((l) => l.trim().length > 0).slice(-limit);
       return lines.map((l) => JSON.parse(l));
     } catch {
@@ -6653,7 +5427,7 @@ function sigV4SigningKey(secret, date, region, service) {
   return hmac(kService, "aws4_request");
 }
 function s3Request(opts) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve, reject) => {
     const { method, cfg, key, body, query } = opts;
     const host = `${cfg.bucket}.s3.${cfg.region}.amazonaws.com`;
     const now = /* @__PURE__ */ new Date();
@@ -6701,7 +5475,7 @@ x-amz-date:${amzDate}
     const req = https.request(reqOptions, (res) => {
       const chunks = [];
       res.on("data", (c) => chunks.push(c));
-      res.on("end", () => resolve2({ statusCode: res.statusCode ?? 0, body: Buffer.concat(chunks).toString("utf-8") }));
+      res.on("end", () => resolve({ statusCode: res.statusCode ?? 0, body: Buffer.concat(chunks).toString("utf-8") }));
     });
     req.on("error", reject);
     if (body) req.write(body);
@@ -6712,7 +5486,7 @@ var BACKUP_VERSION = "1.0";
 var ALGORITHM = "aes-256-gcm";
 var IV_LENGTH = 16;
 function getBackupDir() {
-  return path28__default.join(os12.homedir(), ".code-intel", "backups");
+  return path27.join(os12.homedir(), ".code-intel", "backups");
 }
 function getBackupKey() {
   const keyHex = process.env["CODE_INTEL_BACKUP_KEY"];
@@ -6743,30 +5517,30 @@ var BackupService = class {
   constructor(backupDir) {
     this.backupDir = backupDir ?? getBackupDir();
     this.key = getBackupKey();
-    fs25__default.mkdirSync(this.backupDir, { recursive: true });
+    fs24.mkdirSync(this.backupDir, { recursive: true });
   }
   /**
    * Create a backup for a repository.
    * Returns the backup entry.
    */
   createBackup(repoPath) {
-    const codeIntelDir = path28__default.join(repoPath, ".code-intel");
+    const codeIntelDir = path27.join(repoPath, ".code-intel");
     const id = v4();
     const createdAt = (/* @__PURE__ */ new Date()).toISOString();
     const filesToBackup = [];
     const candidates = ["graph.db", "vector.db", "meta.json"];
     for (const f of candidates) {
-      const fp = path28__default.join(codeIntelDir, f);
-      if (fs25__default.existsSync(fp)) {
+      const fp = path27.join(codeIntelDir, f);
+      if (fs24.existsSync(fp)) {
         filesToBackup.push({ name: f, localPath: fp });
       }
     }
-    const registryPath = path28__default.join(os12.homedir(), ".code-intel", "registry.json");
-    if (fs25__default.existsSync(registryPath)) {
+    const registryPath = path27.join(os12.homedir(), ".code-intel", "registry.json");
+    if (fs24.existsSync(registryPath)) {
       filesToBackup.push({ name: "registry.json", localPath: registryPath });
     }
-    const usersDbPath = path28__default.join(os12.homedir(), ".code-intel", "users.db");
-    if (fs25__default.existsSync(usersDbPath)) {
+    const usersDbPath = path27.join(os12.homedir(), ".code-intel", "users.db");
+    if (fs24.existsSync(usersDbPath)) {
       filesToBackup.push({ name: "users.db", localPath: usersDbPath });
     }
     if (filesToBackup.length === 0) {
@@ -6777,7 +5551,7 @@ var BackupService = class {
       createdAt,
       version: BACKUP_VERSION,
       files: filesToBackup.map((f) => {
-        const data = fs25__default.readFileSync(f.localPath);
+        const data = fs24.readFileSync(f.localPath);
         return {
           name: f.name,
           sha256: crypto4.createHash("sha256").update(data).digest("hex"),
@@ -6791,7 +5565,7 @@ var BackupService = class {
     manifestLenBuf.writeUInt32BE(manifestBuf.length, 0);
     parts.push(manifestLenBuf, manifestBuf);
     for (const f of filesToBackup) {
-      const data = fs25__default.readFileSync(f.localPath);
+      const data = fs24.readFileSync(f.localPath);
       const nameBuf = Buffer.from(f.name, "utf-8");
       const nameLenBuf = Buffer.alloc(2);
       nameLenBuf.writeUInt16BE(nameBuf.length, 0);
@@ -6802,8 +5576,8 @@ var BackupService = class {
     const plaintext = Buffer.concat(parts);
     const encrypted = encryptBuffer(plaintext, this.key);
     const backupFileName = `backup-${id}.cib`;
-    const backupPath = path28__default.join(this.backupDir, backupFileName);
-    fs25__default.writeFileSync(backupPath, encrypted);
+    const backupPath = path27.join(this.backupDir, backupFileName);
+    fs24.writeFileSync(backupPath, encrypted);
     const entry = {
       id,
       createdAt,
@@ -6830,9 +5604,9 @@ var BackupService = class {
   async uploadToS3(entry) {
     const cfg = getS3Config();
     if (!cfg) throw new Error("S3 not configured. Set CODE_INTEL_BACKUP_S3_BUCKET, CODE_INTEL_BACKUP_S3_ACCESS_KEY_ID, CODE_INTEL_BACKUP_S3_SECRET_ACCESS_KEY.");
-    const fileName = path28__default.basename(entry.path);
+    const fileName = path27.basename(entry.path);
     const s3Key = `${cfg.prefix}${fileName}`;
-    const body = fs25__default.readFileSync(entry.path);
+    const body = fs24.readFileSync(entry.path);
     const result = await s3Request({ method: "PUT", cfg, key: s3Key, body });
     if (result.statusCode < 200 || result.statusCode >= 300) {
       throw new Error(`S3 upload failed (HTTP ${result.statusCode}): ${result.body.slice(0, 200)}`);
@@ -6849,8 +5623,8 @@ var BackupService = class {
     if (result.statusCode < 200 || result.statusCode >= 300) {
       throw new Error(`S3 download failed (HTTP ${result.statusCode}): ${result.body.slice(0, 200)}`);
     }
-    fs25__default.mkdirSync(path28__default.dirname(destPath), { recursive: true });
-    fs25__default.writeFileSync(destPath, Buffer.from(result.body, "binary"));
+    fs24.mkdirSync(path27.dirname(destPath), { recursive: true });
+    fs24.writeFileSync(destPath, Buffer.from(result.body, "binary"));
   }
   /**
    * List backup objects in S3 with the configured prefix.
@@ -6896,10 +5670,10 @@ var BackupService = class {
     if (!entry) {
       throw new Error(`Backup "${backupId}" not found.`);
     }
-    if (!fs25__default.existsSync(entry.path)) {
+    if (!fs24.existsSync(entry.path)) {
       throw new Error(`Backup file not found at: ${entry.path}`);
     }
-    const encrypted = fs25__default.readFileSync(entry.path);
+    const encrypted = fs24.readFileSync(entry.path);
     let plaintext;
     try {
       plaintext = decryptBuffer(encrypted, this.key);
@@ -6913,8 +5687,8 @@ var BackupService = class {
     offset += manifestLen;
     const manifest = JSON.parse(manifestStr);
     const restoreBase = targetRepoPath ?? entry.repoPath;
-    const codeIntelDir = path28__default.join(restoreBase, ".code-intel");
-    fs25__default.mkdirSync(codeIntelDir, { recursive: true });
+    const codeIntelDir = path27.join(restoreBase, ".code-intel");
+    fs24.mkdirSync(codeIntelDir, { recursive: true });
     for (const fileEntry of manifest.files) {
       const nameLen = plaintext.readUInt16BE(offset);
       offset += 2;
@@ -6931,18 +5705,18 @@ var BackupService = class {
       }
       let destPath;
       if (name === "registry.json" || name === "users.db") {
-        destPath = path28__default.join(os12.homedir(), ".code-intel", name);
+        destPath = path27.join(os12.homedir(), ".code-intel", name);
       } else {
-        destPath = path28__default.join(codeIntelDir, name);
+        destPath = path27.join(codeIntelDir, name);
       }
-      fs25__default.writeFileSync(destPath, data);
+      fs24.writeFileSync(destPath, data);
     }
   }
   /**
    * Apply retention policy: keep N daily, M weekly, L monthly backups.
    */
   applyRetention(options = { daily: 7, weekly: 4, monthly: 12 }) {
-    const entries = this._loadIndex().filter((e) => fs25__default.existsSync(e.path)).sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+    const entries = this._loadIndex().filter((e) => fs24.existsSync(e.path)).sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
     const keep = /* @__PURE__ */ new Set();
     const now = /* @__PURE__ */ new Date();
     const dailyCutoff = new Date(now);
@@ -6972,7 +5746,7 @@ var BackupService = class {
     for (const e of entries) {
       if (!keep.has(e.id)) {
         try {
-          fs25__default.unlinkSync(e.path);
+          fs24.unlinkSync(e.path);
           deleted++;
         } catch {
         }
@@ -6984,17 +5758,17 @@ var BackupService = class {
   }
   // ── Index helpers ──────────────────────────────────────────────────────────
   _indexPath() {
-    return path28__default.join(this.backupDir, "index.json");
+    return path27.join(this.backupDir, "index.json");
   }
   _loadIndex() {
     try {
-      return JSON.parse(fs25__default.readFileSync(this._indexPath(), "utf-8"));
+      return JSON.parse(fs24.readFileSync(this._indexPath(), "utf-8"));
     } catch {
       return [];
     }
   }
   _saveIndex(entries) {
-    fs25__default.writeFileSync(this._indexPath(), JSON.stringify(entries, null, 2));
+    fs24.writeFileSync(this._indexPath(), JSON.stringify(entries, null, 2));
   }
   _appendIndex(entry) {
     const entries = this._loadIndex();
@@ -7450,11 +6224,11 @@ var openApiSpec = {
 };
 
 // src/http/app.ts
-var __dirname$1 = path28__default.dirname(fileURLToPath(import.meta.url));
+var __dirname$1 = path27.dirname(fileURLToPath(import.meta.url));
 var WEB_DIST = (() => {
-  const bundled = path28__default.resolve(__dirname$1, "..", "web");
-  if (fs25__default.existsSync(bundled)) return bundled;
-  return path28__default.resolve(__dirname$1, "..", "..", "..", "web", "dist");
+  const bundled = path27.resolve(__dirname$1, "..", "web");
+  if (fs24.existsSync(bundled)) return bundled;
+  return path27.resolve(__dirname$1, "..", "..", "..", "web", "dist");
 })();
 function getAllowedOrigins() {
   const env = process.env["CODE_INTEL_CORS_ORIGINS"];
@@ -7623,7 +6397,7 @@ function createApp(graph, repoName, workspaceRoot) {
       vectorIndexBuilding = false;
     }
   }
-  if (workspaceRoot) {
+  if (workspaceRoot && process.env["NODE_ENV"] !== "test") {
     setImmediate(() => ensureVectorIndex().catch(() => {
     }));
   }
@@ -7984,8 +6758,8 @@ function createApp(graph, repoName, workspaceRoot) {
     const registry = loadRegistry();
     const entry = registry.find((r) => r.name === requestedRepo || r.path === requestedRepo);
     if (!entry) return null;
-    const dbPath = path28__default.join(entry.path, ".code-intel", "graph.db");
-    if (!fs25__default.existsSync(dbPath)) return null;
+    const dbPath = path27.join(entry.path, ".code-intel", "graph.db");
+    if (!fs24.existsSync(dbPath)) return null;
     const repoGraph = createKnowledgeGraph();
     const db = new DbManager(dbPath);
     try {
@@ -8071,7 +6845,7 @@ function createApp(graph, repoName, workspaceRoot) {
       return;
     }
     try {
-      const content = fs25__default.readFileSync(file_path, "utf-8");
+      const content = fs24.readFileSync(file_path, "utf-8");
       res.json({ content });
     } catch {
       res.status(404).json({ error: { code: ErrorCodes.NOT_FOUND, message: "File not found" } });
@@ -8329,8 +7103,8 @@ function createApp(graph, repoName, workspaceRoot) {
     for (const member of group.members) {
       const regEntry = registry.find((r) => r.name === member.registryName);
       if (!regEntry) continue;
-      const dbPath = path28__default.join(regEntry.path, ".code-intel", "graph.db");
-      if (!fs25__default.existsSync(dbPath)) continue;
+      const dbPath = path27.join(regEntry.path, ".code-intel", "graph.db");
+      if (!fs24.existsSync(dbPath)) continue;
       const db = new DbManager(dbPath);
       try {
         await db.init();
@@ -8342,10 +7116,10 @@ function createApp(graph, repoName, workspaceRoot) {
     }
     res.json({ nodes: [...mergedGraph.allNodes()], edges: [...mergedGraph.allEdges()] });
   });
-  if (fs25__default.existsSync(WEB_DIST)) {
+  if (fs24.existsSync(WEB_DIST)) {
     app.use(express.static(WEB_DIST));
     app.get("/{*path}", (_req, res) => {
-      res.sendFile(path28__default.join(WEB_DIST, "index.html"));
+      res.sendFile(path27.join(WEB_DIST, "index.html"));
     });
   }
   app.use("/admin", requireRole("admin"));
@@ -9036,7 +7810,7 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
       for (const { filePath: changedFile, changedLines } of changedFiles) {
         for (const node of graph.allNodes()) {
           if (!node.filePath) continue;
-          const normNode = node.filePath.replace(repoRoot + "/", "").replace(repoRoot + path28__default.sep, "");
+          const normNode = node.filePath.replace(repoRoot + "/", "").replace(repoRoot + path27.sep, "");
           const normChanged = changedFile.replace(/^a\/|^b\//, "");
           if (!normNode.endsWith(normChanged) && !normChanged.endsWith(normNode)) continue;
           if (node.startLine !== void 0 && node.endLine !== void 0) {
@@ -9309,20 +8083,20 @@ function parseDiff(diffText) {
 // src/cli/main.ts
 init_metadata();
 async function writeSkillFiles(graph, workspaceRoot, projectName) {
-  const outputDir = path28__default.join(workspaceRoot, ".claude", "skills", "code-intel");
+  const outputDir = path27.join(workspaceRoot, ".claude", "skills", "code-intel");
   const areas = buildAreaMap(graph, workspaceRoot);
   if (areas.length === 0) return { skills: [], outputDir };
-  fs25__default.rmSync(outputDir, { recursive: true, force: true });
-  fs25__default.mkdirSync(outputDir, { recursive: true });
+  fs24.rmSync(outputDir, { recursive: true, force: true });
+  fs24.mkdirSync(outputDir, { recursive: true });
   const skills = [];
   const usedNames = /* @__PURE__ */ new Set();
   for (const area of areas) {
     const kebab = uniqueKebab(area.label, usedNames);
     usedNames.add(kebab);
     const content = renderSkill(area, projectName, kebab);
-    const dir = path28__default.join(outputDir, kebab);
-    fs25__default.mkdirSync(dir, { recursive: true });
-    fs25__default.writeFileSync(path28__default.join(dir, "SKILL.md"), content, "utf-8");
+    const dir = path27.join(outputDir, kebab);
+    fs24.mkdirSync(dir, { recursive: true });
+    fs24.writeFileSync(path27.join(dir, "SKILL.md"), content, "utf-8");
     skills.push({ name: kebab, label: area.label, symbolCount: area.nodes.length, fileCount: area.files.size });
   }
   return { skills, outputDir };
@@ -9502,8 +8276,8 @@ var BLOCK_START = "<!-- code-intel:start -->";
 var BLOCK_END = "<!-- code-intel:end -->";
 function writeContextFiles(workspaceRoot, projectName, stats, skills) {
   const block = buildBlock(projectName, stats, skills);
-  upsertFile(path28__default.join(workspaceRoot, "AGENTS.md"), block, "AGENTS.md");
-  upsertFile(path28__default.join(workspaceRoot, "CLAUDE.md"), block, "CLAUDE.md");
+  upsertFile(path27.join(workspaceRoot, "AGENTS.md"), block, "AGENTS.md");
+  upsertFile(path27.join(workspaceRoot, "CLAUDE.md"), block, "CLAUDE.md");
 }
 function buildBlock(projectName, stats, skills) {
   const skillRows = skills.map(
@@ -9555,7 +8329,7 @@ ${skillTable}
 ${BLOCK_END}`;
 }
 function upsertFile(filePath, block, fileName) {
-  if (!fs25__default.existsSync(filePath)) {
+  if (!fs24.existsSync(filePath)) {
     const newContent = [
       `# ${fileName}`,
       "",
@@ -9566,17 +8340,17 @@ function upsertFile(filePath, block, fileName) {
       "<!-- Add your own custom notes below this line. They will never be overwritten by code-intel. -->",
       ""
     ].join("\n");
-    fs25__default.writeFileSync(filePath, newContent, "utf-8");
+    fs24.writeFileSync(filePath, newContent, "utf-8");
     return;
   }
-  const existing = fs25__default.readFileSync(filePath, "utf-8");
+  const existing = fs24.readFileSync(filePath, "utf-8");
   const startIdx = findLineMarker(existing, BLOCK_START);
   const endIdx = findLineMarker(existing, BLOCK_END, startIdx === -1 ? 0 : startIdx);
   if (startIdx !== -1 && endIdx !== -1 && endIdx > startIdx) {
     const before = existing.slice(0, startIdx);
     const after = existing.slice(endIdx + BLOCK_END.length);
     const updated = (before + block + after).trimEnd() + "\n";
-    fs25__default.writeFileSync(filePath, updated, "utf-8");
+    fs24.writeFileSync(filePath, updated, "utf-8");
     return;
   }
   const appended = [
@@ -9589,7 +8363,7 @@ function upsertFile(filePath, block, fileName) {
     block,
     ""
   ].join("\n");
-  fs25__default.writeFileSync(filePath, appended, "utf-8");
+  fs24.writeFileSync(filePath, appended, "utf-8");
 }
 function findLineMarker(content, marker, startFrom = 0) {
   let idx = content.indexOf(marker, startFrom);
@@ -9631,14 +8405,14 @@ function getChangedFilesSince(workspaceRoot, baseHash) {
 function filterChangedByMtime(allFilePaths, workspaceRoot, storedMtimes) {
   const changed = [];
   for (const absPath of allFilePaths) {
-    const rel = path28__default.relative(workspaceRoot, absPath);
+    const rel = path27.relative(workspaceRoot, absPath);
     const stored = storedMtimes[rel];
     if (stored === void 0) {
       changed.push(absPath);
       continue;
     }
     try {
-      const { mtimeMs } = fs25__default.statSync(absPath);
+      const { mtimeMs } = fs24.statSync(absPath);
       if (mtimeMs > stored) changed.push(absPath);
     } catch {
       changed.push(absPath);
@@ -9650,8 +8424,8 @@ function buildMtimeSnapshot(filePaths, workspaceRoot) {
   const snap = {};
   for (const absPath of filePaths) {
     try {
-      const { mtimeMs } = fs25__default.statSync(absPath);
-      snap[path28__default.relative(workspaceRoot, absPath)] = mtimeMs;
+      const { mtimeMs } = fs24.statSync(absPath);
+      snap[path27.relative(workspaceRoot, absPath)] = mtimeMs;
     } catch {
     }
   }
@@ -9662,8 +8436,8 @@ function decideIncremental(workspaceRoot, allFilePaths, prevCommitHash, storedMt
   if (prevCommitHash) {
     const changed = getChangedFilesSince(workspaceRoot, prevCommitHash);
     if (changed !== null) {
-      const scanSet = new Set(allFilePaths.map((p) => path28__default.relative(workspaceRoot, p)));
-      const changedInScan = changed.filter((rel) => scanSet.has(rel)).map((rel) => path28__default.join(workspaceRoot, rel));
+      const scanSet = new Set(allFilePaths.map((p) => path27.relative(workspaceRoot, p)));
+      const changedInScan = changed.filter((rel) => scanSet.has(rel)).map((rel) => path27.join(workspaceRoot, rel));
       if (total > 0 && changedInScan.length / total > 0.2) {
         return { incremental: false, fallbackReason: `changed files (${changedInScan.length}) > 20% of total (${total})` };
       }
@@ -9776,17 +8550,17 @@ var MigrationRunner = class {
   autoBackupBeforeMigration() {
     try {
       const dbFile = this.db.name;
-      if (!dbFile || !fs25__default.existsSync(dbFile)) return;
-      const backupDir = path28__default.join(os12.homedir(), ".code-intel", "backups", "pre-migration");
-      fs25__default.mkdirSync(backupDir, { recursive: true });
+      if (!dbFile || !fs24.existsSync(dbFile)) return;
+      const backupDir = path27.join(os12.homedir(), ".code-intel", "backups", "pre-migration");
+      fs24.mkdirSync(backupDir, { recursive: true });
       const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
-      const baseName = path28__default.basename(dbFile, ".db");
-      const backupPath = path28__default.join(backupDir, `${baseName}-pre-migration-${ts}.db`);
+      const baseName = path27.basename(dbFile, ".db");
+      const backupPath = path27.join(backupDir, `${baseName}-pre-migration-${ts}.db`);
       try {
         this.db.pragma("wal_checkpoint(TRUNCATE)");
       } catch {
       }
-      fs25__default.copyFileSync(dbFile, backupPath);
+      fs24.copyFileSync(dbFile, backupPath);
     } catch {
     }
   }
@@ -9997,7 +8771,7 @@ program.name("code-intel").description("Code Intelligence Platform \u2014 Static
   Docs: https://github.com/vohongtho/code-intel-platform
 `);
 async function analyzeWorkspace(targetPath, options) {
-  const workspaceRoot = path28__default.resolve(targetPath);
+  const workspaceRoot = path27.resolve(targetPath);
   if (!options?.silent) console.log(`Analyzing: ${workspaceRoot}`);
   logger_default.info(`analyze started: ${workspaceRoot}`);
   if (options?.force) {
@@ -10018,14 +8792,14 @@ async function analyzeWorkspace(targetPath, options) {
     ];
     for (const f of wipeFiles) {
       try {
-        if (fs25__default.existsSync(f)) fs25__default.unlinkSync(f);
+        if (fs24.existsSync(f)) fs24.unlinkSync(f);
       } catch {
       }
     }
   }
   if (!options?.skipGit) {
-    const gitDir = path28__default.join(workspaceRoot, ".git");
-    if (!fs25__default.existsSync(gitDir)) {
+    const gitDir = path27.join(workspaceRoot, ".git");
+    if (!fs24.existsSync(gitDir)) {
       logger_default.warn(`${workspaceRoot} is not a Git repository`);
     }
   }
@@ -10124,17 +8898,17 @@ async function analyzeWorkspace(targetPath, options) {
   const result = await runPipeline(phases, context2);
   if (isIncremental && incrementalChangedFiles && incrementalChangedFiles.length > 0) {
     const dbPath = getDbPath(workspaceRoot);
-    if (fs25__default.existsSync(dbPath)) {
+    if (fs24.existsSync(dbPath)) {
       try {
         const db = new DbManager(dbPath);
         await db.init();
         for (const absPath of incrementalChangedFiles) {
-          const rel = path28__default.relative(workspaceRoot, absPath);
+          const rel = path27.relative(workspaceRoot, absPath);
           await removeNodesForFile(rel, db);
         }
         const { upsertNodes: upsertNodesBatch } = await Promise.resolve().then(() => (init_graph_loader(), graph_loader_exports));
         const changedRelPaths = new Set(
-          incrementalChangedFiles.map((f) => path28__default.relative(workspaceRoot, f))
+          incrementalChangedFiles.map((f) => path27.relative(workspaceRoot, f))
         );
         const nodesToUpsert = [...graph.allNodes()].filter(
           (n) => changedRelPaths.has(n.filePath)
@@ -10159,7 +8933,7 @@ async function analyzeWorkspace(targetPath, options) {
     mergedMtimes = newMtimes;
   }
   const currentCommitHash = getCurrentCommitHash(workspaceRoot) ?? void 0;
-  const repoName = path28__default.basename(workspaceRoot);
+  const repoName = path27.basename(workspaceRoot);
   const indexVersion = v4();
   saveMetadata(workspaceRoot, {
     indexedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -10197,7 +8971,7 @@ async function analyzeWorkspace(targetPath, options) {
     ];
     for (const f of newStaleFiles) {
       try {
-        if (fs25__default.existsSync(f)) fs25__default.unlinkSync(f);
+        if (fs24.existsSync(f)) fs24.unlinkSync(f);
       } catch {
       }
     }
@@ -10214,21 +8988,21 @@ async function analyzeWorkspace(targetPath, options) {
     ];
     for (const f of staleFiles) {
       try {
-        if (fs25__default.existsSync(f)) fs25__default.unlinkSync(f);
+        if (fs24.existsSync(f)) fs24.unlinkSync(f);
       } catch {
       }
     }
     for (const f of newStaleFiles) {
       if (f === dbPathNew) continue;
-      if (fs25__default.existsSync(f)) {
+      if (fs24.existsSync(f)) {
         const dest = f.replace(dbPathNew, dbPath);
         try {
-          fs25__default.renameSync(f, dest);
+          fs24.renameSync(f, dest);
         } catch {
         }
       }
     }
-    fs25__default.renameSync(dbPathNew, dbPath);
+    fs24.renameSync(dbPathNew, dbPath);
     stopSpinner();
     logger_default.info(`DB persisted: ${nodeCount} nodes, ${edgeCount} edges`);
     if (!options?.silent) {
@@ -10249,7 +9023,7 @@ async function analyzeWorkspace(targetPath, options) {
       const staleVdb = [vdbPath, `${vdbPath}-shm`, `${vdbPath}-wal`, `${vdbPath}.shm`, `${vdbPath}.wal`];
       for (const f of staleVdb) {
         try {
-          if (fs25__default.existsSync(f)) fs25__default.unlinkSync(f);
+          if (fs24.existsSync(f)) fs24.unlinkSync(f);
         } catch {
         }
       }
@@ -10349,8 +9123,8 @@ program.command("setup").description("Configure MCP server for your editors (one
     const configFile = `${configDir}/claude_desktop_config.json`;
     try {
       let existing = {};
-      if (fs25__default.existsSync(configFile)) {
-        existing = JSON.parse(fs25__default.readFileSync(configFile, "utf-8"));
+      if (fs24.existsSync(configFile)) {
+        existing = JSON.parse(fs24.readFileSync(configFile, "utf-8"));
       }
       const merged = {
         ...existing,
@@ -10359,8 +9133,8 @@ program.command("setup").description("Configure MCP server for your editors (one
           ...mcpConfig.mcpServers
         }
       };
-      fs25__default.mkdirSync(configDir, { recursive: true });
-      fs25__default.writeFileSync(configFile, JSON.stringify(merged, null, 2) + "\n", "utf-8");
+      fs24.mkdirSync(configDir, { recursive: true });
+      fs24.writeFileSync(configFile, JSON.stringify(merged, null, 2) + "\n", "utf-8");
       console.log(`
   \u2705  Written to ${configFile}`);
     } catch (err) {
@@ -10416,10 +9190,10 @@ program.command("mcp").description("Start MCP server over stdio \u2014 exposes a
     $ code-intel mcp
     $ code-intel mcp ./my-project
 `).action(async (targetPath) => {
-  const workspaceRoot = path28__default.resolve(targetPath);
-  const repoName = path28__default.basename(workspaceRoot);
+  const workspaceRoot = path27.resolve(targetPath);
+  const repoName = path27.basename(workspaceRoot);
   const dbPath = getDbPath(workspaceRoot);
-  const existingIndex = fs25__default.existsSync(dbPath) && loadMetadata(workspaceRoot) !== null;
+  const existingIndex = fs24.existsSync(dbPath) && loadMetadata(workspaceRoot) !== null;
   if (existingIndex) {
     const graph = createKnowledgeGraph();
     const db = new DbManager(dbPath);
@@ -10450,10 +9224,10 @@ program.command("serve").description("Start the local HTTP server + web UI for g
     $ code-intel serve --port 8080
     $ code-intel serve --force
 `).action(async (targetPath, options) => {
-  const workspaceRoot = path28__default.resolve(targetPath);
-  const repoName = path28__default.basename(workspaceRoot);
+  const workspaceRoot = path27.resolve(targetPath);
+  const repoName = path27.basename(workspaceRoot);
   const dbPath = getDbPath(workspaceRoot);
-  const existingIndex = !options.force && fs25__default.existsSync(dbPath) && loadMetadata(workspaceRoot) !== null;
+  const existingIndex = !options.force && fs24.existsSync(dbPath) && loadMetadata(workspaceRoot) !== null;
   if (existingIndex) {
     const meta = loadMetadata(workspaceRoot);
     if (meta.parser === "regex" || meta.parser === void 0) {
@@ -10508,7 +9282,7 @@ program.command("status").description("Show index freshness and statistics for a
     $ code-intel status
     $ code-intel status ./my-project
 `).action((targetPath) => {
-  const workspaceRoot = path28__default.resolve(targetPath);
+  const workspaceRoot = path27.resolve(targetPath);
   const meta = loadMetadata(workspaceRoot);
   if (!meta) {
     console.log(`
@@ -10532,18 +9306,18 @@ function trashDirName(repoPath) {
   return `.code-intel-trash-${date}`;
 }
 function softDeleteCodeIntel(repoPath) {
-  const codeIntelDir = path28__default.join(repoPath, ".code-intel");
-  if (!fs25__default.existsSync(codeIntelDir)) return;
+  const codeIntelDir = path27.join(repoPath, ".code-intel");
+  if (!fs24.existsSync(codeIntelDir)) return;
   const trashName = trashDirName();
-  const trashDir = path28__default.join(repoPath, trashName);
+  const trashDir = path27.join(repoPath, trashName);
   let dest = trashDir;
   let counter = 1;
-  while (fs25__default.existsSync(dest)) {
+  while (fs24.existsSync(dest)) {
     dest = `${trashDir}-${counter++}`;
   }
-  fs25__default.renameSync(codeIntelDir, dest);
-  fs25__default.writeFileSync(
-    path28__default.join(dest, "TRASH_META.json"),
+  fs24.renameSync(codeIntelDir, dest);
+  fs24.writeFileSync(
+    path27.join(dest, "TRASH_META.json"),
     JSON.stringify({ deletedAt: (/* @__PURE__ */ new Date()).toISOString(), repoPath, permanent: false }, null, 2)
   );
   console.log(`  \u2713  Moved to trash: ${dest}`);
@@ -10552,15 +9326,15 @@ function softDeleteCodeIntel(repoPath) {
 function purgeStaleTrashes(repoPath) {
   const cutoff = Date.now() - TRASH_TTL_DAYS * 24 * 60 * 60 * 1e3;
   try {
-    for (const entry of fs25__default.readdirSync(repoPath)) {
+    for (const entry of fs24.readdirSync(repoPath)) {
       if (!entry.startsWith(".code-intel-trash-")) continue;
-      const fullPath = path28__default.join(repoPath, entry);
-      const metaPath = path28__default.join(fullPath, "TRASH_META.json");
-      if (fs25__default.existsSync(metaPath)) {
+      const fullPath = path27.join(repoPath, entry);
+      const metaPath = path27.join(fullPath, "TRASH_META.json");
+      if (fs24.existsSync(metaPath)) {
         try {
-          const meta = JSON.parse(fs25__default.readFileSync(metaPath, "utf-8"));
+          const meta = JSON.parse(fs24.readFileSync(metaPath, "utf-8"));
           if (new Date(meta.deletedAt).getTime() < cutoff) {
-            fs25__default.rmSync(fullPath, { recursive: true, force: true });
+            fs24.rmSync(fullPath, { recursive: true, force: true });
             console.log(`  \u2713  Auto-purged stale trash: ${fullPath}`);
           }
         } catch {
@@ -10587,18 +9361,18 @@ program.command("clean").description("Soft-delete the knowledge graph index for
   if (opts.listTrash) {
     const repos = loadRegistry();
     const roots = repos.map((r) => r.path);
-    if (roots.length === 0) roots.push(path28__default.resolve("."));
+    if (roots.length === 0) roots.push(path27.resolve("."));
     let found = 0;
     for (const root of roots) {
       try {
-        for (const entry of fs25__default.readdirSync(root)) {
+        for (const entry of fs24.readdirSync(root)) {
           if (!entry.startsWith(".code-intel-trash-")) continue;
-          const fullPath = path28__default.join(root, entry);
-          const metaPath = path28__default.join(fullPath, "TRASH_META.json");
+          const fullPath = path27.join(root, entry);
+          const metaPath = path27.join(fullPath, "TRASH_META.json");
           let deletedAt = "unknown";
-          if (fs25__default.existsSync(metaPath)) {
+          if (fs24.existsSync(metaPath)) {
             try {
-              deletedAt = JSON.parse(fs25__default.readFileSync(metaPath, "utf-8")).deletedAt;
+              deletedAt = JSON.parse(fs24.readFileSync(metaPath, "utf-8")).deletedAt;
             } catch {
             }
           }
@@ -10626,9 +9400,9 @@ program.command("clean").description("Soft-delete the knowledge graph index for
     }
     for (const r of repos) {
       if (opts.purge) {
-        const codeIntelDir = path28__default.join(r.path, ".code-intel");
-        if (fs25__default.existsSync(codeIntelDir)) {
-          fs25__default.rmSync(codeIntelDir, { recursive: true, force: true });
+        const codeIntelDir = path27.join(r.path, ".code-intel");
+        if (fs24.existsSync(codeIntelDir)) {
+          fs24.rmSync(codeIntelDir, { recursive: true, force: true });
           console.log(`  \u2713  Hard-deleted ${codeIntelDir}`);
         }
       } else {
@@ -10642,11 +9416,11 @@ program.command("clean").description("Soft-delete the knowledge graph index for
 `);
     return;
   }
-  const workspaceRoot = path28__default.resolve(targetPath);
+  const workspaceRoot = path27.resolve(targetPath);
   if (opts.purge) {
-    const codeIntelDir = path28__default.join(workspaceRoot, ".code-intel");
-    if (fs25__default.existsSync(codeIntelDir)) {
-      fs25__default.rmSync(codeIntelDir, { recursive: true, force: true });
+    const codeIntelDir = path27.join(workspaceRoot, ".code-intel");
+    if (fs24.existsSync(codeIntelDir)) {
+      fs24.rmSync(codeIntelDir, { recursive: true, force: true });
       console.log(`
   \u2713  Hard-deleted ${codeIntelDir}`);
     }
@@ -10658,16 +9432,16 @@ program.command("clean").description("Soft-delete the knowledge graph index for
   console.log("  Index cleaned.\n");
 });
 async function loadOrAnalyzeWorkspace(targetPath) {
-  const workspaceRoot = path28__default.resolve(targetPath);
+  const workspaceRoot = path27.resolve(targetPath);
   const dbPath = getDbPath(workspaceRoot);
-  const existingIndex = fs25__default.existsSync(dbPath) && loadMetadata(workspaceRoot) !== null;
+  const existingIndex = fs24.existsSync(dbPath) && loadMetadata(workspaceRoot) !== null;
   if (existingIndex) {
     const graph = createKnowledgeGraph();
     const db = new DbManager(dbPath);
     await db.init();
     await loadGraphFromDB(graph, db);
     db.close();
-    return { graph, workspaceRoot, repoName: path28__default.basename(workspaceRoot) };
+    return { graph, workspaceRoot, repoName: path27.basename(workspaceRoot) };
   }
   return analyzeWorkspace(targetPath, { silent: true });
 }
@@ -11095,9 +9869,9 @@ groupCmd.command("status <name>").description("Check index freshness and sync st
       console.log(`  \u2717  ${m.groupPath.padEnd(35)} [${m.registryName}]  \u2014 NOT IN REGISTRY`);
       continue;
     }
-    const metaPath = path28__default.join(regEntry.path, ".code-intel", "meta.json");
+    const metaPath = path27.join(regEntry.path, ".code-intel", "meta.json");
     try {
-      const meta = JSON.parse(fs25__default.readFileSync(metaPath, "utf-8"));
+      const meta = JSON.parse(fs24.readFileSync(metaPath, "utf-8"));
       const indexedAt = meta.indexedAt;
       const ageMin = Math.round((now - new Date(indexedAt).getTime()) / 6e4);
       const stale = ageMin > 1440 ? "  \u26A0  STALE (>24h)" : "";
@@ -11130,10 +9904,10 @@ userCmd.command("create <username>").description("Create a new local user accoun
   if (!password) {
     const readline = await import('readline');
     const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
-    password = await new Promise((resolve2) => {
+    password = await new Promise((resolve) => {
       rl.question(`  Password for ${username}: `, (ans) => {
         rl.close();
-        resolve2(ans);
+        resolve(ans);
       });
     });
   }
@@ -11196,10 +9970,10 @@ userCmd.command("reset-password <username>").description("Reset the password for
   if (!password) {
     const readline = await import('readline');
     const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
-    password = await new Promise((resolve2) => {
+    password = await new Promise((resolve) => {
       rl.question(`  New password for ${username}: `, (ans) => {
         rl.close();
-        resolve2(ans);
+        resolve(ans);
       });
     });
   }
@@ -11314,7 +10088,7 @@ backupCmd.command("create [path]").description("Create an encrypted backup of th
     $ code-intel backup create
     $ code-intel backup create ./my-project
 `).action((targetPath = ".") => {
-  const repoPath = path28__default.resolve(targetPath);
+  const repoPath = path27.resolve(targetPath);
   const svc = new BackupService();
   try {
     const entry = svc.createBackup(repoPath);
@@ -11343,7 +10117,7 @@ backupCmd.command("list").description("List all available backups").action(() =>
   Backups (${entries.length}):
 `);
   for (const e of entries) {
-    const exists = fs25__default.existsSync(e.path);
+    const exists = fs24.existsSync(e.path);
     const status = exists ? "\u2713" : "\u2717 (missing)";
     console.log(`  ${status}  ${e.id.slice(0, 8)}  ${e.createdAt}  ${(e.size / 1024).toFixed(1)} KB  \u2192  ${e.repoPath}`);
   }
@@ -11356,7 +10130,7 @@ backupCmd.command("restore <id>").description("Restore a backup by ID").option("
 `).action((id, opts) => {
   const svc = new BackupService();
   try {
-    const targetPath = opts.target ? path28__default.resolve(opts.target) : void 0;
+    const targetPath = opts.target ? path27.resolve(opts.target) : void 0;
     svc.restoreBackup(id, targetPath);
     console.log(`
   \u2705  Backup "${id}" restored successfully.
@@ -11375,8 +10149,8 @@ program.command("migrate").description("Manage database schema migrations").opti
     $ code-intel migrate
     $ code-intel migrate --rollback
 `).action((opts) => {
-  const dbPath = opts.db ?? path28__default.join(os12.homedir(), ".code-intel", "users.db");
-  if (!fs25__default.existsSync(dbPath)) {
+  const dbPath = opts.db ?? path27.join(os12.homedir(), ".code-intel", "users.db");
+  if (!fs24.existsSync(dbPath)) {
     console.error(`
   \u2717  Database not found: ${dbPath}
   Run \`code-intel serve\` or \`code-intel user create\` first.
@@ -11491,15 +10265,15 @@ authCmd.command("login").description("Authenticate via OIDC device flow \u2014 o
   }
   try {
     const tokens = await pollDeviceFlow3(config, deviceResponse);
-    const tokenPath = path28__default.join(os12.homedir(), ".code-intel", "oidc-token.json");
+    const tokenPath = path27.join(os12.homedir(), ".code-intel", "oidc-token.json");
     const tokenData = {
       accessToken: tokens.accessToken,
       refreshToken: tokens.refreshToken,
       server: serverUrl,
       storedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
-    fs25__default.mkdirSync(path28__default.dirname(tokenPath), { recursive: true });
-    fs25__default.writeFileSync(tokenPath, JSON.stringify(tokenData, null, 2), { mode: 384 });
+    fs24.mkdirSync(path27.dirname(tokenPath), { recursive: true });
+    fs24.writeFileSync(tokenPath, JSON.stringify(tokenData, null, 2), { mode: 384 });
     console.log(`  \u2705  Authenticated successfully!`);
     console.log(`  Token stored at: ${tokenPath}`);
     console.log(`  Use CODE_INTEL_TOKEN env var or --token flag to use it with CLI/MCP.
@@ -11512,13 +10286,13 @@ authCmd.command("login").description("Authenticate via OIDC device flow \u2014 o
   }
 });
 authCmd.command("status").description("Show the current OIDC authentication status").action(() => {
-  const tokenPath = path28__default.join(os12.homedir(), ".code-intel", "oidc-token.json");
-  if (!fs25__default.existsSync(tokenPath)) {
+  const tokenPath = path27.join(os12.homedir(), ".code-intel", "oidc-token.json");
+  if (!fs24.existsSync(tokenPath)) {
     console.log("\n  Not authenticated via OIDC. Run: code-intel auth login\n");
     return;
   }
   try {
-    const data = JSON.parse(fs25__default.readFileSync(tokenPath, "utf-8"));
+    const data = JSON.parse(fs24.readFileSync(tokenPath, "utf-8"));
     console.log(`
   \u2705  OIDC token stored`);
     console.log(`  Server : ${data.server ?? "unknown"}`);
@@ -11530,9 +10304,9 @@ authCmd.command("status").description("Show the current OIDC authentication stat
   }
 });
 authCmd.command("logout").description("Remove locally stored OIDC token").action(() => {
-  const tokenPath = path28__default.join(os12.homedir(), ".code-intel", "oidc-token.json");
-  if (fs25__default.existsSync(tokenPath)) {
-    fs25__default.unlinkSync(tokenPath);
+  const tokenPath = path27.join(os12.homedir(), ".code-intel", "oidc-token.json");
+  if (fs24.existsSync(tokenPath)) {
+    fs24.unlinkSync(tokenPath);
     console.log("\n  \u2705  OIDC token removed. You are now logged out.\n");
   } else {
     console.log("\n  No stored token found.\n");
@@ -11656,8 +10430,8 @@ program.command("config-validate <file>").description("Validate a JSON config fi
     $ code-intel config-validate ./config.json
     $ code-intel config-validate ~/.code-intel/config.json
 `).action((file) => {
-  const filePath = path28__default.resolve(file);
-  if (!fs25__default.existsSync(filePath)) {
+  const filePath = path27.resolve(file);
+  if (!fs24.existsSync(filePath)) {
     console.error(`
   \u2717  File not found: ${filePath}
 `);
@@ -11665,7 +10439,7 @@ program.command("config-validate <file>").description("Validate a JSON config fi
   }
   let cfg;
   try {
-    cfg = JSON.parse(fs25__default.readFileSync(filePath, "utf-8"));
+    cfg = JSON.parse(fs24.readFileSync(filePath, "utf-8"));
   } catch (err) {
     console.error(`
   \u2717  Could not parse JSON: ${err instanceof Error ? err.message : err}
@@ -11686,7 +10460,7 @@ ${err instanceof Error ? err.message : err}
 });
 (function ensurePermissions() {
   try {
-    const dir = path28__default.join(os12.homedir(), ".code-intel");
+    const dir = path27.join(os12.homedir(), ".code-intel");
     secureMkdir(dir);
     tightenDbFiles(dir);
   } catch {