@voxgig/sdkgen 3.5.0 → 3.6.0

package/src/helpers/naming.ts

@@ -112,17 +112,67 @@ function isRbCoreConstant(Name: string): boolean {
 }
 
 
+// RUBY SDK-OWNED CONSTANTS — the OTHER half of "already taken".
+//
+// `RB_CORE_CONSTANTS` guards names the LANGUAGE owns. This guards names the
+// GENERATED SCAFFOLDING claims for itself, which is a distinct hazard and the
+// one that stayed open: an entity named `Runner` produced `class Runner` in
+// `<Sdk>_types.rb`, and the generated harness then does
+//
+//   Runner = ProjectNameTestRunner        # tm/rb/test/runner.rb
+//
+// so inside the test process the entity TYPE silently *is* the test runner.
+// Ruby warns (`already initialized constant Runner`) and carries on, which is
+// why it survived: nothing in the suite exercises the type, so `rb` passed.
+// Reported on gitlab-sdk, which has a `Runner` entity (issue #64).
+//
+// EVERYTHING SHARES ONE NAMESPACE HERE, unlike swift. Swift's Tests module is
+// separate from the SDK module, so `SWIFT_SDK_TYPES` can exclude test-only
+// declarations. Ruby has no such split — the types file and the test files are
+// all required into one process when the suite runs, which is exactly the
+// reported symptom — so test-declared names belong in this set.
+//
+// PREFIXED DECLARATIONS ARE DELIBERATELY ABSENT. `ProjectNameUtility` and
+// friends substitute to `<Sdk>Utility`, and a generated entity type is the
+// bare entity name, so those cannot collide. Only the UNPREFIXED declarations
+// are reachable.
+//
+// `rb-sdk-constants.test.ts` re-derives this list from the templates AND the
+// components and fails on drift — the same discipline as
+// `swift-sdk-types.test.ts`, and for the same reason: the first cut of that
+// list was collected by hand and missed three names, one of them declared by
+// a component rather than a template.
+const RB_SDK_CONSTANTS = new Set<string>([
+  // module-level aliases the test harness defines for convenience
+  'Helpers', 'Runner', 'Vs',
+  // vendored struct library and its test scaffolding
+  'StructRunner', 'StructTestClient', 'StructUtilityTest', 'VoxgigStruct',
+  'STRUCT_TEST_JSON_FILE',
+  // the generated/templated test classes
+  'ExistsTest', 'FeatureTest', 'NetsimTest', 'PipelineTest',
+  'PrimaryUtilityTest', 'ReadmeExamplesTest', 'TestHookFeature',
+  'TestInitFeature',
+])
+
+
+// Does `Name` collide with a constant the generated Ruby SDK already declares?
+function isRbSdkConstant(Name: string): boolean {
+  return RB_SDK_CONSTANTS.has(Name)
+}
+
+
 // A top-level-safe Ruby constant name for a generated type: the name
-// unchanged, unless Ruby core already owns it, in which case `Type` is
-// appended (`File` -> `FileType`). Applied ONLY to the bare entity data type
-// — the per-op type names always carry a suffix (`FileCreateData`,
-// `FileLoadMatch`), which no core constant matches.
+// unchanged, unless it is ALREADY TAKEN — by Ruby core, or by the SDK's own
+// scaffolding — in which case `Type` is appended (`File` -> `FileType`,
+// `Runner` -> `RunnerType`). Applied ONLY to the bare entity data type: the
+// per-op type names always carry a suffix (`FileCreateData`,
+// `FileLoadMatch`), which nothing in either set matches.
 //
 // The entity ACCESSOR keeps its original name (`client.File(...)`): methods
 // and constants live in separate namespaces in Ruby, so the accessor never
 // collided and the public surface is unchanged.
 function rbSafeTypeName(Name: string): string {
-  return isRbCoreConstant(Name) ? Name + 'Type' : Name
+  return isRbCoreConstant(Name) || isRbSdkConstant(Name) ? Name + 'Type' : Name
 }
 
 
@@ -195,6 +245,77 @@ function swiftSafeTypeName(Name: string): string {
 }
 
 
+// PHP RESERVED WORDS THAT CANNOT BE A CLASS NAME — a fourth hazard, and the
+// only one of the four where the check must be CASE-INSENSITIVE.
+//
+// PHP's grammar refuses a reserved word where a class name is expected, so a
+// spec with a `Namespace` entity emitted a file that does not parse at all:
+//
+//   /** Namespace entity data model. */
+//   class Namespace
+//   {
+//   }
+//   -> PHP Parse error: syntax error, unexpected token "namespace",
+//                       expecting identifier
+//
+// Found on gitlab-sdk (issue #64), and LATENT in the worst way: `types/` is on
+// the composer classmap but nothing references the file, so PHP never loads it
+// and the php lane passed for as long as the target has existed. It would
+// fatal the moment anything required it, and the documented type is unusable
+// either way.
+//
+// CASE-INSENSITIVITY IS THE WHOLE TRICK. Class and function names in PHP are
+// case-insensitive, so `Namespace`, `NAMESPACE` and `namespace` are one
+// identifier — and the generated name is PascalCase while the reserved word is
+// lowercase. A case-sensitive `Set.has('Namespace')` against a lowercase list
+// therefore matches NOTHING and reopens the bug silently. Entries are stored
+// folded, and the lookup folds too.
+//
+// Taken from the PHP manual's reserved-words tables wholesale rather than
+// grown one collision at a time: the list is fixed by the language, and
+// picking from it by hand is how the second `Namespace` gets shipped.
+const PHP_RESERVED_TYPES = new Set<string>([
+  // keywords
+  'abstract', 'and', 'array', 'as', 'break', 'callable', 'case', 'catch',
+  'class', 'clone', 'const', 'continue', 'declare', 'default', 'do', 'echo',
+  'else', 'elseif', 'empty', 'enddeclare', 'endfor', 'endforeach', 'endif',
+  'endswitch', 'endwhile', 'enum', 'eval', 'exit', 'extends', 'final',
+  'finally', 'fn', 'for', 'foreach', 'function', 'global', 'goto', 'if',
+  'implements', 'include', 'include_once', 'instanceof', 'insteadof',
+  'interface', 'isset', 'list', 'match', 'namespace', 'new', 'or', 'print',
+  'private', 'protected', 'public', 'readonly', 'require', 'require_once',
+  'return', 'static', 'switch', 'throw', 'trait', 'try', 'unset', 'use',
+  'var', 'while', 'xor', 'yield',
+  // compile-time constants
+  '__class__', '__dir__', '__file__', '__function__', '__line__',
+  '__method__', '__namespace__', '__trait__',
+  // reserved as type names / cannot be declared as a class
+  'bool', 'false', 'float', 'int', 'iterable', 'mixed', 'never', 'null',
+  'numeric', 'object', 'parent', 'resource', 'self', 'string', 'true', 'void',
+])
+
+
+// Does `Name` collide with a word PHP reserves, ignoring case as PHP does?
+function isPhpReservedType(Name: string): boolean {
+  return PHP_RESERVED_TYPES.has(String(Name).toLowerCase())
+}
+
+
+// A declarable PHP class name for a generated type: unchanged, unless PHP
+// reserves the word, in which case `Type` is appended (`Namespace` ->
+// `NamespaceType`). Mirrors rbSafeTypeName and swiftSafeTypeName deliberately
+// — same suffix, same "only rename on an actual collision" rule, so every SDK
+// that does not collide is byte-identical to before.
+//
+// Applied ONLY to the bare entity data class. Per-op type names already carry
+// their own suffix (`NamespaceLoadData`, `NamespaceCreateData`), which no
+// reserved word matches, and the entity ACCESSOR is a method rather than a
+// class — PHP resolves those separately — so the public surface is unchanged.
+function phpSafeTypeName(Name: string): string {
+  return isPhpReservedType(Name) ? Name + 'Type' : Name
+}
+
+
 // Is `name` a reserved word (an illegal identifier) in the target language?
 function isReservedName(name: string, lang: string): boolean {
   const set = RESERVED[lang]
@@ -328,9 +449,12 @@ export {
   phpEntityAccessor,
   entityCacheField,
   isRbCoreConstant,
+  isRbSdkConstant,
   rbSafeTypeName,
   isSwiftSdkType,
   swiftSafeTypeName,
+  isPhpReservedType,
+  phpSafeTypeName,
   jsProp,
   jsOptProp,
   jsKey,

package/src/helpers/opShape.ts

@@ -189,6 +189,72 @@ function entityPath(entity: any): string {
 }
 
 
+// The entity's OWN endpoint among an op's points.
+//
+// The other notion of canonical above — "not a `$action` route" — separates a
+// folded-in custom action from the real op. This one separates the entity's
+// own route from a CROSS-REFERENCE: another resource's route that happens to
+// return this entity (`/notifications/{id}/board` for a board). Both are
+// plain GETs with no `$action`, so the path itself is all there is to go on.
+//
+// Two signals, in order:
+//
+//   1. A record route ends in the record's identifier (`/boards/{id}`,
+//      `/accounts/{account_id}/users/{id}`); a cross-reference ends in the
+//      relationship's name (`/posts/{id}/author`). A terminal parameter is
+//      the stronger signal, and unlike depth alone it survives an entity
+//      nested more deeply than the route that points at it — depth by itself
+//      picked `/posts/{id}/author` over `/accounts/{account_id}/users/{id}`
+//      and then generated that op's required params from the wrong route.
+//   2. Failing that, fewest path segments — the shallower route is the one
+//      the entity is named for, which is what settles a `list` op where
+//      neither route ends in an id (`/boards` over `/members/{id}/boards`).
+//
+// Ties keep the earlier point, so the sorted-key order of the model decides
+// and the output stays byte-stable.
+//
+// The same rule runs at RUNTIME, in each language's makePoint template, when
+// no point's `select.exist` matches. It cannot be shared with them — a
+// template ships standalone, outside this package — so it is written twice on
+// purpose, and both sides must move together.
+function terminalParam(point: any): boolean {
+  const parts: any[] = (point && point.parts) || []
+  const last = 0 < parts.length ? parts[parts.length - 1] : ''
+  return 'string' === typeof last && last.startsWith('{')
+}
+
+
+function ownPoint(points: any[]): any {
+  let best = points[0]
+
+  for (const pt of points) {
+    if (null == pt || null == pt.parts || null == best || null == best.parts) {
+      continue
+    }
+
+    const ptterm = terminalParam(pt)
+    const bestterm = terminalParam(best)
+
+    if (ptterm !== bestterm ? ptterm : pt.parts.length < best.parts.length) {
+      best = pt
+    }
+  }
+
+  return best
+}
+
+
+// Do all these points describe the same route? Then they are alternative
+// selectors on one endpoint (the same path, chosen by different query
+// params), not cross-references to different resources.
+function samePath(points: any[]): boolean {
+  const first = ((points[0] && points[0].parts) || []).join('/')
+
+  return points.every((pt: any) =>
+    first === ((pt && pt.parts) || []).join('/'))
+}
+
+
 function opParams(op: any): any[] {
   let points: any[] = op && op.points ? each(op.points) : []
 
@@ -227,6 +293,25 @@ function opParams(op: any): any[] {
     p.reqd = true === requiredOnAll[p.name]
   })
 
+  // Unrelated cross-references share no param, so the intersection came out
+  // empty and NOTHING is required — which generates a `load({})` that drops
+  // the id. Fall back to the entity's own point and take its params whole.
+  //
+  // Two guards, and both are load-bearing:
+  //
+  //   - only when the intersection produced nothing, so a genuine set of
+  //     alternative routes with a shared param still merges (a `page_id` on
+  //     every route stays required, per-route siblings stay optional);
+  //   - only when the points describe DIFFERENT routes. Points on one path
+  //     that differ solely by optional query params (`/users?email=` and
+  //     `/users?name=`) legitimately require nothing, and are not
+  //     cross-references — collapsing them to one point would drop the
+  //     other's fields from the generated request type, so a caller could
+  //     not express them at all.
+  if (1 < points.length && !out.some((p: any) => p.reqd) && !samePath(points)) {
+    return opParams({ points: [ownPoint(points)] })
+  }
+
   return out
 }
 

package/src/helpers/packageMeta.ts

@@ -40,6 +40,27 @@ function langLabel(target: string): string {
   return LANG_LABEL[target] || target
 }
 
+
+// THE NAME WHOSE LANGUAGE RULES APPLY.
+//
+// A target name does two unrelated jobs in this file, and conflating them is
+// the defect this exists to end. `go~go2` installs a SECOND Go SDK: its
+// CONFIG lives under `main.kit.target.go2` (its own module path, its own
+// registry state), but it is still Go — the same go.mod shape, the same
+// `go get` install line, the same "Go" label.
+//
+// So: look config up by the target's OWN name, and select behaviour by this.
+// `origname` is stamped at add time precisely for aliased installs and is
+// empty when a target was installed under its own name, which makes the
+// unaliased case identical to what it was.
+//
+// Ecosystem keys ('npm', 'gem', 'composer') pass through untouched: there is
+// no target node under those names, so they answer for themselves.
+function originName(model: any, target: string): string {
+  const orig = model?.main?.[KIT]?.target?.[target]?.origname
+  return (null != orig && '' !== orig) ? String(orig) : target
+}
+
 // Git host, org/repo path, and the canonical repo URLs.
 //
 // `<origin>/<slug>-sdk` is a DERIVATION, not a law. A project whose repo is
@@ -185,7 +206,10 @@ function goPackageIdent(model: any, target: string): string {
 // The legacy boolean `registry.active: true` is honoured as a back-compat
 // alias for state === 'active'.
 function registryState(model: any, target: string): 'tag' | 'pending' | 'active' | 'inactive' {
-  if ('go' === target || 'go-cli' === target || 'go-mcp' === target) return 'tag'
+  // Tag-only is a property of the Go toolchain, not of one target name, so
+  // an aliased `go~go2` must be tag-only too.
+  const eco = originName(model, target)
+  if ('go' === eco || 'go-cli' === eco || 'go-mcp' === eco) return 'tag'
   const reg = model?.main?.[KIT]?.target?.[target]?.publish?.registry
   if (null == reg || '' === (reg.name || '')) return 'tag'
   if (true === reg.active) return 'active' // legacy alias
@@ -215,13 +239,16 @@ function registryName(model: any, target: string): string {
 // pointer carrying the releases URL.
 function vendorCommand(model: any, target: string): string {
   const { releasesUrl } = repoInfo(model)
-  switch (target) {
+  switch (originName(model, target)) {
+    // `target`, not the literal — the case says WHICH command, the argument
+    // says whose module. Writing the literal here reintroduces the same bug
+    // the switch above exists to fix, one level down, which is exactly what
+    // the first cut of this change did.
     case 'go':
-      return `go get ${packageName(model, 'go')}@latest`
     case 'go-mcp':
-      return `go get ${packageName(model, 'go-mcp')}@latest`
+      return `go get ${packageName(model, target)}@latest`
     case 'go-cli':
-      return `go install ${packageName(model, 'go-cli')}/cmd/${model.name}@latest`
+      return `go install ${packageName(model, target)}/cmd/${model.name}@latest`
     default: {
       const reg = registryName(model, target)
       return `not yet on ${reg || 'the registry'} — install from the git tag: ${releasesUrl}`
@@ -266,7 +293,12 @@ function packageName(model: any, eco: string): string {
     return String(declared)
   }
 
-  switch (eco) {
+  // The lookup above is keyed by the target's OWN name, so an alias reads its
+  // own declared package. The switch below is about FORM — npm scoping,
+  // slash-separated composer names — which belongs to the language, so it
+  // follows the origin. Passing `ts2` here without this would miss every case
+  // and fall to `default`, silently publishing under a non-npm name.
+  switch (originName(model, eco)) {
     case 'npm':
     case 'ts':
       return npmScoped
@@ -282,12 +314,13 @@ function packageName(model: any, eco: string): string {
     case 'composer':
     case 'php':
       return `${origin}/${base}`
+    // `eco`, not the literal: the case is chosen by the LANGUAGE but the
+    // module belongs to the target that asked. `packageName(model, 'go2')`
+    // returning go's module was the same conflation one level down.
     case 'go':
-      return goModule(model, 'go')
     case 'go-cli':
-      return goModule(model, 'go-cli')
     case 'go-mcp':
-      return goModule(model, 'go-mcp')
+      return goModule(model, eco)
     // The notebook/analyst package layered on `py`. Distinct PyPI name so it
     // can version and publish independently of the SDK it wraps.
     case 'py-data':
@@ -306,25 +339,29 @@ function installCommand(model: any, target: string): string {
   if (!isPublished(model, target)) {
     return vendorCommand(model, target)
   }
-  switch (target) {
+  // WHICH package manager is the language's business, so the switch follows
+  // the origin; WHICH package name is this target's own, so every arm passes
+  // `target` rather than a hardcoded ecosystem key. Before, an aliased
+  // `ts~ts2` matched no case and returned '' — a README with an empty install
+  // line — and even had it matched, `packageName(model, 'npm')` would have
+  // printed the ORIGIN's package.
+  switch (originName(model, target)) {
     case 'ts':
-      return `npm install ${packageName(model, 'npm')}`
     case 'js':
-      return `npm install ${packageName(model, 'js')}`
+      return `npm install ${packageName(model, target)}`
     case 'py':
-      return `pip install ${packageName(model, 'pypi')}`
     case 'py-data':
-      return `pip install ${packageName(model, 'py-data')}`
+      return `pip install ${packageName(model, target)}`
     case 'php':
-      return `composer require ${packageName(model, 'composer')}`
+      return `composer require ${packageName(model, target)}`
     case 'rb':
-      return `gem install ${packageName(model, 'gem')}`
+      return `gem install ${packageName(model, target)}`
     case 'lua':
-      return `luarocks install ${packageName(model, 'luarocks')}`
+      return `luarocks install ${packageName(model, target)}`
     case 'go':
-      return `go get ${packageName(model, 'go')}`
+      return `go get ${packageName(model, target)}`
     case 'go-cli':
-      return `go install ${packageName(model, 'go-cli')}/cmd/${model.name}@latest`
+      return `go install ${packageName(model, target)}/cmd/${model.name}@latest`
     default:
       return ''
   }
@@ -333,7 +370,8 @@ function installCommand(model: any, target: string): string {
 // The standard one-line package description (with the generic non-affiliation
 // statement inline) used in every manifest.
 function pkgDescription(model: any, target: string): string {
-  return `Unofficial generated ${langLabel(target)} SDK for the ${apiName(model)} public API.` +
+  return `Unofficial generated ${langLabel(originName(model, target))} SDK` +
+    ` for the ${apiName(model)} public API.` +
     ` Not affiliated with or endorsed by the upstream API provider.`
 }
 
@@ -437,6 +475,7 @@ export {
   GENERATOR_URL,
   LANG_LABEL,
   langLabel,
+  originName,
   repoInfo,
   apiName,
   packageName,

package/src/sdkgen.ts

@@ -10,7 +10,6 @@ import { Aontu } from 'aontu'
 
 import {
   showChanges,
-  getdlog,
 } from '@voxgig/util'
 
 import type {
@@ -60,7 +59,7 @@ import { collectDeps } from './helpers/collectDeps'
 import type { DepEntry } from './helpers/collectDeps'
 import { canonToType, canonToDtype, canonKey } from './helpers/canonType'
 import { OP_SUFFIX, opTypeName, opParams, opActions, entityActions, entityPath, opRequestShape, entityIdField, entityDataIdField, entityOps, entityPrimaryOp, pickExampleEntity, entityClassName, entityTypeCollisions, warnEntityTypeCollisions, deriveEntityNames, entityCollection } from './helpers/opShape'
-import { isReservedName, safeVarName, exampleVarName, phpEntityAccessor, entityCacheField, isRbCoreConstant, rbSafeTypeName, isSwiftSdkType, swiftSafeTypeName, jsProp, jsOptProp, jsKey } from './helpers/naming'
+import { isReservedName, safeVarName, exampleVarName, phpEntityAccessor, entityCacheField, isRbCoreConstant, isRbSdkConstant, rbSafeTypeName, isSwiftSdkType, swiftSafeTypeName, isPhpReservedType, phpSafeTypeName, jsProp, jsOptProp, jsKey } from './helpers/naming'
 import { serverVariables, hasServerVariables } from './helpers/serverVars'
 import { primaryOpCall, idLiteral, matchArg, dataArg, litFor } from './helpers/opExample'
 import type { ExampleLang } from './helpers/opExample'
@@ -108,6 +107,7 @@ import {
   repoInfo,
   apiName,
   langLabel,
+  originName,
   PUBLISHER,
   PUBLISHER_URL,
   SECURITY_EMAIL,
@@ -176,7 +176,38 @@ type SdkGenOptions = {
 const { Jostraca } = JostracaModule
 
 
-const dlog = getdlog('sdkgen', __filename)
+// A BROKEN PROJECT MODEL IS THE USER'S FILE, NOT A CRASH.
+//
+// One constructor for both routes out of `resolveModel` — the throw aontu
+// actually takes, and the `errs` array it documents but never fills — because
+// two spellings of the same error is how this repo keeps reintroducing the
+// same defect.
+//
+// aontu's own diagnostic is the valuable part and is passed through
+// UNTOUCHED: it carries the source excerpt, a caret under the offending
+// token, and an explanation. What it lacks is any statement of WHOSE file
+// this is, so the path leads. Wrapping it in an SdkGenError is what makes the
+// CLI print it as a message instead of dumping the error object and a stack
+// trace through sdkgen's internals — `handleError` reserves clean output for
+// that name.
+function modelError(path: string, cause: any, rooterrs: any[]): any {
+  const detail = String(cause?.msg ?? cause?.message ?? cause ?? '').trim()
+
+  const err: any = new SdkGenError(
+    'Model Error: ' + path + '\n' + detail)
+
+  err.cause$ = [cause]
+  err.rooterrs$ = rooterrs
+
+  // A syntax error is the user's typo, and there is nothing for them to do
+  // with a stack. `why` lives on the structured entries rather than the
+  // thrown wrapper, so it is read from the first of them.
+  if ('syntax' === (cause?.why ?? rooterrs?.[0]?.why)) {
+    err.uxmsg$ = true
+  }
+
+  return err
+}
 
 
 function SdkGen(opts: SdkGenOptions) {
@@ -393,13 +424,6 @@ function SdkGen(opts: SdkGenOptions) {
       showChanges(jopts.log, 'generate-result', eres, Path.dirname(process.cwd()))
     }
 
-    const dlogs = dlog.log()
-    if (0 < dlogs.length) {
-      for (let dlogentry of dlogs) {
-        log.debug({ point: 'generate-warning', dlogentry, note: String(dlogentry) })
-      }
-    }
-
     log.info({ point: 'generate-end' })
 
     return { ok: true, name: 'sdkgen' }
@@ -482,19 +506,39 @@ function SdkGen(opts: SdkGenOptions) {
     const aopts = { path, errs }
     const src = fs.readFileSync(path, 'utf8')
 
-    const model = aontu.generate(src, aopts)
-
-    if (0 < errs.length) {
-      const serr = errs[0]
-      const err: any = new SdkGenError('Model Error: ' + serr.msg)
-      err.cause$ = [serr]
+    // AONTU THROWS; IT DOES NOT FILL `errs`.
+    //
+    // The `errs` array is handed to `generate` and stays empty on every
+    // failure — syntax, unresolved path and unify conflict alike all raise an
+    // AontuError instead (verified against 0.52 by running each). So the
+    // `0 < errs.length` branch this used to have could never fire, and every
+    // broken project model reached the CLI as a bare AontuError: `handleError`
+    // prints the raw object for anything that is not an SdkGenError, so the
+    // user got aontu's diagnostic followed by a stack trace into sdkgen's
+    // `dist/` and a dump of the error's own fields. It read as an sdkgen
+    // crash rather than a problem in their own file.
+    //
+    // The array is still passed, and still checked below, because that is
+    // aontu's documented option and a later version may start using it. Both
+    // routes build the error the same way, so they cannot drift.
+    let model: any
 
-      if ('syntax' === serr.why) {
-        err.uxmsg$ = true
+    try {
+      model = aontu.generate(src, aopts)
+    }
+    catch (aerr: any) {
+      if (true !== aerr?.aontu) {
+        throw aerr
       }
 
-      err.rooterrs$ = errs
-      throw err
+      // The structured errors are reachable after all — the thrown error
+      // carries the accessor the empty array was standing in for.
+      throw modelError(path, aerr,
+        'function' === typeof aerr.errs ? aerr.errs() : [])
+    }
+
+    if (0 < errs.length) {
+      throw modelError(path, errs[0], errs)
     }
 
     model.const = { name: model.name }
@@ -1039,9 +1083,12 @@ export {
   phpEntityAccessor,
   entityCacheField,
   isRbCoreConstant,
+  isRbSdkConstant,
   rbSafeTypeName,
   isSwiftSdkType,
   swiftSafeTypeName,
+  isPhpReservedType,
+  phpSafeTypeName,
   serverVariables,
   hasServerVariables,
   liveStrict,
@@ -1090,6 +1137,7 @@ export {
   repoInfo,
   apiName,
   langLabel,
+  originName,
   PUBLISHER,
   PUBLISHER_URL,
   SECURITY_EMAIL,