@voxgig/sdkgen 2.0.2 → 3.1.0

package/src/action/target.ts

@@ -12,8 +12,14 @@ import {
 
 import { showChanges } from '@voxgig/util'
 
+import { showDryrun } from '../helpers/dryrun'
+
+import { templateReplacements } from '../helpers/stdrep'
+
 import { getelem } from '@voxgig/struct'
 
+import { Aontu } from 'aontu'
+
 import {
   KIT
 } from '../types'
@@ -25,6 +31,13 @@ import type {
 
 import { SdkGenError } from '../utility'
 
+import {
+  availableFeatures,
+  findFeatureSources,
+  featureExcludes,
+  fullsetExcludes,
+} from '../helpers/featureSource'
+
 import {
   feature_add
 } from './feature'
@@ -76,6 +89,16 @@ async function target_add(targets: string[], actx: ActionContext): Promise<Actio
       content: loadContent(actx, 'target')
     },
     model: actx.model,
+    // Dry run must be passed per-call, not left to the Jostraca instance.
+    // jostraca's `generate` runs its own options through OptionsShape FIRST,
+    // which fills in `control.dryrun: false`, and only then merges
+    // `deep({}, gOpts.control, opts.control)` — so the shape default silently
+    // OVERRIDES the instance-level flag. `-y target add ts` printed
+    // ** DRY RUN ** and wrote every file. (Same trap as the `existing` FIX
+    // note in jostraca.js.)
+    control: {
+      dryrun: !!actx.opts.dryrun
+    },
   }
 
   opts.log.info({
@@ -87,9 +110,16 @@ async function target_add(targets: string[], actx: ActionContext): Promise<Actio
   // The `test` feature is required by every generated target (SDK.test()
   // depends on it), so ensure it is added even if the model does not yet
   // declare it.
+  //
+  // Everything else has to be BOTH declared and active: `active` defaults to
+  // false in the schema, and a feature the model has switched off should not
+  // have its source land in the project. This used to be a plain
+  // Object.keys(), so `retry: { active: false }` still shipped every retry
+  // source file.
+  const featuremodel: any = actx.model.main[KIT]?.feature ?? {}
   const features = Array.from(new Set([
     'test',
-    ...Object.keys(actx.model.main[KIT]?.feature ?? {}),
+    ...Object.keys(featuremodel).filter((n: string) => false !== featuremodel[n]?.active),
   ]))
 
   const jres = await jostraca.generate(opts, () =>
@@ -97,6 +127,10 @@ async function target_add(targets: string[], actx: ActionContext): Promise<Actio
 
   showChanges(opts.log, 'target-result', jres)
 
+  if (actx.opts.dryrun) {
+    showDryrun(opts.log, 'target-result', jres, actx.folder)
+  }
+
   // feature_add copies feature templates for targets already registered in
   // the model. The targets added above are not in the in-memory model yet,
   // so TargetRoot copies their feature templates itself.
@@ -167,26 +201,18 @@ const TargetRoot = cmp(function TargetRoot(props: any) {
         })
       })
 
+      // Copy the whole template tree MINUS the source of every feature the
+      // model did not ask for. Which files those are is discovered from the
+      // tree rather than assumed (see helpers/featureSource), because each
+      // language puts feature source somewhere different.
+      const trim = trimFeatures(ctx$, tfolder, torigname, tname, features)
+
       Folder({ name: 'tm/' + tname }, () => {
         Copy({
           from: tfolder + '/tm/' + torigname,
-          exclude: [/src\/feature/],
-          replace: {
-
-            // TODO: standard replacements
-            ProjectName: model.const.Name,
-          }
-        })
-
-        Folder({ name: 'src/feature' }, () => {
-          Copy({ from: tfolder + '/tm/' + torigname + '/src/feature/README.md' })
-
-          each(Array.from(new Set(['base', ...(features ?? [])])), (f: any) => {
-            const fname = f.val$
-            Folder({ name: fname }, () => {
-              Copy({ from: tfolder + '/tm/' + torigname + '/src/feature/' + fname })
-            })
-          })
+          exclude: trim,
+          // Shared with doctor, which re-applies them before comparing.
+          replace: templateReplacements(model, tname),
         })
       })
 
@@ -199,6 +225,116 @@ const TargetRoot = cmp(function TargetRoot(props: any) {
 })
 
 
+// Path patterns that keep a target's unwanted feature source out of the
+// project: the source of every AVAILABLE feature the model did not select,
+// plus the templates that only compile with the complete feature set.
+//
+// Returns an empty list — copy the whole tree, as before — when the target
+// opts out with `feature: { trim: false }`, or when its model cannot be
+// read. Trimming a target whose templates are not ready for it produces a
+// project that does not build, so an unreadable declaration must fail safe
+// rather than fail tidy.
+function trimFeatures(
+  ctx$: any,
+  tfolder: string,
+  torigname: string,
+  tname: string,
+  features: string[],
+): RegExp[] {
+  const { log } = ctx$
+  const fs = ctx$.fs()
+
+  const cfg = readTargetFeature(ctx$, tfolder, torigname, tname)
+
+  if (false === cfg.trim) {
+    log.info({
+      point: 'target-feature-trim', target: tname, trim: false,
+      note: tname + ': feature trim disabled, copying all feature source'
+    })
+    return []
+  }
+
+  // `base` is not a declared feature — it is the always-present foundation
+  // every other feature builds on — so it is never a trim candidate.
+  const selected = new Set(['base', ...(features ?? [])])
+
+  const available = availableFeatures(fs, tfolder)
+  const drop = findFeatureSources(fs, tfolder + '/tm/' + torigname, available)
+    .filter((s) => !selected.has(s.name))
+
+  const trimmed = 0 < drop.length
+
+  log.info({
+    point: 'target-feature-trim', target: tname, trim: true,
+    drop: drop.map((s) => s.name),
+    note: tname + ': ' + (trimmed ?
+      ('dropping ' + drop.length + ' unselected feature source entries') :
+      'all available features selected')
+  })
+
+  return [
+    ...featureExcludes(drop),
+    // The cross-feature test suite is only excluded when something WAS
+    // trimmed; a project carrying the full set keeps its feature tests.
+    ...(trimmed ? fullsetExcludes(cfg.fullset) : []),
+  ]
+}
+
+
+// Load a target's `feature` declaration from its own model file.
+//
+// The target being added is not in the in-memory model yet (that is what
+// `target add` is for), so this reads the very file that is about to be
+// copied into `model/target/`. Each shipped target model is self-contained,
+// so Aontu can resolve it on its own.
+function readTargetFeature(
+  ctx$: any,
+  tfolder: string,
+  torigname: string,
+  tname: string,
+): { trim: boolean, fullset: string[] } {
+  const { log } = ctx$
+  const fs = ctx$.fs()
+
+  const path = tfolder + '/model/target/' + torigname + '.aontu'
+
+  try {
+    const errs: any[] = []
+    const model = new Aontu().generate(fs.readFileSync(path, 'utf8'), { path, errs })
+
+    if (0 < errs.length) {
+      throw new Error(errs.map((e: any) => e.msg || String(e)).join('\n'))
+    }
+
+    const feature = model?.main?.[KIT]?.target?.[torigname]?.feature ?? {}
+
+    return {
+      trim: false !== feature.trim,
+      fullset: Array.isArray(feature.fullset) ? feature.fullset : [],
+    }
+  }
+  catch (err: any) {
+    log.warn({
+      point: 'target-feature-model', target: tname, path,
+      err: err.message,
+      note: tname + ': cannot read target model (' + err.message +
+        '); copying all feature source'
+    })
+    return { trim: false, fullset: [] }
+  }
+}
+
+
+// Last path segment of a ref. A ref may be a bare target name ('go'), a
+// package-relative path ('@acme/kit/go'), or an ABSOLUTE path — and on Windows
+// an absolute path is separated by `\`, so splitting on '/' alone hands back
+// the whole path as the target name and every tree lookup below then misses.
+// On POSIX Path.sep IS '/', so this is the same split it always was.
+function lastSegment(ref: string): string {
+  return getelem(ref.split('/').flatMap((p: string) => p.split(Path.sep)), -1)
+}
+
+
 function resolveTarget(tref: string, ctx$: any) {
   let tname = tref
   let torigname = tref
@@ -208,24 +344,28 @@ function resolveTarget(tref: string, ctx$: any) {
   const fs = ctx$.fs()
 
   let fulltfolder = Path.normalize(Path.join(root, tfolder))
-  tname = getelem(tref.split('/'), -1)
+  tname = lastSegment(tref)
 
   let aliasref = tref
-  torigname = getelem(aliasref.split('/'), -1)
+  torigname = lastSegment(aliasref)
   const aliasing = tref.split('~')
   if (1 < aliasing.length) {
     aliasref = aliasing[0]
     tname = aliasing.slice(1).join('~')
-    torigname = getelem(aliasref.split('/'), -1)
+    torigname = lastSegment(aliasref)
   }
 
   const search: string[] = []
   let found = false
-  if (aliasref.includes('/')) {
+  // Windows: an absolute ref is `D:\a\...` or `D:/a/...`, and a Path.join'd
+  // one carries backslashes, so neither `includes('/')` nor `startsWith('/')`
+  // recognises it. Path.isAbsolute and Path.sep are platform-correct and
+  // reduce to the same answers on POSIX.
+  if (aliasref.includes('/') || aliasref.includes(Path.sep)) {
     // NOTE: the last path element of the ref is the target name, not a folder.
     const aliasbase = Path.dirname(aliasref)
 
-    if (!aliasref.startsWith('/')) {
+    if (!Path.isAbsolute(aliasref)) {
       fulltfolder = Path.normalize(Path.join(root, 'node_modules', aliasbase, '.sdk'))
       search.push(fulltfolder)
       found = fs.existsSync(fulltfolder)
@@ -251,12 +391,19 @@ function resolveTarget(tref: string, ctx$: any) {
     throw new Error('Target folder not found in:\n' + search.join('\n  '))
   }
 
-  const rootslash = root.endsWith('/') ? root : root + '/'
+  // `base` is the target folder relative to the project root. Compare with the
+  // PLATFORM separator: on Windows `root + '/'` never prefixes a normalised
+  // absolute path, so the root would not be stripped and `base` would stay
+  // absolute. Normalise both sides first for the same reason.
+  const nroot = Path.normalize(root)
+  const rootslash = nroot.endsWith(Path.sep) ? nroot : nroot + Path.sep
   const out = {
     tname,
     tfolder: fulltfolder,
     torigname,
-    base: fulltfolder.replace(rootslash, '')
+    base: fulltfolder.startsWith(rootslash)
+      ? fulltfolder.slice(rootslash.length)
+      : fulltfolder
   }
 
   return out
@@ -267,4 +414,6 @@ export {
   action_target,
   target_add,
   resolveTarget,
+  trimFeatures,
+  readTargetFeature,
 }

package/src/cmp/Entity.ts

@@ -5,6 +5,8 @@ import {
 
 import { requirePath } from '../utility'
 
+import { ensureStdrep } from '../helpers/stdrep'
+
 
 import {
   KIT,
@@ -16,6 +18,11 @@ const Entity = cmp(function Entity(props: any) {
   const { target, entity, ctx$ } = props
   const { log } = ctx$
 
+  // Entity_<lang> components pull stdrep off ctx$ for their fragments, and
+  // Entity is the FIRST phase Root runs — so the generator-owned keys have to
+  // exist by here, not just by Main.
+  ensureStdrep(ctx$)
+
   const entitySDK = getModelPath(ctx$.model, `main.${KIT}.entity.${entity.name}`)
 
   const Entity_sdk = requirePath(ctx$, `./cmp/${target.name}/Entity_${target.name}`)

package/src/cmp/ExternalTarget.ts

@@ -0,0 +1,125 @@
+// The Root for a target that generates OUTSIDE the SDK repo
+// (`main: kit: target: <t>: output: path`).
+//
+// WHY THIS EXISTS, rather than a folder name
+//
+// A target's files normally land in `<sdk-repo>/<target>/`, which the
+// consumer's own `Root.ts` arranges with `Folder({ name: target.name })`.
+// Two things stop that reaching a sibling repo:
+//
+//   - jostraca REFUSES a `..` segment in a Folder name (FileHandler.validName
+//     throws). Escaping the output root through a folder name is not an
+//     oversight to work around; it is the guard that keeps generation inside
+//     the tree it was pointed at.
+//   - the output root is `jopts.folder`, per generate() CALL. So writing
+//     somewhere else means another call, not another folder.
+//
+// So an out-of-tree target gets its own generate() pass, rooted at its
+// output path, with this as the Root. It renders ONE target and nothing
+// else: the consumer Root also emits the SDK repo's own furniture (its
+// README, AGENTS.md, the build scaffold), and none of that belongs in a
+// separate package's repo.
+//
+// No Folder wraps the target here — the destination IS the package, so its
+// files go at the root of the output path.
+//
+// The phase gate mirrors the consumer Root exactly, so `output.path` is not
+// a consumer-target feature: point a language target at another repo and it
+// generates there the same way it would in-tree.
+
+import { cmp, each, names } from 'jostraca'
+
+import { Project } from 'jostraca'
+
+import { KIT } from '@voxgig/apidef'
+
+import { Main } from './Main'
+import { Entity } from './Entity'
+import { Feature } from './Feature'
+import { Readme } from './Readme'
+import { Test } from './Test'
+import { AgentGuide } from './AgentGuide'
+
+
+const ExternalTarget = cmp(function ExternalTarget(props: any) {
+  const { model, target, cmpfolder, sdkrelpath } = props
+  const ctx$ = props.ctx$
+
+  ctx$.model = model
+
+  // Components live in the PROJECT, not in the repo being written to. This
+  // pass has retargeted jostraca's output folder, which is what requirePath
+  // otherwise resolves against — see utility.resolvePath.
+  ctx$.cmpfolder = cmpfolder
+
+  // The path from the destination back to the SDK project, for a target whose
+  // output sits beside the SDK in a known layout.
+  ctx$.sdkrelpath = sdkrelpath
+
+  // The same model preamble the consumer's Root.ts performs before it renders
+  // anything: the case-variant name constants (`Name`, `NAME`, ...) and the
+  // ProjectName replacement map that every template substitution reads.
+  //
+  // Done HERE rather than relied upon, because this pass gets the model the
+  // in-tree pass never touched — Root mutates the filtered copy it is handed,
+  // not this one — and because an SDK project with only out-of-tree targets
+  // must generate the same way as one with both.
+  model.const = model.const || { name: model.name }
+  names(model.const, model.name)
+  if (null == model.const.year) {
+    model.const.year = new Date().getFullYear()
+  }
+  names(model, model.name)
+
+  ctx$.stdrep = ctx$.stdrep || {}
+  names(ctx$.stdrep, model.Name, 'Project' + 'Name')
+
+  const entity = model.main[KIT].entity || {}
+  const feature = model.main[KIT].feature || {}
+
+  // Defaults are inclusive: a phase runs unless the target's model turns it
+  // off. Consumer targets (go-cli, go-mcp, py-data, seneca-provider) switch
+  // every phase off and emit everything from Main.
+  const phase = target.phase || {}
+  const phaseActive = (name: string): boolean =>
+    false !== (phase[name] && phase[name].active)
+
+  Project({}, () => {
+    names(target, target.name)
+
+    if (phaseActive('entity')) {
+      each(entity, (entity: any) => {
+        names(entity, entity.name)
+        Entity({ target, entity })
+      })
+    }
+
+    if (phaseActive('feature')) {
+      each(feature)
+        .filter((feature: any) => feature.active)
+        .map((feature: any) => {
+          names(feature, feature.name)
+          Feature({ target, feature })
+        })
+    }
+
+    Main({ target })
+
+    if (phaseActive('readme')) {
+      Readme({ target })
+    }
+
+    if (phaseActive('agentguide')) {
+      AgentGuide({ target })
+    }
+
+    if (phaseActive('test')) {
+      Test({ target })
+    }
+  })
+})
+
+
+export {
+  ExternalTarget,
+}

package/src/cmp/Feature.ts

@@ -1,6 +1,8 @@
 
 import { cmp, Copy, Folder } from 'jostraca'
 
+import { ensureStdrep } from '../helpers/stdrep'
+
 const Feature = cmp(function Feature(props: any) {
   const { target, feature, ctx$ } = props
   const { log } = ctx$
@@ -23,7 +25,7 @@ const Feature = cmp(function Feature(props: any) {
           // local Main_<lang> lost that Copy — got the raw placeholder.
           // voxgig-solardemo-sdk hit exactly that and could not build its
           // TypeScript at all.
-          ...ctx$.stdrep,
+          ...ensureStdrep(ctx$),
           FEATURE_VERSION: feature.version,
           FEATURE_Name: feature.Name,
         }

package/src/cmp/Main.ts

@@ -3,6 +3,8 @@ import { cmp, names } from 'jostraca'
 
 import { requirePath } from '../utility'
 
+import { ensureStdrep } from '../helpers/stdrep'
+
 import {
   KIT
 } from '../types'
@@ -10,7 +12,11 @@ import {
 
 const Main = cmp(function Main(props: any) {
   const { target, ctx$ } = props
-  const { model, stdrep, log } = ctx$
+  const { model, log } = ctx$
+
+  // Generator-owned placeholders (PROJECTENV) that the project's frozen
+  // Root.ts cannot know about.
+  const stdrep = ensureStdrep(ctx$)
 
   const Main_sdk = requirePath(ctx$, `cmp/${target.name}/Main_${target.name}`)
 

package/src/cmp/ReadmeExplanation.ts

@@ -11,7 +11,7 @@ import { requirePath } from '../utility'
 import { entityIdField, pickExampleEntity } from '../helpers/opShape'
 import { idLiteral, matchArg, dataArg } from '../helpers/opExample'
 import type { ExampleLang } from '../helpers/opExample'
-import { safeVarName, exampleVarName } from '../helpers/naming'
+import { safeVarName, exampleVarName, phpEntityAccessor } from '../helpers/naming'
 
 
 function cap(s: string): string {
@@ -110,7 +110,7 @@ with hook methods named after pipeline stages (e.g. \`PrePoint\`,
 stores the returned data and match criteria internally.
 
 \`\`\`php
-$${eLower} = $client->${eName}();
+$${eLower} = $client->${phpEntityAccessor(eName)}();
 $${eLower}->${op}(${arg});
 
 // $${eLower}->data_get() now returns the ${eLower} data from the last ${op}

package/src/cmp/ReadmeTop.ts

@@ -8,7 +8,10 @@ import {
 
 import { requirePath } from '../utility'
 
-import { entityPrimaryOp, entityIdField, opRequestShape } from '../helpers/opShape'
+import {
+  entityPrimaryOp, entityIdField, opRequestShape, entityPath, entityActions,
+} from '../helpers/opShape'
+import { matchArg, idLiteral } from '../helpers/opExample'
 import { canonKey } from '../helpers/canonType'
 import { safeVarName, exampleVarName } from '../helpers/naming'
 
@@ -241,10 +244,21 @@ ${aboutMd.trim()}
       // only remove (or nothing), the op line is omitted entirely.
       const primaryOp = entityPrimaryOp(exEnt)
       let exCall = ''
+      // A `list()` on a NESTED entity needs its parent path params — the
+      // quickstart used to emit `client.Moon().list()` for an entity at
+      // `/planet/{planet_id}/moon`, which 404s against a live server from a
+      // half-built URL. The model knows which params are required; matchArg
+      // renders exactly those.
+      const exIdField = entityIdField(exEnt)
+      const exListArg = matchArg('ts', exEnt, 'list', exIdField,
+        idLiteral(exEnt, 'list', exIdField))
+      const exLoadArg = matchArg('ts', exEnt, 'load', exIdField,
+        idLiteral(exEnt, 'load', exIdField))
+
       if ('list' === primaryOp) {
-        exCall = `const items = await client.${ex}().list()`
+        exCall = `const items = await client.${ex}().list(${exListArg})`
       } else if ('load' === primaryOp) {
-        exCall = `const ${exLower} = await client.${ex}().load()`
+        exCall = `const ${exLower} = await client.${ex}().load(${exLoadArg})`
       } else if ('create' === primaryOp || 'update' === primaryOp) {
         const exIdF = entityIdField(exEnt)
         const shapeItems = opRequestShape(exEnt, primaryOp).items
@@ -424,12 +438,11 @@ The API exposes ${activeEntities.length === 1 ? 'one entity' : activeEntities.le
         // Never emit a blank description cell: fall back to an ops-derived line.
         const entdesc = entityDesc[ent.name] || ent.short || ent.desc ||
           `The ${ent.Name} entity${opNames.length ? ' (' + opNames.join(', ') + ')' : ''}.`
-        const points = each(ops).map((op: any) =>
-          op.points ? each(op.points) : []
-        ).flat()
-        const path = points.length > 0
-          ? (points[0] as any).orig || ''
-          : ''
+        // The entity's canonical route — never a folded-in custom action.
+        // Ops iterate in sorted-key order, so this used to take `create`'s
+        // first point, and an entity with a `/{id}/forbid` action route
+        // advertised THAT as its API path.
+        const path = entityPath(ent)
         Content(`| **${ent.Name}** | ${entdesc} | \`${path}\` |
 `)
       })

package/src/cmp/Registered.ts

@@ -0,0 +1,100 @@
+// `registerComponent` — add a per-target component of your own.
+//
+// WHY THIS EXISTS
+//
+// Every built-in resolves its per-language half by convention:
+// `Main` loads `cmp/<target>/Main_<target>`, `Test` loads
+// `cmp/<target>/Test_<target>`, and `ReadmeTop` loads
+// `cmp/<target>/ReadmeTopQuick_<target>` with `{ ignore: true }` so a target
+// that has not implemented it is simply skipped.
+//
+// A PROJECT had no way into that mechanism. voxgig-solardemo-sdk wanted a
+// per-target `AGENTS.md` and had to hand-wire the dispatch in its own
+// `Root.ts`:
+//
+//   if ('ts' === target.name) { AgentsTs({ target }) }
+//   else if ('go' === target.name) { AgentsGo({ target }) }
+//
+// which duplicates the internal dispatch, does not scale past a couple of
+// targets, and — because the branches live inline in Root.ts — is exactly
+// what stops a project's root wiring from being resynced with the scaffold.
+//
+// With this, the same thing is one line and target-agnostic:
+//
+//   const Agents = registerComponent('Agents')
+//   ...
+//   Agents({ target })
+//
+// resolving `cmp/<target>/Agents_<target>` and doing nothing for a target
+// that has no such file. `doctor` reports those files as ADDITIVE — the
+// project's own work — rather than as drift.
+
+import { cmp } from 'jostraca'
+
+import { requirePath } from '../utility'
+
+import { ensureStdrep } from '../helpers/stdrep'
+
+
+type RegisterOptions = {
+  // Exported member to call. Defaults to the component name, matching every
+  // built-in (`Main_go.ts` exports `Main`).
+  export?: string
+
+  // Whether a target without the component is skipped (the default, matching
+  // ReadmeTop's optional per-target parts) or is an error.
+  optional?: boolean
+}
+
+
+function registerComponent(name: string, options: RegisterOptions = {}) {
+  const member = options.export || name
+  const optional = false !== options.optional
+
+  return cmp(function Registered(props: any) {
+    const { target, ctx$ } = props
+    const { model, log } = ctx$
+
+    const stdrep = ensureStdrep(ctx$)
+
+    const mod: any = requirePath(
+      ctx$, `./cmp/${target.name}/${name}_${target.name}`, { ignore: optional })
+
+    if (null == mod) {
+      log.debug({
+        point: 'generate-registered-absent', component: name, target: target.name,
+        note: name + ': not implemented for ' + target.name
+      })
+      return
+    }
+
+    const fn = mod[member]
+
+    if ('function' !== typeof fn) {
+      log.warn({
+        point: 'generate-registered-noexport', component: name,
+        target: target.name, member,
+        note: name + '_' + target.name + ' does not export ' + member
+      })
+      return
+    }
+
+    // Same call shape as the built-ins, plus whatever the caller passed —
+    // so a registered component is written exactly like Main_<lang>.
+    fn({ ...props, model, target, stdrep })
+
+    log.info({
+      point: 'generate-registered', component: name, target: target.name,
+      note: name + ': target:' + target.name
+    })
+  })
+}
+
+
+export type {
+  RegisterOptions,
+}
+
+export {
+  registerComponent,
+}

package/src/cmp/Test.ts

@@ -5,6 +5,8 @@ import {
 
 import { requirePath } from '../utility'
 
+import { ensureStdrep } from '../helpers/stdrep'
+
 
 import {
   KIT,
@@ -14,7 +16,8 @@ import {
 
 const Test = cmp(function Test(props: any) {
   const { target, ctx$ } = props
-  const { model, stdrep, log } = ctx$
+  const { model, log } = ctx$
+  const stdrep = ensureStdrep(ctx$)
 
   const Test_sdk = requirePath(ctx$, `./cmp/${target.name}/Test_${target.name}`)
   Test_sdk['Test']({ model, target, stdrep })