@voxgig/sdkgen 1.3.14 → 1.3.18

package/project/.sdk/tm/ts/test/utility/PrimaryUtility.test.ts

@@ -31,6 +31,38 @@ describe('PrimaryUtility', async () => {
   }
 
 
+  // Sections deliberately left empty in the shared corpus
+  // (.sdk/test/primary/<name>.aontu carries a PENDING header). Everything
+  // else MUST contribute cases.
+  const PENDING = new Set([
+    'fetcher', 'makeFetchDef', 'makePoint', 'makeResult',
+    'featureAdd', 'featureHook', 'featureInit',
+  ])
+
+  // Run one corpus section, failing loudly when it would run ZERO cases.
+  // A renamed section or a fixture that compiled to an empty `set` used to
+  // pass silently, which defeats the point of a shared oracle. (The guard
+  // lives here rather than in runner.ts, which is vendored verbatim from
+  // @voxgig/struct and must stay byte-identical to upstream.)
+  //
+  // EVERY corpus-backed test goes through here — a guard that only some
+  // sections opt into leaves the rest able to run zero assertions, which is
+  // the exact hole it was added to close.
+  async function runsection(name: string, subject: Function) {
+    const section = spec[name]
+    ok(null != section,
+      `test corpus section '${name}' missing — check the name against .sdk/test/primary/`)
+    ok(null != section.basic && Array.isArray(section.basic.set),
+      `test corpus section '${name}' has no basic.set list`)
+    if (0 === section.basic.set.length && !PENDING.has(name)) {
+      throw new Error(
+        `test corpus section '${name}' is EMPTY — zero cases would run; ` +
+        `add cases, or mark the fixture PENDING in .sdk/test/primary/`)
+    }
+    return runset(section.basic, subject)
+  }
+
+
   before(async () => {
     const runner = await makeRunner(TEST_JSON_FILE, await SDK.test())
     const run = await runner('primary')
@@ -61,24 +93,24 @@ describe('PrimaryUtility', async () => {
 
 
   test('context-basic', async () => {
-    await runset(spec.makeContext.basic, utility.makeContext)
+    await runsection('makeContext', utility.makeContext)
   })
 
 
   test('method-basic', async () => {
-    await runset(spec.prepareMethod.basic, utility.prepareMethod)
+    await runsection('prepareMethod', utility.prepareMethod)
   })
 
 
   test('headers-basic', async () => {
-    await runset(spec.prepareHeaders.basic, utility.prepareHeaders)
+    await runsection('prepareHeaders', utility.prepareHeaders)
   })
 
 
   test('auth-basic', async () => {
     const sdkopts = spec.prepareAuth?.DEF?.setup?.a || {}
     const authClient = SDK.test({}, sdkopts)
-    await runset(spec.prepareAuth.basic, (ctx: any) => {
+    await runsection('prepareAuth', (ctx: any) => {
       ctx.client = authClient
       fixctx(ctx)
       return utility.prepareAuth(ctx)
@@ -87,17 +119,17 @@ describe('PrimaryUtility', async () => {
 
 
   test('params-basic', async () => {
-    await runset(spec.prepareParams.basic, utility.prepareParams)
+    await runsection('prepareParams', utility.prepareParams)
   })
 
 
   test('query-basic', async () => {
-    await runset(spec.prepareQuery.basic, utility.prepareQuery)
+    await runsection('prepareQuery', utility.prepareQuery)
   })
 
 
   test('body-basic', async () => {
-    await runset(spec.prepareBody.basic, (ctx: any) => {
+    await runsection('prepareBody', (ctx: any) => {
       fixctx(ctx)
       return utility.prepareBody(ctx)
     })
@@ -105,17 +137,17 @@ describe('PrimaryUtility', async () => {
 
 
   test('findparam-basic', async () => {
-    await runset(spec.param.basic, utility.param)
+    await runsection('param', utility.param)
   })
 
 
   test('fullurl-basic', async () => {
-    await runset(spec.makeUrl.basic, utility.makeUrl)
+    await runsection('makeUrl', utility.makeUrl)
   })
 
 
   test('operator-basic', async () => {
-    await runset(spec.operator.basic, (opmap: any) => ({
+    await runsection('operator', (opmap: any) => ({
       entity: opmap.entity || '_',
       name: opmap.name || '_',
       input: opmap.input || '_',
@@ -125,7 +157,7 @@ describe('PrimaryUtility', async () => {
 
 
   test('options-basic', async () => {
-    await runset(spec.makeOptions.basic, (vin: any) => {
+    await runsection('makeOptions', (vin: any) => {
       const ctx = utility.makeContext({ options: vin.options, config: vin.config })
       ctx.client = client
       ctx.utility = utility
@@ -137,7 +169,7 @@ describe('PrimaryUtility', async () => {
   test('spec-basic', async () => {
     const sdkopts = spec.makeSpec?.DEF?.setup?.a || {}
     const specClient = SDK.test({}, sdkopts)
-    await runset(spec.makeSpec.basic, (ctx: any) => {
+    await runsection('makeSpec', (ctx: any) => {
       ctx.client = specClient
       ctx.options = specClient.options()
       return utility.makeSpec(ctx)
@@ -146,17 +178,17 @@ describe('PrimaryUtility', async () => {
 
 
   test('reqform-basic', async () => {
-    await runset(spec.transformRequest.basic, utility.transformRequest)
+    await runsection('transformRequest', utility.transformRequest)
   })
 
 
   test('resform-basic', async () => {
-    await runset(spec.transformResponse.basic, utility.transformResponse)
+    await runsection('transformResponse', utility.transformResponse)
   })
 
 
   test('resbasic-basic', async () => {
-    await runset(spec.resultBasic.basic, (ctx: any) => {
+    await runsection('resultBasic', (ctx: any) => {
       fixctx(ctx)
       return utility.resultBasic(ctx)
     })
@@ -164,7 +196,7 @@ describe('PrimaryUtility', async () => {
 
 
   test('resheaders-basic', async () => {
-    await runset(spec.resultHeaders.basic, (ctx: any) => {
+    await runsection('resultHeaders', (ctx: any) => {
       // Convert plain headers map to forEach-based (browser Response API)
       if (ctx.response?.headers && !ctx.response.headers.forEach) {
         const h = ctx.response.headers
@@ -178,7 +210,7 @@ describe('PrimaryUtility', async () => {
 
 
   test('resbody-basic', async () => {
-    await runset(spec.resultBody.basic, async (ctx: any) => {
+    await runsection('resultBody', async (ctx: any) => {
       if (ctx.response && !ctx.response.json) {
         const body = ctx.response.body
         ctx.response.json = async () => body
@@ -200,7 +232,7 @@ describe('PrimaryUtility', async () => {
       system: { fetch: mockFetch }
     })
     const reqUtility = reqClient.utility()
-    await runset(spec.makeRequest.basic, async (ctx: any) => {
+    await runsection('makeRequest', async (ctx: any) => {
       ctx.client = reqClient
       ctx.utility = reqUtility
       ctx.options = reqClient.options()
@@ -210,7 +242,7 @@ describe('PrimaryUtility', async () => {
 
 
   test('response-basic', async () => {
-    await runset(spec.makeResponse.basic, async (ctx: any) => {
+    await runsection('makeResponse', async (ctx: any) => {
       fixctx(ctx)
       // Add json() and forEach to response for proper TS handling
       if (ctx.response && !ctx.response.json) {
@@ -229,7 +261,7 @@ describe('PrimaryUtility', async () => {
 
 
   test('done-basic', async () => {
-    await runset(spec.done.basic, (ctx: any) => {
+    await runsection('done', (ctx: any) => {
       fixctx(ctx)
       return utility.done(ctx)
     })
@@ -237,7 +269,7 @@ describe('PrimaryUtility', async () => {
 
 
   test('error-basic', async () => {
-    await runset(spec.makeError.basic, (...args: any[]) => {
+    await runsection('makeError', (...args: any[]) => {
       const ctx = args[0]
       fixctx(ctx)
       return utility.makeError(...args)
@@ -424,6 +456,18 @@ describe('PrimaryUtility', async () => {
   })
 
 
+  test('path-basic', async () => {
+    // preparePath shipped as an empty `set: []` — every port "passed" it while
+    // running zero cases. Now corpus-driven like every other section.
+    await runsection('preparePath', (ctx: any) => utility.preparePath(ctx))
+  })
+
+
+  test('clean-corpus', async () => {
+    await runsection('clean', (...args: any[]) => utility.clean(args[0], args[1]))
+  })
+
+
   test('clean', () => {
     const ctx = makeFullCtx()
     const val = { key: 'secret123', name: 'test' }

package/project/.sdk/tm/zig/utility/voxgigstruct/struct.zig

@@ -3731,7 +3731,7 @@ fn validationModify(allocator: Allocator, _: JsonValue, key: []const u8, parent:
                 var bad = std.ArrayList([]const u8).init(allocator);
                 for (ckeys.array.data.items) |ck| {
                     if (ck != .string) continue;
-                    if (!((haskey(allocator, pval, ck) catch false))) {
+                    if (!((pval == .object) and (pval.object.get(ck.string) != null))) {
                         bad.append(ck.string) catch {};
                     }
                 }

package/src/cmp/Entity.ts

@@ -21,8 +21,12 @@ const Entity = cmp(function Entity(props: any) {
   const Entity_sdk = requirePath(ctx$, `./cmp/${target.name}/Entity_${target.name}`)
   Entity_sdk['Entity']({ target, entity, entitySDK })
 
+  // Log identifiers, not the model subtrees. `target` and `entity` are large
+  // aontu nodes and this fires once per entity per target (thousands of times
+  // for a big API x 22 targets), so passing them serialised the whole model
+  // fragment each time at default log level.
   log.info({
-    point: 'generate-entity', target, entity,
+    point: 'generate-entity', target: target.name, entity: entity.name,
     note: 'target:' + target.name + ', ' + 'entity: ' + entity.name
   })
 })

package/src/cmp/Feature.ts

@@ -19,7 +19,8 @@ const Feature = cmp(function Feature(props: any) {
   }
 
   log.info({
-    point: 'generate-feature', target, feature,
+    // Identifiers only — see the note in Entity.ts.
+    point: 'generate-feature', target: target.name, feature: feature.name,
     note: 'target:' + target.name + ', ' + 'feature: ' + feature.name
   })
 

package/src/cmp/ReadmeErrors.ts

@@ -9,7 +9,7 @@ import {
 import { entityIdField, pickExampleEntity } from '../helpers/opShape'
 import { primaryOpCall } from '../helpers/opExample'
 import type { ExampleLang, PrimaryCall } from '../helpers/opExample'
-import { safeVarName } from '../helpers/naming'
+import { safeVarName, exampleVarName } from '../helpers/naming'
 
 
 // Error handling is one of the everyday developer tasks, so it gets its
@@ -241,7 +241,7 @@ const ReadmeErrors = cmp(function ReadmeErrors(props: any) {
     const eName = ex.Name || (ex.name[0].toUpperCase() + ex.name.slice(1))
     // Sanitise the variable name against the target's reserved words (a
     // `Delete` entity must not bind `const delete = ...`).
-    const eLower = safeVarName(eName.toLowerCase(), target.name)
+    const eLower = exampleVarName(eName.toLowerCase(), target.name)
     const idF = entityIdField(ex)
     const call = primaryOpCall(target.name as ExampleLang, eName, eLower, primaryOp, idF, ex)
     Content(lang.entity(call, primaryOp))

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 } from '../helpers/naming'
+import { safeVarName, exampleVarName } from '../helpers/naming'
 
 
 function cap(s: string): string {
@@ -240,7 +240,7 @@ const ReadmeExplanation = cmp(function ReadmeExplanation(props: any) {
     eName = ex.Name || (ex.name[0].toUpperCase() + ex.name.slice(1))
     // Sanitise against the target's reserved words (a `Delete` entity must
     // not bind `const delete = ...`).
-    eLower = safeVarName(eName.toLowerCase(), target.name)
+    eLower = exampleVarName(eName.toLowerCase(), target.name)
     const idF = entityIdField(ex)
     const isMatchOp = 'load' === primaryOp || 'remove' === primaryOp
     // Type-correct example id literal (numeric when the id param is integer-
@@ -252,7 +252,7 @@ const ReadmeExplanation = cmp(function ReadmeExplanation(props: any) {
     if ('list' === primaryOp) {
       stateArg = 'go' === target.name ? 'nil' : ''
     } else if (isMatchOp) {
-      stateArg = matchArg(lname, idF, idLit)
+      stateArg = matchArg(lname, ex, primaryOp as string, idF, idLit)
     } else {
       stateArg = dataArg(lname, ex, primaryOp as string, idF)
     }

package/src/cmp/ReadmeTop.ts

@@ -10,7 +10,7 @@ import { requirePath } from '../utility'
 
 import { entityPrimaryOp, entityIdField, opRequestShape } from '../helpers/opShape'
 import { canonKey } from '../helpers/canonType'
-import { safeVarName } from '../helpers/naming'
+import { safeVarName, exampleVarName } from '../helpers/naming'
 
 import {
   installCommand as pkgInstall,
@@ -233,7 +233,7 @@ ${aboutMd.trim()}
         : ' See the [Entities](#entities) table below for the full list.'
       const exEnt = activeEntities[0]
       const ex = exEnt.Name
-      const exLower = safeVarName(ex.toLowerCase(), 'ts')
+      const exLower = exampleVarName(ex.toLowerCase(), 'ts')
       // The example call uses the entity's PRIMARY op — an op it actually
       // exposes (prefer list -> the array, then load -> the record, else a
       // create with its required fields). A create-only entity therefore never

package/src/helpers/canonType.ts

@@ -1,20 +1,27 @@
 // Canonical type-sentinel -> language primitive type mapper.
 //
-// SOURCE OF TRUTH for the sentinel set: @voxgig/apidef
-//   ~/Projects/voxgig/apidef ts/src/utility.ts  ->  `const VALID_CANON`
-// (around line 908). VALID_CANON maps an OpenAPI type NAME -> a `$SENTINEL`
-// string (e.g. 'string' -> `$STRING`). The model stores those sentinels on
-// every `fields[].type` and op `points[].args.params[].type`.
+// SOURCE OF TRUTH for the sentinel set: @voxgig/apidef (`VALID_CANON` +
+// `CANON_ONE`, exported from the package). VALID_CANON maps an OpenAPI type
+// NAME -> a `$SENTINEL` string (e.g. 'string' -> `$STRING`). The model stores
+// those sentinels on every `fields[].type` and op `points[].args.params[].type`.
+// A multi-type (OpenAPI `type: [a, b]`) is stored as the ARRAY-shaped union
+// sentinel `['`$ONE`', [member, ...]]` (see canonToType below).
 //
 // This table maps the SENTINEL the other way -> a concrete primitive type in
 // each target language, so the typed-model generators (EntityTypes_<lang>.ts)
-// can turn the model's field/param sentinels into real language types.
+// and the README type columns (ReadmeRef_<lang>.ts / ReadmeEntity_<lang>.ts)
+// can turn the model's field/param sentinels into real language types. It is
+// the SINGLE mapping per language: components must not keep local copies.
 //
-// Kept as a small duplicate here (rather than importing VALID_CANON) because
-// VALID_CANON is name->sentinel, is not exported from @voxgig/apidef, and would
-// need inverting; a sentinel->type table is what every language generator
-// actually needs. If VALID_CANON gains a new sentinel, add a row below (all
-// languages) and keep the two in sync.
+// Kept as a small mirror here (rather than importing VALID_CANON at runtime)
+// because apidef is a peer dependency and the table is the INVERSE direction.
+//
+// `ts/test/canonsync.test.ts` guards it two ways: the vocabulary and every
+// language column are pinned LOCALLY (that check always runs), and the table
+// is cross-checked against apidef's exported VALID_CANON/CANON_ONE when the
+// installed apidef exports them. Note that the currently published apidef
+// (6.3.1) does NOT export them, so the cross-check skips — do not rely on it
+// alone; add a new sentinel to the local list in the same change.
 //
 // KNOWN GAPS (papered over sanely, documented for the port):
 //  - Unknown / missing sentinel  -> the language's "any" (never throws).
@@ -25,30 +32,99 @@
 //    language's open record/map type.
 //  - No enum/format/nullability beyond the `req` flag.
 
-// Target languages sdkgen supports (go-cli / go-mcp reuse 'go').
-type CanonLang = 'ts' | 'js' | 'py' | 'php' | 'rb' | 'lua' | 'go'
+// Target languages sdkgen supports (go-cli / go-mcp reuse 'go'). The targets
+// with a fully dynamic value model (clojure, haskell, ocaml, perl, zig) have
+// no column: they emit no typed models and document types via the language's
+// dynamic Value/map vocabulary.
+type CanonLang =
+  | 'ts' | 'js' | 'py' | 'php' | 'rb' | 'lua' | 'go'
+  | 'csharp' | 'java' | 'kotlin' | 'scala' | 'swift' | 'dart'
+  | 'rust' | 'c' | 'cpp' | 'elixir'
 
 // Bare sentinel key (backticks + leading `$` stripped, upper-cased)
 // -> per-language primitive type name.
 //
-// ONLY the `ts` column is exercised + tested today (the reference target).
-// The other columns are a starting scaffold for the per-language port; verify
-// each against that language's idioms before wiring its EntityTypes_<lang>.ts.
+// Column notes:
+//  - kotlin: every type is nullable (`?`) — the kotlin emitter drops
+//    per-member optionality because the column is already-nullable.
+//  - java/scala: boxed JVM types (nullable), so optionality needs no marker.
+//  - rust/c/cpp/swift: `Value`/`voxgig_value*`/`VMap` are the vendored
+//    dynamic value types those runtimes ship.
 const CANON_TYPE: Record<string, Record<CanonLang, string>> = {
-  STRING: { ts: 'string', js: 'string', py: 'str', php: 'string', rb: 'String', lua: 'string', go: 'string' },
-  INTEGER: { ts: 'number', js: 'number', py: 'int', php: 'int', rb: 'Integer', lua: 'number', go: 'int' },
-  NUMBER: { ts: 'number', js: 'number', py: 'float', php: 'float', rb: 'Float', lua: 'number', go: 'float64' },
-  BOOLEAN: { ts: 'boolean', js: 'boolean', py: 'bool', php: 'bool', rb: 'Boolean', lua: 'boolean', go: 'bool' },
-  NULL: { ts: 'null', js: 'null', py: 'None', php: 'null', rb: 'NilClass', lua: 'nil', go: 'any' },
-  ARRAY: { ts: 'any[]', js: 'Array', py: 'list', php: 'array', rb: 'Array', lua: 'table', go: '[]any' },
-  OBJECT: { ts: 'Record<string, any>', js: 'Object', py: 'dict', php: 'array', rb: 'Hash', lua: 'table', go: 'map[string]any' },
-  ANY: { ts: 'any', js: '*', py: 'Any', php: 'mixed', rb: 'Object', lua: 'any', go: 'any' },
+  STRING: {
+    ts: 'string', js: 'string', py: 'str', php: 'string', rb: 'String',
+    lua: 'string', go: 'string', csharp: 'string', java: 'String',
+    kotlin: 'String?', scala: 'String', swift: 'String', dart: 'String',
+    rust: 'String', c: 'char*', cpp: 'std::string', elixir: 'String.t()',
+  },
+  INTEGER: {
+    ts: 'number', js: 'number', py: 'int', php: 'int', rb: 'Integer',
+    lua: 'number', go: 'int', csharp: 'long', java: 'Long',
+    kotlin: 'Long?', scala: 'java.lang.Long', swift: 'Int', dart: 'int',
+    rust: 'i64', c: 'int64_t', cpp: 'int64_t', elixir: 'integer()',
+  },
+  NUMBER: {
+    ts: 'number', js: 'number', py: 'float', php: 'float', rb: 'Float',
+    lua: 'number', go: 'float64', csharp: 'double', java: 'Double',
+    kotlin: 'Double?', scala: 'java.lang.Double', swift: 'Double', dart: 'num',
+    rust: 'f64', c: 'double', cpp: 'double', elixir: 'float()',
+  },
+  BOOLEAN: {
+    ts: 'boolean', js: 'boolean', py: 'bool', php: 'bool', rb: 'Boolean',
+    lua: 'boolean', go: 'bool', csharp: 'bool', java: 'Boolean',
+    kotlin: 'Boolean?', scala: 'java.lang.Boolean', swift: 'Bool', dart: 'bool',
+    rust: 'bool', c: 'bool', cpp: 'bool', elixir: 'boolean()',
+  },
+  NULL: {
+    ts: 'null', js: 'null', py: 'None', php: 'null', rb: 'NilClass',
+    lua: 'nil', go: 'any', csharp: 'object?', java: 'Object',
+    kotlin: 'Any?', scala: 'Object', swift: 'Value', dart: 'Object',
+    rust: 'Value', c: 'voxgig_value*', cpp: 'Value', elixir: 'nil',
+  },
+  ARRAY: {
+    ts: 'any[]', js: 'Array', py: 'list', php: 'array', rb: 'Array',
+    lua: 'table', go: '[]any', csharp: 'List<object?>', java: 'List<Object>',
+    kotlin: 'List<Any?>?', scala: 'java.util.List[Object]', swift: '[Value]',
+    dart: 'List<dynamic>', rust: 'Vec<Value>', c: 'voxgig_value*',
+    cpp: 'std::vector<Value>', elixir: 'list()',
+  },
+  OBJECT: {
+    ts: 'Record<string, any>', js: 'Object', py: 'dict', php: 'array',
+    rb: 'Hash', lua: 'table', go: 'map[string]any',
+    csharp: 'Dictionary<string, object?>', java: 'Map<String, Object>',
+    kotlin: 'Map<String, Any?>?', scala: 'java.util.Map[String, Object]',
+    swift: 'VMap', dart: 'Map<String, dynamic>',
+    rust: 'std::collections::HashMap<String, Value>', c: 'voxgig_value*',
+    cpp: 'std::map<std::string, Value>', elixir: 'map()',
+  },
+  ANY: {
+    ts: 'any', js: '*', py: 'Any', php: 'mixed', rb: 'Object',
+    lua: 'any', go: 'any', csharp: 'object?', java: 'Object',
+    kotlin: 'Any?', scala: 'Object', swift: 'Value', dart: 'dynamic',
+    rust: 'Value', c: 'voxgig_value*', cpp: 'Value', elixir: 'any()',
+  },
 }
 
 // Per-language fallback for unknown / missing sentinels.
 // js uses JSDoc's `*` (any type); lua uses `any` (LuaLS).
 const CANON_ANY: Record<CanonLang, string> = {
-  ts: 'any', js: '*', py: 'Any', php: 'mixed', rb: 'Object', lua: 'any', go: 'any',
+  ts: 'any', js: '*', py: 'Any', php: 'mixed', rb: 'Object',
+  lua: 'any', go: 'any', csharp: 'object?', java: 'Object',
+  kotlin: 'Any?', scala: 'Object', swift: 'Value', dart: 'dynamic',
+  rust: 'Value', c: 'voxgig_value*', cpp: 'Value', elixir: 'any()',
+}
+
+// Union ($ONE) member separator for languages with a native union/sum type
+// syntax. Languages absent here have no way to express an anonymous union in
+// a type position, so a $ONE sentinel degrades to that language's "any".
+// (php 8 unions exist but cannot combine with the `?` optional prefix the
+// emitters use, so php deliberately degrades to `mixed`.)
+const CANON_UNION_JOIN: Partial<Record<CanonLang, string>> = {
+  ts: ' | ',
+  js: '|',
+  py: ' | ',
+  lua: '|',
+  elixir: ' | ',
 }
 
 
@@ -64,10 +140,29 @@ function canonKey(sentinel: unknown): string {
 
 // Map a field/param type sentinel to a target-language primitive type.
 // Unknown or missing sentinel -> that language's "any" (never throws).
+//
+// The union sentinel `['`$ONE`', [member, ...]]` (apidef CANON_ONE, produced
+// for OpenAPI multi-types) renders as a joined member union in languages with
+// union syntax (see CANON_UNION_JOIN); elsewhere it degrades to "any".
+// Members may themselves be unions (handled recursively) or the literal
+// 'Any' apidef emits for an unknown member name (canonKey maps it to ANY).
 function canonToType(sentinel: unknown, lang: string): string {
   const l = lang as CanonLang
   const fallback = CANON_ANY[l] ?? 'any'
 
+  if (Array.isArray(sentinel)) {
+    if ('ONE' === canonKey(sentinel[0]) && Array.isArray(sentinel[1])) {
+      const join = CANON_UNION_JOIN[l]
+      if (null == join) {
+        return fallback
+      }
+      const members = sentinel[1].map((m: unknown) => canonToType(m, l))
+      const uniq = members.filter((m: string, i: number) => members.indexOf(m) === i)
+      return 0 === uniq.length ? fallback : uniq.join(join)
+    }
+    return fallback
+  }
+
   const row = CANON_TYPE[canonKey(sentinel)]
   if (null == row) {
     return fallback
@@ -82,6 +177,7 @@ export {
   canonKey,
   CANON_TYPE,
   CANON_ANY,
+  CANON_UNION_JOIN,
 }
 
 export type {

package/src/helpers/collectDeps.ts

@@ -27,21 +27,53 @@ function collectDeps(
   model: SdkModel,
   targetName: string,
   targetDeps: Record<string, ModelDep> | undefined,
+  log?: any,
 ): DepEntry[] {
   const out: DepEntry[] = []
   const feature = getModelPath(model, `main.${KIT}.feature`)
 
+  // Deduplicate by package name. Two features can require the same package
+  // (or a feature and the target itself can), and every Package_<lang>.ts
+  // renders one manifest line per entry — a duplicate key is a hard parse
+  // error in go.mod and Cargo.toml, and silently last-wins in package.json.
+  // FIRST occurrence wins, so the deterministic (sorted-key) feature order
+  // decides; a conflicting version is reported rather than silently dropped.
+  const seen: Record<string, DepEntry> = {}
+
+  const add = (dep: any, source: 'feature' | 'target', owner: string) => {
+    const name = dep.key$
+    if (null == name) return
+
+    const prev = seen[name]
+    if (null != prev) {
+      if (log?.warn && prev.version !== dep.version) {
+        log.warn({
+          point: 'dep-version-conflict', target: targetName, dep: name,
+          kept: prev.version, dropped: dep.version, from: owner,
+          note: `${targetName}: dependency ${name} declared twice with ` +
+            `different versions — keeping ${prev.version} (${prev.source}), ` +
+            `ignoring ${dep.version} (${source} ${owner})`,
+        })
+      }
+      return
+    }
+
+    const entry: DepEntry = {
+      name,
+      version: dep.version,
+      source,
+      raw: dep,
+    }
+    seen[name] = entry
+    out.push(entry)
+  }
+
   each(feature, (f: any) => {
     const langDeps = f?.deps?.[targetName]
     if (!langDeps) return
     each(langDeps, (dep: any) => {
       if (dep?.active) {
-        out.push({
-          name: dep.key$,
-          version: dep.version,
-          source: 'feature',
-          raw: dep,
-        })
+        add(dep, 'feature', f.name)
       }
     })
   })
@@ -49,12 +81,7 @@ function collectDeps(
   if (targetDeps) {
     each(targetDeps, (dep: any) => {
       if (dep?.active !== false) {
-        out.push({
-          name: dep.key$,
-          version: dep.version,
-          source: 'target',
-          raw: dep,
-        })
+        add(dep, 'target', targetName)
       }
     })
   }