@voxgig/sdkgen 4.9.0 → 4.10.0

package/project/.sdk/src/cmp/rb/Config_rb.ts

@@ -33,6 +33,74 @@ import {
 } from './utility_rb'
 
 
+// PLUGIN DEFINITION REQUIRES AND THE FEATURE_PLUGINS MAP (the ruby peer of
+// cmp/py/Config_py.ts's pluginImports/pluginDefs).
+//
+// Upstream sekreto replaced its self-registration registry with
+// voxgig/plugin definitions: a provider kind the caller did not pass in via
+// `plugins: [...]` is unknown to that Sekreto. So config requires each
+// active plugin's module and names its exported definition CONSTANT (the
+// model's `def.rb` map), handing the list to the feature through
+// FEATURE_PLUGINS.
+//
+// The `def` map is declared in the model rather than derived from filenames
+// because one module may export several definitions (sekreto's aws.rb
+// exports AWSSECRETS and AWSPARAMS) - hence the de-duplication by path, so
+// a two-definition module yields ONE require. A def value is the module's
+// path under tm/rb, which is this target's root, so the require_relative is
+// that path without its extension.
+//
+// GATED, unlike go and py: the whole block is emitted only when an active
+// feature DECLARES a plugin catalogue for this target. An SDK that does not
+// carry the secrets feature must be byte-identical to what it was before
+// the feature existed, and an unread constant is not a thing a simple SDK
+// should have to explain.
+function rbPlugins(model: any, feature: any) {
+  // path -> [constant, ...], so one require serves a two-definition module.
+  const bypath: Record<string, string[]> = {}
+  const defs: Record<string, string[]> = {}
+  let declared = false
+
+  each(feature, (f: any) => {
+    // `only_active: false`, and this is the whole subtlety: the feature
+    // object a component is handed has ALREADY been filtered, so asking it
+    // whether a catalogue EXISTS answers no as soon as every group is off.
+    // (Same trap helpers/featureSource documents one level down.)
+    const all = getModelPath(model, `main.${KIT}.feature.${f.name}.plugin`,
+      { required: false, only_active: false }) || {}
+
+    if (0 < Object.keys(all).length) {
+      declared = true
+    }
+
+    const syms: string[] = []
+
+    each(f.plugin, (plugin: any) => {
+      // Filter on `active` HERE rather than trusting the feature object to
+      // arrive filtered: getting it wrong in this direction emits a require
+      // for a module the plugin trim just deleted - an SDK that does not
+      // load, rather than one that merely carries too much.
+      if (false === plugin.active || null == plugin.active) return
+
+      for (const [sym, one] of Object.entries(plugin.def?.rb || {})) {
+        const path = String(one)
+        ; (bypath[path] = bypath[path] || []).push(sym)
+        syms.push(sym)
+      }
+    })
+
+    if (0 < syms.length) {
+      defs[f.name] = syms.sort()
+    }
+  })
+
+  const requires = Object.keys(bypath).sort().map(
+    (path: string) => `require_relative '${path.replace(/\.rb$/, '')}'`)
+
+  return { requires, defs, declared }
+}
+
+
 const Config = cmp(async function Config(props: any) {
   const ctx$ = props.ctx$
   const target = props.target
@@ -80,12 +148,34 @@ const Config = cmp(async function Config(props: any) {
   const { def: configDef, json: configJson } = configDefinition(model, target.name)
   const asData = isConfigData(configJson, configReprSetting(model))
 
+  const { requires, defs, declared } = rbPlugins(model, feature)
+
+  const pluginRequireBlock = 0 === requires.length ? '' :
+    '\n' + requires.join('\n') + '\n'
+
+  // Emitted whenever a catalogue is declared, even with every group off:
+  // the feature module reads the map unconditionally, and an SDK whose
+  // chain is all built-ins still has to answer with an empty list.
+  const featurePluginsBlock = !declared ? '' :
+    `  # The sekreto plugin DEFINITIONS the model selected per feature,
+  # required above from the modules the catalogue's active \`plugin.def\`
+  # entries declare. Handed to each feature (secrets builds its Sekreto
+  # with them): a provider kind not listed here is unknown to this SDK.
+  FEATURE_PLUGINS = {
+` +
+    Object.keys(defs).sort().map((fname: string) =>
+      `    "${fname}" => [${defs[fname].join(', ')}],\n`).join('') +
+    `  }.freeze
+
+
+`
+
   File({ name: 'config.' + target.ext }, () => {
 
     Content(`# ${model.const.Name} SDK configuration
-${asData ? "\nrequire 'json'\n" : ''}
+${asData ? "\nrequire 'json'\n" : ''}${pluginRequireBlock}
 module ${model.const.Name}Config
-  # Return the process-wide config, built once on first use. The SDK reads
+${featurePluginsBlock}  # Return the process-wide config, built once on first use. The SDK reads
   # the config on every request and never writes to it, so one instance is
   # shared by every client rather than rebuilt per client.
   #

package/project/.sdk/src/cmp/rb/EntityTypes_rb.ts

@@ -50,11 +50,21 @@ function symName(name: string): string {
 // Emit one typed value class: a YARD @!attribute block plus a keyword-init
 // Struct. Ruby's `Struct.new` rejects zero members, so an empty shape falls
 // back to a plain empty class (keeps the type name available).
+//
+// A member with an EMPTY name is dropped first. `Struct.new(:"")` raises
+// `NameError: cannot make operator ID : attrset` when the file loads, which
+// takes the whole SDK down rather than just that type -- and quoting does
+// not help, since the empty symbol is the one Ruby will not accept (`:"a-b"`
+// and `:"1x"` are both fine). A model should not carry a nameless field, so
+// upstream is where it gets fixed; this keeps one bad field from costing the
+// target everything.
 function emitStruct(
   typeName: string,
   doc: string,
-  members: Array<{ name: string, type: unknown, optional: boolean }>,
+  allmembers: Array<{ name: string, type: unknown, optional: boolean }>,
 ) {
+  const members = allmembers.filter((m) => '' !== String(m.name ?? '').trim())
+
   let block = `# ${doc}\n`
 
   members.forEach((m) => {

package/project/.sdk/src/cmp/rb/Main_rb.ts

@@ -4,6 +4,7 @@ import * as Path from 'node:path'
 import {
   cmp, each, names, cmap,
   List, File, Content, Copy, Folder, Fragment, Line, FeatureHook,
+  pluginExcludes,
   targetFeatures,
   TEST_CONTROL_EXCLUDE
 } from '@voxgig/sdkgen'
@@ -45,7 +46,12 @@ const Main = cmp(async function Main(props: any) {
   // Copy tm/rb files with replacements
   Copy({
     from: 'tm/' + target.name,
-    exclude: [/src\//, TEST_CONTROL_EXCLUDE],
+    // pluginExcludes: the generate-time plugin trim (an INACTIVE plugin
+    // group's declared files stay out of the tree - the model's `path`
+    // entries are target-root-relative, which is this Copy's root). The
+    // FEATURE-level trim for rb stays an add-time concern (vendor-tag
+    // rollout, Decision 5).
+    exclude: [/src\//, TEST_CONTROL_EXCLUDE, ...pluginExcludes(model)],
     replace: {
       ...props.ctx$.stdrep,
     }

package/project/.sdk/src/cmp/rust/Main_rust.ts

@@ -5,6 +5,7 @@ import {
   cmp, each,
   File, Content, Copy, Folder, Fragment,
   entityClassName,
+  pluginExcludes,
   targetFeatures,
   TEST_CONTROL_EXCLUDE
 } from '@voxgig/sdkgen'
@@ -55,7 +56,11 @@ const Main = cmp(async function Main(props: any) {
   // here exactly like the go target.
   Copy({
     from: 'tm/' + target.name,
-    exclude: [/src\//, TEST_CONTROL_EXCLUDE],
+    // pluginExcludes: the generate-time plugin trim (an INACTIVE plugin
+    // group's declared files stay out of the tree - the model's `path`
+    // entries are target-root-relative, which is this Copy's root). The
+    // FEATURE-level trim for rust stays an add-time concern, as go's does.
+    exclude: [/src\//, TEST_CONTROL_EXCLUDE, ...pluginExcludes(model)],
     replace: {
       ...props.ctx$.stdrep,
       RUSTCRATE: rustcrate,
@@ -109,6 +114,99 @@ pub mod base;
 `)
       each(feature, (feat: any) => Content(`pub mod ${feat.name};\n`))
     })
+
+    // feature/<name>/plugins.rs - a feature's PLUGIN module index.
+    //
+    // GENERATED, and it has no go/py analogue: rust compiles only the
+    // modules a parent DECLARES, and the declared set varies with the
+    // plugin trim, so a static index would either name a file the trim
+    // just deleted or leave an active kind out of the build.
+    //
+    // It sits one level ABOVE the vendored `plugins/` directory on
+    // purpose: the vendoring guard fails any non-vendored file inside a
+    // vendor dir. Nothing is lost by that - an .rs file no module
+    // declares is not compiled at all, so an inactive group's vendored
+    // file left on disk is inert whether or not the trim reached it.
+    //
+    // This is rust's replacement for go's core-emitted FeaturePlugins map
+    // (Config_go), and it is better placed: core/config.rs never has to
+    // name a feature's types.
+    each(feature, (feat: any) => {
+      // `only_active: false`, the same subtlety pluginExcludesFor
+      // documents: the feature object a component is handed has already
+      // been filtered, so a feature whose plugins are ALL inactive would
+      // arrive with nothing here and the index would not be emitted at
+      // all - leaving `pub mod plugins;` in the feature source pointing
+      // at a file that does not exist.
+      const declared = getModelPath(model,
+        `main.${KIT}.feature.${feat.name}.plugin`,
+        { required: false, only_active: false }) || {}
+
+      if (0 === Object.keys(declared).length) {
+        return
+      }
+
+      const mods = new Set<string>()
+      const syms = new Set<string>()
+
+      each(declared, (plugin: any) => {
+        // Filter on `active` HERE (Config_go's note): getting this wrong
+        // declares a module for a file the trim just removed, which is a
+        // compile error rather than a silent one.
+        if (true !== plugin.active) return
+
+        for (const [sym, one] of Object.entries(plugin.def?.rust || {})) {
+          // 'feature/secrets/plugins/aws.rs' -> the module `aws`.
+          mods.add(String(one).replace(/^.*\//, '').replace(/\.rs$/, ''))
+          syms.add(sym)
+        }
+      })
+
+      // The shared HTTP client the vendored vault kinds import
+      // (`use super::httpjson::...`) belongs to NO plugin group - trimming
+      // it with any one group would delete a file the others compile
+      // against - so it ships with the feature core and is DECLARED here
+      // only when something reaches for it. That is what keeps rustls out
+      // of a chain that is [dotenv, env] or [secretspec].
+      const NOHTTP = ['secretspec']
+      const http = Array.from(mods).some((m: string) => !NOHTTP.includes(m))
+
+      Folder({ name: feat.name }, () => {
+        File({ name: 'plugins.' + target.ext }, () => {
+          Content(`// The plugin definitions the model selected for the \`${feat.name}\`
+// feature, and the modules they live in (generated - see Main_rust).
+//
+// Upstream sekreto's contract since its registry was retired: a provider
+// kind not handed to the constructor is unknown to that Sekreto. So this
+// list IS the SDK's provider vocabulary, and a kind nobody selected is
+// neither declared nor compiled.
+
+use crate::feature::${feat.name}::plugin::catalog::Definition;
+
+`)
+          if (http) {
+            Content(`pub mod httpjson;
+`)
+          }
+          for (const m of Array.from(mods).sort()) {
+            Content(`pub mod ${m};
+`)
+          }
+
+          Content(`
+pub fn definitions() -> Vec<Definition> {
+    vec![
+`)
+          for (const sym of Array.from(syms).sort()) {
+            Content(`        ${sym}(),
+`)
+          }
+          Content(`    ]
+}
+`)
+        })
+      })
+    })
   })
 
   // entity/mod.rs — the entity module index.

package/project/.sdk/src/cmp/rust/Package_rust.ts

@@ -5,6 +5,7 @@ import {
   cmp,
   collectDeps,
   packageVersion,
+  targetFeatures,
 } from '@voxgig/sdkgen'
 
 
@@ -49,17 +50,17 @@ path = "lib.rs"
       // deps require an explicit version.
       const version = d.source === 'target' ? (d.version || '*') : d.version
       if ('dev' === (d.raw as any)?.kind) {
-        dev[d.name] = version
+        dev[d.name] = depValue(version, d.raw)
       }
       else {
-        prod[d.name] = version
+        prod[d.name] = depValue(version, d.raw)
       }
     }
 
     Content(`[dependencies]
 `)
-    for (const [name, version] of Object.entries(prod)) {
-      Content(`${name} = "${version}"
+    for (const [name, value] of Object.entries(prod)) {
+      Content(`${name} = ${value}
 `)
     }
 
@@ -67,15 +68,80 @@ path = "lib.rs"
       Content(`
 [dev-dependencies]
 `)
-      for (const [name, version] of Object.entries(dev)) {
-        Content(`${name} = "${version}"
+      for (const [name, value] of Object.entries(dev)) {
+        Content(`${name} = ${value}
 `)
       }
     }
+
+    // [[test]] stanzas for the feature suites.
+    //
+    // cargo auto-discovers `tests/*.rs` and `tests/<dir>/main.rs`, but NOT
+    // `tests/<dir>/<dir>/main.rs` - and the two-level path is not
+    // negotiable: a feature's tests must live inside a `feature/`
+    // container so `target add` trims them WITH the feature
+    // (helpers/featureSource), exactly as go's tm/go/test/feature/secrets/
+    // and py's tm/py/test/feature/secrets/ do. A one-level
+    // tests/secrets/main.rs would auto-discover and then be left behind in
+    // a project that does not select the feature, carrying a suite that
+    // cannot compile.
+    //
+    // So the suite is DECLARED, and only for a feature that both applies
+    // to this target and is active in the model - which is also exactly
+    // when `target add` kept its directory.
+    const suites = Object.keys(targetFeatures(model, target))
+      .filter((name: string) => null != FEATURE_TESTS[name])
+      .sort()
+
+    for (const name of suites) {
+      Content(`
+[[test]]
+name = "${name}_feature"
+path = "${FEATURE_TESTS[name]}"
+`)
+    }
   })
 })
 
 
+// Which features ship a rust integration-test suite, and where its crate
+// root is. A map rather than a convention because the file has to EXIST:
+// cargo fails the whole manifest on a `[[test]]` path it cannot find, so
+// this may only name suites the templates actually carry.
+const FEATURE_TESTS: Record<string, string> = {
+  secrets: 'tests/feature/secrets/main.rs',
+}
+
+
+// One Cargo dependency's value: the bare version string, or the TABLE form
+// when the model asks for anything more.
+//
+// `default: false` and `features: [...]` are not decoration. The secrets
+// feature's vendored HTTP helper speaks rustls, and `rustls = "0.23"` with
+// DEFAULT features pulls aws-lc-rs/aws-lc-sys and a cmake C build, while
+// the ring feature set is what the target's existing `ureq` dep already
+// compiles. Without the table form, turning on one feature would add a
+// native toolchain requirement to every SDK that selected it.
+function depValue(version: string, raw: any): string {
+  const features: string[] = Array.isArray(raw?.features) ? raw.features : []
+  const nodefault = false === raw?.default
+
+  if (0 === features.length && !nodefault) {
+    return `"${version}"`
+  }
+
+  const parts = [`version = "${version}"`]
+  if (nodefault) {
+    parts.push('default-features = false')
+  }
+  if (0 < features.length) {
+    parts.push('features = [' + features.map((f) => `"${f}"`).join(', ') + ']')
+  }
+
+  return '{ ' + parts.join(', ') + ' }'
+}
+
+
 export {
   Package
 }

package/project/.sdk/src/cmp/scala/Config_scala.ts

@@ -45,6 +45,43 @@ const Config = cmp(async function Config(props: any) {
 
   const headers = getModelPath(model, `main.${KIT}.config.headers`) || {}
 
+  // PLUGIN DEFINITIONS, per feature (the scala peer of Config_go's
+  // featurePlugins map and Config_ts's pluginDefs).
+  //
+  // Since sekreto retired its import-time registry, provider kinds are
+  // voxgig/plugin definitions: a kind the caller did not pass in via
+  // `plugins` is unknown to that Sekreto. So the config names each active
+  // plugin's exported Definition and hands the list to the feature.
+  //
+  // The scala symbols are fully-qualified top-level `val`s
+  // (`com.voxgig.sekreto.plugins.hashicorp`), so unlike go there is no
+  // import to emit - and an inactive group therefore leaves no reference at
+  // all behind for the generate-time plugin trim to dangle.
+  //
+  // Typed List[Any], never List[Definition]: core must not name a vendored
+  // type, or a tree carrying the feature source without the feature selected
+  // would fail to compile.
+  const featurePlugins: Record<string, string[]> = {}
+  each(feature, (f: any) => {
+    const syms: string[] = []
+    each(f.plugin, (plugin: any) => {
+      // Filter on `active` HERE rather than trusting the feature object to
+      // arrive filtered (the trap Config_ts documents): naming a symbol the
+      // trim just deleted is a build break, not a warning.
+      if (false === plugin.active || null == plugin.active) return
+      for (const sym of Object.keys(plugin.def?.scala || {})) {
+        syms.push(sym)
+      }
+    })
+    if (0 < syms.length) {
+      featurePlugins[f.name] = syms.sort()
+    }
+  })
+
+  const featurePluginsBlock =
+    Object.keys(featurePlugins).sort().map((fname: string) =>
+      `    case "${fname}" => List(${featurePlugins[fname].join(', ')})\n`).join('')
+
   const authActive = isAuthActive(model)
   const authPrefix = resolveAuthPrefix(model)
 
@@ -114,6 +151,13 @@ object Config {
 
   def sharedConfig(): JMap[String, Object] = sharedConfigVal
 
+  // The plugin definitions the model selected per feature, as List[Any] so a
+  // feature consumes them without core naming a vendored type. Empty when no
+  // active feature declares active plugin groups for this target.
+  def featurePlugins(name: String): List[Any] = name match {
+${featurePluginsBlock}    case _ => Nil
+  }
+
   def makeFeature(name: String): Feature = name match {
 `)
 

package/project/.sdk/src/cmp/scala/Main_scala.ts

@@ -5,6 +5,7 @@ import {
   cmp, each,
   File, Content, Copy, Folder, Fragment,
   targetFeatures,
+  pluginExcludes,
   TEST_CONTROL_EXCLUDE
 } from '@voxgig/sdkgen'
 
@@ -43,6 +44,48 @@ const Main = cmp(async function Main(props: any) {
   // The Scala package root for every runtime piece (like GOMODULE for go).
   const scalapackage = scalaPackage(model)
 
+  // THE PLUGIN TRIM, over the WHOLE model rather than its active half.
+  //
+  // pluginExcludes(model) walks only the model's ACTIVE features
+  // (helpers/featureSource), which is right for a target whose feature trim
+  // is on: an inactive feature's whole tree is already gone at `target add`,
+  // so it has no plugin files left to exclude. Scala's feature trim is OFF
+  // (see the Copy below), so the opposite holds - an inactive feature's tree
+  // is all still here, and its plugins are the part of it that costs the
+  // most. Before this, a scala SDK whose model never mentioned `secrets`
+  // shipped and compiled all nine vendored provider clients: the one trim
+  // the target has walked straight past the feature that owns them.
+  //
+  // EVERY declared group of an inactive feature goes, not just the groups
+  // marked inactive. A feature that is off has no active plugins whatever
+  // its `plugin` map says - `main: kit: feature: secrets: { active: false
+  // plugin: vault: active: true }` selects nothing, because targetFeatures
+  // drops the feature before Config ever reads a group - so shipping vault's
+  // files for it would leave a provider client in the tree that nothing in
+  // the SDK can reach. That is why this reads the declared paths directly
+  // rather than reusing pluginExcludesFor, whose rule (exclude the groups
+  // marked `active: false`) is the right one only for a LIVE feature.
+  //
+  // Rooting matches pluginExcludes': scala's declared paths are
+  // target-root-relative, which is this Copy's root, and the other targets'
+  // paths in the same list cannot match anything in a scala tree.
+  const esc = (s: string) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+  const allfeature = getModelPath(model, `main.${KIT}.feature`,
+    { required: false, only_active: false }) || {}
+  const inactivePluginExcludes: RegExp[] = []
+  for (const fname of Object.keys(allfeature)) {
+    if (null != (feature as any)[fname]) continue
+    const groups = getModelPath(model, `main.${KIT}.feature.${fname}.plugin`,
+      { required: false, only_active: false }) || {}
+    for (const gname of Object.keys(groups)) {
+      for (const one of (groups[gname].path || [])) {
+        const pat = esc(String(one))
+        inactivePluginExcludes.push(new RegExp('(^|/)' +
+          pat.replace(/\\\/$/, '') + (/\/$/.test(String(one)) ? '/' : '$')))
+      }
+    }
+  }
+
   Package({ target })
 
   Gitignore({})
@@ -52,7 +95,31 @@ const Main = cmp(async function Main(props: any) {
   // ProjectName carries the SDK name into vendored template strings.
   Copy({
     from: 'tm/' + target.name,
-    exclude: [/src\//, TEST_CONTROL_EXCLUDE],
+    // The generate-time plugin trim, in both halves: pluginExcludes for an
+    // ACTIVE feature's inactive groups, inactivePluginExcludes (above) for
+    // the groups of a feature that is itself off. An inactive group's
+    // declared files stay out of the tree - the model's `path` entries are
+    // target-root-relative, which is this Copy's root.
+    //
+    // Scala's FEATURE-level trim is off (model/target/scala.aon `feature: {
+    // trim: false }`, because the cross-feature tests are fused into one
+    // sdktest/SdkTestMain.scala, which constructs fifteen feature classes by
+    // name), so this is the ONLY trim the target has, and what it does NOT
+    // reach is worth stating rather than leaving to be discovered: every
+    // feature's own source ships to every scala SDK whatever the model says,
+    // secrets included, so a secrets-off SDK still carries SecretsFeature,
+    // the vendored sekreto and voxgig/plugin cores, and the two UNGROUPED
+    // plugin files (plugins/Sigv4.scala's HMAC-SHA256 signer and
+    // plugins/Httpjson.scala's fetch + ProcessBuilder helpers, which belong
+    // to no group because four and eight kinds respectively compile against
+    // them). What it DOES reach is the nine provider clients, and they are
+    // the bulk: measured on a feature-off SDK, 26 files rather than 35.
+    exclude: [
+      /src\//,
+      TEST_CONTROL_EXCLUDE,
+      ...pluginExcludes(model),
+      ...inactivePluginExcludes,
+    ],
     replace: {
       ...props.ctx$.stdrep,
       ProjectName: model.const.Name,

package/project/.sdk/src/cmp/swift/Config_swift.ts

@@ -44,13 +44,64 @@ const Config = cmp(async function Config(props: any) {
   // matches the token-replaced runtime.
   const configJson = json.replace(/ProjectName/g, model.const.Name)
 
+  // PLUGIN DEFINITIONS AND THE featurePlugins MAP (the swift peer of
+  // Config_go's featurePlugins / Config_ts's pluginDefs).
+  //
+  // Upstream sekreto replaced its self-registration registry with
+  // voxgig/plugin definitions: a provider kind the caller did not pass in
+  // via `plugins:` is unknown to that Sekreto. So the config names each
+  // active plugin's exported Definition BY SYMBOL (the model's per-target
+  // `def.swift` map - `hashicorp`, a top-level `let` in the vendored
+  // SekretoPlugins module) and hands the list to the feature through
+  // SdkConfig.featurePlugins.
+  //
+  // Typed `[String: [Any]]`, as go types it `[]any`, so Config never has to
+  // name `Definition` - and so needs `import SekretoPlugins` only when a
+  // definition is actually listed. The feature reads the list back and
+  // downcasts.
+  //
+  // The ACCESSOR IS EMITTED UNCONDITIONALLY (empty map when nothing is
+  // selected). Its caller, feature/SecretsFeature.swift, ships whenever the
+  // feature is active, and java gated the accessor on "a feature declares a
+  // plugin block" - which a project that never selected secrets does not
+  // have - and shipped an SDK that did not compile (.handover-briefs/
+  // fixb-java.md). One rule: what a template may reference, Config always
+  // declares.
+  const featurePlugins: Record<string, string[]> = {}
+  each(feature, (f: any) => {
+    const syms: string[] = []
+    each(f.plugin, (plugin: any) => {
+      // Filter on `active` HERE rather than trusting the feature object to
+      // arrive filtered (see Config_ts.pluginImports: getting this wrong
+      // names a definition the trim just deleted, and swiftc fails the
+      // whole module on the unresolved symbol).
+      if (false === plugin.active || null == plugin.active) return
+      for (const sym of Object.keys(plugin.def?.swift || {})) {
+        syms.push(sym)
+      }
+    })
+    if (0 < syms.length) {
+      featurePlugins[f.name] = syms.sort()
+    }
+  })
+
+  const pluginImport = 0 === Object.keys(featurePlugins).length ? '' :
+    '\nimport SekretoPlugins\n'
+
+  const featurePluginsBlock = 0 === Object.keys(featurePlugins).length ?
+    '  private static let featurePluginsVal: [String: [Any]] = [:]\n' :
+    '  private static let featurePluginsVal: [String: [Any]] = [\n' +
+    Object.keys(featurePlugins).sort().map((fname: string) =>
+      `    "${fname}": [${featurePlugins[fname].join(', ')}],\n`).join('') +
+    '  ]\n'
+
   File({ name: 'Config.' + target.ext }, () => {
 
     Content(`// ${model.const.Name} SDK - generated model configuration and feature
 // factory. GENERATED from the API model - do not edit by hand.
 
 import Foundation
-
+${pluginImport}
 public enum SdkConfig {
   public static func makeConfig() -> VMap {
     let json = #"""
@@ -91,6 +142,16 @@ ${configJson}
     Content(`    default: return BaseFeature()
     }
   }
+
+  // The plugin definitions the model selected per feature, as [Any] so a
+  // feature can consume them without core naming the plugin module's
+  // types. Empty when no active feature declares active plugin groups for
+  // this target.
+${featurePluginsBlock}
+  // featurePlugins is the definitions list for one feature's chain.
+  public static func featurePlugins(_ name: String) -> [Any] {
+    return featurePluginsVal[name] ?? []
+  }
 }
 `)
   })