@voxgig/sdkgen 3.6.0 → 3.7.0

package/project/.sdk/src/cmp/lua/Package_lua.ts

@@ -4,6 +4,7 @@ import {
   File,
   cmp,
   collectDeps,
+  each,
   pkgDescription,
   keywords,
   repoInfo, packageName,
@@ -11,6 +12,11 @@ import {
 } from '@voxgig/sdkgen'
 
 
+import {
+  KIT,
+  getModelPath,
+} from '@voxgig/apidef'
+
 import type {
   Model,
 } from '@voxgig/apidef'
@@ -66,6 +72,23 @@ dependencies = {
 `)
     }
 
+    // Feature modules must be listed too, or an install-from-rock ships a
+    // features.lua whose requires cannot resolve. Emitted from the model
+    // (each = sorted order, byte-stable), plus the base feature every
+    // factory falls back to. The station feature additionally carries the
+    // VENDORED voxgig_station library beside its adapter (no voxgig-station
+    // rock exists to depend on - station design 9.2's registry-less tier).
+    const feature = getModelPath(model, `main.${KIT}.feature`)
+    let featureModules = `    ["feature.base_feature"] = "feature/base_feature.lua",\n`
+    each(feature, (f: any) => {
+      featureModules +=
+        `    ["feature.${f.name}_feature"] = "feature/${f.name}_feature.lua",\n`
+      if ('station' === f.name) {
+        featureModules +=
+          `    ["feature.station.voxgig_station"] = "feature/station/voxgig_station.lua",\n`
+      }
+    })
+
     Content(`}
 build = {
   type = "builtin",
@@ -74,7 +97,7 @@ build = {
     ["config"] = "config.lua",
     ["config_shared"] = "config_shared.lua",
     ["features"] = "features.lua",
-  }
+${featureModules}  }
 }
 `)
   })

package/project/.sdk/src/cmp/perl/Config_perl.ts

@@ -3,24 +3,15 @@ import {
   Content,
   File,
   cmp,
-  each,
-  isAuthActive,
-  resolveAuthPrefix,
+  configDefinition,
 } from '@voxgig/sdkgen'
 
 
 import {
-  KIT,
   Model,
-  getModelPath,
 } from '@voxgig/apidef'
 
 
-import {
-  clean,
-} from './utility_perl'
-
-
 // The config is emitted as a JSON heredoc parsed at load time by the
 // vendored struct utility (Voxgig::Struct::parse_json). This keeps
 // booleans/nulls faithful (Perl has no native boolean scalar) and yields
@@ -32,57 +23,14 @@ const Config = cmp(async function Config(props: any) {
 
   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)
-  // config.auth.prefix override -> spec-derived info.security.prefix -> 'Bearer'
-  const authPrefix = resolveAuthPrefix(model)
-
-  let baseUrl = ''
-  try { baseUrl = getModelPath(model, `main.${KIT}.info.servers.0.url`) } catch (_e) { }
-
-  // Build the config structure with deterministic (sorted) key order for
-  // the model-derived collections (each() iterates sorted).
-  const featureBlock: any = {}
-  each(feature, (f: any) => {
-    featureBlock[f.name] = clean(f.config || {})
-  })
-
-  const entityOptions: any = {}
-  each(entity, (ent: any) => {
-    entityOptions[ent.name] = {}
-  })
-
-  const entityBlock: any = {}
-  each(entity, (ent: any) => {
-    entityBlock[ent.name] = clean({
-      fields: ent.fields,
-      name: ent.name,
-      op: ent.op,
-      relations: ent.relations,
-    }, true)
-  })
+  // THE canonical config object, from the shared helper - this component
+  // used to hand-assemble its own (and had already drifted: no server
+  // block, no identity beyond main.name). Passing the target name opts
+  // in to the main slug/version/target identity fields (station
+  // descriptor inputs), matching the ts/js/rb targets.
+  const { def: configDef } = configDefinition(model, target.name)
 
-  const options: any = {
-    base: baseUrl,
-  }
-  if (authActive) {
-    options.auth = { prefix: authPrefix }
-  }
-  options.headers = headers
-  options.entity = entityOptions
-
-  const config = {
-    main: { name: model.const.Name },
-    feature: featureBlock,
-    options,
-    entity: entityBlock,
-  }
-
-  const configJson = JSON.stringify(config, null, 2)
+  const configJson = JSON.stringify(configDef, null, 2)
 
   File({ name: 'config.pm' }, () => {
 

package/project/.sdk/src/cmp/php/Config_php.ts

@@ -70,8 +70,10 @@ const Config = cmp(async function Config(props: any) {
   // The same config as an OBJECT, built by the shared helper so this target's
   // literal and the data that replaces it above the threshold are the same
   // config by construction. The JSON is what the threshold is measured on -
-  // emitted source size varies by language, the model does not.
-  const { json: configJson } = configDefinition(model)
+  // emitted source size varies by language, the model does not. Passing the
+  // target name opts in to the main.slug/version/target identity fields -
+  // both representations below carry them, keeping the reps interchangeable.
+  const { def: configDef, json: configJson } = configDefinition(model, target.name)
   const asData = isConfigData(configJson, configReprSetting(model))
 
   File({ name: 'config.' + target.ext }, () => {
@@ -174,6 +176,10 @@ class ${model.const.Name}Config
     }
     else {
 
+    // Identity beyond the camel Name: values from configDefinition's def, not
+    // re-derived here, so the literal rep and the data rep cannot disagree on
+    // identity (the slug is CARRIED, never derived from the camel name -
+    // station's descriptor reads all three; mirrors cmp/ts's #MainMeta).
     Content(`    /**
      * Build a fresh, fully materialised config array. Every call rebuilds the
      * whole structure, so prefer shared_config unless you need a private copy.
@@ -183,6 +189,9 @@ class ${model.const.Name}Config
         return [
             "main" => [
                 "name" => "${model.const.Name}",
+                "slug" => ${phps(configDef.main.slug)},
+                "version" => ${phps(configDef.main.version)},
+                "target" => ${phps(configDef.main.target)},
             ],
             "feature" => [
 `)

package/project/.sdk/src/cmp/php/Main_php.ts

@@ -130,6 +130,31 @@ class ${model.const.Name}Features
                 return new ${model.const.Name}BaseFeature();
         }
     }
+
+    /**
+     * Does a generated feature class back this name? False for a name only
+     * an options extend instance can supply (the station adopt path) - the
+     * constructor uses this to skip make_feature for such names instead of
+     * adding a stray BaseFeature.
+     */
+    public static function has_feature(string $name): bool
+    {
+        switch ($name) {
+            case "base":
+`)
+
+    each(feature, (feat: any) => {
+      if (feat.name !== 'base') {
+        Content(`            case "${feat.name}":
+`)
+      }
+    })
+
+    Content(`                return true;
+            default:
+                return false;
+        }
+    }
 }
 `)
   })

package/project/.sdk/src/cmp/php/fragment/Main.fragment.php

@@ -58,6 +58,12 @@ class ProjectNameSDK
 
         $this->_rootctx->options = $this->options;
 
+        // Feature INSTANCES supplied at construction (the station adopt
+        // path) are read from the RAW construction options - extend is
+        // consumed exactly once, here; make_options strips it from the
+        // processed map so options_map() stays clean data.
+        $extend_val = is_array($options["extend"] ?? null) ? $options["extend"] : [];
+
         // Add features in the resolved order (make_options puts an explicit
         // list order first, else defaults to test-first). Ordering matters: the
         // `test` feature installs the base mock transport and the transport
@@ -70,6 +76,20 @@ class ProjectNameSDK
                 foreach ($featureorder as $fname) {
                     $fopts = ProjectNameHelpers::to_map($feature_opts[$fname] ?? null);
                     if ($fopts && isset($fopts["active"]) && $fopts["active"] === true) {
+                        // An active name with no generated feature class is
+                        // legal when an extend-supplied instance carries that
+                        // name (station's adopt path): the instance is added
+                        // below, positioned by its own __after__ entry, so
+                        // skip it here rather than add a BaseFeature stray
+                        // that would silently shift feature positions.
+                        if (!ProjectNameFeatures::has_feature($fname)) {
+                            foreach ($extend_val as $ef) {
+                                if (is_object($ef) && method_exists($ef, 'get_name')
+                                    && $fname === $ef->get_name()) {
+                                    continue 2;
+                                }
+                            }
+                        }
                         ($utility->feature_add)($this->_rootctx, ProjectNameFeatures::make_feature($fname));
                     }
                 }
@@ -77,12 +97,9 @@ class ProjectNameSDK
         }
 
         // Add extension features.
-        $extend_val = Struct::getprop($this->options, "extend");
-        if (is_array($extend_val)) {
-            foreach ($extend_val as $f) {
-                if (is_object($f) && method_exists($f, 'get_name')) {
-                    ($utility->feature_add)($this->_rootctx, $f);
-                }
+        foreach ($extend_val as $f) {
+            if (is_object($f) && method_exists($f, 'get_name')) {
+                ($utility->feature_add)($this->_rootctx, $f);
             }
         }
 

package/project/.sdk/src/cmp/py/Config_py.ts

@@ -67,8 +67,10 @@ const Config = cmp(async function Config(props: any) {
   // The same config as an OBJECT, built by the shared helper so this target's
   // literal and the data that replaces it above the threshold are the same
   // config by construction. The JSON is what the threshold is measured on -
-  // emitted source size varies by language, the model does not.
-  const { json: configJson } = configDefinition(model)
+  // emitted source size varies by language, the model does not. Passing the
+  // target name opts in to the main.slug/version/target identity fields -
+  // the literal path below emits them too, keeping the two reps in step.
+  const { def: configDef, json: configJson } = configDefinition(model, target.name)
   const asData = isConfigData(configJson, configReprSetting(model))
 
   File({ name: 'config.' + target.ext }, () => {
@@ -130,6 +132,10 @@ def make_config():
       return
     }
 
+    // Identity values from configDefinition's def, not re-derived here, so
+    // the literal rep and the data rep cannot disagree on identity (the
+    // slug is CARRIED, never derived from the camel name - station's
+    // descriptor reads all three; see cmp/ts/Config_ts.ts #MainMeta).
     Content(`def make_config():
     """Build a fresh, fully materialised config dict.
 
@@ -139,6 +145,9 @@ def make_config():
     return {
         "main": {
             "name": "${model.const.Name}",
+            "slug": ${JSON.stringify(configDef.main.slug)},
+            "version": ${JSON.stringify(configDef.main.version)},
+            "target": ${JSON.stringify(configDef.main.target)},
         },
         "feature": {
 `)

package/project/.sdk/src/cmp/py/Main_py.ts

@@ -158,24 +158,34 @@ from ${model.const.Name.toLowerCase()}_sdk.feature.base_feature import ${model.c
 
     Content(`
 
-def _make_feature(name):
-    features = {
-        "base": lambda: ${model.const.Name}BaseFeature(),
+_FEATURES = {
+    "base": lambda: ${model.const.Name}BaseFeature(),
 `)
 
     each(feature, (feat: any) => {
       if (feat.name !== 'base') {
         const fname = feat.name.charAt(0).toUpperCase() + feat.name.slice(1)
-        Content(`        "${feat.name}": lambda: ${model.const.Name}${fname}Feature(),
+        Content(`    "${feat.name}": lambda: ${model.const.Name}${fname}Feature(),
 `)
       }
     })
 
-    Content(`    }
-    factory = features.get(name)
+    Content(`}
+
+
+def _make_feature(name):
+    factory = _FEATURES.get(name)
     if factory is not None:
         return factory()
-    return features["base"]()
+    return _FEATURES["base"]()
+
+
+# True when this SDK was generated with the named feature class - the
+# constructor's tolerance for extend-carried features reads this (an
+# active name with no generated class must not become a BaseFeature
+# stray when an extend instance carries it).
+def _has_feature(name):
+    return name in _FEATURES
 `)
   })
 

package/project/.sdk/src/cmp/py/fragment/Main.fragment.py

@@ -10,7 +10,7 @@ from projectname_sdk.utility import register
 
 # Load features
 from projectname_sdk.feature.base_feature import ProjectNameBaseFeature
-from projectname_sdk.features import _make_feature
+from projectname_sdk.features import _has_feature, _make_feature
 
 
 class ProjectNameSDK:
@@ -46,21 +46,38 @@ class ProjectNameSDK:
         # `test` feature installs the base mock transport and the transport
         # features (retry/cache/netsim/proxy/ratelimit) wrap whatever is
         # current, so `test` must be added before them to sit at the base.
+        # Extension feature INSTANCES come from the RAW construction
+        # options - extend is consumed exactly once, here. make_options
+        # strips the key before cloning (vs.clone flattens arbitrary
+        # objects), so self.options never carries the instances.
         feature_opts = helpers.to_map(vs.getprop(self.options, "feature"))
+        extend = options.get("extend") if isinstance(options, dict) else None
+        if not isinstance(extend, list):
+            extend = []
         if feature_opts is not None:
             featureorder = vs.getpath(self.options, "__derived__.featureorder")
             if isinstance(featureorder, list):
                 for fname in featureorder:
                     fopts = helpers.to_map(feature_opts.get(fname))
                     if fopts is not None and fopts.get("active") is True:
+                        # An active name with no generated feature class is
+                        # legal when an extend-supplied instance carries that
+                        # name (station's adopt path): the instance is added
+                        # below, positioned by its own __after__ entry, so
+                        # skip it here rather than add a BaseFeature stray
+                        # that would silently shift feature positions.
+                        if not _has_feature(fname) and any(
+                            fname == (f.get("name") if isinstance(f, dict)
+                                      else getattr(f, "name", None))
+                            for f in extend
+                        ):
+                            continue
                         utility.feature_add(self._rootctx, _make_feature(fname))
 
         # Add extension features.
-        extend = vs.getprop(self.options, "extend")
-        if isinstance(extend, list):
-            for f in extend:
-                if isinstance(f, dict) or (hasattr(f, "get_name") and callable(f.get_name)):
-                    utility.feature_add(self._rootctx, f)
+        for f in extend:
+            if isinstance(f, dict) or (hasattr(f, "get_name") and callable(f.get_name)):
+                utility.feature_add(self._rootctx, f)
 
         # Initialize features.
         for f in self.features:

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

@@ -71,7 +71,10 @@ const Config = cmp(async function Config(props: any) {
   // literal and the data that replaces it above the threshold are the same
   // config by construction. The JSON is what the threshold is measured on -
   // emitted source size varies by language, the model does not.
-  const { json: configJson } = configDefinition(model)
+  // Passing the target name opts in to the main slug/version/target identity
+  // fields (station descriptor inputs) - the literal path below emits them
+  // too, keeping data and literal reps in step.
+  const { def: configDef, json: configJson } = configDefinition(model, target.name)
   const asData = isConfigData(configJson, configReprSetting(model))
 
   File({ name: 'config.' + target.ext }, () => {
@@ -127,6 +130,9 @@ module ${model.const.Name}Config
     {
       "main" => {
         "name" => "${model.const.Name}",
+        "slug" => ${rbs(String(configDef.main.slug))},
+        "version" => ${rbs(String(configDef.main.version))},
+        "target" => ${rbs(String(configDef.main.target))},
       },
       "feature" => {
 `)

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

@@ -50,8 +50,11 @@ const Config = cmp(async function Config(props: any) {
   // representations render from the same `def`, so they cannot describe
   // different configs - and this target picks up `options.server` (the
   // OpenAPI server-variable defaults), which the hand-rolled build here
-  // omitted entirely.
-  const { def: config, json: configJson } = configDefinition(model)
+  // omitted entirely. Passing target.name opts into the main
+  // slug/version/target identity fields (station descriptor input, mirrors
+  // Config_ts) - both reps below render from this same def, so the data
+  // and literal branches pick the fields up together.
+  const { def: config, json: configJson } = configDefinition(model, target.name)
   const asData = isConfigData(configJson, configReprSetting(model))
 
   File({ name: 'config.' + target.ext }, () => {

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

@@ -3,9 +3,8 @@ import {
   Content,
   File,
   cmp,
+  configDefinition,
   each,
-  isAuthActive,
-  resolveAuthPrefix,
 } from '@voxgig/sdkgen'
 
 
@@ -16,11 +15,6 @@ import {
 } from '@voxgig/apidef'
 
 
-import {
-  clean,
-} from './utility_swift'
-
-
 // Generates core/Config.swift: the SdkConfig enum holding the generated model
 // config (makeConfig, materialised at runtime by parsing an embedded JSON
 // literal - pure data, so a JSON round-trip is faithful and avoids emitting
@@ -32,59 +26,19 @@ const Config = cmp(async function Config(props: any) {
 
   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) { }
-
-  // Assemble the config object (pure JSON data).
-  const featureConfigs: any = {}
-  each(feature, (f: any) => {
-    featureConfigs[f.name] = f.config || {}
-  })
-
-  const optionsEntity: any = {}
-  each(entity, (ent: any) => {
-    optionsEntity[ent.name] = {}
-  })
-
-  const entityDefs: any = {}
-  each(entity, (ent: any) => {
-    entityDefs[ent.name] = clean({
-      fields: ent.fields,
-      name: ent.name,
-      op: ent.op,
-      relations: ent.relations,
-    }, true)
-  })
-
-  const options: any = {
-    base: baseUrl,
-    headers,
-    entity: optionsEntity,
-  }
-  if (authActive) {
-    options.auth = { prefix: authPrefix }
-  }
-
-  const configObj = {
-    main: { name: model.const.Name },
-    feature: featureConfigs,
-    options,
-    entity: entityDefs,
-  }
+  // The config as data, built by the shared helper so every target embeds
+  // the same model by construction. Passing target.name opts this target
+  // into main.slug / main.version / main.target (the three station
+  // descriptor identity fields, station design §4); swift has only the
+  // JSON-literal rep, so that one call covers every rep this target emits.
+  const { json } = configDefinition(model, target.name)
 
   // Model-data defaults may carry the ProjectName placeholder (e.g. the
   // clienttrack clientName); resolve it to the API name so the embedded JSON
   // matches the token-replaced runtime.
-  const configJson = JSON.stringify(configObj, null, 2)
-    .replace(/ProjectName/g, model.const.Name)
+  const configJson = json.replace(/ProjectName/g, model.const.Name)
 
   File({ name: 'Config.' + target.ext }, () => {
 

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

@@ -17,8 +17,30 @@ import type {
 // under Sources/ProjectNameSDK (the copied runtime + generated sources); the
 // test target compiles Tests/ProjectNameSDKTests. Directory names are the
 // verbatim copied paths (Copy does not rewrite path components); the target
-// NAMES carry the API name. Runtime is dependency-free (Foundation + the
-// vendored struct); target/feature deps, when declared, become SwiftPM deps.
+// NAMES carry the API name.
+//
+// Dependencies: the runtime itself is dependency-free (Foundation + the
+// vendored struct), but declared target/feature deps flow into the manifest
+// via collectDeps. SwiftPM cannot name a package by product alone, so a
+// swift deps entry carries its coordinates in a documented convention:
+//
+//   deps: swift: {
+//     'VoxgigStation': { active: true, version: '0.0.1', kind: prod,
+//       url: 'https://github.com/voxgig/station-swift' }
+//   }
+//
+//   - the entry KEY is the SwiftPM PRODUCT name (also the module the
+//     generated source imports);
+//   - the extra `url` field is the git repository SwiftPM resolves
+//     (`.package(url:from:)`); the package identity SwiftPM derives from it
+//     is the URL's last path component (minus any .git), which is what the
+//     `.product(name:package:)` reference must use;
+//   - `version` feeds `from:` - a plain semver (any leading range operator
+//     like '>=' is stripped, since `from:` already means >=).
+//
+// An entry WITHOUT a `url` is not expressible in a SwiftPM manifest (no
+// registry-less by-name dependencies), so it is skipped - unadorned entries
+// keep today's zero-dependency output.
 const Package = cmp(async function Package(props: any) {
   const ctx$ = props.ctx$
   const target = props.target
@@ -27,28 +49,48 @@ const Package = cmp(async function Package(props: any) {
 
   const Name = model.const.Name
 
-  const deps: Record<string, string> = {}
+  type SwiftDep = { product: string, url: string, from: string, identity: string }
+  const deps: SwiftDep[] = []
   for (const d of collectDeps(model, target.name, target.deps, ctx$.log)) {
-    deps[d.name] = d.source === 'target' ? (d.version || '0.0.0') : d.version
+    const url = 'string' === typeof (d.raw as any)?.url ? (d.raw as any).url : ''
+    if ('' === url) {
+      continue
+    }
+    const from = (d.version || '0.0.0').replace(/^[^0-9]+/, '')
+    const identity = (url.split('/').pop() || '').replace(/\.git$/, '')
+    deps.push({ product: d.name, url, from, identity })
   }
-  // Vendored, dependency-free by design; declared deps (if any) are ignored
-  // here since the runtime imports only Foundation + the in-tree struct.
+
+  const pkgdeps = 0 === deps.length ? '' :
+    '\n    dependencies: [\n' +
+    deps.map((d) =>
+      `        .package(url: "${d.url}", from: "${d.from}"),\n`).join('') +
+    '    ],'
+
+  const targetdeps = 0 === deps.length ? '' :
+    '\n            dependencies: [\n' +
+    deps.map((d) =>
+      `                .product(name: "${d.product}", package: "${d.identity}"),\n`)
+      .join('') +
+    '            ],'
 
   File({ name: 'Package.swift' }, () => {
     Content(`// swift-tools-version:5.9
 //
-// ${Name} SDK - SwiftPM manifest. Zero runtime dependencies (Foundation +
-// the vendored Voxgig Struct port under Sources/ProjectNameSDK/Struct).
+// ${Name} SDK - SwiftPM manifest. The runtime itself is dependency-free
+// (Foundation + the vendored Voxgig Struct port under
+// Sources/ProjectNameSDK/Struct); declared feature/target deps (if any)
+// appear below.
 import PackageDescription
 
 let package = Package(
     name: "${Name}Sdk",
     products: [
         .library(name: "${Name}Sdk", targets: ["${Name}Sdk"]),
-    ],
+    ],${pkgdeps}
     targets: [
         .target(
-            name: "${Name}Sdk",
+            name: "${Name}Sdk",${targetdeps}
             path: "Sources/ProjectNameSDK"),
         .testTarget(
             name: "${Name}SdkTests",

package/project/.sdk/src/cmp/ts/Config_ts.ts

@@ -81,7 +81,7 @@ const Config = cmp(async function Config(props: any) {
   // literal and the data that replaces it above the threshold are the same
   // config by construction. The JSON is what the threshold is measured on -
   // emitted source size varies by language, the model does not.
-  const { json: configJson } = configDefinition(model)
+  const { def: configDef, json: configJson } = configDefinition(model, target.name)
   const asData = isConfigData(configJson, configReprSetting(model))
 
   File({ name: 'Config.' + target.ext }, () => {
@@ -128,6 +128,14 @@ const Config = cmp(async function Config(props: any) {
             `'./feature/${f.name}/${nom(f, 'Name')}Feature'`)
         }),
 
+        // Values from configDefinition's def, not re-derived here, so the
+        // literal rep and the data rep cannot disagree on identity.
+        '// #MainMeta': () => {
+          Line(`    slug: ${JSON.stringify(configDef.main.slug)},`)
+          Line(`    version: ${JSON.stringify(configDef.main.version)},`)
+          Line(`    target: ${JSON.stringify(configDef.main.target)},`)
+        },
+
         '// #FeatureClasses': () => each(feature, (f: any) => {
           // Trailing comma: the map has one entry per feature, so entries
           // must be comma-separated (a single feature hid this until now).

package/project/.sdk/src/cmp/ts/EntityTypes_ts.ts

@@ -21,7 +21,7 @@ import {
   File, Content,
 } from '@voxgig/sdkgen'
 
-import { canonToType, opTypeName, opRequestShape, warnEntityTypeCollisions , deriveEntityNames, opActions } from '@voxgig/sdkgen'
+import { canonToType, opTypeName, opRequestShape, warnEntityTypeCollisions , deriveEntityNames, opActions, tsSafeTypeName } from '@voxgig/sdkgen'
 
 import {
   KIT,
@@ -74,11 +74,14 @@ const EntityTypes = cmp(function EntityTypes(props: any) {
 
     entityList.forEach((ent: any) => {
       const Name = ent.Name
+      // A TS/JS global (Record, Array, Promise, ...) would shadow itself
+      // for the rest of the file — see tsSafeTypeName.
+      const TypeName = tsSafeTypeName(Name)
       const fields = (ent.fields ? each(ent.fields) : [])
         .filter((f: any) => f.active !== false)
 
       // Entity data model: one property per field, `req:false` -> optional.
-      Content(`export interface ${Name} {
+      Content(`export interface ${TypeName} {
 `)
       fields.forEach((f: any) => {
         const opt = false === f.req ? '?' : ''