@voxgig/sdkgen 4.21.0 → 4.23.0

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,
 }
 
 

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

@@ -6,30 +6,6 @@ import { ENTITYSPEC } from '../../Schema'
 import { BaseFeature } from '../base/BaseFeature'
 
 
-// Payload validation against the model's own field types.
-//
-// The specs are NOT written here and not written in the model either: every
-// entity field already carries a canonical type sentinel (`$STRING`,
-// `$INTEGER`, the `$ONE` union for an OpenAPI multi-type), which is the same
-// vocabulary struct.validate speaks. The generator maps them once
-// (helpers/canonSpec) and emits `ENTITYSPEC` beside this file, so a field
-// whose type changes in the API spec changes what this feature enforces with
-// no edit anywhere.
-//
-// WHAT IS CHECKED
-//   outbound (PreSpec)  the payload the caller asked to send, against
-//                       `spec.op[<opname>]` — the operation's request shape,
-//                       which is the SAME partiality policy that decides what
-//                       the generated `<Name>CreateData` type requires.
-//   inbound  (PreDone)  each record the operation returned, against
-//                       `spec.data` — the entity's own field types.
-//
-// WHAT IS NOT. The model carries no array element types, no nested object
-// schemas, no enums, formats or bounds (see canonSpec's note), so this checks
-// the shape the model knows and nothing more. It is a guard against the
-// mistakes the model CAN see — a number where a string belongs, a required
-// field left out, a misspelled key under `strict` — not a substitute for the
-// server's own validation.
 class ValidateFeature extends BaseFeature {
   version = '0.0.1'
   name = 'validate'
@@ -49,12 +25,6 @@ class ValidateFeature extends BaseFeature {
     this._options = options || {}
     this.active = (options as any).active
 
-    // DEFAULTS ARE APPLIED HERE, not by the option spec. The model's
-    // `config.options` documents them and types them; it does not inject
-    // them, because each feature entry in the spec is optional and struct
-    // fills in nothing through an optional union. So every feature resolves
-    // its own — and a `mode` left undefined here once meant `'throw' !==
-    // undefined`, which silently turned every rejection into a no-op.
     this._request = false !== this._options.request
     this._response = true === this._options.response
 
@@ -64,16 +34,10 @@ class ValidateFeature extends BaseFeature {
     // rejects the typo outright; this is what happens if it ever does not.
     this._mode = 'report' === this._options.mode ? 'report' : 'throw'
 
-    // `strict` is applied ONCE, here, by rebuilding the spec tree without the
-    // `$OPEN` markers — rather than per call, which would clone a spec for
-    // every request an SDK ever makes.
     this._spec = true === this._options.strict ? close(ENTITYSPEC) : ENTITYSPEC
   }
 
 
-  // Outbound. `makeSpec` short-circuits on an `ctx.out.spec` that is already
-  // set, so assigning the error here rejects the operation before the request
-  // is built — the same seam rbac uses one stage earlier.
   PreSpec(this: any, ctx: any) {
     if (!this.active || !this._request) {
       return
@@ -100,22 +64,6 @@ class ValidateFeature extends BaseFeature {
   }
 
 
-  // Inbound. PreDone rather than PreResult: the records are extracted from
-  // the response body by `makeResult`, which runs between the two, so at
-  // PreResult there is nothing to check but the envelope.
-  //
-  // HOOK ORDER MATTERS HERE, and the default order is not the one you want.
-  // PreDone hooks fire in feature ADD order, which defaults to `test` first
-  // and then names sorted — and `validate` sorts last, after `audit`,
-  // `cost`, `debug`, `metrics` and `telemetry`. Those observers therefore
-  // record the operation as a success before this hook has looked at it.
-  // Activating features as an ORDERED ARRAY fixes it:
-  //
-  //   feature: [{ name: 'validate', active: true, response: true },
-  //             { name: 'metrics', active: true }]
-  //
-  // What this feature can fix from here, it does: the result is marked
-  // failed and its records are cleared, so the entity absorbs nothing.
   PreDone(this: any, ctx: any) {
     if (!this.active || !this._response) {
       return
@@ -140,10 +88,6 @@ class ValidateFeature extends BaseFeature {
         continue
       }
 
-      // A NON-OBJECT IS A FAILURE, not something to skip. A load that
-      // answered `42` where the entity's spec wants a record used to pass
-      // this feature silently, which is the one outcome a validator must
-      // never produce. struct rejects it with the field it could not find.
       for (const e of this._check(ctx, unwrap(record), spec.data, 'response')) {
         errs.push(e)
       }
@@ -156,33 +100,15 @@ class ValidateFeature extends BaseFeature {
     const err = ctx.error('validate_failed',
       'Invalid response for entity "' + entname(ctx) + '": ' + errs.join('; '))
 
-    // BOTH, and `ok` is the load-bearing half: `done` returns `resdata`
-    // whenever `result.ok` is true and never looks at `err`, so setting the
-    // error alone handed the caller the very records that failed the spec.
     ctx.result.ok = false
     ctx.result.err = err
 
-    // AND THE DATA GOES. The load/update fragments copy `result.resdata`
-    // into the entity's own state on any non-null value, BEFORE `done`
-    // raises — so rejecting the operation while leaving the records in place
-    // left the caller holding an entity populated from a payload this
-    // feature had just declared invalid. Clearing it is the only half of
-    // that this feature owns; see the note on hook order below.
     ctx.result.resdata = undefined
 
     return err
   }
 
 
-  // The payload an operation is about to send.
-  //
-  // TWO SLOTS, AND THE OP PICKS. A body op (create/update/patch) carries the
-  // caller's argument in `reqdata` over the entity's `data`; a match op
-  // (load/list/remove) carries it in `reqmatch` over `match`. That is what
-  // the Entity*Op fragments pass to makeContext and what makePoint reads
-  // (`getprop(ctx, 'req' + op.input)`) — so reading `reqdata` for every op
-  // checked a `load({ id })` against the entity's STALE stored match and
-  // rejected it for the id the caller had just supplied.
   _payload(this: any, ctx: any, opname: string): Record<string, any> {
     const body = 'create' === opname || 'update' === opname || 'patch' === opname
 
@@ -207,9 +133,6 @@ class ValidateFeature extends BaseFeature {
   }
 
 
-  // One validate call. Errors are COLLECTED, never thrown: struct throws on
-  // the first failure unless given an `errs` array, and a caller fixing a
-  // payload wants every problem with it, not the first one.
   _check(this: any, ctx: any, data: any, spec: any, direction: string): string[] {
     const struct = ctx.utility.struct
     const errs: string[] = []
@@ -242,13 +165,6 @@ class ValidateFeature extends BaseFeature {
 }
 
 
-// A RESULT RECORD AS DATA.
-//
-// `makeResult` turns every record of a LIST into an entity instance
-// (`entity.make()` then `ent.data(entry)`), so what reaches PreDone for a
-// list is wrappers, not records — and a wrapper checked against a field spec
-// fails on every required field while its actual data goes unchecked. A load
-// returns the record itself, so this has to handle both.
 function unwrap(record: any): any {
   if (null != record && 'function' === typeof record.data) {
     const data = record.data()
@@ -265,9 +181,6 @@ function entname(ctx: any): string {
 }
 
 
-// The spec tree with every `$OPEN` marker removed, so an undeclared key is an
-// error rather than a pass. Rebuilt rather than mutated: ENTITYSPEC is a
-// module constant shared by every client in the process.
 function close(node: any): any {
   if (Array.isArray(node)) {
     return node.map((n: any) => close(n))

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

@@ -14,18 +14,6 @@ function clean(ctx: Context, val: any) {
   const cleankeyre = options?.__derived__?.clean?.keyre
   const hintsize = 4
 
-  /*
-  if (null != cleankeyre) {
-    val = walk(clone(val), (key: any, subval: any) => {
-      if (cleankeyre.exec(key) && 'string' === typeof subval) {
-        const len = size(subval)
-        const hint = (hintsize * 4) < len ? slice(subval, 0, hintsize) : ''
-        subval = pad(hint, len, '*')
-      }
-      return subval
-    })
-  }
-  */
 
   return val
 }

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

@@ -12,7 +12,6 @@ function featureAdd(ctx: Context, f: Feature) {
   let added = false
   const features = client._features
 
-  // TODO: make this a utility
   if (fopts.__before__ || fopts.__after__ || fopts.__replace__) {
 
     for (let i = 0; i < features.length; i++) {