@voxgig/sdkgen 4.21.0 → 4.22.0

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

@@ -5,14 +5,6 @@ import type { ProjectNameSDK } from '../../ProjectNameSDK'
 import { BaseFeature } from '../base/BaseFeature'
 
 
-// Network behaviour simulation. Wraps the active transport (the live
-// `fetch` or the `test` feature's in-memory mock) and injects realistic
-// network conditions so offline unit tests can exercise slowness,
-// transient failures, rate limiting and outages deterministically.
-//
-// Every injection mode is counter-driven (per client instance) so tests
-// are reproducible without mocking timers. `failRate` adds optional
-// pseudo-random failures via a seeded LCG for coverage-style testing.
 class NetsimFeature extends BaseFeature {
   version = '0.0.1'
   name = 'netsim'

package/project/.sdk/tm/ts/src/feature/paging/PagingFeature.ts

@@ -5,14 +5,6 @@ import type { ProjectNameSDK } from '../../ProjectNameSDK'
 import { BaseFeature } from '../base/BaseFeature'
 
 
-// Pagination support for list operations. On the way out (PreRequest) it
-// stamps page/limit (or a cursor) into the request query; on the way back
-// (PreResult) it reads the server's pagination signals — a `Link:
-// rel="next"` header, `X-Next-Page`/`X-Total-Count` headers, or `next`/
-// `cursor`/`hasMore` fields in the body — and records them on
-// `ctx.result.paging`. Generated SDKs build auto-iteration on top of this
-// (advance the cursor/page and re-issue the list call until `hasMore` is
-// false). Parameter names and page size are configurable.
 class PagingFeature extends BaseFeature {
   version = '0.0.1'
   name = 'paging'
@@ -45,7 +37,6 @@ class PagingFeature extends BaseFeature {
     const limitParam = this._options.limitParam || 'limit'
     const cursorParam = this._options.cursorParam || 'cursor'
 
-    // A per-call cursor/page from ctrl takes priority (used by auto-iteration).
     const paging = (ctx.ctrl && ctx.ctrl.paging) || {}
 
     // GraphQL paginates through operation VARIABLES, not the query string.
@@ -94,7 +85,6 @@ class PagingFeature extends BaseFeature {
       hasMore: false,
     }
 
-    // Link: <...>; rel="next"
     const link = this._header(headers, 'link')
     if (null != link) {
       const m = /<([^>]+)>\s*;\s*rel="?next"?/i.exec(link)
@@ -126,7 +116,6 @@ class PagingFeature extends BaseFeature {
       }
     }
 
-    // Body-level cursors.
     if (body && 'object' === typeof body) {
       if (null != body.next) { paging.next = paging.next || body.next }
       if (null != body.cursor) { paging.cursor = body.cursor }
@@ -171,8 +160,6 @@ class PagingFeature extends BaseFeature {
     const afterVar = this._options.afterVar || 'after'
     const firstVar = this._options.firstVar || 'first'
 
-    // Only bind variables the operation actually declares, or the server
-    // rejects the document.
     const declared: Record<string, boolean> = {}
     for (const v of ((point.graphql && point.graphql.vars) || [])) {
       declared[v.name] = true

package/project/.sdk/tm/ts/src/feature/proxy/ProxyFeature.ts

@@ -5,14 +5,6 @@ import type { ProjectNameSDK } from '../../ProjectNameSDK'
 import { BaseFeature } from '../base/BaseFeature'
 
 
-// Outbound HTTP(S) proxy support. Wraps the active transport and attaches
-// proxy routing to each request's fetch definition. The proxy target comes
-// from options (`url`) or, when `fromEnv` is set, the standard
-// HTTPS_PROXY / HTTP_PROXY / NO_PROXY environment variables. Constructing a
-// concrete agent/dispatcher is dependency-specific, so a factory may be
-// supplied via `options.agent` (e.g. wrapping undici's ProxyAgent); when
-// absent the request is annotated with `fetchdef.proxy` for the transport
-// to honour. Hosts matching `noProxy` bypass the proxy.
 class ProxyFeature extends BaseFeature {
   version = '0.0.1'
   name = 'proxy'

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

@@ -5,12 +5,6 @@ import type { ProjectNameSDK } from '../../ProjectNameSDK'
 import { BaseFeature } from '../base/BaseFeature'
 
 
-// Client-side rate limiting via a token bucket. Each request consumes a
-// token; when the bucket is empty the request waits until the bucket
-// refills at `rate` tokens per second (with capacity `burst`). This keeps
-// the client under a server's published quota rather than discovering it
-// via 429s. The clock (`now`) and the wait (`sleep`) are injectable so the
-// accounting can be tested deterministically without wall-clock timing.
 class RatelimitFeature extends BaseFeature {
   version = '0.0.1'
   name = 'ratelimit'

package/project/.sdk/tm/ts/src/feature/rbac/RbacFeature.ts

@@ -5,14 +5,6 @@ import type { ProjectNameSDK } from '../../ProjectNameSDK'
 import { BaseFeature } from '../base/BaseFeature'
 
 
-// Client-side role/permission enforcement. Before an operation resolves its
-// endpoint, the required permission for that entity+operation is checked
-// against the permissions the client holds; a disallowed call is
-// short-circuited with an `rbac_denied` error and never touches the
-// network. Required permissions come from `rules` (keyed by
-// `<entity>.<op>`, `<op>`, or `*`); the default when no rule matches is
-// controlled by `deny` (default: allow when unspecified). Held permissions
-// are the `permissions` list (a `*` grants everything).
 class RbacFeature extends BaseFeature {
   version = '0.0.1'
   name = 'rbac'
@@ -43,7 +35,6 @@ class RbacFeature extends BaseFeature {
 
     const required = this._required(ctx)
     if (null == required) {
-      // No rule: honour the default policy.
       if (true === this._options.deny) {
         return this._reject(ctx, '<default-deny>')
       }

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

@@ -5,12 +5,6 @@ import type { ProjectNameSDK } from '../../ProjectNameSDK'
 import { BaseFeature } from '../base/BaseFeature'
 
 
-// Automatic retry of transient failures with exponential backoff and
-// jitter. Wraps the active transport so a single operation call may make
-// several HTTP attempts. A failure is retryable when the transport throws
-// / returns an Error, or responds with a status in `statuses`
-// (default: 408, 425, 429, 500, 502, 503, 504). An HTTP 429/503 with a
-// `Retry-After` header overrides the computed backoff.
 class RetryFeature extends BaseFeature {
   version = '0.0.1'
   name = 'retry'

package/project/.sdk/tm/ts/src/feature/secrets/SecretsFeature.ts

@@ -10,39 +10,6 @@ import { Sekreto, envkey } from './sekreto'
 import { FEATURE_PLUGINS } from '../../Config'
 
 
-// Secret access via a vendored @voxgig/sekreto provider chain, and the
-// access-token exchange some APIs require on top of it.
-//
-// The SDK's `apikey` option keeps exactly its old meaning: an explicit
-// credential given in code. This feature makes it ONE SOURCE among several
-// rather than the only one: when active, the apikey is resolved through a
-// sekreto chain in which the explicit option (when set) is the FIRST
-// provider — a `memory` store named `options` — so an explicit value always
-// wins, by sekreto's own first-hit rule rather than by special-case logic.
-// When the option is unset, the remaining providers (env, dotenv, a vault)
-// are asked in order, and moving a credential from code to a vault becomes
-// a configuration change.
-//
-// SOME APIs will not take a long-lived credential at all. What the chain
-// resolves is then a REFRESH token, which buys a short-lived ACCESS token
-// from a token endpoint; the access token is what every request carries,
-// and it expires. `exchange.active` turns that round trip on: the resolved
-// secret is POSTed to `exchange.path` (relative to options.base), the
-// access token from the response is written to options.apikey, and a
-// response in `exchange.statuses` (401) buys another and retries once.
-//
-// That last part is why this feature wraps the transport. Expiry is only
-// ever discovered from a RESPONSE, and the transport is the one place a
-// response can be seen before the operation pipeline turns it into a
-// result. With the exchange off, nothing is wrapped.
-//
-// Resolution is ASYNC (providers may do IO), but the auth header is built
-// by the synchronous prepareAuth inside makeSpec. The bridge is the
-// feature hook pipeline: every entity op awaits featureHook('PreSpec')
-// before calling makeSpec, so the PreSpec hook below resolves the secret
-// once and writes it into the live options where prepareAuth already
-// looks. prepareAuth itself is untouched. SolardemoSDK.prepare() bypasses
-// feature hooks entirely, so it awaits client._secrets.resolve() itself.
 class SecretsFeature extends BaseFeature {
   version = '0.1.0'
   name = 'secrets'
@@ -53,16 +20,11 @@ class SecretsFeature extends BaseFeature {
   _resolving?: Promise<void>
   _cache: boolean = true
 
-  // Exchange state. `_exchange` is the resolved config (null when off),
-  // `_refresh` the credential the chain gave us, and `_buying` the single
-  // in-flight token purchase concurrent callers share.
   _exchange: any = null
   _refresh?: string
   _buying?: Promise<string>
 
 
-  // Sync by contract (the constructor cannot await): build the chain only,
-  // never look anything up here.
   init(ctx: Context, fopts: FeatureOptions): void {
     const client = ctx.client
     const options = ctx.options
@@ -71,8 +33,6 @@ class SecretsFeature extends BaseFeature {
     this._secretname = 'string' === typeof (fopts as any).name &&
       '' !== (fopts as any).name ? (fopts as any).name : 'apikey'
 
-    // Exchange config, normalised once. Null when off, so every later
-    // decision is a null check rather than a repeated `true === ...active`.
     const xopts = (fopts as any).exchange
     this._exchange = (null != xopts && true === xopts.active) ? {
       path: 'string' === typeof xopts.path ? xopts.path : 'auth/token',
@@ -85,14 +45,6 @@ class SecretsFeature extends BaseFeature {
 
     const providers: any[] = []
 
-    // The explicit credential, when set, is the first store in the chain.
-    //
-    // WHICH option that is depends on the exchange. Without one, the secret
-    // being resolved IS the credential the transport sends, so `apikey` is
-    // it. With one, the secret is a REFRESH token and `apikey` means the
-    // opposite thing — an access token the caller already holds — so the
-    // explicit seat belongs to `exchange.refresh`, and apikey is left alone
-    // to serve as the starting access token (see resolve below).
     const explicit = null == this._exchange ?
       options.apikey :
       (null == xopts ? undefined : xopts.refresh)
@@ -117,19 +69,8 @@ class SecretsFeature extends BaseFeature {
       cache: this._cache,
     })
 
-    // Seam for ProjectNameSDK.prepare() (no feature hooks on that path)
-    // and for the public secrets() accessor.
-    //
-    // Cast, because `_secrets` is emitted on the SDK class only when this
-    // feature is active, while this file is copied into the target tree by
-    // Main's blanket copy whether or not the model declares the feature.
-    // Typing the assignment would make the SDK fail to compile in exactly
-    // the case the feature is switched off.
     ;(client as any)._secrets = this
 
-    // Wrap the transport ONLY when there is an exchange to defend. A spent
-    // access token is discovered from the response, and this is the one
-    // place a response can be seen and the request tried again.
     if (null != this._exchange) {
       const self = this
       const utility = ctx.utility
@@ -142,15 +83,6 @@ class SecretsFeature extends BaseFeature {
   }
 
 
-  // The LIVE Sekreto instance, for the SDK's secrets() accessor and for
-  // callers who want arbitrary secrets or redaction:
-  //
-  //   await sdk.secrets().get('db.password')
-  //   sdk.secrets().redact(logline)
-  //
-  // Public, so the accessor does not have to reach into a private field.
-  // Never a clone: sekreto holds provider state (caches, vault leases)
-  // that has to stay live to be worth anything.
   sekreto(): any {
     return this._sekreto
   }
@@ -161,25 +93,6 @@ class SecretsFeature extends BaseFeature {
   }
 
 
-  // Resolve the apikey before the first request. Concurrent ops share the
-  // one IN-FLIGHT promise; a settled one is not reused unless caching is
-  // on. A provider ERROR (unreachable vault, bad creds) rejects and fails
-  // the op — sekreto's miss-vs-error rule: never fall through to an
-  // unauthenticated request because a store was broken.
-  //
-  // The promise is cleared on REJECTION, after success when caching is off,
-  // and after a MISS however caching is set. Holding a settled promise
-  // forever would mean a transient vault outage poisoned the client
-  // permanently — every later operation failing with the original error long
-  // after the vault recovered — and it would make the documented
-  // `cache: false` a lie, since the chain would never be asked a second time.
-  //
-  // The MISS rule is sekreto's, not this feature's: `A miss is never cached:
-  // the next read asks again`, in sekreto's own source. Retaining a settled
-  // miss here would override that from the layer above, and a secret
-  // provisioned after startup — a mounted file, a policy granted a minute
-  // late — would never be picked up for the life of the client. `cache` is
-  // about caching a HIT; it was never a promise to keep saying no.
   resolve(): Promise<void> {
     if (null == this._resolving) {
       const inflight = this._resolveonce()
@@ -235,13 +148,6 @@ class SecretsFeature extends BaseFeature {
       return true
     }
 
-    // `auth: null` is the documented way to send NO credential, and a
-    // purchase is a credential-bearing call: the refresh token goes to the
-    // token endpoint in the request body. _withRefresh honours suppression
-    // for the RETRY, but it runs after this — by then the refresh token has
-    // already left the process, and no later check can call it back. The
-    // suppression has to be honoured here, before the first purchase, or it
-    // only ever half-held.
     if (null == this._client.options().auth) {
       return false
     }
@@ -252,21 +158,7 @@ class SecretsFeature extends BaseFeature {
   }
 
 
-  // Buy an access token with the refresh token.
-  //
-  // Concurrent callers share the ONE in-flight purchase: a client running
-  // four operations at once must not open four token requests, and three of
-  // the four tokens would be wasted. The promise is cleared once settled,
-  // so the next expiry buys a fresh one rather than replaying this result.
   private _buy(): Promise<string> {
-    // TEST MODE BUYS NOTHING.
-    //
-    // The test feature replaces the transport so that no request leaves the
-    // process; an exchange here would be the one HTTP call it could not
-    // stop, and it would need a live token endpoint for a suite whose whole
-    // point is not needing one. So test mode gets a deterministic,
-    // obviously-fake token instead — the same answer makeOptions gives a
-    // required server variable, for the same reason.
     if ('live' !== this._client._mode) {
       return Promise.resolve('test-' + this._exchange.response)
     }
@@ -303,8 +195,6 @@ class SecretsFeature extends BaseFeature {
 
     const options = this._client.options()
 
-    // The token endpoint is RELATIVE to the base, which already carries
-    // whatever account or tenant segment the server URL declares.
     const base = String(options.base || "").replace(/\/+$/, "")
     const url = base + "/" + String(x.path).replace(/^\/+/, "")
 
@@ -314,10 +204,6 @@ class SecretsFeature extends BaseFeature {
       throw new Error("secrets: no fetch implementation for the token exchange")
     }
 
-    // Deliberately NOT the SDK transport. The transport is what this
-    // feature wraps, and sending the token request back through it would
-    // recurse on the first 401 — and would route the exchange through the
-    // test mock, which knows nothing about it.
     const res = await fetch(url, {
       method: x.method,
       headers: { "content-type": "application/json" },
@@ -343,25 +229,12 @@ class SecretsFeature extends BaseFeature {
   }
 
 
-  // Buy a token and try the request again when the API says the current one
-  // is spent. Wraps the transport; installed only when exchanging.
-  //
-  // The retry rewrites the Authorization header IN PLACE on the fetchdef,
-  // because the header was built by the synchronous prepareAuth before this
-  // request left, and it carries the token that just failed. Rebuilt the
-  // way prepareAuth builds it, from the same options.auth.prefix, so the
-  // two cannot drift.
   async _withRefresh(
     this: any, ctx: any, url: string, fetchdef: any, inner: any
   ): Promise<any> {
     const x = this._exchange
     const max = null == x ? 0 : x.retries
 
-    // `auth: null` is the documented way to send NO credential, and
-    // prepareAuth honours it by removing the header. A refusal of a
-    // deliberately unauthenticated request is not an expired token and
-    // cannot be fixed by buying one — retrying would transmit exactly the
-    // credential the caller suppressed.
     if (null == this._client.options().auth) {
       return inner(ctx, url, fetchdef)
     }
@@ -369,8 +242,6 @@ class SecretsFeature extends BaseFeature {
     let attempt = 0
 
     for (; ;) {
-      // The credential THIS attempt goes out with, captured before it
-      // leaves: it is what tells a stale refusal apart from a fresh one.
       const used = this._client._options.apikey
 
       const res = await inner(ctx, url, fetchdef)
@@ -379,13 +250,6 @@ class SecretsFeature extends BaseFeature {
         return res
       }
 
-      // Another request may have bought a token while this one was in
-      // flight. Concurrent 401s share the in-flight purchase, but
-      // STAGGERED ones do not: the first finishes and clears it, and the
-      // second would then buy again — a second exchange for a token that
-      // is already current, and on a provider that invalidates the
-      // previous credential on issuance, one that breaks the first
-      // request's own retry. So spend what is current before buying.
       const current = this._client._options.apikey
       let token: string
 

package/project/.sdk/tm/ts/src/feature/streaming/StreamingFeature.ts

@@ -5,13 +5,6 @@ import type { ProjectNameSDK } from '../../ProjectNameSDK'
 import { BaseFeature } from '../base/BaseFeature'
 
 
-// Streaming result support. For list-style operations it attaches a
-// `result.stream()` async-iterator so callers can consume items
-// incrementally with `for await (const item of result.stream())` instead of
-// materialising the whole array. The iterator reads the result's data
-// lazily, so it reflects the parsed entities. A `chunkDelay` (ms) simulates
-// paced/chunked delivery for offline tests via the injectable `sleep`; a
-// `chunkSize` groups items into batches when set.
 class StreamingFeature extends BaseFeature {
   version = '0.0.1'
   name = 'streaming'

package/project/.sdk/tm/ts/src/feature/telemetry/TelemetryFeature.ts

@@ -5,13 +5,6 @@ import type { ProjectNameSDK } from '../../ProjectNameSDK'
 import { BaseFeature } from '../base/BaseFeature'
 
 
-// Distributed-tracing telemetry. Opens a span per operation (PrePoint),
-// propagates trace context to the server as W3C `traceparent` plus
-// `X-Trace-Id` / `X-Span-Id` headers (PreRequest), and closes the span on
-// completion (PreDone) or failure (PreUnexpected). Finished spans are kept
-// on `client._telemetry.spans`; an `exporter` callback, when provided, is
-// invoked with each finished span. Trace/span id generation and the clock
-// are injectable for deterministic tests.
 class TelemetryFeature extends BaseFeature {
   version = '0.0.1'
   name = 'telemetry'

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

@@ -8,14 +8,17 @@ import { BaseFeature } from '../base/BaseFeature'
 const S_NOT_FOUND = 'Not found'
 
 
-// Which param is entity X's own identifier, as opposed to a parent key —
-// the load op's canonical point's LAST path segment, by construction (a
-// route addresses parents first, the record last). Mirrors recordKey in
-// sdkgen's Main_seneca-provider.ts; written again here because a template
-// ships standalone, outside that package. A renamed id (e.g. Airtable's
-// record_id) needs its own seeded field: matching only ever happens
-// against the API's real param names, never a bare 'id' the API itself
-// does not use.
+// The `%04x%04x%04x%04x` every other target mints, so the id's shape does not
+// depend on which language answered.
+function mintId(): string {
+  let out = ''
+  for (let i = 0; i < 4; i++) {
+    out += ((Math.random() * 0x10000) | 0).toString(16).padStart(4, '0')
+  }
+  return out
+}
+
+
 function ownIdField(config: any, getpath: any, entityName: string): string {
   let fallback = ''
 
@@ -32,17 +35,6 @@ function ownIdField(config: any, getpath: any, entityName: string): string {
       if (ptterm !== bestterm ? ptterm : pt.parts.length < best.parts.length) best = pt
     }
     const parts: string[] = (best && best.parts) || []
-    // THE LAST PART, not the last param anywhere in the path. A record route
-    // ENDS in its key: /orgs/{org}/private-registries/{secret_name} does,
-    // /orgs/{org}/private-registries/public-key does not. Reading the last
-    // param wherever it fell returned `{org}` for that second path — a PARENT
-    // reference — and the seeding walk then stamped the record's own key over
-    // org_id, destroying the ORG01 the fixture set and the test looks up from
-    // idmap. github's private_registry failed its update with a 404 that named
-    // nothing to do with orgs.
-    //
-    // A point that does not end in a param says nothing about this entity's
-    // key, so move on to the next op rather than guess from it.
     const lastPart = 0 < parts.length ? String(parts[parts.length - 1]) : ''
     if (lastPart.startsWith('{')) return lastPart.slice(1, -1)
 
@@ -66,23 +58,6 @@ function ownIdField(config: any, getpath: any, entityName: string): string {
     }
   }
 
-  // ONLY AFTER EVERY OP, because an op whose routes all end in a literal
-  // says nothing while another op may still name the key outright.
-  // github's `private_registry` reads
-  // `/orgs/{org}/private-registries/public-key` under `load` and writes
-  // `/orgs/{org}/private-registries/{secret_name}` under `update`:
-  // returning the load route's last parameter made the key `org`, and its
-  // update answered 404 for want of a registry named after an
-  // organisation.
-  //
-  // Reached at all only by an entity with no record-terminal route
-  // anywhere — github's `copilot` is read from
-  // `/orgs/{org_id}/members/{username}/copilot`, whose key is plainly
-  // `username`. Abstaining left the mock stamping no key on a created
-  // record while the provider addressed it by `username`, so the load
-  // straight after a create found nothing. The provider's recordKey has
-  // always used this fallback; matching it removes a disagreement rather
-  // than adding a guess.
   if ('' !== fallback) {
     return fallback
   }
@@ -141,22 +116,11 @@ class TestFeature extends BaseFeature {
       const delprop = struct.delprop
       const getdef = struct.getdef
 
-      // Shape the mock payload the way the real API would, so the op's
-      // response transform recovers the entity from it. A point carrying
-      // `transform.res: \`body.item\`` describes an API that answers
-      // `{item: {...}}`; handing back the bare entity means the transform
-      // unwraps a property that is not there and the caller gets undefined.
-      // The mock has to agree with the model, or it only ever simulates APIs
-      // whose responses happen to be unwrapped.
       function envelope(data: any) {
         const restf = getprop(getprop(ctx.point, 'transform', {}), 'res')
         if (null == data || 'string' !== typeof restf) {
           return data
         }
-        // Rebuild whatever nesting the op's response transform unwraps, so
-        // the mock agrees with the model. Multi-segment on purpose: GraphQL
-        // ops unwrap `body.data.<field>` (and `body.data.<field>.<entity>`
-        // for mutation payloads), not just a single envelope property.
         const m = restf.match(/^`body\.(.+)`$/)
         if (null == m) {
           return data
@@ -253,10 +217,7 @@ class TestFeature extends BaseFeature {
         const args = self.buildArgs(ctx, op, ctx.reqdata)
         let id = param(ctx, 'id')
         if (null == id) {
-          id = ((1e4 * Math.random() | 0).toString(16) +
-            (1e4 * Math.random() | 0).toString(16) +
-            (1e4 * Math.random() | 0).toString(16) +
-            (1e4 * Math.random() | 0).toString(16)).padEnd(16, '0')
+          id = mintId()
         }
 
         const ent = clone(ctx.reqdata)
@@ -390,20 +351,6 @@ class TestFeature extends BaseFeature {
     const qand: any[] = []
     const q = { '`$AND`': qand }
 
-    // WHERE A PATH PARAMETER'S VALUE ACTUALLY LIVES IN A RECORD.
-    //
-    // A request addresses a record by path parameter; a stored record carries
-    // whatever the API's response carries. Those are not always the same
-    // name, and are not always at the same depth: github addresses a repo by
-    // `{owner}/{repo}` and returns the owner as an OBJECT (`owner.login`)
-    // with the repository under `name`. Matching by parameter name alone
-    // found nothing for such a record, so a seeded composite record was
-    // unfindable and every read of it came back 404.
-    //
-    // `id.from` in the model says where each parameter is carried, as a
-    // dotted path. `select` matches a NESTED query shape but not a dotted
-    // key, so the path is expanded into one — `owner.login` becomes
-    // `{ owner: { login: value } }`.
     const idfrom = getpath(ctx.config, [
       'entity', getprop(ctx.entity, 'name'), 'id', 'from']) || {}
 
@@ -416,29 +363,6 @@ class TestFeature extends BaseFeature {
       return out
     }
 
-    // THE COMPOSITE PARTS FROM THE ENTITY MATCH TOO.
-    //
-    // A path parameter does not have to travel with the body. The seneca
-    // provider puts a composite record's parts in the ENTITY MATCH and
-    // leaves the body as the caller wrote it, because a path parameter is
-    // not a field — so `update`, which builds its query from `reqdata`,
-    // never looked at them. The query then matched every repo and
-    // `Repo({match:{owner,repo}}).update(...)` answered 404 while the same
-    // call with the parts in the body succeeded.
-    //
-    // EXACTLY THE PARTS, and only when nothing else addresses the record.
-    //
-    // Not every key the match holds: the match ACCRETES across calls on one
-    // entity instance, so after a create and an update it carries that
-    // record's parent scope as well — and the create branch below stamps the
-    // record's OWN key over the field it was seeded with, so a later read
-    // constrained on an accreted value finds nothing. Twenty-five of this
-    // SDK's own entity tests failed that way.
-    //
-    // And not when the call already carries an `id`: a direct id IS the
-    // address, and an accreted part then only narrows it wrongly — this
-    // SDK's own activity test updates `id: ACTIVITY00` on an entity whose
-    // match still holds the `repo` a previous list used.
     const match = ctx.match || {}
     const names: any[] = [...keysof(args)]
 
@@ -488,6 +412,7 @@ class TestFeature extends BaseFeature {
 export {
   TestFeature,
   ownIdField,
+  mintId,
 }