@voxgig/sdkgen 4.20.0 → 4.21.0

package/project/.sdk/src/cmp/kotlin/Schema_kotlin.ts

@@ -0,0 +1,111 @@
+import {
+  Content,
+  File,
+  cmp,
+  entitySpecMap,
+  optionSpec,
+} from '@voxgig/sdkgen'
+
+
+import {
+  Model,
+} from '@voxgig/apidef'
+
+
+import {
+  kotlinPackage,
+  jsonAppendLines,
+} from './utility_kotlin'
+
+
+// THE GENERATED SCHEMA MODULE: the model's schemas, as data the SDK can run.
+//
+// The kotlin peer of src/cmp/ts/Schema_ts.ts. Same two members, same source:
+// optspec from `main.kit.optspec` plus each feature's own `config.options`,
+// entityspec from the entity field sentinels — both built by the shared
+// helpers, so what kotlin validates against and what ts validates against
+// cannot drift.
+//
+// EMBEDDED AS JSON, PARSED AT LOAD, where ts emits an object literal: JSON is
+// a subset of TypeScript's own literal syntax and is not a subset of
+// kotlin's. Chunked StringBuilder appends, exactly as Config.kt carries its
+// config, keep every string constant far below the JVM's 64KB limit no matter
+// how many features or entities the model grows.
+//
+// The round-trip is exact because the spec holds only strings and booleans:
+// pinned by "strings and booleans only, so the JSON round-trip is lossless"
+// in ts/test/optspec.test.ts. That is not incidental — Json.parse decodes a
+// JSON number to one kotlin type and struct reads a spec BY EXAMPLE, so one
+// number in here would mean something different in kotlin than in ts.
+const Schema = cmp(async function Schema(props: any) {
+  const ctx$ = props.ctx$
+  const target = props.target
+
+  const model: Model = ctx$.model
+  const kotlinpackage = kotlinPackage(model)
+
+  const optspec = optionSpec(model, target.name)
+  const entityspec = entitySpecMap(model, target.name) || {}
+
+  // Beside Config.kt, and for the same reason: core owns the generated data,
+  // so nothing in utility or feature has to reach up for it.
+  File({ name: 'Schema.' + target.ext }, () => {
+
+    Content(`package ${kotlinpackage}.core
+
+import ${kotlinpackage}.utility.Json
+
+/**
+ * ${model.const.Name} ${target.Name} SDK: generated schemas. Do not edit.
+ *
+ * Generated from the model: \`main.kit.optspec\` and each feature's
+ * \`config.options\` for the option spec; entity \`fields[].type\` for the
+ * entity specs.
+ */
+@Suppress("UNCHECKED_CAST")
+object Schema {
+
+  // Parsed ONCE, on first use. The spec is read on every client construction
+  // and never mutated, so a per-call parse would be pure waste — and a shared
+  // map is safe for the same reason the spec is a constant: makeOptions
+  // validates AGAINST it and writes into the options, never into the spec.
+  //
+  // 'by lazy' defaults to LazyThreadSafetyMode.SYNCHRONIZED, as
+  // Config.sharedConfig uses, so concurrent first calls parse it exactly once.
+
+  /** The option spec makeOptions validates client options against. */
+  val optspec: MutableMap<String, Any?> by lazy {
+    Json.parse(optspecJson()) as MutableMap<String, Any?>
+  }
+
+  /** Per-entity data and request specs, keyed by entity name. */
+  val entityspec: MutableMap<String, Any?> by lazy {
+    Json.parse(entityspecJson()) as MutableMap<String, Any?>
+  }
+
+  private fun optspecJson(): String {
+    val b = StringBuilder()
+`)
+
+    Content(jsonAppendLines(optspec, 'b'))
+
+    Content(`    return b.toString()
+  }
+
+  private fun entityspecJson(): String {
+    val b = StringBuilder()
+`)
+
+    Content(jsonAppendLines(entityspec, 'b'))
+
+    Content(`    return b.toString()
+  }
+}
+`)
+  })
+})
+
+
+export {
+  Schema
+}

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

@@ -22,6 +22,7 @@ import {
 
 import { Package } from './Package_lua'
 import { Config } from './Config_lua'
+import { Schema } from './Schema_lua'
 import { PrepareAuth } from './PrepareAuth_lua'
 import { Gitignore } from './Gitignore_lua'
 import { MainEntity } from './MainEntity_lua'
@@ -100,43 +101,78 @@ const Main = cmp(async function Main(props: any) {
   // syntax; the guard holds that), which the C compiler cannot read - so
   // the rule feeds the compiler from line four. Line numbers in a compiler
   // diagnostic are therefore three lower than in the file.
+  //
+  // TWO HELPERS, NOT ONE, AND THEY ARE BUILT DIFFERENTLY. The transport
+  // helper is a PROGRAM the plugins run; the mini vault's crypto is a
+  // LOADABLE MODULE the interpreter opens with package.loadlib, so it is
+  // compiled -shared -fPIC and keeps its `.so` name. Each is emitted only
+  // for the groups that actually use it: a chain of `[hashicorp]` builds
+  // no vault, and a chain of `[minivault]` opens no socket and links no
+  // TLS.
   const nativeGroups: string[] = []
+  let wantsVault = false
   each(feature, (f: any) => {
     each(f.plugin, (plugin: any) => {
       if (false === plugin.active || null == plugin.active) return
       if (0 < Object.keys(plugin.def?.lua || {}).length) {
         nativeGroups.push(f.name + '.' + plugin.name)
+        if ('minivault' === plugin.name) {
+          wantsVault = true
+        }
       }
     })
   })
 
+  // The transport helper serves every kind that reaches the network or a
+  // child process. The vault reaches neither, so a vault-only chain needs
+  // the module and not the program.
+  const wantsNet = nativeGroups.some((one) => !/\.minivault$/.test(one))
+
   if (0 < nativeGroups.length) {
     Folder({ name: 'feature' }, () => {
       Folder({ name: 'secrets' }, () => {
         File({ name: 'native.mk' }, () => {
-          Content(`# ${model.const.Name} SDK: the sekreto transport helper build.
+          Content(`# ${model.const.Name} SDK: the sekreto native helper build.
 #
 # GENERATED because a secrets plugin group is active
-# (${nativeGroups.sort().join(', ')}): the plugin provider kinds run this
-# helper for every socket and child process, since Lua 5.4 has none. An
-# SDK without an active plugin group has no such file, and its Makefile's
-# optional include of it is a no-op - nothing is compiled and OpenSSL is
-# not linked.
+# (${nativeGroups.sort().join(', ')}). Lua 5.4 has no sockets, no TLS and no
+# cryptography, so the kinds that need any of the three reach a small
+# compiled helper - and this file builds only the ones this SDK's chain
+# actually uses. An SDK without an active plugin group has no such file,
+# and its Makefile's optional include of it is a no-op: nothing is
+# compiled and nothing is linked.
 #
 # The source carries the vendoring tool's three-line provenance header in
 # lua comment syntax, which the compiler cannot read: it is fed the file
 # from line four. Compiler line numbers are therefore three lower than the
 # file's.
-NATIVE := feature/secrets/native/sekreto-net
+NATIVE := ${[
+            wantsNet ? 'feature/secrets/native/sekreto-net' : '',
+            wantsVault ? 'feature/secrets/native/sekretovault.so' : '',
+          ].filter((one) => '' !== one).join(' ')}
 
 CC ?= cc
 CFLAGS ?= -std=c11 -O2 -Wall -Wextra
 LDLIBS ?= -lssl -lcrypto
-
+${wantsNet ? `
 feature/secrets/native/sekreto-net: feature/secrets/native/sekretonet.c
 	@command -v $(CC) >/dev/null 2>&1 || { echo "secrets: a C compiler ($(CC)) is needed to build the sekreto transport helper that this SDK's plugin provider kinds run - install one, or use only the built-in provider kinds" >&2; exit 1; }
 	tail -n +4 $< | $(CC) $(CFLAGS) -x c - -o $@ $(LDLIBS)
-`)
+` : ''}${wantsVault ? `
+# The mini vault's crypto is a LOADABLE MODULE, not a program: minivault.lua
+# opens it with package.loadlib and calls luaopen_sekretovault, so it is
+# compiled -shared -fPIC and keeps the .so name that call expects. It links
+# libcrypto alone - the vault reads a file and never opens a socket, so it
+# needs no TLS.
+#
+# LUA_CFLAGS is where a consumer points the compiler at lua.h when it is not
+# on the default include path (Homebrew, a pkg-config build, a vendored Lua).
+LUA_CFLAGS ?= $(shell pkg-config --cflags lua5.4 2>/dev/null || pkg-config --cflags lua 2>/dev/null)
+
+feature/secrets/native/sekretovault.so: feature/secrets/native/sekretovault.c
+	@command -v $(CC) >/dev/null 2>&1 || { echo "secrets: a C compiler ($(CC)) is needed to build the mini vault's crypto module - install one, or use only the built-in provider kinds" >&2; exit 1; }
+	tail -n +4 $< | $(CC) $(CFLAGS) $(LUA_CFLAGS) -fPIC -shared -x c - -o $@ -lcrypto
+` : ''}`)
         })
       })
     })
@@ -194,6 +230,7 @@ self._utility.feature_hook(self._rootctx, "${name}")
   // Generate config module
   Folder({ name: '.' }, () => {
     Config({ target })
+    Schema({ target })
   })
 
   // GENERATED, NOT COPIED. Where the credential goes is a fact about the

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

@@ -159,6 +159,7 @@ build = {
     ["config"] = "config.lua",
     ["config_shared"] = "config_shared.lua",
     ["config_plugins"] = "config_plugins.lua",
+    ["schema"] = "schema.lua",
     ["features"] = "features.lua",
 ${featureModules}  }
 }

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

@@ -20,6 +20,7 @@ Use \`helpers.to_map()\` to safely validate that a value is a table.
 lua/
 ├── ${model.name}_sdk.lua    -- Main SDK module
 ├── config.lua               -- Configuration
+├── schema.lua               -- Generated option + entity specs
 ├── features.lua             -- Feature factory
 ├── core/                    -- Core types and context
 ├── entity/                  -- Entity implementations

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

@@ -0,0 +1,72 @@
+import {
+  Content,
+  File,
+  cmp,
+  entitySpecMap,
+  optionSpec,
+} from '@voxgig/sdkgen'
+
+
+import {
+  Model,
+} from '@voxgig/apidef'
+
+
+import {
+  luaLongString,
+} from './utility_lua'
+
+
+// THE GENERATED SCHEMA MODULE: the model's schemas, as data the SDK can run.
+//
+// The lua peer of src/cmp/ts/Schema_ts.ts. Same two exports, same source —
+// OPTSPEC from `main.kit.optspec` plus each feature's own `config.options`,
+// ENTITYSPEC from the entity field sentinels — built by the shared helpers,
+// so what lua validates against and what ts validates against cannot drift.
+//
+// EMBEDDED AS JSON IN A LONG BRACKET, PARSED AT LOAD: the mechanism
+// config.lua already uses for the model above the size threshold.
+// `luaLongString` picks a bracket level no `]]` in the content can close, so
+// the sentinels' backticks and the JSON's own quoting survive verbatim with
+// no escaping at all.
+//
+// The round-trip is exact because the spec holds only strings and booleans —
+// pinned by "strings and booleans only, so the JSON round-trip is lossless"
+// in ts/test/optspec.test.ts.
+const Schema = cmp(async function Schema(props: any) {
+  const ctx$ = props.ctx$
+  const target = props.target
+
+  const model: Model = ctx$.model
+
+  const optspec = optionSpec(model, target.name)
+  const entityspec = entitySpecMap(model, target.name) || {}
+
+  File({ name: 'schema.' + target.ext }, () => {
+    Content(`-- ${model.const.Name} ${target.Name} SDK: generated schemas. Do not edit.
+--
+-- Generated from the model: \`main.kit.optspec\` and each feature's
+-- \`config.options\` for OPTSPEC; entity \`fields[].type\` for ENTITYSPEC.
+
+local json = require("dkjson")
+
+local OPTSPEC_DATA = ${luaLongString(JSON.stringify(optspec))}
+
+local ENTITYSPEC_DATA = ${luaLongString(JSON.stringify(entityspec))}
+
+-- Parsed ONCE, at require. The spec is read on every client construction and
+-- never mutated, so a per-call parse would be pure waste — and sharing the
+-- table is safe for the same reason: make_options validates AGAINST it and
+-- writes into the options, never into the spec.
+return {
+  OPTSPEC = json.decode(OPTSPEC_DATA),
+  ENTITYSPEC = json.decode(ENTITYSPEC_DATA),
+}
+`)
+  })
+})
+
+
+export {
+  Schema
+}

package/project/.sdk/src/cmp/ocaml/Config_ocaml.ts

@@ -62,6 +62,14 @@ type SecretsBuild = {
   groups: string[],
   tlsGroups: string[],
   tls: boolean,
+  // C stubs an active group brings with it, keyed by the group that
+  // brought them, in the order the groups sort. tls_stubs.c is NOT here:
+  // it belongs to the tls HELPER, which no group owns - these are stubs a
+  // KIND owns, declared in its own `path` list. The mini vault is the
+  // first, and the shape is general: a kind whose implementation needs C
+  // says so by listing a .c file, and the build compiles what it lists.
+  stubs: string[],
+  stubGroups: string[],
   plugin: string[],
   core: string[],
   helpers: string[],
@@ -93,6 +101,8 @@ function secretsBuild(model: Model, target: any): SecretsBuild | null {
 
   const groups: string[] = []
   const tlsGroups: string[] = []
+  const stubGroups: string[] = []
+  const stubs = new Set<string>()
   const syms = new Set<string>()
   const kinds = new Set<string>()
 
@@ -105,6 +115,17 @@ function secretsBuild(model: Model, target: any): SecretsBuild | null {
     if (0 === Object.keys(defs).length) return
     groups.push(plugin.name)
     if (true === plugin.needs?.fetch) tlsGroups.push(plugin.name)
+
+    // `stub`, keyed by TARGET - not a filter over `path`, which is one flat
+    // list across every target: ocaml's minivault_stubs.c sits beside c's
+    // boru.c and hashicorp.c, and a prefix filter handed this build both of
+    // them. Declared per target, so what ocaml compiles is what the model
+    // says ocaml compiles.
+    const own = (plugin.stub?.[target.name] || []).map((one: any) => String(one))
+    if (0 < own.length) {
+      stubGroups.push(plugin.name)
+      for (const one of own) stubs.add(one)
+    }
     for (const [sym, path] of Object.entries(defs)) {
       syms.add(sym)
       kinds.add(String(path))
@@ -116,6 +137,8 @@ function secretsBuild(model: Model, target: any): SecretsBuild | null {
     groups: groups.sort(),
     tlsGroups: tlsGroups.sort(),
     tls,
+    stubs: Array.from(stubs).sort(),
+    stubGroups: stubGroups.sort(),
     plugin: SECRETS_PLUGIN_MODULES,
     core: SECRETS_CORE_MODULES,
     helpers: [
@@ -308,7 +331,7 @@ let make_feature (name : string) : feature =
     const OCAML_FEATURES = [
       'audit', 'cache', 'clienttrack', 'cost', 'debug', 'idempotency', 'log',
       'metrics', 'netsim', 'paging', 'proxy', 'ratelimit', 'rbac',
-      'retry', 'streaming', 'telemetry', 'test', 'timeout',
+      'retry', 'streaming', 'telemetry', 'test', 'timeout', 'validate',
     ]
 
     each(feature, (f: any) => {

package/project/.sdk/src/cmp/ocaml/Main_ocaml.ts

@@ -21,6 +21,7 @@ import {
 
 import { Package } from './Package_ocaml'
 import { Config, secretsBuild } from './Config_ocaml'
+import { Schema } from './Schema_ocaml'
 import { Gitignore } from './Gitignore_ocaml'
 import { MainEntity } from './MainEntity_ocaml'
 import { SdkError } from './SdkError_ocaml'
@@ -153,25 +154,44 @@ FEATURE_SRC = $(SECRETS_PLUGIN) $(SECRETS_CORE) $(SECRETS_HELPERS) $(SECRETS_KIN
 FEATURE_TESTS = test/feature/secrets/t_secrets.ml
 `)
 
-          if (build.tls) {
+          // EVERY C OBJECT THIS CHAIN NEEDS, from two different owners.
+          // tls_stubs.c belongs to the transport HELPER, which no group
+          // owns and which any kind reaching the network pulls in;
+          // minivault_stubs.c belongs to the KIND, and is listed in that
+          // group's own `path`. Both link against libcrypto and only the
+          // transport needs libssl, so the link line is assembled rather
+          // than written twice - an SDK with both gets each library once.
+          const objs = [
+            ...(build.tls ? ['feature/secrets/plugins/tls_stubs.o'] : []),
+            ...build.stubs.map((one) => one.replace(/\.c$/, '.o')),
+          ]
+          const libs = [
+            ...(build.tls ? ['-cclib', '-lssl'] : []),
+            ...(build.tls || 0 < build.stubs.length ? ['-cclib', '-lcrypto'] : []),
+          ]
+
+          if (0 < objs.length) {
             Content(`
-# THE ONE EXTERNAL DEPENDENCY, behind the plugin groups that need a
-# transport (${build.tlsGroups.join(', ')}): plugins/tls.ml's externals live in
-# plugins/tls_stubs.c against OpenSSL, so the stub is compiled here and the
-# bytecode executables are linked \`-custom\` with libssl and libcrypto.
-# The stub is fed from line four (past the provenance header, see above).
+# THE C OBJECTS THIS CHAIN NEEDS${build.tls ? `, and the one external
+# dependency behind the plugin groups that need a transport
+# (${build.tlsGroups.join(', ')}): plugins/tls.ml's externals live in
+# plugins/tls_stubs.c against OpenSSL` : ''}${0 < build.stubs.length ? `${build.tls ? '. ' : `,
+# behind `}the mini vault's own stub (${build.stubGroups.join(', ')}), whose
+# AES-256-GCM and PBKDF2 come from libcrypto` : ''}. Each stub is compiled
+# here and the bytecode executables are linked \`-custom\`, and each is fed
+# to the compiler from line four (past the provenance header, see above).
 OCAMLLIB = $(shell $(OCAMLC) -where)
-FEATURE_OBJ = feature/secrets/plugins/tls_stubs.o
-FEATURE_LINK = -custom -cclib -lssl -cclib -lcrypto
-
-feature/secrets/plugins/tls_stubs.o: feature/secrets/plugins/tls_stubs.c
-	@command -v $(CC) >/dev/null 2>&1 || { echo "secrets: a C compiler ($(CC)) is needed to build the OpenSSL binding that this SDK's secrets plugin kinds (${build.tlsGroups.join(', ')}) run - install one, or use only the built-in provider kinds" >&2; exit 1; }
+FEATURE_OBJ = ${objs.join(' ')}
+FEATURE_LINK = -custom ${libs.join(' ')}
+${objs.map((obj) => `
+${obj}: ${obj.replace(/\.o$/, '.c')}
+	@command -v $(CC) >/dev/null 2>&1 || { echo "secrets: a C compiler ($(CC)) is needed to build the C stub that this SDK's secrets plugin kinds (${build.groups.join(', ')}) run - install one, or use only the built-in provider kinds" >&2; exit 1; }
 	tail -n +4 $< | $(CC) -std=c11 -O2 -Wall -Wextra -I$(OCAMLLIB) -x c - -c -o $@
-`)
+`).join('')}`)
           }
           else {
             Content(`
-# No active plugin group needs a transport, so the OpenSSL binding is not
+# No active plugin group needs a transport or a C stub, so nothing is
 # compiled and nothing is linked beyond the OCaml distribution.
 FEATURE_OBJ =
 FEATURE_LINK =
@@ -183,6 +203,7 @@ FEATURE_LINK =
   }
 
   // Generated API config + branded-error re-export.
+  Schema({ target })
   Config({ target })
   SdkError({ target })
 

package/project/.sdk/src/cmp/ocaml/ReadmeExplanation_ocaml.ts

@@ -22,6 +22,7 @@ Build request maps with the \`jo\` / \`ja\` helpers and read fields back with
 ${target.name}/
 ├── sdk_client.ml               -- Main SDK client (constructors + accessors)
 ├── sdk_config.ml               -- Embedded API config + feature factory
+├── sdk_schema.ml               -- Generated option + entity specs
 ├── sdk_error.ml                -- Branded error re-exports
 ├── sdk_entity_*.ml             -- Per-entity implementations (one each)
 ├── sdk_types.ml                -- Core pipeline types

package/project/.sdk/src/cmp/ocaml/Schema_ocaml.ts

@@ -0,0 +1,99 @@
+import {
+  Content,
+  File,
+  cmp,
+  entitySpecMap,
+  optionSpec,
+} from '@voxgig/sdkgen'
+
+
+import {
+  Model,
+} from '@voxgig/apidef'
+
+
+import {
+  ocamlString,
+} from './utility_ocaml'
+
+
+// THE GENERATED SCHEMA MODULE: the model's schemas, as data the SDK can run.
+//
+// The ocaml peer of src/cmp/ts/Schema_ts.ts. Same two members, same source:
+// optspec from `main.kit.optspec` plus each feature's own `config.options`,
+// entityspec from the entity field sentinels — both built by the shared
+// helpers, so what ocaml validates against and what ts validates against
+// cannot drift.
+//
+// EMBEDDED AS JSON, PARSED AT LOAD, where ts emits an object literal: JSON is
+// a subset of TypeScript's own literal syntax and is not a subset of ocaml's.
+// A string constant read by `Sdk_json.json_read`, exactly as sdk_config.ml
+// carries its data rep above the size threshold.
+//
+// COMPILE ORDER. ocaml links a fixed module list, and sdk_runtime.ml's
+// make_options reads this, so sdk_schema.ml is named in RUNTIME (the
+// Makefile) between sdk_helpers.ml and sdk_runtime.ml. It opens nothing of
+// the SDK beyond Voxgig_struct and Sdk_json, so it cannot close a cycle.
+//
+// The round-trip is exact because the spec holds only strings and booleans:
+// pinned by "strings and booleans only, so the JSON round-trip is lossless"
+// in ts/test/optspec.test.ts. json_read yields `Num (float)` for any number,
+// and struct reads a spec BY EXAMPLE, so one number in here would mean
+// something different in ocaml than in ts.
+const Schema = cmp(async function Schema(props: any) {
+  const ctx$ = props.ctx$
+  const target = props.target
+
+  const model: Model = ctx$.model
+
+  const optspec = optionSpec(model, target.name)
+  const entityspec = entitySpecMap(model, target.name) || {}
+
+  File({ name: 'sdk_schema.' + target.ext }, () => {
+
+    Content(`(* ${model.const.Name} SDK: generated schemas. Do not edit.
+ *
+ * Built from the model: main.kit.optspec and each feature's config.options
+ * for the option spec; entity fields[].type for the entity specs.
+ *
+ * opt_spec_value () - the option spec make_options validates client options
+ * against. entity_spec_value () - per-entity data and request specs, keyed by
+ * entity name. Both parse once and memoise: the spec is read on every client
+ * construction and never mutated, so a per-call parse would be pure waste.
+ *
+ * The returned values are SHARED: treat them as read-only. make_options
+ * validates AGAINST the spec and writes into the options, never into it. *)
+
+open Voxgig_struct
+
+let optspec_data = "${ocamlString(JSON.stringify(optspec))}"
+
+let entityspec_data = "${ocamlString(JSON.stringify(entityspec))}"
+
+let optspec_memo : value option ref = ref None
+
+let entityspec_memo : value option ref = ref None
+
+let opt_spec_value () : value =
+  match !optspec_memo with
+  | Some v -> v
+  | None ->
+    let v = Sdk_json.json_read optspec_data in
+    optspec_memo := Some v;
+    v
+
+let entity_spec_value () : value =
+  match !entityspec_memo with
+  | Some v -> v
+  | None ->
+    let v = Sdk_json.json_read entityspec_data in
+    entityspec_memo := Some v;
+    v
+`)
+  })
+})
+
+
+export {
+  Schema
+}

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

@@ -23,6 +23,7 @@ import {
 
 import { Package } from './Package_perl'
 import { Config } from './Config_perl'
+import { Schema } from './Schema_perl'
 import { PrepareAuth } from './PrepareAuth_perl'
 import { Gitignore } from './Gitignore_perl'
 import { MainEntity } from './MainEntity_perl'
@@ -130,6 +131,7 @@ const Main = cmp(async function Main(props: any) {
   // Generate config module
   Folder({ name: '.' }, () => {
     Config({ target })
+    Schema({ target })
   })
 
   // GENERATED, NOT COPIED. Where the credential goes is a fact about the

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

@@ -20,6 +20,7 @@ is a hashref.
 ${target.name}/
 ├── lib/${model.const.Name}SDK.pm    -- Main SDK module (package ${model.const.Name}SDK)
 ├── config.pm                    -- Configuration
+├── schema.pm                    -- Generated option + entity specs
 ├── features.pm                  -- Feature factory
 ├── core/                        -- Core types and context
 ├── entity/                      -- Entity implementations