@voxgig/sdkgen 4.34.0 → 4.34.2

package/project/.sdk/tm/ts/src/Control.ts

@@ -6,11 +6,14 @@ class Control {
   throw?: boolean
   err?: any
   explain?: any
+  // Cancels the request in flight, which ts and js alone do so far.
+  signal?: AbortSignal
 
   constructor(ctrlmap: Record<string, any>) {
     this.throw = getprop(ctrlmap, 'throw')
     this.err = getprop(ctrlmap, 'err')
     this.explain = getprop(ctrlmap, 'explain')
+    this.signal = getprop(ctrlmap, 'signal')
   }
 }
 

package/project/.sdk/tm/ts/src/Response.ts

@@ -27,7 +27,16 @@ function readJson(resmap: Record<string, any>): Function {
   if ('function' === typeof resmap.text) {
     return async () => {
       const text = await resmap.text()
-      return '' === text.trim() ? undefined : JSON.parse(text)
+      if ('' === text.trim()) {
+        return undefined
+      }
+      try {
+        return JSON.parse(text)
+      }
+      catch (err: any) {
+        err.text = text
+        throw err
+      }
     }
   }
   return resmap.json ? resmap.json.bind(resmap) : async () => undefined

package/project/.sdk/tm/ts/src/Spec.ts

@@ -16,6 +16,9 @@ class Spec {
   body: any
   url?: string
   path?: string
+  // The query parameters prepareAuth placed: the credential, which the
+  // request sends and the entity's match leaves out.
+  authquery: string[]
 
   constructor(specmap: Record<string, any>) {
     this.parts = getprop(specmap, 'parts', [])
@@ -31,6 +34,7 @@ class Spec {
     this.body = getprop(specmap, 'body')
     this.url = getprop(specmap, 'url')
     this.path = getprop(specmap, 'path')
+    this.authquery = getprop(specmap, 'authquery', [])
   }
 }
 

package/project/.sdk/tm/ts/src/feature/base/BaseFeature.ts

@@ -40,6 +40,34 @@ class BaseFeature implements Feature {
 
   PreUnexpected(this: any, _ctx: any) { }
 
+
+  // Settles as `wait` does unless the signal aborts first, which runs `stop`
+  // and rejects with the signal's reason.
+  _untilAbort(this: any, wait: Promise<any>, signal?: any, stop?: () => void): Promise<any> {
+    if (null == signal) {
+      return wait
+    }
+    return new Promise((resolve, reject) => {
+      const abort = () => {
+        if (null != stop) {
+          stop()
+        }
+        reject(signal.reason)
+      }
+      if (signal.aborted) {
+        return abort()
+      }
+      signal.addEventListener('abort', abort, { once: true })
+      wait.then((value) => {
+        signal.removeEventListener('abort', abort)
+        resolve(value)
+      }, (err) => {
+        signal.removeEventListener('abort', abort)
+        reject(err)
+      })
+    })
+  }
+
 }
 
 

package/project/.sdk/tm/ts/src/feature/netsim/NetsimFeature.ts

@@ -46,7 +46,7 @@ class NetsimFeature extends BaseFeature {
 
     // Total outage: every call fails at the transport level.
     if (true === opts.offline) {
-      await this._sleep(this._pickLatency())
+      await this._sleep(this._pickLatency(), fetchdef?.signal)
       applied.offline = true
       this._track(ctx, applied)
       return ctx.error('netsim_offline', 'Simulated network offline (URL was: "' + url + '")')
@@ -54,7 +54,7 @@ class NetsimFeature extends BaseFeature {
 
     // Connection-level errors for the first N calls (e.g. ECONNRESET).
     if (call <= (opts.errorTimes | 0)) {
-      await this._sleep(this._pickLatency())
+      await this._sleep(this._pickLatency(), fetchdef?.signal)
       applied.error = true
       this._track(ctx, applied)
       return ctx.error('netsim_conn', 'Simulated connection error (call ' + call + ')')
@@ -62,7 +62,7 @@ class NetsimFeature extends BaseFeature {
 
     // Rate-limit responses (HTTP 429 + Retry-After) for the first N calls.
     if (call <= (opts.rateLimitTimes | 0)) {
-      await this._sleep(this._pickLatency())
+      await this._sleep(this._pickLatency(), fetchdef?.signal)
       applied.rateLimited = true
       this._track(ctx, applied)
       return this._respond(ctx, 429, undefined, {
@@ -77,7 +77,7 @@ class NetsimFeature extends BaseFeature {
     const failByEvery = 0 < (opts.failEvery | 0) && 0 === call % opts.failEvery
     const failByRate = 0 < (opts.failRate || 0) && this._rand() < opts.failRate
     if (failByCount || failByEvery || failByRate) {
-      await this._sleep(this._pickLatency())
+      await this._sleep(this._pickLatency(), fetchdef?.signal)
       applied.failStatus = failStatus
       this._track(ctx, applied)
       return this._respond(ctx, failStatus, undefined, { statusText: 'Simulated Failure' })
@@ -87,7 +87,7 @@ class NetsimFeature extends BaseFeature {
     const latency = this._pickLatency()
     applied.latency = latency
     this._track(ctx, applied)
-    await this._sleep(latency)
+    await this._sleep(latency, fetchdef?.signal)
     return inner(ctx, url, fetchdef)
   }
 
@@ -110,15 +110,17 @@ class NetsimFeature extends BaseFeature {
   }
 
 
-  _sleep(this: any, ms: number): Promise<void> {
+  _sleep(this: any, ms: number, signal?: any): Promise<void> {
     if (null == ms || 0 >= ms) {
       return Promise.resolve()
     }
     const sleep = this._options.sleep
     if ('function' === typeof sleep) {
-      return Promise.resolve(sleep(ms))
+      return this._untilAbort(Promise.resolve(sleep(ms)), signal)
     }
-    return new Promise((r) => setTimeout(r, ms))
+    let timer: any
+    return this._untilAbort(new Promise((r) => { timer = setTimeout(r, ms) }), signal,
+      () => clearTimeout(timer))
   }
 
 

package/project/.sdk/tm/ts/src/feature/ratelimit/RatelimitFeature.ts

@@ -34,13 +34,13 @@ class RatelimitFeature extends BaseFeature {
     const inner = utility.fetcher
 
     utility.fetcher = async function (ctx2: any, url: string, fetchdef: any) {
-      await self._acquire(ctx2)
+      await self._acquire(ctx2, fetchdef?.signal)
       return inner(ctx2, url, fetchdef)
     }
   }
 
 
-  async _acquire(this: any, ctx: any): Promise<void> {
+  async _acquire(this: any, ctx: any, signal?: any): Promise<void> {
     const rate = this._options.rate || 5
     const burst = null == this._options.burst ? rate : this._options.burst
 
@@ -59,7 +59,7 @@ class RatelimitFeature extends BaseFeature {
     const needed = 1 - this._tokens
     const waitMs = Math.ceil((needed / rate) * 1000)
     this._track(ctx, waitMs)
-    await this._sleep(waitMs)
+    await this._sleep(waitMs, signal)
     this._last = this._now()
     this._tokens = 0
   }
@@ -74,15 +74,17 @@ class RatelimitFeature extends BaseFeature {
   }
 
 
-  _sleep(this: any, ms: number): Promise<void> {
+  _sleep(this: any, ms: number, signal?: any): Promise<void> {
     if (null == ms || 0 >= ms) {
       return Promise.resolve()
     }
     const sleep = this._options.sleep
     if ('function' === typeof sleep) {
-      return Promise.resolve(sleep(ms))
+      return this._untilAbort(Promise.resolve(sleep(ms)), signal)
     }
-    return new Promise((r) => setTimeout(r, ms))
+    let timer: any
+    return this._untilAbort(new Promise((r) => { timer = setTimeout(r, ms) }), signal,
+      () => clearTimeout(timer))
   }
 
 

package/project/.sdk/tm/ts/src/feature/retry/RetryFeature.ts

@@ -40,6 +40,7 @@ class RetryFeature extends BaseFeature {
     const maxDelay = null == opts.maxDelay ? 2000 : opts.maxDelay
     const factor = null == opts.factor ? 2 : opts.factor
 
+    const signal = fetchdef?.signal
     let attempt = 0
     let last: any
 
@@ -56,6 +57,12 @@ class RetryFeature extends BaseFeature {
 
       last = res
 
+      // An abort is never retried, whatever the transport threw for it: the
+      // reason need not be an Error, so decide before the retryable test.
+      if (threw && true === signal?.aborted) {
+        throw signal.reason
+      }
+
       const retryable = this._retryable(res)
       if (!retryable || attempt >= max) {
         // Out of attempts: rethrow a thrown error to preserve pipeline
@@ -66,9 +73,13 @@ class RetryFeature extends BaseFeature {
         return res
       }
 
+      if (true === signal?.aborted) {
+        throw signal.reason
+      }
+
       const wait = this._backoff(res, attempt, minDelay, maxDelay, factor)
       this._track(ctx, attempt + 1, res, wait)
-      await this._sleep(wait)
+      await this._sleep(wait, signal)
       attempt++
     }
   }
@@ -121,15 +132,17 @@ class RetryFeature extends BaseFeature {
   }
 
 
-  _sleep(this: any, ms: number): Promise<void> {
+  _sleep(this: any, ms: number, signal?: any): Promise<void> {
     if (null == ms || 0 >= ms) {
       return Promise.resolve()
     }
     const sleep = this._options.sleep
     if ('function' === typeof sleep) {
-      return Promise.resolve(sleep(ms))
+      return this._untilAbort(Promise.resolve(sleep(ms)), signal)
     }
-    return new Promise((r) => setTimeout(r, ms))
+    let timer: any
+    return this._untilAbort(new Promise((r) => { timer = setTimeout(r, ms) }), signal,
+      () => clearTimeout(timer))
   }
 
 

package/project/.sdk/tm/ts/src/feature/test/TestFeature.ts

@@ -22,7 +22,7 @@ function mintId(): string {
 function ownIdField(config: any, getpath: any, entityName: string): string {
   let fallback = ''
 
-  for (const opname of ['load', 'remove', 'update']) {
+  for (const opname of ['load', 'remove', 'update', 'patch']) {
     const points = getpath(config, ['entity', entityName, 'op', opname, 'points']) || []
     const canonical = points.filter((pt: any) =>
       null == (pt && pt.select && pt.select['$action']))
@@ -66,6 +66,28 @@ function ownIdField(config: any, getpath: any, entityName: string): string {
 }
 
 
+// The record the mock keeps: the request data without `$body`, which only the
+// wire carries.
+function recordOf(reqdata: any): any {
+  const out = { ...(reqdata || {}) }
+  delete out.$body
+  return out
+}
+
+
+// The key a list response wraps each record under, where the response
+// transform is `["`$EACH`", "body", { "`$MERGE`": "`.<key>`" }]`.
+function itemEnvelopeKey(restf: any): string | null {
+  if (!Array.isArray(restf) || 3 !== restf.length ||
+    '`$EACH`' !== restf[0] || 'body' !== restf[1]) {
+    return null
+  }
+  const merge = restf[2]?.['`$MERGE`']
+  const m = 'string' === typeof merge ? merge.match(/^`\.([^.`$]+)`$/) : null
+  return null == m ? null : m[1]
+}
+
+
 class TestFeature extends BaseFeature {
   version = '0.0.1'
   name = 'test'
@@ -118,6 +140,10 @@ class TestFeature extends BaseFeature {
 
       function envelope(data: any) {
         const restf = getprop(getprop(ctx.point, 'transform', {}), 'res')
+        const itemkey = itemEnvelopeKey(restf)
+        if (null != itemkey && Array.isArray(data)) {
+          return data.map((item: any) => ({ [itemkey]: item }))
+        }
         if (null == data || 'string' !== typeof restf) {
           return data
         }
@@ -188,8 +214,8 @@ class TestFeature extends BaseFeature {
           return respond(200, out)
         }
       }
-      else if ('update' === op.name) {
-        const args = self.buildArgs(ctx, op, ctx.reqdata)
+      else if ('update' === op.name || 'patch' === op.name) {
+        const args = self.buildArgs(ctx, op, recordOf(ctx.reqdata))
         const found = select(entmap, args)
         const ent = getelem(found, 0)
         if (null == ent) {
@@ -197,7 +223,7 @@ class TestFeature extends BaseFeature {
           return respond(404, undefined, { statusText: S_NOT_FOUND })
         }
         else {
-          merge([ent, (ctx.reqdata || {})])
+          merge([ent, recordOf(ctx.reqdata)])
           delprop(ent, '$KEY')
           const out = clone(ent)
           return respond(200, out)
@@ -215,13 +241,13 @@ class TestFeature extends BaseFeature {
         return respond(200)
       }
       else if ('create' === op.name) {
-        const args = self.buildArgs(ctx, op, ctx.reqdata)
+        const args = self.buildArgs(ctx, op, recordOf(ctx.reqdata))
         let id = param(ctx, 'id')
         if (null == id) {
           id = mintId()
         }
 
-        const ent = clone(ctx.reqdata)
+        const ent = clone(recordOf(ctx.reqdata))
         setprop(ent, 'id', id)
 
         // A record created during the run needs the same real-key seeding
@@ -268,10 +294,12 @@ class TestFeature extends BaseFeature {
       return max <= min ? min : min + ((max - min) >> 1)
     }
 
-    function sleep(ms: number): Promise<void> {
+    function sleep(ms: number, signal?: any): Promise<void> {
       if (null == ms || 0 >= ms) { return Promise.resolve() }
-      if ('function' === typeof net.sleep) { return Promise.resolve(net.sleep(ms)) }
-      return new Promise((r) => setTimeout(r, ms))
+      if ('function' === typeof net.sleep) { return self._untilAbort(Promise.resolve(net.sleep(ms)), signal) }
+      let timer: any
+      return self._untilAbort(new Promise((r) => { timer = setTimeout(r, ms) }), signal,
+        () => clearTimeout(timer))
     }
 
     return async function netsimFetcher(ctx: any, url: string, fetchdef: any) {
@@ -279,15 +307,15 @@ class TestFeature extends BaseFeature {
       const call = self._netcalls
 
       if (true === net.offline) {
-        await sleep(pickLatency())
+        await sleep(pickLatency(), fetchdef?.signal)
         return ctx.error('netsim_offline', 'Simulated network offline (URL was: "' + url + '")')
       }
       if (call <= (net.errorTimes | 0)) {
-        await sleep(pickLatency())
+        await sleep(pickLatency(), fetchdef?.signal)
         return ctx.error('netsim_conn', 'Simulated connection error (call ' + call + ')')
       }
       if (call <= (net.failTimes | 0)) {
-        await sleep(pickLatency())
+        await sleep(pickLatency(), fetchdef?.signal)
         const status = null == net.failStatus ? 503 : net.failStatus
         return {
           status,
@@ -297,7 +325,7 @@ class TestFeature extends BaseFeature {
           headers: { forEach(_cb: any) { }, get(_k: string) { return undefined } },
         }
       }
-      await sleep(pickLatency())
+      await sleep(pickLatency(), fetchdef?.signal)
       return inner(ctx, url, fetchdef)
     }
   }

package/project/.sdk/tm/ts/src/feature/timeout/TimeoutFeature.ts

@@ -7,9 +7,9 @@ import { BaseFeature } from '../base/BaseFeature'
 
 // Per-request timeout. Wraps the active transport and races each attempt
 // against a deadline; if the deadline wins, the request resolves to a
-// timeout error instead of hanging. An `AbortController` is signalled (via
-// `fetchdef.signal`) so a live `fetch` is actually cancelled, while the
-// mock transport simply loses the race.
+// timeout error instead of hanging. The `AbortController` behind
+// `fetchdef.signal` cancels a live `fetch` at the deadline or at the caller's
+// own abort, while the mock transport simply loses the race.
 class TimeoutFeature extends BaseFeature {
   version = '0.0.1'
   name = 'timeout'
@@ -46,9 +46,20 @@ class TimeoutFeature extends BaseFeature {
 
     // Attach an abort signal so a real fetch can be cancelled on timeout.
     let controller: any
+    const caller = fetchdef.signal
+    let follow: any
     if ('function' === typeof (globalThis as any).AbortController) {
       controller = new (globalThis as any).AbortController()
       fetchdef = { ...fetchdef, signal: controller.signal }
+      if (null != caller) {
+        follow = () => controller.abort(caller.reason)
+        if (caller.aborted) {
+          follow()
+        }
+        else {
+          caller.addEventListener('abort', follow, { once: true })
+        }
+      }
     }
 
     let timer: any
@@ -84,6 +95,9 @@ class TimeoutFeature extends BaseFeature {
       else if (null != timer) {
         clearTimeout(timer)
       }
+      if (null != follow) {
+        caller.removeEventListener('abort', follow)
+      }
     }
   }
 

package/project/.sdk/tm/ts/src/feature/validate/ValidateFeature.ts

@@ -123,6 +123,8 @@ class ValidateFeature extends BaseFeature {
     // fields will never name it — and under `strict` every custom-action
     // call would be rejected for the one key that made it reachable.
     delete out.$action
+    // Nor is `$body`, the raw request body.
+    delete out.$body
 
     return out
   }

package/project/.sdk/tm/ts/src/tsconfig.json

@@ -12,6 +12,7 @@
     "target": "es2022",
     "types": ["node"],
     "declaration": true,
-    "declarationDir": "../dist"
+    "declarationDir": "../dist",
+    "composite": true
   }
 }

package/project/.sdk/tm/ts/src/utility/CleanUtility.ts

@@ -236,7 +236,7 @@ function clean(ctx: Context, val: any) {
   }
 
   if (val instanceof Error) {
-    val.message = cleanString(cfg, String(val.message))
+    setMessage(val, cleanString(cfg, String(val.message)))
     if ('string' === typeof val.stack) {
       val.stack = cleanString(cfg, val.stack)
     }
@@ -261,6 +261,29 @@ function clean(ctx: Context, val: any) {
 }
 
 
+// Assigned where assignment works. A DOMException's message is an inherited
+// getter with no setter, which strict code cannot assign, so it is defined
+// on the instance; an own message that can be neither is left as it is.
+function setMessage(err: any, text: string): void {
+  let owner = err
+  let desc = Object.getOwnPropertyDescriptor(owner, 'message')
+  while (null == desc && null != (owner = Object.getPrototypeOf(owner))) {
+    desc = Object.getOwnPropertyDescriptor(owner, 'message')
+  }
+  if (null == desc || desc.writable || null != desc.set) {
+    err.message = text
+  }
+  else if (owner !== err || desc.configurable) {
+    Object.defineProperty(err, 'message', {
+      value: text,
+      writable: true,
+      enumerable: owner === err && !!desc.enumerable,
+      configurable: true,
+    })
+  }
+}
+
+
 function cleanKey(ctx: Context, key: any): boolean {
   return sensitiveKey(cleanConfig(ctx), key)
 }
@@ -298,5 +321,6 @@ export {
   cleanAddSensitive,
   cleanKey,
   makeCleanConfig,
+  setMessage,
   splitvalues,
 }

package/project/.sdk/tm/ts/src/utility/FetcherUtility.ts

@@ -1,6 +1,26 @@
 
 import { Context, Response } from '../types'
 
+
+// Several CDNs refuse a library's own agent, so outside a browser a request
+// without one carries the browser-shaped agent most other targets send.
+const DEFAULT_USER_AGENT = 'Mozilla/5.0 (compatible; ProjectNameSDK/1.0)'
+
+
+function defaultUserAgent(fetchdef: Record<string, any>) {
+  if (null == (globalThis as any).process?.versions?.node) {
+    return
+  }
+  const headers = fetchdef.headers = fetchdef.headers || {}
+  for (const name of Object.keys(headers)) {
+    if ('user-agent' === name.toLowerCase()) {
+      return
+    }
+  }
+  headers['user-agent'] = DEFAULT_USER_AGENT
+}
+
+
 // Make HTTP call using library. Replace this utility for mocking etc.
 async function fetcher(
   ctx: Context,
@@ -24,6 +44,8 @@ async function fetcher(
 
   const fetch = options.system.fetch
 
+  defaultUserAgent(fetchdef)
+
   const response = await fetch(fullurl, fetchdef)
 
   return response
@@ -31,5 +53,6 @@ async function fetcher(
 
 
 export {
-  fetcher
+  fetcher,
+  DEFAULT_USER_AGENT,
 }

package/project/.sdk/tm/ts/src/utility/MakeErrorUtility.ts

@@ -2,7 +2,7 @@
 import { Result, Context } from '../types'
 
 
-import { clean } from './CleanUtility'
+import { clean, setMessage } from './CleanUtility'
 
 import { clone, delprop } from './StructUtility'
 
@@ -31,7 +31,7 @@ function makeError(ctx: Context, err?: any) {
   }
 
   const errmsg = err.message || 'unknown error'
-  err.message = 'ProjectNameSDK: ' + op.name + ': ' + errmsg
+  setMessage(err, 'ProjectNameSDK: ' + op.name + ': ' + errmsg)
 
   // Reachable for a debugger, invisible to a serialiser.
   if (null != err.ctx) {

package/project/.sdk/tm/ts/src/utility/MakeFetchDefUtility.ts

@@ -1,6 +1,8 @@
 
 import { Context, Result } from '../types'
 
+import { isJsonRequest, isRawValue, isStream } from './MediaUtility'
+
 
 function makeFetchDef(ctx: Context): any | Error {
   const spec = ctx.spec
@@ -32,9 +34,20 @@ function makeFetchDef(ctx: Context): any | Error {
     headers: spec.headers,
   }
 
+  if (null != ctx.ctrl?.signal) {
+    fetchdef.signal = ctx.ctrl.signal
+  }
+
   if (null != spec.body) {
-    fetchdef.body =
-      'object' === typeof spec.body ? jsonify(spec.body) : spec.body
+    const body = spec.body
+    // A JSON point's body is JSON whatever its value; a scalar elsewhere goes as given.
+    fetchdef.body = isRawValue(body) || ('object' !== typeof body && !isJsonRequest(ctx.point)) ?
+      body : jsonify(body)
+
+    // Node's fetch refuses a stream body without it.
+    if (isStream(body)) {
+      fetchdef.duplex = 'half'
+    }
   }
 
   return fetchdef

package/project/.sdk/tm/ts/src/utility/MakeOptionsUtility.ts

@@ -124,16 +124,16 @@ function makeOptions(ctx: Context) {
 }
 
 
-// Registration skips entity blocks: entity settings and seed records hold no credential.
+// Registration skips entity blocks, and rbac's rules, keyed by entity and op names.
 function settings(opts: any): any {
-  const noent = (b: any) => null != b && 'object' === typeof b && !Array.isArray(b)
-    ? { ...b, entity: undefined } : b
-  const feature = Array.isArray(opts.feature) ? opts.feature.map(noent)
+  const plain = (b: any, name?: string) => null != b && 'object' === typeof b && !Array.isArray(b)
+    ? { ...b, entity: undefined, ...('rbac' === name ? { rules: undefined } : {}) } : b
+  const feature = Array.isArray(opts.feature) ? opts.feature.map((b: any) => plain(b, b?.name))
     : null != opts.feature && 'object' === typeof opts.feature
-      ? Object.fromEntries(Object.entries(opts.feature).map(([k, v]) => [k, noent(v)]))
+      ? Object.fromEntries(Object.entries(opts.feature).map(([k, v]) => [k, plain(v, k)]))
       : opts.feature
   return { ...opts, clean: undefined, __derived__: undefined, entity: undefined,
-    test: noent(opts.test), feature }
+    test: plain(opts.test), feature }
 }
 
 

package/project/.sdk/tm/ts/src/utility/MakePointUtility.ts

@@ -1,6 +1,9 @@
 
 import { Context, Point } from '../types'
 
+import { paramValue } from './ParamUtility'
+import { allowed } from './PrepareMethodUtility'
+
 
 function terminalParam(point: any): boolean {
   const parts = point.parts
@@ -26,6 +29,22 @@ function ownPoint(points: any[]): any {
 }
 
 
+// The path parameters of a point that neither the call nor the entity gives a
+// value for, looked up as prepareParams looks them up.
+function unfilled(ctx: Context, point: any): string[] {
+  const missing: string[] = []
+
+  for (const part of (point.parts || [])) {
+    const name = /^\{([^{}\/]+)\}$/.exec(String(part))?.[1]
+    if (null != name && null == paramValue(ctx, point, name)) {
+      missing.push(name)
+    }
+  }
+
+  return missing
+}
+
+
 function makePoint(ctx: Context): Point | Error {
   if (ctx.out.point) {
     return ctx.point = ctx.out.point
@@ -35,7 +54,7 @@ function makePoint(ctx: Context): Point | Error {
   const op = ctx.op
   const options = ctx.options
 
-  if (!options.allow.op.includes(op.name)) {
+  if (!allowed(options.allow.op, op.name)) {
     return ctx.error('point_op_allow', 'Operation "' + op.name +
       '" not allowed by SDK option allow.op value: "' + options.allow.op + '"')
   }
@@ -93,7 +112,24 @@ function makePoint(ctx: Context): Point | Error {
           '" action "' + reqselector.$action + '" is not valid.')
       }
 
-      point = ownPoint(op.points)
+      // A call without an action falls back to a point without one, as
+      // generation does, and only to a route the call can fill.
+      const plain = op.points.filter((cand: any) => null == cand.select?.$action)
+
+      if (0 === plain.length) {
+        return ctx.error('point_action_required', 'Operation "' + op.name +
+          '" has only action endpoints; pass $action to choose one.')
+      }
+
+      const fillable = plain.filter((cand: any) => 0 === unfilled(ctx, cand).length)
+
+      if (0 === fillable.length) {
+        return ctx.error('point_no_match', 'Operation "' + op.name +
+          '" has no endpoint whose path parameters are all given (missing: ' +
+          unfilled(ctx, ownPoint(plain)).join(', ') + ').')
+      }
+
+      point = ownPoint(fillable)
     }
 
     if (