@voxgig/sdkgen 1.3.17 → 1.3.19

package/project/.sdk/src/cmp/lean/ReadmeExplanation_lean.ts

@@ -0,0 +1,19 @@
+import { cmp, Content } from '@voxgig/sdkgen'
+
+const ReadmeExplanation = cmp(function ReadmeExplanation(_props: any) {
+  Content(`The SDK is **config-driven**: the API model is embedded as JSON in
+\`SdkConfig.lean\` and parsed into a \`Value\` when a client is constructed. An
+operation looks up its entity and op in that model, selects the matching
+endpoint (a point whose \`select.exist\` keys are satisfied), builds the URL from
+the point's path parts, applies the request transform, performs the call, then
+applies the response transform. Because the pipeline is data-driven rather than
+generated per entity, every entity and every API follow exactly the same path.
+
+The HTTP transport shells out to \`curl\` via \`IO.Process\` — Lean 4 has no HTTP
+library in its standard distribution, and this keeps the package free of Lake
+dependencies.
+
+`)
+})
+
+export { ReadmeExplanation }

package/project/.sdk/src/cmp/lean/ReadmeHowto_lean.ts

@@ -0,0 +1,25 @@
+import { cmp, Content } from '@voxgig/sdkgen'
+
+const ReadmeHowto = cmp(function ReadmeHowto(_props: any) {
+  Content(`**Handle a missing record.** A \`load\` that finds nothing yields a
+non-map value, so match on it:
+
+\`\`\`lean
+match (← Entity.load sdk m (← emptyMap)) with
+| .map _ => IO.println "found"
+| _ => IO.println "not found"
+\`\`\`
+
+**Test without a server.** \`Sdk.testSdk0\` takes seed data (the shape of the
+generated \`<Entity>TestData.json\`) and answers operations from an in-memory
+store, so entity behaviour can be exercised offline:
+
+\`\`\`lean
+let seed ← SdkJson.jsonRead (← IO.FS.readFile "../.sdk/test/entity/<e>/<E>TestData.json")
+let sdk ← Sdk.testSdk0 seed
+\`\`\`
+
+`)
+})
+
+export { ReadmeHowto }

package/project/.sdk/src/cmp/lean/ReadmeInstall_lean.ts

@@ -0,0 +1,38 @@
+import { cmp, Content, isPublished, repoInfo } from '@voxgig/sdkgen'
+
+const ReadmeInstall = cmp(function ReadmeInstall(props: any) {
+  const { target, ctx$ } = props
+  const { model } = ctx$
+
+  if (isPublished(model, target.name)) {
+    Content(`\`\`\`bash
+cd ${target.name} && lake build
+\`\`\`
+
+`)
+    return
+  }
+
+  const { releasesUrl } = repoInfo(model)
+  Content(`This package is not yet published to [Reservoir](https://reservoir.lean-lang.org).
+Install it from the GitHub release tag (\`${target.name}/vX.Y.Z\`, see
+[Releases](${releasesUrl})) or from a source checkout. The runtime is
+dependency-free (only the Lean 4 prelude + Std; the HTTP transport shells out
+to \`curl\`), so a plain Lake build is all that is needed:
+
+\`\`\`bash
+cd ${target.name} && lake build
+\`\`\`
+
+Run the offline struct-corpus test (no server needed) and the live entity
+tests (point them at a server with \`SDK_TEST_BASE\`):
+
+\`\`\`bash
+lake exe structcorpus
+SDK_TEST_BASE=http://localhost:8901 lake exe runner
+\`\`\`
+
+`)
+})
+
+export { ReadmeInstall }

package/project/.sdk/src/cmp/lean/ReadmeIntro_lean.ts

@@ -0,0 +1,25 @@
+import { cmp, Content } from '@voxgig/sdkgen'
+import { KIT, getModelPath } from '@voxgig/apidef'
+
+const ReadmeIntro = cmp(function ReadmeIntro(props: any) {
+  const { target, ctx$: { model } } = props
+  const info = (model.main && model.main.kit && model.main.kit.info) || {}
+  const tagline = info.tagline || ''
+
+  Content(`# ${model.Name} ${target.title} SDK
+
+${tagline}
+
+The ${target.title} SDK for the ${model.Name} API — an entity-oriented client
+for Lean 4. The API is surfaced as capitalised Entities with a small, uniform
+verb set (\`list\`, \`load\`, \`create\`, \`update\`, \`remove\`); every operation is
+driven by the embedded config through the dependency-free vendored voxgig
+\`Value\` struct model, and runs in struct's \`SIO\` monad.
+
+`)
+
+  // touch the model so a mis-shaped model surfaces here, not at render time.
+  getModelPath(model, `main.${KIT}.entity`)
+})
+
+export { ReadmeIntro }

package/project/.sdk/src/cmp/lean/ReadmeModel_lean.ts

@@ -0,0 +1,24 @@
+import { cmp, Content } from '@voxgig/sdkgen'
+
+const ReadmeModel = cmp(function ReadmeModel(_props: any) {
+  Content(`Every value crossing the SDK boundary — options, request payloads,
+responses and results — is a vendored voxgig \`Value\` (see \`VoxgigStruct.lean\`):
+a JSON-shaped, heap-backed node, the Lean equivalent of the \`map[string]any\`
+the Go and Python SDKs pass around. Operations run in struct's \`SIO\` monad
+(\`ReaderT Ctx IO\`), so a single \`mkCtx\` is threaded through a run:
+
+\`\`\`lean
+let ctx ← mkCtx
+(do
+  let sdk ← Sdk.newSdk (← emptyMap)
+  ...
+).run ctx
+\`\`\`
+
+Build values with \`newMap\` / \`newList\`, read them with \`getprop\` / \`getpath\`,
+and render them with \`stringify\` (debug) or \`jsonify\` (strict JSON).
+
+`)
+})
+
+export { ReadmeModel }

package/project/.sdk/src/cmp/lean/ReadmeOptions_lean.ts

@@ -0,0 +1,22 @@
+import { cmp, Content } from '@voxgig/sdkgen'
+
+const ReadmeOptions = cmp(function ReadmeOptions(_props: any) {
+  Content(`Options are a struct \`Value\` map passed to \`Sdk.newSdk\`:
+
+| Option | Meaning |
+| --- | --- |
+| \`base\` | API base URL (overrides the built-in default) |
+| \`prefix\` / \`suffix\` | Path fragments wrapped around every request path |
+| \`headers\` | Default request headers (merged with per-request headers) |
+| \`apikey\` | Bearer/api key, sent via the \`authorization\` header |
+| \`entity\` | Per-entity option overrides, keyed by entity name |
+
+\`\`\`lean
+let opts ← newMap #[("base", .str "https://api.example.com"), ("apikey", .str key)]
+let sdk ← Sdk.newSdk opts
+\`\`\`
+
+`)
+})
+
+export { ReadmeOptions }

package/project/.sdk/src/cmp/lean/ReadmeQuick_lean.ts

@@ -0,0 +1,50 @@
+import { cmp, Content, isAuthActive, envName } from '@voxgig/sdkgen'
+import { KIT, getModelPath } from '@voxgig/apidef'
+
+// A capitalised entity op namespace + a representative read op for the example.
+function pickEntity(model: any): { ns: string, op: string } | null {
+  const entity = getModelPath(model, `main.${KIT}.entity`)
+  const ents = Object.values(entity || {}).filter((e: any) => e.active !== false)
+  for (const e of ents as any[]) {
+    const ops = Object.keys(e.op || {})
+    const op = ops.includes('list') ? 'list' : ops[0]
+    if (op) {
+      return { ns: e.name.charAt(0).toUpperCase() + e.name.slice(1), op }
+    }
+  }
+  return null
+}
+
+const ReadmeQuick = cmp(function ReadmeQuick(props: any) {
+  const { ctx$: { model } } = props
+  const pick = pickEntity(model)
+  const ns = pick ? pick.ns : 'Entity'
+  const op = pick ? pick.op : 'list'
+  const auth = isAuthActive(model)
+  const optLines = [`("base", .str "https://api.example.com")`]
+  if (auth) {
+    optLines.push(`("apikey", .str (← IO.getEnv "${envName(model)}").getD "")`)
+  }
+
+  Content(`Construct a client with \`Sdk.newSdk\` and call an entity op. Everything runs
+in struct's \`SIO\` monad, so wrap your calls and \`.run\` them on a fresh \`mkCtx\`:
+
+\`\`\`lean
+import SdkClient
+
+open VoxgigStruct
+
+def main : IO Unit := do
+  let ctx ← mkCtx
+  (do
+    let opts ← newMap #[${optLines.join(', ')}]
+    let sdk ← Sdk.newSdk opts
+    let result ← ${ns}.${op} sdk (← emptyMap) (← emptyMap)
+    IO.println s!"result: {← stringify result}"
+  ).run ctx
+\`\`\`
+
+`)
+})
+
+export { ReadmeQuick }

package/project/.sdk/src/cmp/lean/ReadmeRef_lean.ts

@@ -0,0 +1,16 @@
+import { cmp, Content } from '@voxgig/sdkgen'
+
+const ReadmeRef = cmp(function ReadmeRef(_props: any) {
+  Content(`| Module | Purpose |
+| --- | --- |
+| \`SdkClient\` | \`Sdk.newSdk\` / \`Sdk.testSdk\` and the per-entity op namespaces |
+| \`SdkConfig\` | the embedded API model (JSON) |
+| \`SdkRuntime\` | the config-driven operation pipeline and curl transport |
+| \`SdkUtility\` | request-shaping utilities (spec, url, params, transforms, result) |
+| \`SdkJson\` | JSON text to struct \`Value\` |
+| \`VoxgigStruct\` | the vendored voxgig struct value model |
+
+`)
+})
+
+export { ReadmeRef }

package/project/.sdk/src/cmp/lean/ReadmeTopHowto_lean.ts

@@ -0,0 +1,16 @@
+import { cmp, Content } from '@voxgig/sdkgen'
+
+// The Lean stanza of the top-level README how-to section.
+const ReadmeTopHowto = cmp(function ReadmeTopHowto(props: any) {
+  const { target } = props
+  Content(`For Lean, point the client at another server with the \`base\` option,
+and run the entity suite against it with \`SDK_TEST_BASE\`:
+
+\`\`\`bash
+cd ${target.name} && SDK_TEST_BASE=http://localhost:8901 lake exe runner
+\`\`\`
+
+`)
+})
+
+export { ReadmeTopHowto }

package/project/.sdk/src/cmp/lean/ReadmeTopQuick_lean.ts

@@ -0,0 +1,23 @@
+import { cmp, Content } from '@voxgig/sdkgen'
+
+// The Lean stanza of the top-level (multi-language) README quick start.
+const ReadmeTopQuick = cmp(function ReadmeTopQuick(props: any) {
+  const { target } = props
+  Content(`\`\`\`lean
+import SdkClient
+open VoxgigStruct
+
+def main : IO Unit := do
+  let ctx ← mkCtx
+  (do
+    let sdk ← Sdk.newSdk (← emptyMap)
+    IO.println s!"client ready"
+  ).run ctx
+\`\`\`
+
+Build it with \`cd ${target.name} && lake build\`.
+
+`)
+})
+
+export { ReadmeTopQuick }

package/project/.sdk/src/cmp/lean/ReadmeTopTest_lean.ts

@@ -0,0 +1,18 @@
+import { cmp, Content } from '@voxgig/sdkgen'
+
+// The Lean stanza of the top-level README test section.
+const ReadmeTopTest = cmp(function ReadmeTopTest(props: any) {
+  const { target } = props
+  Content(`\`\`\`bash
+cd ${target.name}
+lake build
+lake exe primary        # shared corpus: request-shaping utilities
+lake exe feature        # the feature catalog (retry, cache, rbac, netsim, …)
+lake exe structcorpus   # shared corpus: the vendored struct model
+lake exe runner         # entity behaviour (offline; add SDK_TEST_BASE for live)
+\`\`\`
+
+`)
+})
+
+export { ReadmeTopTest }

package/project/.sdk/src/cmp/lean/Test_lean.ts

@@ -0,0 +1,207 @@
+import {
+  Content,
+  File,
+  Folder,
+  cmp,
+  each,
+} from '@voxgig/sdkgen'
+
+import {
+  KIT,
+  Model,
+  getModelPath,
+} from '@voxgig/apidef'
+
+
+// True when an op has at least one endpoint point that needs no path params
+// (a top-level operation the live smoke test can call without an id).
+function hasParamFreePoint(op: any): boolean {
+  if (null == op) return false
+  const points = op.points || []
+  for (const pt of points) {
+    const params = ((pt.args || {}).params) || []
+    if (params.length === 0) return true
+  }
+  return false
+}
+
+
+// Synthesize a create payload from the entity's required non-id fields.
+function synthData(fields: any): any {
+  const o: any = {}
+  each(fields, (f: any) => {
+    if (f.req && f.name !== 'id') {
+      const t = String(f.type || '').toLowerCase()
+      o[f.name] =
+        (t.includes('number') || t.includes('integer') || t.includes('decimal')) ? 42
+          : t.includes('bool') ? true
+            : 'leantest'
+    }
+  })
+  return o
+}
+
+
+// The generated `test/Runner.lean` exe runs TWO lanes:
+//
+//  - OFFLINE (always): a test-mode client seeded from the entity's generated
+//    `<Entity>TestData.json` answers operations from an in-memory store, so
+//    entity behaviour (list/load/create/load-back/remove) is verified with no
+//    server — the same guarantee the `test` feature gives the other targets.
+//  - LIVE (only when SDK_TEST_BASE is set): the same flow against a real
+//    server, exercising the curl transport end to end.
+const Test = cmp(async function Test(props: any) {
+  const ctx$ = props.ctx$
+  const target = props.target
+  const model: Model = ctx$.model
+
+  const entity = getModelPath(model, `main.${KIT}.entity`)
+
+  // Per-entity OFFLINE (test-mode) blocks: seeded store, no server.
+  let offline = ''
+  each(entity, (e: any) => {
+    const ns = e.name.charAt(0).toUpperCase() + e.name.slice(1)
+    const Name = e.Name || (e.name.charAt(0).toUpperCase() + e.name.slice(1))
+    const ops = e.op || {}
+    if (!ops.list && !ops.load) return
+    offline += `    -- ${e.name}: offline (test-mode) entity behaviour
+    (do
+      let seedPath := "../.sdk/test/entity/${e.name}/${Name}TestData.json"
+      if !(← System.FilePath.pathExists seedPath) then
+        IO.println s!"skip - ${e.name}: no seed at {seedPath}"
+      else do
+        let seed ← SdkJson.jsonRead (← IO.FS.readFile seedPath)
+        let tclient ← Sdk.testSdk0 seed
+        let existing ← SdkRuntime.gp (← SdkRuntime.gp seed "existing") "${e.name}"
+        let ids ← keysof existing
+        -- list returns every seeded entity
+        let items ← ${ns}.list tclient (← emptyMap) (← emptyMap)
+        let n ← (match items with | .list lid => do pure (← listItems lid).size | _ => pure 0)
+        if n == ids.size then pass s!"${e.name}.list offline -> {n} seeded"
+        else fail s!"${e.name}.list offline: got {n}, want {ids.size}"
+        -- load the first seeded entity by id
+        if ids.size > 0 then do
+          let wid := ids[0]!
+          let m ← newMap #[("id", .str wid)]
+          let got ← ${ns}.load tclient m (← emptyMap)
+          let gid ← SdkRuntime.gpS got "id"
+          if gid == wid then pass s!"${e.name}.load offline (id={wid})"
+          else fail s!"${e.name}.load offline: got {gid}, want {wid}"
+        -- create -> load back -> remove, all in the store
+        let newmap ← SdkRuntime.gp (← SdkRuntime.gp seed "new") "${e.name}"
+        let nks ← keysof newmap
+        if nks.size > 0 then do
+          let payload ← SdkRuntime.gp newmap nks[0]!
+          let created ← ${ns}.create tclient payload (← emptyMap)
+          let cid ← SdkRuntime.gpS created "id"
+          if cid == "" then fail "${e.name}.create offline returned no id" else do
+            let m2 ← newMap #[("id", .str cid)]
+            let back ← ${ns}.load tclient m2 (← emptyMap)
+            if (← SdkRuntime.gpS back "id") == cid then
+              pass s!"${e.name}.create/load offline (id={cid})"
+            else fail s!"${e.name}.create/load offline mismatch"
+            let _ ← ${ns}.remove tclient m2 (← emptyMap)
+            let gone ← ${ns}.load tclient m2 (← emptyMap)
+            match gone with
+            | .map _ => fail s!"${e.name}.remove offline: still present"
+            | _ => pass s!"${e.name}.remove offline (id={cid})")
+`
+  })
+
+  // Per-entity LIVE test blocks.
+  let blocks = ''
+  each(entity, (e: any) => {
+    const ns = e.name.charAt(0).toUpperCase() + e.name.slice(1)
+    const listOp = (e.op || {}).list
+    const createOp = (e.op || {}).create
+    const removeOp = (e.op || {}).remove
+
+    if (hasParamFreePoint(listOp)) {
+      blocks += `    -- ${e.name}: list smoke
+    (do
+      let items ← ${ns}.list client (← emptyMap) (← emptyMap)
+      match items with
+      | .list lid => pass s!"${e.name}.list -> {(← listItems lid).size} items"
+      | _ => fail "${e.name}.list did not return a list")
+`
+    }
+
+    // Round-trip when create is param-free (creatable without an id); load and
+    // remove then use the id returned by create.
+    const loadOp = (e.op || {}).load
+    if (hasParamFreePoint(createOp) && loadOp && removeOp) {
+      const data = JSON.stringify(synthData(e.fields))
+      blocks += `    -- ${e.name}: create / load / remove round-trip
+    (do
+      let d ← SdkJson.jsonRead ${JSON.stringify(data)}
+      let created ← ${ns}.create client d (← emptyMap)
+      let nid ← SdkRuntime.gpS created "id"
+      if nid == "" then fail "${e.name}.create returned no id" else do
+        let m ← newMap #[("id", .str nid)]
+        let back ← ${ns}.load client m (← emptyMap)
+        let bid ← SdkRuntime.gpS back "id"
+        if bid == nid then pass s!"${e.name}.create/load round-trip (id={nid})"
+        else fail s!"${e.name}.load mismatch: {bid} != {nid}"
+        let _ ← ${ns}.remove client m (← emptyMap)
+        pass s!"${e.name}.remove (id={nid})")
+`
+    }
+  })
+
+  // The live lane nests two levels deeper than the offline lane.
+  const liveBlocks = blocks.split('\n').map((l) => l ? '  ' + l : l).join('\n')
+
+  Folder({ name: 'test' }, () => {
+  File({ name: 'Runner.' + target.ext }, () => {
+    Content(`-- ${model.const.Name} SDK test runner (generated by @voxgig/sdkgen).
+--
+-- OFFLINE lane (always): a test-mode client seeded from the generated entity
+-- test data answers operations from an in-memory store — no server needed.
+-- LIVE lane (only when SDK_TEST_BASE is set): the same flow over real HTTP.
+
+import VoxgigStruct
+import SdkJson
+import SdkRuntime
+import SdkClient
+
+open VoxgigStruct
+
+initialize npass : IO.Ref Nat ← IO.mkRef 0
+initialize nfail : IO.Ref Nat ← IO.mkRef 0
+
+def pass (msg : String) : SIO Unit := do
+  npass.modify (· + 1)
+  IO.println s!"ok   - {msg}"
+
+def fail (msg : String) : SIO Unit := do
+  nfail.modify (· + 1)
+  IO.println s!"FAIL - {msg}"
+
+def defaultBase : String := "http://localhost:8901"
+
+def main : IO UInt32 := do
+  let liveBase ← IO.getEnv "SDK_TEST_BASE"
+  let ctx ← mkCtx
+  let offline : SIO Unit := do
+${offline}  offline.run ctx
+  match liveBase with
+  | none => IO.println "skip - live lane (set SDK_TEST_BASE to enable)"
+  | some base => do
+    let live : SIO Unit := do
+      let opts ← newMap #[("base", .str base)]
+      let client ← Sdk.newSdk opts
+${liveBlocks}    live.run ctx
+  let p ← npass.get
+  let f ← nfail.get
+  IO.println ""
+  IO.println s!"PASS {p}  FAIL {f}"
+  if f > 0 then return 1 else return 0
+`)
+  })
+  })
+})
+
+
+export {
+  Test
+}

package/project/.sdk/src/cmp/lean/utility_lean.ts

@@ -0,0 +1,78 @@
+import * as Path from 'node:path'
+
+import {
+  clone,
+  walk,
+} from '@voxgig/struct'
+
+
+function projectPath(suffix?: string): string {
+  return Path.normalize(Path.join(__dirname, '../../..', suffix ?? ''))
+}
+
+
+// A Lean 4 string literal. Lean strings are UTF-8, so non-ASCII passes through;
+// only the structural characters need escaping. (Backticks are ordinary in Lean
+// strings, so the config's `body`-style transform exprs embed verbatim.)
+function leanString(s: string): string {
+  let out = '"'
+  for (const ch of String(s)) {
+    if (ch === '"') out += '\\"'
+    else if (ch === '\\') out += '\\\\'
+    else if (ch === '\n') out += '\\n'
+    else if (ch === '\t') out += '\\t'
+    else if (ch === '\r') out += '\\r'
+    else out += ch
+  }
+  return out + '"'
+}
+
+
+// Lean reserved words that cannot be bare identifiers.
+const LEAN_RESERVED = new Set<string>([
+  'do', 'let', 'fun', 'match', 'with', 'if', 'then', 'else', 'by', 'end',
+  'namespace', 'section', 'open', 'import', 'def', 'partial', 'mutual',
+  'structure', 'inductive', 'class', 'instance', 'where', 'deriving', 'return',
+  'try', 'catch', 'for', 'in', 'while', 'have', 'show', 'from', 'set_option',
+])
+
+
+// A collision-free lower-camel Lean identifier for a model name.
+function leanVarName(name: string): string {
+  let s = String(name).replace(/[^a-zA-Z0-9_]/g, '_')
+  if (s.length === 0) {
+    s = 'x'
+  }
+  s = s.charAt(0).toLowerCase() + s.slice(1)
+  if (!/^[a-z_]/.test(s)) {
+    s = 'e_' + s
+  }
+  return LEAN_RESERVED.has(s) ? s + '_' : s
+}
+
+
+// The lowercase-hyphenated package name (used for the lake package + repo).
+function pkgName(model: any): string {
+  const org = (model.origin || 'voxgig-sdk').replace(/-sdk$/, '')
+  return `${org}-${model.name}-sdk`.toLowerCase().replace(/[^a-z0-9-]/g, '-')
+}
+
+
+// Remove `$`-suffixed model annotation keys (so the embedded config is clean).
+function clean(o: any) {
+  return walk(clone(o), (k: any, v: any, p: any) => {
+    if (null != k && k.endsWith('$')) {
+      delete p[k]
+    }
+    return v
+  })
+}
+
+
+export {
+  clean,
+  leanString,
+  leanVarName,
+  pkgName,
+  projectPath,
+}

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

@@ -11,6 +11,7 @@ import {
   each,
   isAuthActive,
   resolveAuthPrefix,
+  serverVariables,
 } from '@voxgig/sdkgen'
 
 
@@ -46,6 +47,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 ? '' :
+    '      server = {\n' +
+    svars.map((v: any) => `        [${JSON.stringify(v.name)}] = ${JSON.stringify(v.dflt)},\n`).join('') +
+    '      },\n'
+
   const authBlock = authActive
     ? `      auth = {
         prefix = "${authPrefix}",
@@ -73,7 +82,7 @@ local function make_config()
     Content(`    },
     options = {
       base = "${baseUrl}",
-${authBlock}      headers = ${formatLuaTable(headers, 3)},
+${serverBlock}${authBlock}      headers = ${formatLuaTable(headers, 3)},
       entity = {
 `)
 

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

@@ -21,7 +21,7 @@ import {
   File, Content,
 } from '@voxgig/sdkgen'
 
-import { canonToType, opTypeName, opRequestShape, warnEntityTypeCollisions } from '@voxgig/sdkgen'
+import { canonToType, opTypeName, opRequestShape, warnEntityTypeCollisions , deriveEntityNames } from '@voxgig/sdkgen'
 
 import {
   KIT,
@@ -53,11 +53,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/lua/Entity_lua.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 {
@@ -24,7 +24,7 @@ const Entity = cmp(function Entity(props: any) {
   // data-type name. The class is a module-local table (snake-cased file name),
   // so this is used only for the local identifier — kept uniform with the other
   // languages.
-  const entityColl = getModelPath(model, `main.${KIT}.entity`)
+  const entityColl = entityCollection(model)
   const cls = entityClassName(entity, entityColl)
 
   const entrep = {
@@ -40,7 +40,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 || {})
 
       const opfrags =
         (['load', 'list', 'create', 'update', 'remove']

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

@@ -57,7 +57,7 @@ dependencies = {
 `)
 
     const seen = new Set<string>(['lua', 'dkjson'])
-    for (const d of collectDeps(model, target.name, target.deps)) {
+    for (const d of collectDeps(model, target.name, target.deps, ctx$.log)) {
       if (seen.has(d.name)) continue
       seen.add(d.name)
       const v = d.source === 'target' ? (d.version || '0.0') : d.version