@voxgig/sdkgen 3.5.0 → 3.6.0

package/project/.sdk/src/cmp/seneca-provider/Main_seneca-provider.ts

@@ -14,6 +14,7 @@ import {
 } from '@voxgig/apidef'
 
 import { Tests, Scripts, Workflow, Readme, Docs } from './Extras_seneca-provider'
+import { Gitignore } from './Gitignore_seneca-provider'
 
 
 // The `seneca-provider` target: a Seneca plugin exposing this API's entities
@@ -206,9 +207,10 @@ function parentEntityOf(key: string, names: string[]): string {
 // published package to the SDK instead.
 //
 // Order: the project's `output: repo`, else the Seneca convention.
-function providerRepo(model: any, lower: string): { url: string, path: string } {
+function providerRepo(model: any, lower: string, tname: string):
+  { url: string, path: string } {
   const host = model?.main?.[KIT]?.repo?.host || 'github.com'
-  const declared = model?.main?.[KIT]?.target?.['seneca-provider']?.output?.repo
+  const declared = model?.main?.[KIT]?.target?.[tname]?.output?.repo
   const path = null != declared && '' !== declared ?
     String(declared) : `senecajs/seneca-${lower}-provider`
 
@@ -219,8 +221,8 @@ function providerRepo(model: any, lower: string): { url: string, path: string }
 // The provider's published package name: the project's pin when it has one,
 // else `@seneca/<name>-provider`. packageName() cannot answer this — its
 // derivations are all SDK-shaped (`@<origin>/<slug>-sdk`).
-function providerPackage(model: any, lower: string): string {
-  const declared = model?.main?.[KIT]?.target?.['seneca-provider']
+function providerPackage(model: any, lower: string, tname: string): string {
+  const declared = model?.main?.[KIT]?.target?.[tname]
     ?.publish?.registry?.package
   return null != declared && '' !== declared ?
     String(declared) : `@seneca/${lower}-provider`
@@ -253,6 +255,8 @@ const Main = cmp(function Main(props: any) {
   // The SDK is a PUBLISHED dependency, not a path: this package lives in its
   // own repo. Its name is whatever the ts target publishes under, pin
   // included, so the two can never disagree.
+  // The TypeScript SDK this provider WRAPS — a different target, so it
+  // keeps its own name and does not follow this provider's alias.
   const sdkPkg = packageName(model, 'npm')
   const sdkVersion = packageVersion(model, 'ts')
 
@@ -374,7 +378,7 @@ const Main = cmp(function Main(props: any) {
       'all. Remove the target, or add an entity with CRUD ops.')
   }
 
-  const repo = providerRepo(model, lower)
+  const repo = providerRepo(model, lower, target.name)
 
   // The companion test server lives in the SDK repo's `app/` and is NOT
   // published, so the only way to reach it is the local checkout. The path
@@ -440,7 +444,7 @@ const Main = cmp(function Main(props: any) {
     // The provider's OWN published name. Not derived from the SDK slug the
     // way a language target's is — a provider is `@seneca/<name>-provider` —
     // so read the project's pin directly and default to that shape.
-    pkgName: providerPackage(model, lower),
+    pkgName: providerPackage(model, lower, target.name),
     // Whether this API authenticates at all. Decides if the plugin plumbs a
     // credential: the SDK's auth stage emits nothing for an auth-inactive
     // model and strips the authorization header regardless of options, so
@@ -448,14 +452,20 @@ const Main = cmp(function Main(props: any) {
     authActive: isAuthActive(model),
   }
 
-  // Static furniture: LICENSE, CODE_OF_CONDUCT, Makefile, .gitignore,
-  // tsfmt.json and both tsconfigs. Same for every provider.
+  // `.gitignore` is EMITTED rather than copied — npm strips that filename
+  // from the tarball, so as a template it reached only checkout users. See
+  // Gitignore_seneca-provider. Called before the Copy, as every language
+  // target calls its own.
+  Gitignore({})
+
+  // Static furniture: LICENSE, CODE_OF_CONDUCT, Makefile, tsfmt.json and
+  // both tsconfigs. Same for every provider.
   Copy({
     from: 'tm/' + target.name,
     replace: { ...ctx$.stdrep },
   })
 
-  PackageJson({ provider })
+  PackageJson({ provider, target })
   ProviderSource({ provider })
   ProviderDoc({ provider })
   Tests({ provider })
@@ -469,9 +479,8 @@ const Main = cmp(function Main(props: any) {
 // --- package.json -----------------------------------------------------------
 
 const PackageJson = cmp(function PackageJson(props: any) {
-  const { provider } = props
+  const { provider, target } = props
   const { model } = props.ctx$
-  const target = model.main[KIT].target['seneca-provider']
 
   const deps = collectDeps(model, target.name, target.deps, props.ctx$.log)
 

package/project/.sdk/src/cmp/swift/Test_swift.ts

@@ -1,14 +1,9 @@
 
-import {
-  KIT,
-  getModelPath
-} from '@voxgig/apidef'
-
 import type {
   ModelEntity
 } from '@voxgig/apidef'
 
-import { cmp, each, Folder } from '@voxgig/sdkgen'
+import { cmp, each, Folder, entityCollection } from '@voxgig/sdkgen'
 
 
 import { TestEntity } from './TestEntity_swift'
@@ -26,7 +21,10 @@ const Test = cmp(function Test(props: any) {
   // are generated here.
   Folder({ name: 'Tests' }, () => {
     Folder({ name: 'ProjectNameSDKTests' }, () => {
-      each(getModelPath(model, `main.${KIT}.entity`), (entity: ModelEntity) => {
+      const entity = each(entityCollection(model))
+        .filter((e: any) => false !== e.active)
+
+      each(entity, (entity: ModelEntity) => {
         TestEntity({ target, entity })
         TestDirect({ target, entity })
       })

package/project/.sdk/src/cmp/ts/Package_ts.ts

@@ -61,7 +61,7 @@ const Package = cmp(async function Package(props: any) {
   const { repoUrl, issuesUrl } = repoInfo(model)
 
   const pkg = {
-    name: packageName(model, 'npm'),
+    name: packageName(model, target.name),
     version: packageVersion(model, target.name),
     description: pkgDescription(model, target.name),
     keywords: keywords(model),

package/project/.sdk/src/cmp/ts/Test_ts.ts

@@ -1,14 +1,9 @@
 
-import {
-  KIT,
-  getModelPath
-} from '@voxgig/apidef'
-
 import type {
   ModelEntity
 } from '@voxgig/apidef'
 
-import { cmp, each, Folder } from '@voxgig/sdkgen'
+import { cmp, each, Folder, entityCollection } from '@voxgig/sdkgen'
 
 
 // import { Quick } from './Quick_ts'
@@ -31,7 +26,13 @@ const Test = cmp(function Test(props: any) {
     ReadmeExamplesTest({ target })
 
     Folder({ name: 'entity' }, () => {
-      each(model.main[KIT].entity, (entity: ModelEntity) => {
+      // entityCollection is the cached, UNFILTERED collection (AGENTS.md), so
+      // the active filter the raw model read this replaced never applied is
+      // written out here. Tests follow Main: an inactive entity has no source.
+      const entity = each(entityCollection(model))
+        .filter((e: any) => false !== e.active)
+
+      each(entity, (entity: ModelEntity) => {
         TestEntity({ target, entity })
         TestDirect({ target, entity })
       })

package/project/.sdk/src/cmp/zig/Test_zig.ts

@@ -1,14 +1,9 @@
 
-import {
-  KIT,
-  getModelPath
-} from '@voxgig/apidef'
-
 import type {
   ModelEntity
 } from '@voxgig/apidef'
 
-import { cmp, each, Folder, File, Content } from '@voxgig/sdkgen'
+import { cmp, each, Folder, File, Content, entityCollection } from '@voxgig/sdkgen'
 
 import { TestEntity } from './TestEntity_zig'
 import { TestDirect } from './TestDirect_zig'
@@ -30,7 +25,8 @@ const Test = cmp(function Test(props: any) {
   const { model } = props.ctx$
   const { target } = props
 
-  const entity = getModelPath(model, `main.${KIT}.entity`)
+  const entity = each(entityCollection(model))
+    .filter((e: any) => false !== e.active)
 
   Folder({ name: 'test' }, () => {
     File({ name: 'generated_test.' + target.ext }, () => {

package/project/.sdk/tm/c/utility/make_point.c

@@ -13,6 +13,29 @@ static voxgig_value* get_elem_i(voxgig_value* list, int64_t i) {
   return r ? r : voxgig_new_undef();
 }
 
+// How many path segments a point has.
+static size_t parts_len(voxgig_value* point) {
+  voxgig_value* parts = getp(point, "parts");
+  return voxgig_is_list(parts) ? voxgig_as_list(parts)->len : 0;
+}
+
+// Does this point's path end in a parameter? A record route ends in the
+// record's identifier (/boards/{id}); a cross-reference that also returns
+// the entity ends in the relationship's name (/posts/{id}/author). That,
+// then fewest segments, is what tells the entity's own route from a
+// cross-reference. The same rule runs at generation time, in
+// helpers/opShape.ts — both sides must move together.
+static bool terminal_param(voxgig_value* point) {
+  voxgig_value* parts = getp(point, "parts");
+  if (!voxgig_is_list(parts)) return false;
+  voxgig_list* pl = voxgig_as_list(parts);
+  if (0 == pl->len) return false;
+  voxgig_value* last = pl->items[pl->len - 1];
+  if (!voxgig_is_string(last)) return false;
+  const char* s = voxgig_as_string(last);
+  return NULL != s && '{' == s[0];
+}
+
 voxgig_value* make_point_util(Context* ctx, PNError** err) {
   *err = NULL;
 
@@ -58,9 +81,10 @@ voxgig_value* make_point_util(Context* ctx, PNError** err) {
     voxgig_value* selector = is_data ? ctx->data : ctx->mtch;
 
     voxgig_value* point = voxgig_new_undef();
+    bool matched = false;
     for (int64_t i = 0; i < plen; i++) {
-      point = get_elem_i(points, i);
-      voxgig_value* select_def = to_map(getp(point, "select"));
+      voxgig_value* cand = get_elem_i(points, i);
+      voxgig_value* select_def = to_map(getp(cand, "select"));
       bool found = true;
 
       if (!v_is_noval(selector) && !v_is_noval(select_def)) {
@@ -85,7 +109,44 @@ voxgig_value* make_point_util(Context* ctx, PNError** err) {
         if (!v_eq(req_action, select_action)) found = false;
       }
 
-      if (found) break;
+      if (found) {
+        point = cand;
+        matched = true;
+        break;
+      }
+    }
+
+    // select.exist can list more than the params needed to pick a point, so
+    // nothing matches — fall back to the entity's own route rather than
+    // whichever point came last.
+    if (!matched) {
+      // A request naming an action reaches here only because that action's
+      // own point failed its exist test, so it is unbuildable whatever we
+      // pick. Refuse it BEFORE choosing a fallback: the guard below compares
+      // the chosen point's $action and would wave the request through
+      // whenever the fallback lands on the action point itself.
+      voxgig_value* unmatched_action = getp(reqselector, "$action");
+      if (!v_is_noval(unmatched_action)) {
+        char* actstr = voxgig_stringify(unmatched_action, -1);
+        char buf[512];
+        snprintf(buf, sizeof(buf), "Operation \"%s\" action \"%s\" is not valid.",
+                 op->name, actstr ? actstr : "");
+        *err = context_make_error(ctx, "point_action_invalid", buf);
+        return NULL;
+      }
+
+      point = get_elem_i(points, 0);
+      for (int64_t i = 0; i < plen; i++) {
+        voxgig_value* cand = get_elem_i(points, i);
+        bool cand_term = terminal_param(cand);
+        bool best_term = terminal_param(point);
+        if (cand_term != best_term) {
+          if (cand_term) point = cand;
+        }
+        else if (parts_len(cand) < parts_len(point)) {
+          point = cand;
+        }
+      }
     }
 
     voxgig_value* req_action = getp(reqselector, "$action");

package/project/.sdk/tm/clojure/src/sdk/core.clj

@@ -641,21 +641,56 @@
                             sa (vs/getprop select-def "$action")]
                         (when (not= ra sa) (reset! found false))))
                     @found))
-                ;; "first matching point, else the last point" (mirrors the
-                ;; reference loop that keeps the last-visited point).
-                chosen (loop [ps (vec (op-points op)) last nil]
-                         (if (empty? ps) last
-                             (let [p (first ps)]
-                               (if (point-matches? p) p (recur (rest ps) p)))))
+                ;; How many path segments a point has, and whether its path
+                ;; ends in a parameter. A record route ends in the record's
+                ;; identifier (/boards/{id}); a cross-reference that also
+                ;; returns the entity ends in the relationship's name
+                ;; (/posts/{id}/author). That, then fewest segments, is what
+                ;; tells the entity's own route from a cross-reference. The
+                ;; same rule runs at generation time, in helpers/opShape.ts —
+                ;; both sides must move together.
+                parts-len (fn [p]
+                            (let [parts (vs/getprop p "parts")]
+                              (if (vs/islist parts) (vs/size parts) 0)))
+                terminal-param? (fn [p]
+                                  (let [parts (vs/getprop p "parts")]
+                                    (and (vs/islist parts)
+                                         (pos? (vs/size parts))
+                                         (let [last-part (vs/getelem parts (dec (vs/size parts)))]
+                                           (and (string? last-part)
+                                                (str/starts-with? last-part "{"))))))
+                own-point (fn [ps]
+                            (reduce (fn [best cand]
+                                      (let [ct (terminal-param? cand)
+                                            bt (terminal-param? best)]
+                                        (if (not= ct bt)
+                                          (if ct cand best)
+                                          (if (< (parts-len cand) (parts-len best)) cand best))))
+                                    (first ps) ps))
+                matched (first (filter point-matches? (vec (op-points op))))
                 req-action (vs/getprop reqselector "$action")]
-            (if (and reqselector req-action chosen)
-              (let [point-select (to-map (vs/getprop chosen "select"))
-                    point-action (vs/getprop point-select "$action")]
-                (if (not= req-action point-action)
-                  [nil (ctx-error ctx "point_action_invalid"
-                                  (str "Operation \"" (op-name op) "\" action \"" (vs/stringify req-action) "\" is not valid."))]
-                  (do (oset! ctx :point chosen) [(oget ctx :point) nil])))
-              (do (oset! ctx :point chosen) [(oget ctx :point) nil]))))))))
+            (cond
+              ;; select.exist can list more than the params needed to pick a
+              ;; point, so nothing matches. A request naming an action reaches
+              ;; here only because that action's own point failed its exist
+              ;; test, so it is unbuildable whatever we pick — refuse it
+              ;; BEFORE falling back, since the guard below compares the
+              ;; chosen point's $action and would wave the request through
+              ;; whenever the fallback lands on the action point itself.
+              (and (nil? matched) reqselector req-action)
+              [nil (ctx-error ctx "point_action_invalid"
+                              (str "Operation \"" (op-name op) "\" action \"" (vs/stringify req-action) "\" is not valid."))]
+
+              :else
+              (let [chosen (or matched (own-point (vec (op-points op))))]
+                (if (and reqselector req-action chosen)
+                  (let [point-select (to-map (vs/getprop chosen "select"))
+                        point-action (vs/getprop point-select "$action")]
+                    (if (not= req-action point-action)
+                      [nil (ctx-error ctx "point_action_invalid"
+                                      (str "Operation \"" (op-name op) "\" action \"" (vs/stringify req-action) "\" is not valid."))]
+                      (do (oset! ctx :point chosen) [(oget ctx :point) nil])))
+                  (do (oset! ctx :point chosen) [(oget ctx :point) nil]))))))))))
 
 (defn u-make-spec [ctx]
   (if (some? (out-get ctx "spec"))

package/project/.sdk/tm/cpp/utility/pipeline.hpp

@@ -330,9 +330,10 @@ inline Value makePoint(CtxPtr ctx) {
     }
 
     Value point;
+    bool matched = false;
     for (size_t i = 0; i < op->points.size(); i++) {
-      point = op->points[i];
-      Value selectDef = Helpers::toMapAny(getp(point, "select"));
+      Value cand = op->points[i];
+      Value selectDef = Helpers::toMapAny(getp(cand, "select"));
       bool found = true;
 
       if (selector.is_map() && selectDef.is_map()) {
@@ -356,7 +357,58 @@ inline Value makePoint(CtxPtr ctx) {
         if (reqAction != selectAction) found = false;
       }
 
-      if (found) break;
+      if (found) {
+        point = cand;
+        matched = true;
+        break;
+      }
+    }
+
+    // select.exist can list more than the params needed to pick a point (for
+    // /boards/{id} it is Trello's 17 optional query-includes), so a plain
+    // {id} call matches NOTHING. Fall back to the entity's own route rather
+    // than whichever point came last.
+    if (!matched) {
+      // A request naming an action reaches here only because that action's
+      // own point failed its exist test, so it is unbuildable whatever we
+      // pick. Refuse it BEFORE choosing a fallback: the guard below compares
+      // the chosen point's $action and would wave the request through
+      // whenever the fallback lands on the action point itself.
+      Value unmatchedAction = getp(reqselector, "$action", Value(nullptr));
+      if (!unmatchedAction.is_null()) {
+        throw ctx->makeError("point_action_invalid",
+            "Operation \"" + op->name + "\" action \"" +
+            Struct::stringify(unmatchedAction) + "\" is not valid.");
+      }
+
+      // A terminal parameter marks a record route (/boards/{id}); a
+      // cross-reference ends in the relationship's name (/posts/{id}/author).
+      // Failing that, the shallower path wins. The same rule runs at
+      // generation time, in helpers/opShape.ts — both sides must move
+      // together.
+      auto partsLen = [](const Value& p) -> size_t {
+        Value parts = getp(p, "parts");
+        return parts.is_list() ? parts.as_list()->size() : 0;
+      };
+      auto terminalParam = [](const Value& p) -> bool {
+        Value parts = getp(p, "parts");
+        if (!parts.is_list() || parts.as_list()->empty()) return false;
+        const Value& last = parts.as_list()->back();
+        return last.is_string() && 0 == last.as_string().rfind("{", 0);
+      };
+
+      point = op->points[0];
+      for (size_t i = 0; i < op->points.size(); i++) {
+        const Value& cand = op->points[i];
+        bool candTerm = terminalParam(cand);
+        bool bestTerm = terminalParam(point);
+        if (candTerm != bestTerm) {
+          if (candTerm) point = cand;
+        }
+        else if (partsLen(cand) < partsLen(point)) {
+          point = cand;
+        }
+      }
     }
 
     if (reqselector.is_map()) {

package/project/.sdk/tm/csharp/feature/TestFeature.cs

@@ -313,10 +313,44 @@ public class TestFeature : BaseFeature
     {
         var opname = op.Name;
 
-        // Get last point from config.
+        // Pick the entity's own endpoint from config, not a cross-reference
+        // from another resource that also returns it — the same rule
+        // MakePoint falls back to, so the seed-data query is built from the
+        // endpoint the request will actually be sent to: a terminal `{id}`
+        // marks a record route, and failing that the shallower path wins.
         var points = StructUtils.GetPath(ctx.Config,
             StructUtils.Jt("entity", ctx.Entity!.GetName(), "op", opname, "points"));
-        var point = StructUtils.GetElem(points, -1);
+        var point = StructUtils.GetElem(points, 0);
+        if (points is List<object?> pointList)
+        {
+            static int PointPartsLen(object? p) =>
+                StructUtils.GetProp(p, "parts") is List<object?> parts ? parts.Count : 0;
+            static bool PointTerminalParam(object? p)
+            {
+                if (StructUtils.GetProp(p, "parts") is not List<object?> parts || parts.Count == 0)
+                {
+                    return false;
+                }
+                return parts[parts.Count - 1] is string last && last.StartsWith("{");
+            }
+
+            foreach (var candidate in pointList)
+            {
+                var candTerm = PointTerminalParam(candidate);
+                var bestTerm = PointTerminalParam(point);
+                if (candTerm != bestTerm)
+                {
+                    if (candTerm)
+                    {
+                        point = candidate;
+                    }
+                }
+                else if (PointPartsLen(candidate) < PointPartsLen(point))
+                {
+                    point = candidate;
+                }
+            }
+        }
 
         // Get required params.
         var paramsPath = StructUtils.GetPath(point, StructUtils.Jt("args", "params"));

package/project/.sdk/tm/csharp/utility/MakePoint.cs

@@ -6,6 +6,27 @@ namespace ProjectNameSdk.Util;
 
 public static partial class SdkUtility
 {
+    // How many path segments a point has.
+    private static int PartsLen(Dictionary<string, object?>? point)
+    {
+        return StructUtils.GetProp(point, "parts") is List<object?> parts ? parts.Count : 0;
+    }
+
+    // Does this point's path end in a parameter? A record route ends in the
+    // record's identifier (/boards/{id}); a cross-reference that also returns
+    // the entity ends in the relationship's name (/posts/{id}/author). That,
+    // then fewest segments, is what tells the entity's own route from a
+    // cross-reference. The same rule runs at generation time, in
+    // helpers/opShape.ts — both sides must move together.
+    private static bool TerminalParam(Dictionary<string, object?>? point)
+    {
+        if (StructUtils.GetProp(point, "parts") is not List<object?> parts || parts.Count == 0)
+        {
+            return false;
+        }
+        return parts[parts.Count - 1] is string last && last.StartsWith("{");
+    }
+
     internal static Dictionary<string, object?>? MakePointUtil(Context ctx)
     {
         if (ctx.Out.TryGetValue("point", out var outPoint) && outPoint != null)
@@ -62,10 +83,10 @@ public static partial class SdkUtility
             }
 
             Dictionary<string, object?>? point = null;
+            var matched = false;
             foreach (var candidate in op.Points)
             {
-                point = candidate;
-                var selectDef = Helpers.ToMapAny(StructUtils.GetProp(point, "select"));
+                var selectDef = Helpers.ToMapAny(StructUtils.GetProp(candidate, "select"));
                 var found = true;
 
                 if (selector != null && selectDef != null)
@@ -98,10 +119,52 @@ public static partial class SdkUtility
 
                 if (found)
                 {
+                    point = candidate;
+                    matched = true;
                     break;
                 }
             }
 
+            // select.exist can list more than the params needed to pick a
+            // point, so nothing matches — fall back to the entity's own
+            // route rather than the last point.
+            if (!matched)
+            {
+                // A request naming an action reaches here only because that
+                // action's own point failed its exist test, so it is
+                // unbuildable whatever we pick. Refuse it BEFORE choosing a
+                // fallback: the guard below compares the chosen point's
+                // $action and would wave the request through whenever the
+                // fallback lands on the action point itself.
+                var unmatchedAction = reqselector != null
+                    ? StructUtils.GetProp(reqselector, "$action") : null;
+                if (unmatchedAction != null)
+                {
+                    throw ctx.MakeError("point_action_invalid",
+                        "Operation \"" + op.Name +
+                        "\" action \"" + StructUtils.Stringify(unmatchedAction) +
+                        "\" is not valid.");
+                }
+
+                point = op.Points[0];
+                foreach (var candidate in op.Points)
+                {
+                    var candTerm = TerminalParam(candidate);
+                    var bestTerm = TerminalParam(point);
+                    if (candTerm != bestTerm)
+                    {
+                        if (candTerm)
+                        {
+                            point = candidate;
+                        }
+                    }
+                    else if (PartsLen(candidate) < PartsLen(point))
+                    {
+                        point = candidate;
+                    }
+                }
+            }
+
             if (reqselector != null)
             {
                 var reqAction = StructUtils.GetProp(reqselector, "$action");

package/project/.sdk/tm/dart/lib/feature/test/TestFeature.dart

@@ -214,10 +214,40 @@ class TestFeature extends BaseFeature {
     final param = ctx.utility.param;
 
     final opname = op.name;
-    final point = vs.getelem(
-        vs.getpath(ctx.config,
-            ['entity', _entname(ctx.entity), 'op', opname, 'points']),
-        -1);
+
+    // Pick the entity's own endpoint from config, not a cross-reference from
+    // another resource that also returns it — the same rule makePoint falls
+    // back to, so the seed-data query is built from the endpoint the request
+    // will actually be sent to: a terminal `{id}` marks a record route, and
+    // failing that the shallower path wins.
+    final points = vs.getpath(
+        ctx.config, ['entity', _entname(ctx.entity), 'op', opname, 'points']);
+    var point = vs.getelem(points, 0);
+    if (points is List) {
+      int pointPartsLen(dynamic p) {
+        final parts = vs.getprop(p, 'parts');
+        return parts is List ? parts.length : 0;
+      }
+
+      bool pointTerminalParam(dynamic p) {
+        final parts = vs.getprop(p, 'parts');
+        if (parts is! List || parts.isEmpty) {
+          return false;
+        }
+        final last = parts[parts.length - 1];
+        return last is String && last.startsWith('{');
+      }
+
+      for (final cand in points) {
+        if (pointTerminalParam(cand) != pointTerminalParam(point)) {
+          if (pointTerminalParam(cand)) {
+            point = cand;
+          }
+        } else if (pointPartsLen(cand) < pointPartsLen(point)) {
+          point = cand;
+        }
+      }
+    }
 
     final reqd = vs.transform(
       vs.select(vs.getpath(point, ['args', 'params']), {'reqd': true}),