Introducing @knitpkg:wired: Actual MQL #embody for Composite Packages in KnitPkg – Buying and selling Methods – 24 March 2026

In the event you’ve performed with KnitPkg composite packages, you’ve most likely hit this basic drawback:

• Throughout improvement, you need MetaEditor to resolve all of your  #embody s in order that IntelliSense and unit assessments work.
• However when your bundle is put in as a dependency, these  #embody s should level to the actual put in headers beneath  knitpkg/embody/ , to not some dev‑solely helper.

Till now, the “basic” resolution was:

• Embrace a giant  autocomplete.mqh  file to make symbols from dependencies seen;
• Declare the actual exterior dependencies through  /* @knitpkg:embody “…” */  directives, which KnitPkg rewrites into actual  #embody  statements throughout  kp set up .

This works, but it surely has two downsides:

1. autocomplete.mqh  pulls in all the pieces out of your dependencies, polluting IntelliSense with numerous unrelated names.
2. Your actual dependencies are hidden inside feedback as an alternative of being seen as regular MQL consists of.

KnitPkg v1.1.0 introduces a greater strategy.

What Is  @knitpkg:wired ?

@knitpkg:wired  is a brand new directive for composite packages that allows you to write actual MQL  #embody  paths to dependency headers, whereas nonetheless letting KnitPkg “rewire” these consists of when your bundle is put in some place else.

As a substitute of doing this (basic strategy):

#embody "../../../autocomplete/autocomplete.mqh"

#embody "../../../autocomplete/knitpkg/embody/douglasrechia/bar/TimeSeries.mqh" 

• The  #embody  is actual MQL, pointing to the header beneath  knitpkg/autocomplete/knitpkg/embody/… .
• MetaEditor resolves it straight, so IntelliSense and unit assessments simply work.
• The  /* @knitpkg:wired */  annotation sits on the similar line because the  #embody .
• Throughout  kp set up , KnitPkg detects this annotation and rewrites the trail from the  autocomplete  construction to the actual put in header beneath  knitpkg/embody/… .

So inside your dev repo, your file may appear like this:

#embody "../../../autocomplete/knitpkg/embody/douglasrechia/bar/TimeSeries.mqh" 

namespace douglasrechia
{
  bool CrossUp(ITimeSeriesdouble> &series1,
               ITimeSeriesdouble> &series2,
               int shift = 0)
  {
    if(shift 0) return false;
    if(shift >= series1.Measurement() - 1) return false;
    if(shift >= series2.Measurement() - 1) return false;

    return series1.ValueAtShift(shift + 1) 1) &&
           series1.ValueAtShift(shift)     > series2.ValueAtShift(shift);
  }
}

When  barhelper  is put in as a dependency in one other mission, KnitPkg rewrites that embody so it factors on the put in  TimeSeries.mqh  beneath  knitpkg/embody/douglasrechia/bar/…  as an alternative of the autocomplete copy.

For an additional instance, see this.

Why This Is Higher for Composite Packages

From the MQL developer’s perspective,  @knitpkg:wired  is rather more pure than the outdated  autocomplete.mqh + @knitpkg:embody  combo:

1. The consists of are trustworthy MQL.
   You see precisely which headers you’re together with, as regular  #embody  statements. There isn’t any “magic” hidden inside feedback.

2. No extra namespace air pollution.
   You embody solely the precise headers you want from every dependency, as an alternative of pulling all the pieces into the present translation unit through  autocomplete.mqh .

3. MetaEditor simply works.
   As a result of the  #embody  references the header beneath  knitpkg/autocomplete/knitpkg/embody/… , MetaEditor resolves it usually. IntelliSense and unit assessments see the identical code you see.

4. Set up-time wiring is computerized.
   kp set up  merely detects  /* @knitpkg:wired */  and overwrites the embody path to focus on the put in bundle header. You don’t have to take care of a separate checklist of  @knitpkg:embody  directives.

The outcome: your composite packages learn like idiomatic MQL code, whereas nonetheless behaving accurately when put in as dependencies.

How To Use  @knitpkg:wired  in Your Package deal

Right here’s the workflow in observe:

1. Declare the dependency. 

In your composite bundle (for instance  barhelper ), add the dependency with the CLI:

kp add @douglasrechia/bar

This updates your  knitpkg.yaml  with one thing like:

dependencies: ‘@douglasrechia/bar’: ^1.0.0

2. Generate autocomplete headers. 

Run:

kp autocomplete

This populates  knitpkg/autocomplete/knitpkg/embody/…  with headers in your dependencies, preserving their construction. These are the headers your dev-time consists of ought to goal whenever you write  @knitpkg:wired  consists of.

3. Write wired consists of in your public headers. 

In a header beneath  knitpkg/embody/// , embody dependency headers from the  autocomplete  tree and annotate them:

#embody "../../../autocomplete/knitpkg/embody/douglasrechia/bar/TimeSeries.mqh" 

A couple of guidelines:

• The trail should level someplace beneath  knitpkg/autocomplete/knitpkg/embody/ .
• The trail needs to be relative to the header that’s together with it.
• The  /* @knitpkg:wired */  annotation have to be on the similar line because the  #embody .

4. Validate with kp checkinstall. Earlier than publishing your bundle, run:

kp checkinstall

This simulates set up and verifies that each one wired consists of will resolve accurately when your bundle is consumed as a dependency.

Comparability With the Basic  @knitpkg:embody  Method

For context, here’s what the basic strategy regarded like in a composite bundle header:

#embody "../../../autocomplete/autocomplete.mqh"

Throughout improvement:

• autocomplete.mqh  brings all dependency headers into a neighborhood construction so MetaEditor can resolve symbols for IntelliSense and compilation.
• The  @knitpkg:embody  directive lives inside a remark and is just interpreted by KnitPkg at set up time.

When the bundle is put in as a dependency, KnitPkg:

• Feedback out the  #embody “../../../autocomplete/autocomplete.mqh”  line so it doesn’t leak into the patron’s code;
• Converts every  @knitpkg:embody  directive into an actual MQL  #embody  pointing on the put in dependency headers beneath  knitpkg/embody/… .

This nonetheless works and is totally supported, however in observe it has some drawbacks:

• You could have two sources of reality for dependencies (the dev-time  autocomplete.mqh  and the install-time  @knitpkg:embody  feedback).
• autocomplete pulls in a number of stuff you could not want.
• The actual dependency edges are hidden in feedback moderately than expressed as regular  #embody s.

@knitpkg:wired  was designed particularly to take away these wrinkles and make composite packages really feel like simple MQL initiatives that simply occur to be wired up by KnitPkg at set up time.

Really useful Utilization

Going ahead:

• For composite packages,  @knitpkg:wired  is the really helpful sample to specific dependencies between packages in public headers.
• For single packages (these with no dependencies), you don’t want  kp autocomplete ,  @knitpkg:wired , or  @knitpkg:embody  in any respect; your headers compile as common  .mqh  recordsdata.
• For inside consists of inside the similar bundle, you continue to use regular relative  #embody  statements with no KnitPkg directives.

If you have already got packages utilizing  autocomplete.mqh + @knitpkg:embody , they are going to proceed to work. You’ll be able to migrate progressively: as you contact current headers, you’ll be able to swap them to  @knitpkg:wired  if you need the cleaner, extra specific type.

Wrap-Up

@knitpkg:wired  is a small directive, but it surely considerably simplifies how composite packages are written:

• Actual MQL consists of as an alternative of remark‑primarily based indirection.
• Cleaner IntelliSense, much less namespace litter.
• Automated path rewiring at set up time, validated by  kp checkinstall .

In the event you’re sustaining packages that rely upon others, I strongly suggest making an attempt the wired strategy in your subsequent refactor or new bundle.

In the event you’d like, I may help you change considered one of your current KnitPkg packages step-by-step from  @knitpkg:embody  to  @knitpkg:wired —do you have got a selected repo in thoughts?