@voxgig/sdkgen 3.5.1 → 3.7.0

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

@@ -3,9 +3,8 @@ import {
   Content,
   File,
   cmp,
+  configDefinition,
   each,
-  isAuthActive,
-  resolveAuthPrefix,
 } from '@voxgig/sdkgen'
 
 
@@ -16,11 +15,6 @@ import {
 } from '@voxgig/apidef'
 
 
-import {
-  clean,
-} from './utility_swift'
-
-
 // Generates core/Config.swift: the SdkConfig enum holding the generated model
 // config (makeConfig, materialised at runtime by parsing an embedded JSON
 // literal - pure data, so a JSON round-trip is faithful and avoids emitting
@@ -32,59 +26,19 @@ const Config = cmp(async function Config(props: any) {
 
   const model: Model = ctx$.model
 
-  const entity = getModelPath(model, `main.${KIT}.entity`)
   const feature = getModelPath(model, `main.${KIT}.feature`)
 
-  const headers = getModelPath(model, `main.${KIT}.config.headers`) || {}
-
-  const authActive = isAuthActive(model)
-  const authPrefix = resolveAuthPrefix(model)
-
-  let baseUrl = ''
-  try { baseUrl = getModelPath(model, `main.${KIT}.info.servers.0.url`) } catch (_e) { }
-
-  // Assemble the config object (pure JSON data).
-  const featureConfigs: any = {}
-  each(feature, (f: any) => {
-    featureConfigs[f.name] = f.config || {}
-  })
-
-  const optionsEntity: any = {}
-  each(entity, (ent: any) => {
-    optionsEntity[ent.name] = {}
-  })
-
-  const entityDefs: any = {}
-  each(entity, (ent: any) => {
-    entityDefs[ent.name] = clean({
-      fields: ent.fields,
-      name: ent.name,
-      op: ent.op,
-      relations: ent.relations,
-    }, true)
-  })
-
-  const options: any = {
-    base: baseUrl,
-    headers,
-    entity: optionsEntity,
-  }
-  if (authActive) {
-    options.auth = { prefix: authPrefix }
-  }
-
-  const configObj = {
-    main: { name: model.const.Name },
-    feature: featureConfigs,
-    options,
-    entity: entityDefs,
-  }
+  // The config as data, built by the shared helper so every target embeds
+  // the same model by construction. Passing target.name opts this target
+  // into main.slug / main.version / main.target (the three station
+  // descriptor identity fields, station design §4); swift has only the
+  // JSON-literal rep, so that one call covers every rep this target emits.
+  const { json } = configDefinition(model, target.name)
 
   // Model-data defaults may carry the ProjectName placeholder (e.g. the
   // clienttrack clientName); resolve it to the API name so the embedded JSON
   // matches the token-replaced runtime.
-  const configJson = JSON.stringify(configObj, null, 2)
-    .replace(/ProjectName/g, model.const.Name)
+  const configJson = json.replace(/ProjectName/g, model.const.Name)
 
   File({ name: 'Config.' + target.ext }, () => {
 

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

@@ -17,8 +17,30 @@ import type {
 // under Sources/ProjectNameSDK (the copied runtime + generated sources); the
 // test target compiles Tests/ProjectNameSDKTests. Directory names are the
 // verbatim copied paths (Copy does not rewrite path components); the target
-// NAMES carry the API name. Runtime is dependency-free (Foundation + the
-// vendored struct); target/feature deps, when declared, become SwiftPM deps.
+// NAMES carry the API name.
+//
+// Dependencies: the runtime itself is dependency-free (Foundation + the
+// vendored struct), but declared target/feature deps flow into the manifest
+// via collectDeps. SwiftPM cannot name a package by product alone, so a
+// swift deps entry carries its coordinates in a documented convention:
+//
+//   deps: swift: {
+//     'VoxgigStation': { active: true, version: '0.0.1', kind: prod,
+//       url: 'https://github.com/voxgig/station-swift' }
+//   }
+//
+//   - the entry KEY is the SwiftPM PRODUCT name (also the module the
+//     generated source imports);
+//   - the extra `url` field is the git repository SwiftPM resolves
+//     (`.package(url:from:)`); the package identity SwiftPM derives from it
+//     is the URL's last path component (minus any .git), which is what the
+//     `.product(name:package:)` reference must use;
+//   - `version` feeds `from:` - a plain semver (any leading range operator
+//     like '>=' is stripped, since `from:` already means >=).
+//
+// An entry WITHOUT a `url` is not expressible in a SwiftPM manifest (no
+// registry-less by-name dependencies), so it is skipped - unadorned entries
+// keep today's zero-dependency output.
 const Package = cmp(async function Package(props: any) {
   const ctx$ = props.ctx$
   const target = props.target
@@ -27,28 +49,48 @@ const Package = cmp(async function Package(props: any) {
 
   const Name = model.const.Name
 
-  const deps: Record<string, string> = {}
+  type SwiftDep = { product: string, url: string, from: string, identity: string }
+  const deps: SwiftDep[] = []
   for (const d of collectDeps(model, target.name, target.deps, ctx$.log)) {
-    deps[d.name] = d.source === 'target' ? (d.version || '0.0.0') : d.version
+    const url = 'string' === typeof (d.raw as any)?.url ? (d.raw as any).url : ''
+    if ('' === url) {
+      continue
+    }
+    const from = (d.version || '0.0.0').replace(/^[^0-9]+/, '')
+    const identity = (url.split('/').pop() || '').replace(/\.git$/, '')
+    deps.push({ product: d.name, url, from, identity })
   }
-  // Vendored, dependency-free by design; declared deps (if any) are ignored
-  // here since the runtime imports only Foundation + the in-tree struct.
+
+  const pkgdeps = 0 === deps.length ? '' :
+    '\n    dependencies: [\n' +
+    deps.map((d) =>
+      `        .package(url: "${d.url}", from: "${d.from}"),\n`).join('') +
+    '    ],'
+
+  const targetdeps = 0 === deps.length ? '' :
+    '\n            dependencies: [\n' +
+    deps.map((d) =>
+      `                .product(name: "${d.product}", package: "${d.identity}"),\n`)
+      .join('') +
+    '            ],'
 
   File({ name: 'Package.swift' }, () => {
     Content(`// swift-tools-version:5.9
 //
-// ${Name} SDK - SwiftPM manifest. Zero runtime dependencies (Foundation +
-// the vendored Voxgig Struct port under Sources/ProjectNameSDK/Struct).
+// ${Name} SDK - SwiftPM manifest. The runtime itself is dependency-free
+// (Foundation + the vendored Voxgig Struct port under
+// Sources/ProjectNameSDK/Struct); declared feature/target deps (if any)
+// appear below.
 import PackageDescription
 
 let package = Package(
     name: "${Name}Sdk",
     products: [
         .library(name: "${Name}Sdk", targets: ["${Name}Sdk"]),
-    ],
+    ],${pkgdeps}
     targets: [
         .target(
-            name: "${Name}Sdk",
+            name: "${Name}Sdk",${targetdeps}
             path: "Sources/ProjectNameSDK"),
         .testTarget(
             name: "${Name}SdkTests",

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/Config_ts.ts

@@ -81,7 +81,7 @@ const Config = cmp(async function Config(props: any) {
   // literal and the data that replaces it above the threshold are the same
   // config by construction. The JSON is what the threshold is measured on -
   // emitted source size varies by language, the model does not.
-  const { json: configJson } = configDefinition(model)
+  const { def: configDef, json: configJson } = configDefinition(model, target.name)
   const asData = isConfigData(configJson, configReprSetting(model))
 
   File({ name: 'Config.' + target.ext }, () => {
@@ -128,6 +128,14 @@ const Config = cmp(async function Config(props: any) {
             `'./feature/${f.name}/${nom(f, 'Name')}Feature'`)
         }),
 
+        // Values from configDefinition's def, not re-derived here, so the
+        // literal rep and the data rep cannot disagree on identity.
+        '// #MainMeta': () => {
+          Line(`    slug: ${JSON.stringify(configDef.main.slug)},`)
+          Line(`    version: ${JSON.stringify(configDef.main.version)},`)
+          Line(`    target: ${JSON.stringify(configDef.main.target)},`)
+        },
+
         '// #FeatureClasses': () => each(feature, (f: any) => {
           // Trailing comma: the map has one entry per feature, so entries
           // must be comma-separated (a single feature hid this until now).

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

@@ -21,7 +21,7 @@ import {
   File, Content,
 } from '@voxgig/sdkgen'
 
-import { canonToType, opTypeName, opRequestShape, warnEntityTypeCollisions , deriveEntityNames, opActions } from '@voxgig/sdkgen'
+import { canonToType, opTypeName, opRequestShape, warnEntityTypeCollisions , deriveEntityNames, opActions, tsSafeTypeName } from '@voxgig/sdkgen'
 
 import {
   KIT,
@@ -74,11 +74,14 @@ const EntityTypes = cmp(function EntityTypes(props: any) {
 
     entityList.forEach((ent: any) => {
       const Name = ent.Name
+      // A TS/JS global (Record, Array, Promise, ...) would shadow itself
+      // for the rest of the file — see tsSafeTypeName.
+      const TypeName = tsSafeTypeName(Name)
       const fields = (ent.fields ? each(ent.fields) : [])
         .filter((f: any) => f.active !== false)
 
       // Entity data model: one property per field, `req:false` -> optional.
-      Content(`export interface ${Name} {
+      Content(`export interface ${TypeName} {
 `)
       fields.forEach((f: any) => {
         const opt = false === f.req ? '?' : ''

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

@@ -4,7 +4,7 @@ import * as Path from 'node:path'
 import {
   cmp, each, camelify, names,
   File, Content, Folder, Fragment, Line, FeatureHook, Slot,
-  opTypeName, entityClassName, entityCollection,
+  opTypeName, entityClassName, entityCollection, tsSafeTypeName,
 } from '@voxgig/sdkgen'
 
 import {
@@ -33,9 +33,14 @@ const Entity = cmp(function Entity(props: any) {
 
   names(entrep, entity.Name, 'EntityName')
 
+  // A TS/JS global (Record, Array, Promise, ...) would shadow itself for
+  // the rest of the file — see tsSafeTypeName. The runtime `this.Name`
+  // string stays entity.Name; only the TYPE reference is ever renamed.
+  const dataType = tsSafeTypeName(entity.Name)
+
   // Import exactly the typed models this entity references: its data type plus
   // one request type per ACTIVE op (matches what EntityTypes_ts.ts emits).
-  const typeNames = [entity.Name]
+  const typeNames = [dataType]
   const opnamesAll = Object.keys(entity.op || {})
   ;['load', 'list', 'create', 'update', 'remove'].forEach((opname: string) => {
     if (opnamesAll.includes(opname)) {
@@ -69,6 +74,7 @@ const Entity = cmp(function Entity(props: any) {
           entityname: entity.name,
           SdkName: model.const.Name,
           EntityName: entity.Name,
+          EntityDataType: dataType,
 
           // Class token decoupled from the EntityName data-type token in
           // Entity.fragment.ts so the class can be renamed independently.

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/ts/fragment/Config.data.fragment.ts

@@ -34,6 +34,13 @@ class Config {
     return fi
   }
 
+  // False for a feature added at runtime via options.extend (station's
+  // adopt path) - the constructor uses this to skip makeFeature for names
+  // no generated class backs.
+  hasFeature(this: any, fn: string) {
+    return null != FEATURE_CLASS[fn]
+  }
+
 }
 
 

package/project/.sdk/src/cmp/ts/fragment/Config.fragment.ts

@@ -17,9 +17,17 @@ class Config {
     return fi
   }
 
+  // False for a feature added at runtime via options.extend (station's
+  // adopt path) - the constructor uses this to skip makeFeature for names
+  // no generated class backs.
+  hasFeature(this: any, fn: string) {
+    return null != FEATURE_CLASS[fn]
+  }
+
 
   main = {
     name: '$$const.Name$$',
+    // #MainMeta
   }
 
 

package/project/.sdk/src/cmp/ts/fragment/Entity.fragment.ts

@@ -18,7 +18,7 @@ import type {
 
 
 // TODO: needs Entity superclass
-class EntyClass extends ProjectNameEntityBase<EntityName> {
+class EntyClass extends ProjectNameEntityBase<EntityDataType> {
 
   constructor(client: ProjectNameSDK, entopts: any) {
     super(client, entopts)

package/project/.sdk/src/cmp/ts/fragment/Main.fragment.ts

@@ -52,18 +52,26 @@ class ProjectNameSDK {
     // the `test` feature installs the base mock transport and the transport
     // features (retry/cache/netsim/proxy/ratelimit) wrap whatever is current,
     // so `test` must be added before them to sit at the base of the chain.
+    const extend = this._options.extend || []
+
     const featureorder = getpath(this._options, '__derived__.featureorder') || []
     for (const fname of featureorder) {
       const fopts = this._options.feature[fname] || {}
       if (fopts.active) {
+        // An active name with no generated class is legal when an
+        // extend-supplied instance carries that name (station's adopt
+        // path): the instance is added below, positioned by its own
+        // __after__ entry, so skip it here rather than fail construction.
+        if (!this._rootctx.config.hasFeature(fname) &&
+          extend.some((f: any) => fname === f.name)) {
+          continue
+        }
         featureAdd(this._rootctx, this._rootctx.config.makeFeature(fname))
       }
     }
 
-    if (null != this._options.extend) {
-      for (let f of this._options.extend) {
-        featureAdd(this._rootctx, f)
-      }
+    for (let f of extend) {
+      featureAdd(this._rootctx, f)
     }
 
     for (let f of this._features) {

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/Makefile

@@ -7,7 +7,12 @@ CFLAGS ?= -std=c11 -Wall -Wextra -Wno-unused-parameter -D_GNU_SOURCE -O0 -g
 INC := -I core -I utility/struct
 LDLIBS := -lm
 
-LIB_SRCS := $(wildcard core/*.c utility/*.c utility/struct/*.c feature/*.c entity/*.c)
+# feature/*/*.c: a feature may carry a vendored library payload in its own
+# subdirectory (the station feature vendors voxgig_station there - C has no
+# package registry, so tier-C libraries ride the feature source; see
+# utility/struct/ for the same precedent at the utility level). Empty when
+# no feature ships one.
+LIB_SRCS := $(wildcard core/*.c utility/*.c utility/struct/*.c feature/*.c feature/*/*.c entity/*.c)
 LIB_OBJS := $(LIB_SRCS:.c=.o)
 
 TEST_SRCS := $(wildcard tests/*.c)

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

@@ -166,8 +166,19 @@ voxgig_value* make_options_util(Context* ctx) {
         if (has_test) {
           voxgig_list_push(voxgig_as_list(feature_order), v_str("test"));
         }
+        // Station special case, mirroring test's: its transport wrap must
+        // sit immediately outside the base transport (inside retry/cache/
+        // netsim), so map-form activation hoists it to just after test -
+        // or first, when no test entry exists. Without this the sorted
+        // default would init station last and wrap OUTSIDE the recording
+        // features, turning its wire-truth events into fiction.
         for (size_t i = 0; i < fn; i++) {
-          if (strcmp(names[i], "test") != 0) {
+          if (strcmp(names[i], "station") == 0) {
+            voxgig_list_push(voxgig_as_list(feature_order), v_str("station"));
+          }
+        }
+        for (size_t i = 0; i < fn; i++) {
+          if (strcmp(names[i], "test") != 0 && strcmp(names[i], "station") != 0) {
             voxgig_list_push(voxgig_as_list(feature_order), v_str(names[i]));
           }
         }

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"))