@voxgig/sdkgen 1.3.17 → 1.3.19

package/project/.sdk/src/cmp/csharp/ReadmeExamplesTest_csharp.ts

@@ -160,13 +160,25 @@ public class ReadmeExamplesTest
     public void AllCsharpBlocksAreStructurallyBalanced()
     {
         var failures = new List<string>();
+        var fence = new string((char)96, 3);
         foreach (var doc in Docs())
         {
             if (!System.IO.File.Exists(doc.path))
             {
                 continue;
             }
-            var blocks = CsharpBlocks(System.IO.File.ReadAllText(doc.path));
+            var text = System.IO.File.ReadAllText(doc.path);
+            // A well-formed document has an EVEN number of triple-backtick fence
+            // markers — every block that opens also closes. An odd count means a
+            // fence was opened but never closed at end-of-document; because block
+            // extraction keys off fence parity, such an unterminated csharp block
+            // can silently vanish instead of being checked. Fail loudly.
+            if ((text.Split(fence).Length - 1) % 2 != 0)
+            {
+                failures.Add(doc.label +
+                    " has an unclosed code fence (odd number of triple-backtick markers)");
+            }
+            var blocks = CsharpBlocks(text);
             var balanced = 0;
             for (var i = 0; i < blocks.Count; i++)
             {

package/project/.sdk/src/cmp/csharp/TestDirect_csharp.ts

@@ -73,7 +73,7 @@ const TestDirect = cmp(function TestDirect(props: any) {
     ? `\n                ["apikey"] = env["${PROJECTNAME}_APIKEY"],`
     : ''
 
-  const opnames = Object.keys(entity.op)
+  const opnames = Object.keys(entity.op || {})
   const hasLoad = opnames.includes('load')
   const hasList = opnames.includes('list')
 
@@ -81,8 +81,8 @@ const TestDirect = cmp(function TestDirect(props: any) {
     return
   }
 
-  const loadOp = entity.op.load
-  const listOp = entity.op.list
+  const loadOp = entity.op?.load
+  const listOp = entity.op?.list
 
   // Get load point info
   const loadPoint = loadOp?.points?.[0]

package/project/.sdk/src/cmp/csharp/TestEntity_csharp.ts

@@ -78,9 +78,28 @@ const TestEntity = cmp(function TestEntity(props: any) {
 
   const genCtx: GenCtx = { model, entity, flow: basicflow, PROJUPPER }
 
-  const opsList = Array.from(new Set(
+  const opNames = Array.from(new Set(
     (allSteps as any[]).map((s: any) => s.op).filter(Boolean)))
-    .map(o => `"${o}"`).join(', ')
+  const opsList = opNames.map(o => `"${o}"`).join(', ')
+
+  // An entity whose basic flow has no ops must not emit the per-op skip
+  // loop. `new[] { }` is an empty implicitly-typed array and C# cannot infer
+  // its element type — CS0826, which fails the whole test project to build.
+  // The loop is dead code in that case anyway, and so is the `_mode` local
+  // that only it reads (CS0219 unused-variable otherwise).
+  const skipBlock = 0 === opNames.length ? '' : `        // Per-op sdk-test-control.json skip - basic test exercises a flow
+        // with multiple ops; skipping any op skips the whole flow.
+        var _mode = setup.Live ? "live" : "unit";
+        foreach (var _op in new[] { ${opsList} })
+        {
+            var (_shouldSkip, _) = TestRunner.IsControlSkipped(
+                "entityOp", "${entity.name}." + _op, _mode);
+            if (_shouldSkip)
+            {
+                return; // skipped via sdk-test-control.json
+            }
+        }
+`
 
   File({ name: entity.Name + 'EntityTest.' + target.ext }, () => {
 
@@ -107,19 +126,7 @@ public class ${entity.Name}EntityTest
     public void Basic()
     {
         var setup = ${entity.Name}BasicSetup(null);
-        // Per-op sdk-test-control.json skip - basic test exercises a flow
-        // with multiple ops; skipping any op skips the whole flow.
-        var _mode = setup.Live ? "live" : "unit";
-        foreach (var _op in new[] { ${opsList} })
-        {
-            var (_shouldSkip, _) = TestRunner.IsControlSkipped(
-                "entityOp", "${entity.name}." + _op, _mode);
-            if (_shouldSkip)
-            {
-                return; // skipped via sdk-test-control.json
-            }
-        }
-        // The basic flow consumes synthetic IDs from the fixture. In live
+${skipBlock}        // The basic flow consumes synthetic IDs from the fixture. In live
         // mode without an *_ENTID env override, those IDs hit the live API
         // and 4xx; set ${PROJUPPER}_TEST_${ENTUPPER}_ENTID JSON to run live.
         if (setup.SyntheticOnly)

package/project/.sdk/src/cmp/dart/EntityTypes_dart.ts

@@ -23,7 +23,7 @@ import {
   File, Content,
 } from '@voxgig/sdkgen'
 
-import { canonKey, canonToType, opTypeName, opRequestShape, warnEntityTypeCollisions } from '@voxgig/sdkgen'
+import { canonKey, canonToType, opTypeName, opRequestShape, warnEntityTypeCollisions, deriveEntityNames } from '@voxgig/sdkgen'
 
 import {
   KIT,
@@ -147,11 +147,10 @@ const EntityTypes = cmp(function EntityTypes(props: any) {
   // filter, so inactive entities still get class files referencing these
   // typed names. Filter on `name` (always present), NOT `active` — parity
   // with the go emitter's fix.
-  const entityList = each(entity).filter((e: any) => e && null != e.name)
+  const entityList = deriveEntityNames(entity)
   // Derive the PascalCase Name up-front — it is set LAZILY by names(), so an
   // entity not yet named (e.g. a fieldless placeholder) would otherwise read
   // `Name = undefined` below. Parity with the go emitter's fix.
-  entityList.forEach((e: any) => { if (null == e.Name) names(e, e.name) })
 
   // Surface duplicate generated type names (two entities with the same
   // PascalCase Name) — they would redeclare a type in statically-typed

package/project/.sdk/src/cmp/dart/Entity_dart.ts

@@ -4,7 +4,7 @@ import * as Path from 'node:path'
 import {
   cmp, camelify, names,
   Content, File, Folder, Fragment,
-  entityClassName,
+  entityClassName, entityCollection,
 } from '@voxgig/sdkgen'
 
 import {
@@ -23,7 +23,7 @@ const Entity = cmp(function Entity(props: any) {
   // `<Name>Entity`, disambiguated when it would clash with another entity's
   // data-type name. The class file name and the Main accessor both use
   // this, so they always agree.
-  const entityColl = getModelPath(model, `main.${KIT}.entity`)
+  const entityColl = entityCollection(model)
   const cls = entityClassName(entity, entityColl)
 
   const entrep = {
@@ -38,7 +38,7 @@ const Entity = cmp(function Entity(props: any) {
 
     File({ name: cls + '.' + target.ext }, () => {
 
-      const opnames = Object.keys(entity.op)
+      const opnames = Object.keys(entity.op || {})
 
       const opfrags =
         (['load', 'list', 'create', 'update', 'remove']

package/project/.sdk/src/cmp/dart/MainEntity_dart.ts

@@ -1,6 +1,6 @@
 
 
-import { cmp, Content, entityClassName } from '@voxgig/sdkgen'
+import { cmp, Content, entityClassName, entityCollection } from '@voxgig/sdkgen'
 
 import {
   KIT,
@@ -15,7 +15,7 @@ const MainEntity = cmp(async function MainEntity(props: any) {
   // Return the collision-free class TYPE (entityClassName); the accessor
   // METHOD name (entity.Name) is unchanged so callers still write
   // client.<Name>().
-  const cls = entityClassName(entity, getModelPath(model, `main.${KIT}.entity`))
+  const cls = entityClassName(entity, entityCollection(model))
 
   Content(`
   // Entity access: \`client.${entity.Name}().list()\` / \`client.${entity.Name}().load({'id': ...})\`.

package/project/.sdk/src/cmp/dart/Main_dart.ts

@@ -4,7 +4,7 @@ import * as Path from 'node:path'
 import {
   cmp, each,
   List, File, Copy, Folder, Fragment, Line,
-  entityClassName,
+  entityClassName, entityCollection,
 } from '@voxgig/sdkgen'
 
 
@@ -61,7 +61,7 @@ const Main = cmp(async function Main(props: any) {
       Line(``)
 
       List({ item: entity }, ({ item }: any) => {
-        const cls = entityClassName(item, entity)
+        const cls = entityClassName(item, entityCollection(model))
         return Line(`import 'entity/${cls}.dart';`)
       })
 
@@ -70,7 +70,7 @@ const Main = cmp(async function Main(props: any) {
       Line(``)
       Line(`export '${model.const.Name}Types.dart';`)
       List({ item: entity }, ({ item }: any) => {
-        const cls = entityClassName(item, entity)
+        const cls = entityClassName(item, entityCollection(model))
         return Line(`export 'entity/${cls}.dart';`)
       })
 

package/project/.sdk/src/cmp/dart/Package_dart.ts

@@ -59,7 +59,7 @@ topics:
     // Runtime is dependency-free (dart:io + dart:convert + vendored struct);
     // target/feature deps, when declared, land here.
     const deps: Record<string, string> = {}
-    for (const d of collectDeps(model, target.name, target.deps)) {
+    for (const d of collectDeps(model, target.name, target.deps, ctx$.log)) {
       deps[d.name] = d.source === 'target' ? (d.version || 'any') : d.version
     }
 

package/project/.sdk/src/cmp/dart/TestDirect_dart.ts

@@ -47,7 +47,7 @@ const TestDirect = cmp(function TestDirect(props: any) {
       'apikey': env['${PROJECTNAME}_APIKEY'],`
     : ''
 
-  const opnames = Object.keys(entity.op)
+  const opnames = Object.keys(entity.op || {})
   const hasLoad = opnames.includes('load')
   const hasList = opnames.includes('list')
 
@@ -157,7 +157,7 @@ dynamic unwrapListData(dynamic data) {
 
 
 function generateDirectLoad(model: Model, entity: ModelEntity) {
-  const loadOp = entity.op.load
+  const loadOp = entity.op?.load
   const loadPoint: ModelPoint | undefined = loadOp?.points?.[0]
 
   if (null == loadPoint) {
@@ -197,7 +197,7 @@ function generateDirectLoad(model: Model, entity: ModelEntity) {
     .join('\n')
 
   // Get list info for live mode bootstrapping
-  const listOp = entity.op.list
+  const listOp = entity.op?.list
   const listPoint = listOp?.points?.[0]
   const listParams = listPoint?.args?.params || []
   const listPath = listPoint ? normalizePathParams(listPoint.parts || [], listParams, listPoint.rename?.param) : ''
@@ -350,7 +350,7 @@ ${paramAsserts}      }
 
 
 function generateDirectList(model: Model, entity: ModelEntity) {
-  const listOp = entity.op.list
+  const listOp = entity.op?.list
   const listPoint: ModelPoint | undefined = listOp?.points?.[0]
 
   if (null == listPoint) {

package/project/.sdk/src/cmp/elixir/EntityTypes_elixir.ts

@@ -29,7 +29,7 @@ import {
   File, Folder, Content,
 } from '@voxgig/sdkgen'
 
-import { opRequestShape, OP_SUFFIX, warnEntityTypeCollisions } from '@voxgig/sdkgen'
+import { opRequestShape, OP_SUFFIX, warnEntityTypeCollisions, deriveEntityNames } from '@voxgig/sdkgen'
 
 import {
   KIT,
@@ -89,10 +89,9 @@ const EntityTypes = cmp(function EntityTypes(props: any) {
   // each generated module carries @specs referencing its Types aliases, so an
   // alias is required for each or the project won't compile. Filter on `name`
   // (always present), NOT `active` — parity with the go emitter's fix.
-  const entityList = each(entity).filter((e: any) => e && null != e.name)
+  const entityList = deriveEntityNames(entity)
   // Derive the PascalCase Name up-front — it is set LAZILY by names(), so an
   // entity not yet named would otherwise read `Name = undefined` below.
-  entityList.forEach((e: any) => { if (null == e.Name) names(e, e.name) })
 
   // Surface duplicate generated type names (two entities with the same
   // PascalCase Name) — they would redeclare a type in statically-typed

package/project/.sdk/src/cmp/elixir/Entity_elixir.ts

@@ -23,7 +23,7 @@ const Entity = cmp(function Entity(props: any) {
     Folder({ name: 'entity' }, () => {
       File({ name: entity.name + '_entity.' + target.ext }, () => {
 
-        const opnames = Object.keys(entity.op)
+        const opnames = Object.keys(entity.op || {})
 
         const opfrags =
           (['load', 'list', 'create', 'update', 'remove']

package/project/.sdk/src/cmp/elixir/ReadmeExamplesTest_elixir.ts

@@ -71,9 +71,18 @@ defmodule ${Name}.ReadmeExamplesTest do
     end)
   end
 
+  # True when every opening fence in \`text\` has a matching closing fence.
+  # Splitting on the fence yields (fence_count + 1) segments, so an even fence
+  # count (odd segment count) means all fences are paired. An unclosed
+  # \`\`\`elixir fence at EOF would otherwise leave a truncated/empty block that
+  # parses cleanly and slips through the syntax gate silently.
+  defp fences_balanced?(text) do
+    rem(length(String.split(text, @fence)) - 1, 2) == 0
+  end
+
   defp doc_blocks(path) do
     case File.read(path) do
-      {:ok, text} -> {:present, elixir_blocks(text)}
+      {:ok, text} -> {:present, elixir_blocks(text), fences_balanced?(text)}
       _ -> :absent
     end
   end
@@ -85,7 +94,16 @@ defmodule ${Name}.ReadmeExamplesTest do
           :absent ->
             {fails, present, total}
 
-          {:present, blocks} ->
+          {:present, blocks, balanced?} ->
+            # An unclosed fence is a malformed doc — fail rather than silently
+            # scanning past the truncated block.
+            fence_fails =
+              if balanced? do
+                []
+              else
+                [label <> " has an unclosed " <> @fence <> "elixir fence (odd fence count)"]
+              end
+
             block_fails =
               blocks
               |> Enum.with_index()
@@ -105,7 +123,7 @@ defmodule ${Name}.ReadmeExamplesTest do
                 end
               end)
 
-            {fails ++ block_fails, present + 1, total + length(blocks)}
+            {fails ++ fence_fails ++ block_fails, present + 1, total + length(blocks)}
         end
       end)
 

package/project/.sdk/src/cmp/go/Config_go.ts

@@ -11,6 +11,7 @@ import {
   each,
   isAuthActive,
   resolveAuthPrefix,
+  serverVariables,
 } from '@voxgig/sdkgen'
 
 
@@ -25,6 +26,7 @@ import {
 import {
   clean,
   formatGoMap,
+  goFeatureName,
 } from './utility_go'
 
 
@@ -46,6 +48,14 @@ const Config = cmp(async function Config(props: any) {
   let baseUrl = ''
   try { baseUrl = getModelPath(model, `main.${KIT}.info.servers.0.url`) } catch (_e) { }
 
+  // Templated server URL: emit the spec's server-variable defaults so the
+  // runtime can substitute {name} placeholders in base (see make_options).
+  const svars = serverVariables(model)
+  const serverBlock = 0 === svars.length ? '' :
+    '\t\t\t"server": map[string]any{\n' +
+    svars.map((v: any) => `\t\t\t\t${JSON.stringify(v.name)}: ${JSON.stringify(v.dflt)},\n`).join('') +
+    '\t\t\t},\n'
+
   const authBlock = authActive
     ? `			"auth": map[string]any{
 				"prefix": "${authPrefix}",
@@ -76,7 +86,7 @@ const Config = cmp(async function Config(props: any) {
     Content(`		},
 		"options": map[string]any{
 			"base": "${baseUrl}",
-${authBlock}			"headers": ${formatGoMap(headers, 3)},
+${serverBlock}${authBlock}			"headers": ${formatGoMap(headers, 3)},
 			"entity": map[string]any{
 `)
 
@@ -102,7 +112,9 @@ func makeFeature(name string) Feature {
 `)
 
     each(feature, (f: any) => {
-      const fname = f.name.charAt(0).toUpperCase() + f.name.slice(1)
+      // MUST match Main_go.ts, which DECLARES these identifiers in registry.go
+      // and the root init(); see goFeatureName.
+      const fname = goFeatureName(f)
       if (f.name !== 'base') {
         Content(`	case "${f.name}":
 		if New${fname}FeatureFunc != nil {

package/project/.sdk/src/cmp/go/EntityTypes_go.ts

@@ -27,11 +27,11 @@
 //     with every field optional (Go's analog of TS `Partial<Name>`).
 
 import {
-  cmp, each, names,
+  cmp, each,
   File, Content, Folder,
 } from '@voxgig/sdkgen'
 
-import { canonToType, opTypeName, opRequestShape, warnEntityTypeCollisions } from '@voxgig/sdkgen'
+import { canonToType, opTypeName, opRequestShape, warnEntityTypeCollisions , deriveEntityNames } from '@voxgig/sdkgen'
 
 import {
   KIT,
@@ -62,16 +62,105 @@ function goField(name: string): string {
 }
 
 
+// The json struct tag is the WIRE CONTRACT: it decides the key requests
+// marshal under and the key responses populate from.
+//
+// Can this spec-derived name be carried in a Go json struct tag AT ALL?
+//
+// It cannot always be. `encoding/json`'s isValidTag accepts letters, digits and
+// a fixed punctuation set; a name containing a double quote, a backtick or a
+// backslash is REJECTED, and Go then silently falls back to the Go FIELD name.
+// Verified against go1.24 — for a field named `na"me`:
+//
+//   raw literal      `json:"na"me"`        -> marshals as {"na": ...}   (truncated)
+//   escaped literal  "json:\"na\\\"me\""   -> marshals as {"NaMe": ...} (tag ignored)
+//
+// So there is no encoding that preserves such a name. An earlier version here
+// stripped the offending characters, which is worse than either: it silently
+// changed the wire contract, marshalling under a key the API never uses and
+// never populating from the real response key. Names that cannot be
+// represented are skipped with a warning instead — the same treatment
+// csharp/java give names with no legal identifier form.
+const GO_TAG_PUNCT = '!#$%&()*+-./:;<=>?@[]^_{|}~ '
+
+function goTaggable(name: string): boolean {
+  const s = String(name)
+  if ('' === s) {
+    return false
+  }
+  for (const c of s) {
+    if (GO_TAG_PUNCT.includes(c)) continue
+    if (/[\p{L}\p{Nd}]/u.test(c)) continue
+    return false
+  }
+  return true
+}
+
+
+function goTag(name: string, omitempty: boolean): string {
+  const jsonName = String(name) + (omitempty ? ',omitempty' : '')
+  return '`json:"' + jsonName + '"`'
+}
+
+
 // One Go struct field line. `optional` -> pointer + ,omitempty (Go's closest
-// analog to an optional/absent field).
-function fieldLine(name: string, sentinel: any, optional: boolean): string {
+// analog to an optional/absent field). `ident` overrides the derived field
+// identifier when goField() would collide with a sibling (see uniqueGoFields).
+function fieldLine(name: string, sentinel: any, optional: boolean, ident?: string): string {
   const gt = canonToType(sentinel, LANG)
   const typ = optional ? ('*' + gt) : gt
-  const tag = optional ? `\`json:"${name},omitempty"\`` : `\`json:"${name}"\``
-  return `\t${goField(name)} ${typ} ${tag}\n`
+  return `\t${ident || goField(name)} ${typ} ${goTag(name, optional)}\n`
 }
 
 
+// Collision-free Go field identifiers for one struct's members.
+//
+// goField() is lossy — it strips every non-alphanumeric character — so
+// `some_field`, `some-field` and `someField` all map to `SomeField`. Emitting
+// them into the same struct is a "field redeclared" compile error, and Go is
+// the only target exposed to it (ts/py/… keep the raw key). Later duplicates
+// get a numeric suffix; the FIRST occurrence keeps the natural name, and the
+// json tag always keeps the original wire name, so behaviour is unchanged.
+// Deterministic: members arrive in sorted-key order from opRequestShape/each.
+function uniqueGoFields(members: { name: string }[]): string[] {
+  const taken: Record<string, boolean> = {}
+  return members.map((m) => {
+    const base = goField(m.name)
+    let ident = base
+    let n = 1
+    while (taken[ident]) {
+      n++
+      ident = base + n
+    }
+    taken[ident] = true
+    return ident
+  })
+}
+
+
+// Keep a member only when its name survives into a Go json tag; warn once per
+// dropped member so the omission is visible rather than a silent contract change.
+function skipUntaggable(member: any, typeName: string, log: any): boolean {
+  if (null == member || null == member.name) {
+    return false
+  }
+  if (goTaggable(member.name)) {
+    return true
+  }
+  if (log && log.warn) {
+    log.warn({
+      point: 'entity-types-skip-field', typeName, field: member.name,
+      note: `go: field "${member.name}" of ${typeName} cannot be carried in a ` +
+        `Go json struct tag (encoding/json rejects the name, and Go would ` +
+        `silently marshal under the field name instead); omitted from the ` +
+        `typed model (still reachable via the runtime map)`,
+    })
+  }
+  return false
+}
+
+
+
 const EntityTypes = cmp(function EntityTypes(props: any) {
   const { target } = props
   const { model, log } = props.ctx$
@@ -84,14 +173,11 @@ const EntityTypes = cmp(function EntityTypes(props: any) {
   // Emit for every entity that gets an entity file. Main_go.ts / Entity_go.ts
   // iterate entities WITHOUT an `active` filter and reference the typed data
   // type `<Name>` in every *_entity.go, so a struct is required for each or the
-  // package won't compile. Filter on `name` (always present), NOT `Name`:
-  // `Name` is the PascalCase variant derived LAZILY by `names()`, so filtering
-  // on it silently drops any entity whose `Name` hasn't been derived yet by an
-  // earlier component (order-dependent — e.g. fieldless placeholder entities),
-  // producing `undefined: <Name>` in the generated Go. Derive `Name` here so
-  // the struct set is deterministic and matches the *_entity.go set.
-  const entityList = each(entity).filter((e: any) => e && null != e.name)
-  entityList.forEach((e: any) => { if (null == e.Name) names(e, e.name) })
+  // package won't compile. deriveEntityNames() selects on `name` (always
+  // present) and derives the lazily-set PascalCase `Name` up front, so the
+  // struct set is deterministic and matches the *_entity.go set regardless of
+  // which component runs first.
+  const entityList = deriveEntityNames(entity)
 
   // Surface duplicate generated type names (two entities with the same
   // PascalCase Name) — they would redeclare a type in statically-typed
@@ -123,8 +209,11 @@ import "encoding/json"
         Content(`// ${Name} is the typed data model for the ${ent.name} entity.
 type ${Name} struct {
 `)
-        fields.forEach((f: any) => {
-          Content(fieldLine(f.name, f.type, false === f.req))
+        const taggable = fields.filter(
+          (f: any) => skipUntaggable(f, Name, log))
+        const fieldIdents = uniqueGoFields(taggable)
+        taggable.forEach((f: any, i: number) => {
+          Content(fieldLine(f.name, f.type, false === f.req, fieldIdents[i]))
         })
         Content(`}
 
@@ -146,8 +235,11 @@ type ${Name} struct {
           Content(`// ${typeName} is the typed request payload for ${Name}.${cap(opname)}Typed.
 type ${typeName} struct {
 `)
-          items.forEach((it: any) => {
-            Content(fieldLine(it.name, it.type, it.optional))
+          const taggableItems = items.filter(
+            (it: any) => skipUntaggable(it, typeName, log))
+          const itemIdents = uniqueGoFields(taggableItems)
+          taggableItems.forEach((it: any, i: number) => {
+            Content(fieldLine(it.name, it.type, it.optional, itemIdents[i]))
           })
           Content(`}
 

package/project/.sdk/src/cmp/go/Entity_go.ts

@@ -4,7 +4,7 @@ import * as Path from 'node:path'
 import {
   cmp, each, camelify, names,
   File, Content, Folder, Fragment, Line, FeatureHook, Slot,
-  entityClassName,
+  entityClassName, entityCollection,
 } from '@voxgig/sdkgen'
 
 import {
@@ -26,7 +26,7 @@ const Entity = cmp(function Entity(props: any) {
   // Collision-free entity CLASS name (see entityClassName): normally
   // `<Name>Entity`, but disambiguated (e.g. `<Name>EntityClient`) when it would
   // clash with another entity's data-type name. The DATA type stays `<Name>`.
-  const entityColl = getModelPath(model, `main.${KIT}.entity`)
+  const entityColl = entityCollection(model)
   const cls = entityClassName(entity, entityColl)
 
   const entrep = {
@@ -42,7 +42,7 @@ const Entity = cmp(function Entity(props: any) {
 
     File({ name: entity.name + '_entity.' + target.ext }, () => {
 
-      const opnames = Object.keys(entity.op)
+      const opnames = Object.keys(entity.op || {})
 
       // For each CRUD op: if the spec defines it, splice in the real
       // implementation. Otherwise emit a stub that satisfies the static

package/project/.sdk/src/cmp/go/Main_go.ts

@@ -4,7 +4,7 @@ import * as Path from 'node:path'
 import {
   cmp, each, names, cmap,
   List, File, Content, Copy, Folder, Fragment, Line, FeatureHook,
-  entityClassName,
+  entityClassName, entityCollection,
 } from '@voxgig/sdkgen'
 
 
@@ -19,6 +19,7 @@ import {
 } from '@voxgig/apidef'
 
 
+import { goFeatureName } from './utility_go'
 import { Package } from './Package_go'
 import { Config } from './Config_go'
 import { Gitignore } from './Gitignore_go'
@@ -82,7 +83,7 @@ const Main = cmp(async function Main(props: any) {
 
             '#BuildFeatures': ({ indent }: any) => {
               each(feature, (feat: any) => {
-                const fname = feat.name.charAt(0).toUpperCase() + feat.name.slice(1)
+                const fname = goFeatureName(feat)
                 Content({ indent }, `u.FeatureAdd(s.rootctx, New${fname}FeatureFunc())
 `)
               })
@@ -119,7 +120,7 @@ var NewBaseFeatureFunc func() Feature
       // Feature constructor function vars (non-base)
       each(feature, (feat: any) => {
         if (feat.name !== 'base') {
-          const fname = feat.name.charAt(0).toUpperCase() + feat.name.slice(1)
+          const fname = goFeatureName(feat)
           Content(`var New${fname}FeatureFunc func() Feature
 
 `)
@@ -177,7 +178,7 @@ func init() {
     // Register non-base feature constructors
     each(feature, (feat: any) => {
       if (feat.name !== 'base') {
-        const fname = feat.name.charAt(0).toUpperCase() + feat.name.slice(1)
+        const fname = goFeatureName(feat)
         Content(`	core.New${fname}FeatureFunc = func() core.Feature {
 		return feature.New${fname}Feature()
 	}
@@ -188,7 +189,7 @@ func init() {
     // Register entity constructors
     each(entity, (ent: any) => {
       Content(`	core.New${ent.Name}EntityFunc = func(client *core.${model.const.Name}SDK, entopts map[string]any) core.${model.const.Name}Entity {
-		return entity.New${entityClassName(ent, entity)}(client, entopts)
+		return entity.New${entityClassName(ent, entityCollection(model))}(client, entopts)
 	}
 `)
     })
@@ -219,7 +220,7 @@ func Test() *${model.const.Name}SDK { return TestSDK(nil, nil) }
 
     each(feature, (feat: any) => {
       if (feat.name !== 'base') {
-        const fname = feat.name.charAt(0).toUpperCase() + feat.name.slice(1)
+        const fname = goFeatureName(feat)
         Content(`var New${fname}Feature = feature.New${fname}Feature
 `)
       }

package/project/.sdk/src/cmp/go/Package_go.ts

@@ -31,7 +31,7 @@ go 1.20
 
     const deps: Record<string, string> = {}
     const replaceDirs: Record<string, string> = {}
-    for (const d of collectDeps(model, target.name, target.deps)) {
+    for (const d of collectDeps(model, target.name, target.deps, ctx$.log)) {
       // Target-level deps default to 'v0.0.0' when version is absent;
       // feature deps require an explicit version.
       deps[d.name] = d.source === 'target' ? (d.version || 'v0.0.0') : d.version

package/project/.sdk/src/cmp/go/TestDirect_go.ts

@@ -75,7 +75,7 @@ const TestDirect = cmp(function TestDirect(props: any) {
     ? `\n\t\t\t"apikey": env["${PROJECTNAME}_APIKEY"],`
     : ''
 
-  const opnames = Object.keys(entity.op)
+  const opnames = Object.keys(entity.op || {})
   const hasLoad = opnames.includes('load')
   const hasList = opnames.includes('list')
 
@@ -83,8 +83,8 @@ const TestDirect = cmp(function TestDirect(props: any) {
     return
   }
 
-  const loadOp = entity.op.load
-  const listOp = entity.op.list
+  const loadOp = entity.op?.load
+  const listOp = entity.op?.list
 
   // Get load point info
   const loadPoint = loadOp?.points?.[0]