@voxgig/sdkgen 1.3.17 → 1.3.19

package/project/.sdk/src/cmp/js/Config_js.ts

@@ -12,6 +12,7 @@ import {
   indent,
   isAuthActive,
   resolveAuthPrefix,
+  serverVariables,
 } from '@voxgig/sdkgen'
 
 
@@ -53,6 +54,14 @@ const Config = cmp(async function Config(props: any) {
     `
     : ''
 
+  // Templated server URL: emit the spec's server-variable defaults so the
+  // runtime can substitute {name} placeholders in base (see makeOptions).
+  const svars = serverVariables(model)
+  const serverBlock = 0 === svars.length ? '' :
+    'server: {\n' +
+    svars.map((v: any) => `      ${JSON.stringify(v.name)}: ${JSON.stringify(v.dflt)},\n`).join('') +
+    '    },\n\n    '
+
   File({ name: 'Config.' + target.ext }, () => {
 
     Fragment({
@@ -60,6 +69,8 @@ const Config = cmp(async function Config(props: any) {
 
       replace: {
 
+        "'SERVERBLOCK'": serverBlock,
+
         "'AUTHBLOCK'": authBlock,
 
         "'HEADERS'": indent(JSON.stringify(headers, null, 2), 4).trim(),

package/project/.sdk/src/cmp/js/EntityTypes_js.ts

@@ -26,7 +26,7 @@ import {
   File, Content,
 } from '@voxgig/sdkgen'
 
-import { canonToType, opTypeName, opRequestShape, warnEntityTypeCollisions } from '@voxgig/sdkgen'
+import { canonToType, opTypeName, opRequestShape, warnEntityTypeCollisions , deriveEntityNames } from '@voxgig/sdkgen'
 
 import {
   KIT,
@@ -57,11 +57,10 @@ const EntityTypes = cmp(function EntityTypes(props: any) {
   // filter, so inactive entities still get class files referencing these
   // typed names. Filter on `name` (always present), NOT `active` — parity
   // with the go emitter's fix.
-  const entityList = each(entity).filter((e: any) => e && null != e.name)
+  const entityList = deriveEntityNames(entity)
   // Derive the PascalCase Name up-front — it is set LAZILY by names(), so an
   // entity not yet named (e.g. a fieldless placeholder) would otherwise read
   // `Name = undefined` below. Parity with the go emitter's fix.
-  entityList.forEach((e: any) => { if (null == e.Name) names(e, e.name) })
 
   // Surface duplicate generated type names (two entities with the same
   // PascalCase Name) — they would redeclare a type in statically-typed

package/project/.sdk/src/cmp/js/Entity_js.ts

@@ -4,7 +4,7 @@ import * as Path from 'node:path'
 import {
   cmp, each, camelify, names,
   File, Content, Folder, Fragment, Line, FeatureHook, Slot,
-  entityClassName,
+  entityClassName, entityCollection,
 } from '@voxgig/sdkgen'
 
 import {
@@ -22,7 +22,7 @@ const Entity = cmp(function Entity(props: any) {
   // Collision-free entity CLASS name (see entityClassName): normally
   // `<Name>Entity`, disambiguated when it would clash with another entity's
   // data-type name. The class file name and the Main require path both use this.
-  const entityColl = getModelPath(model, `main.${KIT}.entity`)
+  const entityColl = entityCollection(model)
   const cls = entityClassName(entity, entityColl)
 
   const entrep = {
@@ -37,7 +37,7 @@ const Entity = cmp(function Entity(props: any) {
 
     File({ name: cls + '.' + target.name }, () => {
 
-      const opnames = Object.keys(entity.op)
+      const opnames = Object.keys(entity.op || {})
 
       const opfrags =
         (['load', 'list', 'create', 'update', 'remove']

package/project/.sdk/src/cmp/js/MainEntity_js.ts

@@ -1,6 +1,6 @@
 
 
-import { cmp, Content, entityClassName } from '@voxgig/sdkgen'
+import { cmp, Content, entityClassName, entityCollection } from '@voxgig/sdkgen'
 
 import {
   KIT,
@@ -14,7 +14,7 @@ const MainEntity = cmp(async function MainEntity(props: any) {
 
   // Return the collision-free class (entityClassName); the accessor METHOD name
   // (entity.Name) is unchanged so callers still write client.<Name>().
-  const cls = entityClassName(entity, getModelPath(model, `main.${KIT}.entity`))
+  const cls = entityClassName(entity, entityCollection(model))
 
   Content(`
   // Entity access: \`client.${entity.Name}().list()\` / \`client.${entity.Name}().load({ id })\`.

package/project/.sdk/src/cmp/js/Main_js.ts

@@ -4,7 +4,7 @@ import * as Path from 'node:path'
 import {
   cmp, each, names, cmap,
   List, File, Content, Copy, Folder, Fragment, Line, FeatureHook,
-  entityClassName,
+  entityClassName, entityCollection,
 } from '@voxgig/sdkgen'
 
 
@@ -57,7 +57,7 @@ const Main = cmp(async function Main(props: any) {
       Line(`// ${model.const.Name} ${target.Name} SDK\n`)
 
       List({ item: entity }, ({ item }: any) => {
-        const cls = entityClassName(item, entity)
+        const cls = entityClassName(item, entityCollection(model))
         return Line(`const { ${cls} } = require('./entity/${cls}')`)
       })
 

package/project/.sdk/src/cmp/js/TestDirect_js.ts

@@ -48,7 +48,7 @@ const TestDirect = cmp(function TestDirect(props: any) {
       apikey: env.${PROJECTNAME}_APIKEY,`
     : ''
 
-  const opnames = Object.keys(entity.op)
+  const opnames = Object.keys(entity.op || {})
   const hasLoad = opnames.includes('load')
   const hasList = opnames.includes('list')
 
@@ -134,7 +134,7 @@ function directSetup(mockres) {
 
 
 function generateDirectLoad(model: Model, entity: ModelEntity) {
-  const loadOp = entity.op.load
+  const loadOp = entity.op?.load
   const loadPoint: ModelPoint | undefined = loadOp?.points?.[0]
 
   if (null == loadPoint) {
@@ -145,7 +145,7 @@ function generateDirectLoad(model: Model, entity: ModelEntity) {
   const loadPath = normalizePathParams(loadPoint.parts || [], loadParams, loadPoint.rename?.param)
 
   // Get list info for live mode bootstrapping
-  const listOp = entity.op.list
+  const listOp = entity.op?.list
   const listPoint = listOp?.points?.[0]
   const listParams = listPoint?.args?.params || []
   const listPath = listPoint ? normalizePathParams(listPoint.parts || [], listParams, listPoint.rename?.param) : ''
@@ -231,7 +231,7 @@ ${paramAsserts}    }
 
 
 function generateDirectList(model: Model, entity: ModelEntity) {
-  const listOp = entity.op.list
+  const listOp = entity.op?.list
   const listPoint: ModelPoint | undefined = listOp?.points?.[0]
 
   if (null == listPoint) {

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

@@ -19,7 +19,7 @@ class Config {
 
 
   main = {
-    name: 'ProjectName',
+    name: '$$const.Name$$',
   }
 
 
@@ -31,7 +31,7 @@ class Config {
   options = {
     base: '$$main.kit.info.servers.0.url$$',
 
-    'AUTHBLOCK'headers: 'HEADERS',
+    'SERVERBLOCK''AUTHBLOCK'headers: 'HEADERS',
 
     entity: {
       // #EntityConfigs

package/project/.sdk/src/cmp/js/fragment/Direct.test.fragment.js

@@ -17,6 +17,10 @@ describe('EntityNameDirect', async () => {
 
   test('direct-exists', async () => {
     const sdk = new ProjectNameSDK({
+      // Concrete base: a live construction must satisfy any server
+      // variables a templated base URL declares; overriding base with a
+      // literal (as the direct flow tests do) sidesteps the requirement.
+      base: 'http://localhost:8080',
       system: { fetch: async () => ({}) }
     })
     assert('function' === typeof sdk.direct)

package/project/.sdk/src/cmp/kotlin/EntityTypes_kotlin.ts

@@ -39,7 +39,7 @@ import {
   File, Content,
 } from '@voxgig/sdkgen'
 
-import { canonToType, opTypeName, opRequestShape, warnEntityTypeCollisions } from '@voxgig/sdkgen'
+import { canonToType, opTypeName, opRequestShape, warnEntityTypeCollisions , deriveEntityNames } from '@voxgig/sdkgen'
 
 import {
   KIT,
@@ -132,11 +132,10 @@ const EntityTypes = cmp(function EntityTypes(props: any) {
   // filter, so inactive entities still get class files referencing these
   // typed names. Filter on `name` (always present), NOT `active` — parity
   // with the go emitter's fix.
-  const entityList = each(entity).filter((e: any) => e && null != e.name)
+  const entityList = deriveEntityNames(entity)
   // Derive the PascalCase Name up-front — it is set LAZILY by names(), so an
   // entity not yet named (e.g. a fieldless placeholder) would otherwise read
   // `Name = undefined` below. Parity with the go/py/csharp/java emitter's fix.
-  entityList.forEach((e: any) => { if (null == e.Name) names(e, e.name) })
 
   // Surface duplicate generated type names (two entities with the same
   // PascalCase Name) — they would redeclare a type in statically-typed

package/project/.sdk/src/cmp/kotlin/Entity_kotlin.ts

@@ -4,7 +4,7 @@ import * as Path from 'node:path'
 import {
   cmp, camelify, names,
   File, Content, Folder, Fragment,
-  entityClassName,
+  entityClassName, entityCollection,
 } from '@voxgig/sdkgen'
 
 import {
@@ -25,7 +25,7 @@ const Entity = cmp(function Entity(props: any) {
   // Collision-free entity CLASS name (see entityClassName): normally
   // `<Name>Entity`, but disambiguated (e.g. `<Name>EntityClient`) when it
   // would clash with another entity's data-type name.
-  const entityColl = getModelPath(model, `main.${KIT}.entity`)
+  const entityColl = entityCollection(model)
   const cls = entityClassName(entity, entityColl)
 
   const entrep = {
@@ -41,7 +41,7 @@ const Entity = cmp(function Entity(props: any) {
 
     File({ name: cls + '.' + target.ext }, () => {
 
-      const opnames = Object.keys(entity.op)
+      const opnames = Object.keys(entity.op || {})
 
       // For each CRUD op: if the spec defines it, splice in the real
       // implementation. Otherwise emit a stub that satisfies the SdkEntity

package/project/.sdk/src/cmp/kotlin/MainEntity_kotlin.ts

@@ -1,5 +1,5 @@
 
-import { cmp, Content, entityClassName } from '@voxgig/sdkgen'
+import { cmp, Content, entityClassName, entityCollection } from '@voxgig/sdkgen'
 
 import {
   KIT,
@@ -17,7 +17,7 @@ const MainEntity = cmp(async function MainEntity(props: any) {
   const { model } = props.ctx$
 
   const kotlinpackage = kotlinPackage(model)
-  const entityColl = getModelPath(model, `main.${KIT}.entity`)
+  const entityColl = entityCollection(model)
   const cls = entityClassName(entity, entityColl)
   const accessor = kotlinVarName(entity.name)
 

package/project/.sdk/src/cmp/kotlin/Package_kotlin.ts

@@ -30,7 +30,7 @@ const Package = cmp(async function Package(props: any) {
 
   // Dep name convention: "group:artifact" with an explicit version.
   const deps: { group: string, artifact: string, version: string, kind: string }[] = []
-  for (const d of collectDeps(model, target.name, target.deps)) {
+  for (const d of collectDeps(model, target.name, target.deps, ctx$.log)) {
     const [dgroup, dartifact] = String(d.name).split(':')
     if (dgroup && dartifact && d.version) {
       deps.push({

package/project/.sdk/src/cmp/kotlin/ReadmeExamplesTest_kotlin.ts

@@ -46,7 +46,9 @@ const ReadmeExamplesTest = cmp(function ReadmeExamplesTest(props: any) {
 // Checks, PER DOCUMENT:
 //   1. PRESENCE: the doc exists and holds at least one kotlin block.
 //   2. STRUCTURE: every kotlin block's braces / parens / brackets balance, so a
-//      truncated or malformed generated snippet fails loudly.
+//      truncated or malformed generated snippet fails loudly. Every code fence
+//      is also terminated (even fence count), so an unclosed fence at EOF is
+//      caught rather than accepted as a complete block.
 //
 // GENERATED by @voxgig/sdkgen — do not edit by hand.
 
@@ -97,6 +99,22 @@ class ReadmeExamplesTest {
     return Files.readString(path)
   }
 
+  // Count triple-backtick fence markers. A well-formed document opens and
+  // closes every fenced block, so the total must be EVEN. An odd count means a
+  // fence was opened but never closed (a truncated / malformed doc) — the
+  // split-based extraction in kotlinBlocks() would otherwise accept the
+  // unterminated trailing segment as a complete block and pass silently.
+  private fun fenceCount(text: String): Int {
+    val fence = 96.toChar().toString().repeat(3)
+    var count = 0
+    var idx = text.indexOf(fence)
+    while (idx >= 0) {
+      count++
+      idx = text.indexOf(fence, idx + fence.length)
+    }
+    return count
+  }
+
   // True when every open/close delimiter balances (ignores the subtlety of
   // delimiters inside string literals — a generated snippet never nests an
   // unbalanced delimiter in a string, and this catches truncation).
@@ -145,7 +163,14 @@ class ReadmeExamplesTest {
       if (!Files.exists(path)) {
         continue
       }
-      val blocks = kotlinBlocks(readDoc(path, doc[0]))
+      val src = readDoc(path, doc[0])
+      // A fence opened but never closed is a malformed doc — fail loudly
+      // rather than silently accepting the unterminated trailing segment as a
+      // complete block.
+      if (fenceCount(src) % 2 != 0) {
+        failures.add(doc[0] + " has an unterminated code fence")
+      }
+      val blocks = kotlinBlocks(src)
       var balancedCount = 0
       for (i in blocks.indices) {
         if (balanced(blocks[i])) {

package/project/.sdk/src/cmp/kotlin/TestDirect_kotlin.ts

@@ -72,7 +72,7 @@ const TestDirect = cmp(function TestDirect(props: any) {
 
   const authActive = isAuthActive(model)
 
-  const opnames = Object.keys(entity.op)
+  const opnames = Object.keys(entity.op || {})
   const hasLoad = opnames.includes('load')
   const hasList = opnames.includes('list')
 
@@ -80,8 +80,8 @@ const TestDirect = cmp(function TestDirect(props: any) {
     return
   }
 
-  const loadOp = entity.op.load
-  const listOp = entity.op.list
+  const loadOp = entity.op?.load
+  const listOp = entity.op?.list
 
   const loadPoint = loadOp?.points?.[0]
   const loadPath = loadPoint ? normalizePathParams(loadPoint.parts || [], loadPoint?.args?.params || [], loadPoint?.rename?.param) : ''

package/project/.sdk/src/cmp/lean/Config_lean.ts

@@ -0,0 +1,88 @@
+import {
+  Content,
+  File,
+  cmp,
+  each,
+  isAuthActive,
+  resolveAuthPrefix,
+} from '@voxgig/sdkgen'
+
+import {
+  KIT,
+  Model,
+  getModelPath,
+} from '@voxgig/apidef'
+
+import {
+  clean,
+  leanString,
+} from './utility_lean'
+
+
+// SdkConfig.lean: the embedded API model, serialised to a JSON string. The
+// config-driven runtime (SdkRuntime) parses it into a struct `Value` at client
+// construction — the whole SDK is data-driven, so there is no per-entity code.
+const Config = cmp(async function Config(props: any) {
+  const ctx$ = props.ctx$
+  const target = props.target
+
+  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) { }
+
+  const featureConfig: any = {}
+  each(feature, (f: any) => { featureConfig[f.name] = f.config || {} })
+
+  const entityOptions: any = {}
+  each(entity, (ent: any) => { entityOptions[ent.name] = {} })
+
+  const options: any = {
+    base: baseUrl,
+    headers,
+    entity: entityOptions,
+  }
+  if (authActive) {
+    options.auth = { prefix: authPrefix }
+  }
+
+  const entityConfig = Object.values(entity || {}).reduce((a: any, n: any) => (
+    a[n.name] = clean({
+      fields: n.fields,
+      name: n.name,
+      op: n.op,
+      relations: n.relations,
+    }), a), {})
+
+  const config = {
+    main: { name: model.const.Name },
+    feature: featureConfig,
+    options,
+    entity: entityConfig,
+  }
+
+  File({ name: 'SdkConfig.' + target.ext }, () => {
+    Content(`-- Generated API configuration for the config-driven runtime.
+-- The embedded model is parsed into a struct Value at client construction.
+
+namespace SdkConfig
+
+def configJson : String :=
+  ${leanString(JSON.stringify(config))}
+
+end SdkConfig
+`)
+  })
+})
+
+
+export {
+  Config
+}

package/project/.sdk/src/cmp/lean/Entity_lean.ts

@@ -0,0 +1,9 @@
+import { cmp } from '@voxgig/sdkgen'
+
+// Entities are generic in the Lean target: there is no per-entity generated
+// module. Every entity's operations are dispatched by the config-driven
+// SdkRuntime (see SdkClient), so this component emits nothing. It exists only
+// so the neutral Entity component can resolve a language delegate.
+const Entity = cmp(function Entity(_props: any) {})
+
+export { Entity }

package/project/.sdk/src/cmp/lean/Gitignore_lean.ts

@@ -0,0 +1,18 @@
+import { Content, File, cmp } from '@voxgig/sdkgen'
+
+const Gitignore = cmp(async function Gitignore(_props: any) {
+  File({ name: '.gitignore' }, () => {
+    Content(`# Lake build output
+.lake/
+build/
+lake-packages/
+
+# IDE / OS
+.idea/
+.vscode/
+.DS_Store
+`)
+  })
+})
+
+export { Gitignore }

package/project/.sdk/src/cmp/lean/Main_lean.ts

@@ -0,0 +1,120 @@
+import {
+  cmp, each,
+  File, Content, Copy, Folder,
+} from '@voxgig/sdkgen'
+
+import type {
+  ModelEntity
+} from '@voxgig/apidef'
+
+import {
+  KIT,
+  getModelPath
+} from '@voxgig/apidef'
+
+import { Package } from './Package_lean'
+import { Config } from './Config_lean'
+import { Gitignore } from './Gitignore_lean'
+
+
+// Op name -> generated wrapper. list/load/remove take a match; create takes
+// data; update takes both. Any non-standard op falls back to the match+data
+// form. Every wrapper delegates to the config-driven SdkRuntime.
+function opWrapper(entName: string, opName: string): string {
+  const q = `"${entName}"`
+  switch (opName) {
+    case 'list':
+      return `  def list (c m co : Value) : SIO Value := SdkRuntime.opList c ${q} m co\n`
+    case 'load':
+      return `  def load (c m co : Value) : SIO Value := SdkRuntime.opLoad c ${q} m co\n`
+    case 'remove':
+      return `  def remove (c m co : Value) : SIO Value := SdkRuntime.opRemove c ${q} m co\n`
+    case 'create':
+      return `  def create (c d co : Value) : SIO Value := SdkRuntime.opCreate c ${q} d co\n`
+    case 'update':
+      return `  def update (c m d co : Value) : SIO Value := SdkRuntime.opUpdate c ${q} m d co\n`
+    default:
+      return `  def ${opName} (c m d co : Value) : SIO Value := SdkRuntime.runOp c ${q} "${opName}" m d co\n`
+  }
+}
+
+
+const Main = cmp(async function Main(props: any) {
+
+  const { target } = props
+  const { model } = props.ctx$
+
+  const entity: ModelEntity = getModelPath(model, `main.${KIT}.entity`)
+
+  Package({ target })
+  Gitignore({})
+
+  // Copy tm/lean verbatim (placeholder substitution applies): the runtime under
+  // src/ (VoxgigStruct, Vregex, SdkJson, SdkRuntime), plus LICENSE/VERSION. The
+  // per-feature custom-source scaffold under src/feature is excluded.
+  Copy({
+    from: 'tm/' + target.name,
+    exclude: [/src\/feature\//],
+    replace: {
+      ...props.ctx$.stdrep,
+    }
+  })
+
+  // Generated modules under src/: the embedded API config and the public
+  // client (constructors + one op namespace per entity).
+  Folder({ name: 'src' }, () => {
+
+    Config({ target })
+
+    File({ name: 'SdkClient.' + target.ext }, () => {
+
+      let namespaces = ''
+      each(entity, (e: any) => {
+        // Capitalise the entity name for its op namespace.
+        const ns = e.name.charAt(0).toUpperCase() + e.name.slice(1)
+        let ops = ''
+        each(e.op, (op: any) => { ops += opWrapper(e.name, op.name) })
+        namespaces += `namespace ${ns}\n${ops}end ${ns}\n\n`
+      })
+
+      Content(`-- ${model.const.Name} SDK public client (generated by @voxgig/sdkgen).
+--
+-- Constructors (newSdk / testSdk) and one op namespace per entity. Entities are
+-- generic: every op delegates to the config-driven SdkRuntime, so the pipeline
+-- is identical for every entity and every API.
+
+import VoxgigStruct
+import SdkRuntime
+import SdkConfig
+
+open VoxgigStruct
+
+namespace Sdk
+
+/-- Construct a live client from an options map (empty map = defaults). -/
+def newSdk (options : Value) : SIO Value :=
+  SdkRuntime.mkClientV options SdkConfig.configJson
+
+/-- No-argument convenience constructor. -/
+def newSdk0 : SIO Value := do newSdk (← emptyMap)
+
+/-- Construct a test-mode client: operations are answered from an in-memory
+    store seeded with the entity test data, so no server is needed. -/
+def testSdk (seed : Value) (options : Value) : SIO Value :=
+  SdkRuntime.mkTestClientV options SdkConfig.configJson seed
+
+/-- Test client with default options. -/
+def testSdk0 (seed : Value) : SIO Value := do testSdk seed (← emptyMap)
+
+end Sdk
+
+${namespaces}`)
+    })
+  })
+
+})
+
+
+export {
+  Main
+}

package/project/.sdk/src/cmp/lean/Package_lean.ts

@@ -0,0 +1,68 @@
+import {
+  Content,
+  File,
+  cmp,
+} from '@voxgig/sdkgen'
+
+import type {
+  Model,
+} from '@voxgig/apidef'
+
+import { pkgName } from './utility_lean'
+
+
+// Each runtime module is its own `lean_lib` (Lake globs `<LibName>.lean` from
+// srcDir), matching the vendored struct project's layout. The runtime is
+// dependency-free (prelude + Std only); the HTTP transport shells to curl.
+const LIBS = [
+  'Vregex', 'VoxgigStruct', 'SdkJson', 'SdkUtility', 'SdkFeature', 'SdkFeatures', 'SdkRuntime', 'SdkConfig',
+  'SdkClient',
+]
+
+
+const Package = cmp(async function Package(props: any) {
+  const ctx$ = props.ctx$
+  const model: Model = ctx$.model
+
+  const libBlocks = LIBS.map((n) =>
+    `[[lean_lib]]\nname = "${n}"\nsrcDir = "src"\n`).join('\n')
+
+  File({ name: 'lakefile.toml' }, () => {
+    Content(`# ${model.const.Name} SDK for Lean 4 (generated by @voxgig/sdkgen).
+name = "${pkgName(model)}"
+version = "0.0.1"
+defaultTargets = ["SdkClient"]
+
+${libBlocks}
+[[lean_exe]]
+name = "runner"
+srcDir = "test"
+root = "Runner"
+
+[[lean_exe]]
+name = "structcorpus"
+srcDir = "test"
+root = "StructCorpus"
+
+[[lean_exe]]
+name = "primary"
+srcDir = "test"
+root = "TPrimaryUtility"
+
+[[lean_exe]]
+name = "feature"
+srcDir = "test"
+root = "TFeature"
+`)
+  })
+
+  // Pin the toolchain to the version the runtime is developed against.
+  File({ name: 'lean-toolchain' }, () => {
+    Content(`leanprover/lean4:v4.32.1\n`)
+  })
+})
+
+
+export {
+  Package
+}

package/project/.sdk/src/cmp/lean/ReadmeEntity_lean.ts

@@ -0,0 +1,29 @@
+import { cmp, Content, each } from '@voxgig/sdkgen'
+
+// One section per entity: its op namespace and the verbs it supports.
+const ReadmeEntity = cmp(function ReadmeEntity(props: any) {
+  const { entity } = props
+  if (null == entity) return
+  const ns = entity.name.charAt(0).toUpperCase() + entity.name.slice(1)
+  const ops = Object.keys(entity.op || {}).sort()
+  if (0 === ops.length) return
+
+  let rows = ''
+  for (const op of ops) {
+    const call =
+      'create' === op ? `${ns}.create sdk data (← emptyMap)`
+        : 'update' === op ? `${ns}.update sdk match data (← emptyMap)`
+          : `${ns}.${op} sdk match (← emptyMap)`
+    rows += `| \`${op}\` | \`${call}\` |\n`
+  }
+
+  Content(`Operations are in the \`${ns}\` namespace; each takes the client first
+and per-call options last.
+
+| Op | Call |
+| --- | --- |
+${rows}
+`)
+})
+
+export { ReadmeEntity }