@voxgig/sdkgen 4.20.0 → 4.22.0

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

@@ -37,21 +37,12 @@ const Config = cmp(async function Config(props: any) {
   const Name = model.const.Name
 
   const entity = getModelPath(model, `main.${KIT}.entity`)
-  // Gated by the applicability tags, so this target never imports or
-  // registers a feature it has no source for. One rule, one place:
-  // helpers/applicability.
   const feature = targetFeatures(model, target)
 
   const headers = getModelPath(model, `main.${KIT}.config.headers`) || {}
 
   const authActive = isAuthActive(model)
   const authPrefix = resolveAuthPrefix(model)
-  // `in` and `name` travel with the prefix now. apidef resolved both from
-  // the spec's securityScheme all along (joplin's says `in: "query",
-  // name: "token"`) and generation dropped them, so an apiKey-in-query API
-  // got an Authorization header it does not read. Emitted below ONLY when
-  // they differ from the header/Authorization defaults, so a header SDK's
-  // config.ex is byte-identical to what it generated before.
   const authIn = resolveAuthIn(model)
   const authName = resolveAuthName(model)
 
@@ -62,34 +53,8 @@ const Config = cmp(async function Config(props: any) {
     ? `        "auth" => %{"prefix" => ${elixirString(authPrefix)}},\n`
     : ''
 
-  // THE PLUGIN DEFINITIONS PER FEATURE (the elixir peer of Config_go's
-  // FeaturePlugins and Config_ts's pluginDefs).
-  //
-  // Upstream sekreto replaced its self-registration registry with
-  // voxgig/plugin definitions: a provider kind the caller did not pass in
-  // via `plugins: [...]` is unknown to that Sekreto, so the model's choice
-  // of plugin groups IS the SDK's provider vocabulary. Each active plugin's
-  // `def` key is a fully-qualified elixir CALL (`Sekreto.Plugins.Hashicorp
-  // .hashicorp`), emitted here as `...()` and handed to the feature.
-  //
-  // The smallest of the four emitters: Elixir resolves modules globally, by
-  // their `defmodule`, so there is no import block to keep in step with the
-  // trim - naming the call is the whole of it.
-  //
-  // Filter on `active` HERE rather than trusting the feature object to
-  // arrive filtered (the trap Config_ts and Config_go both carry a warning
-  // about): emitting a call into a module the plugin trim just deleted is
-  // an `UndefinedFunctionError` at the first client construction.
   const featurePlugins: Record<string, string[]> = {}
 
-  // DECLARED at all, active or not - the emit gate. An SDK that selects no
-  // plugin-bearing feature gets no function, so config.ex is byte-identical
-  // to what it was before this feature existed: inactive costs nothing.
-  // (`only_active: false` for the same reason pluginExcludes needs it - the
-  // feature object a component is handed has ALREADY been filtered, so its
-  // `plugin` map holds only the ACTIVE groups and a project with the feature
-  // on but every group off would read as "no plugins declared" and lose the
-  // function the feature calls.)
   let declared = false
 
   each(feature, (f: any) => {
@@ -129,63 +94,20 @@ const Config = cmp(async function Config(props: any) {
 `
 
   Folder({ name: 'lib' }, () => {
-    // The same config as an OBJECT, built by the shared helper so this
-    // target's literal and the data that replaces it above the threshold are
-    // the same config by construction. The JSON is what the threshold is
-    // measured on - emitted source size varies by language, the model does not.
-    // Passing target.name opts in to the main slug/version/target identity
-    // fields (station descriptor input, mirrors Config_ts) - both reps below
-    // render from this same def, so the data and literal branches pick the
-    // fields up together.
     const { def: configDef } = configDefinition(model, target.name)
 
-    // THE PLACEMENT, ONTO THE CANONICAL DEFINITION RATHER THAN INTO ONE
-    // BRANCH. Both reps below render from `configDef` - the literal through
-    // formatElixir, the data through JSON - so overlaying the fact here is
-    // what keeps them the same config either side of the threshold. (Targets
-    // whose literal is a hand-assembled fragment had to emit the block twice
-    // and only did it once; elixir renders `options` whole, so it cannot
-    // drift.)
-    //
-    // The optspec in utility.ex's make_options declares `in` and `name` for
-    // exactly this reason: this port's validate REJECTS a key the spec does
-    // not list, so a config carrying a placement the optspec has never heard
-    // of does not degrade quietly - the client cannot be constructed at all
-    // (`** (Voxgig.Struct.Error) Unexpected keys at field auth: in, name`,
-    // measured by removing the optspec entry from a generated query SDK).
     if (authActive && null != configDef.options && null != configDef.options.auth) {
       if ('header' !== authIn) configDef.options.auth.in = authIn
       if ('Authorization' !== authName) configDef.options.auth.name = authName
     }
 
-    // Re-stringified AFTER the overlay, so the size the threshold is measured
-    // on is the size of the config actually emitted. For a header SDK the
-    // overlay adds nothing and this is byte-identical to configDefinition's
-    // own json.
     const configJson = JSON.stringify(configDef)
     const asData = isConfigData(configJson, configReprSetting(model))
 
-    // configDefinition's `def.entity` verbatim, NOT rebuilt here. The reduce
-    // this replaces was one of fourteen copies of that function's entityDefs
-    // loop, and when configDefinition started reconstructing a point's
-    // `parts` from apidef's segment vector (its ADR-003), only the copies
-    // that read `configDef` got it — this target's literal config emitted
-    // paths with no parts at all while its data config had them. One rule,
-    // one place.
     const entityClean = configDef.entity
 
     File({ name: 'config.ex' }, () => {
 
-      // ABOVE THE THRESHOLD: emit the model as DATA.
-      //
-      // The literal is one nested `%{}` the Elixir compiler expands and holds
-      // in the module's constant pool; a binary is one token. `Json.parse`
-      // builds the vendored struct's heap nodes DIRECTLY - the same nodes
-      // `Helpers.deep/1` produces from a plain map - so make_config returns
-      // exactly what it returned before.
-      //
-      // `ProjectName.Json` is already the SDK's response decoder (see
-      // `safe_json` in utility.ex), so this adds no dependency.
       if (asData) {
         Content(`# ${Name} SDK configuration
 #

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

@@ -1,28 +1,5 @@
 
 
-// Typed-model generator (Elixir target). Port of EntityTypes_ts.ts / _rb.ts.
-//
-// Reads main.<KIT>.entity.<e>.fields[] and per-op params
-// (op.<name>.points[].args.params[]) and emits one module, lib/<app>_types.ex,
-// holding an `@type` alias per active entity plus a request/match type per
-// active op, each with a `@typedoc` documenting its concrete members.
-//
-// TYPE CHOICE: the SDK carries data as string-keyed struct value nodes, and
-// Elixir map typespecs cannot pin individual string keys (only
-// `optional(String.t()) => v`), so every alias resolves to an open string-keyed
-// map `%{optional(String.t()) => any()}`. The precise per-member shape is
-// documented in the accompanying @typedoc (the honest Elixir analogue of the
-// TS interface / rb Struct). Field/param sentinels ($STRING, $INTEGER, ...) are
-// turned into real Elixir typespec fragments (String.t(), integer(), ...) by
-// the shared sdkgen canonToType 'elixir' column (via the `elixirType`
-// delegate in utility_elixir).
-//
-// Op type-name scheme mirrors every other language — derived from the SHARED
-// OP_SUFFIX policy, snake_cased for Elixir:
-//   <ename>, <ename>_load_match, <ename>_list_match, <ename>_create_data,
-//   <ename>_update_data, <ename>_remove_match.
-// The generated entity modules reference these aliases from @spec annotations
-// on their op functions (see fragment/Entity*Op.fragment.ex).
 
 import {
   cmp, each, names,
@@ -39,16 +16,11 @@ import {
 import { elixirType } from './utility_elixir'
 
 
-// Snake_case op type name, derived from the SHARED OP_SUFFIX policy (the
-// PascalCase scheme <Name><Op><Match|Data> rendered Elixir-style):
-//   <ename>_load_match, <ename>_create_data, ...
 function elixirOpTypeName(ename: string, opname: string): string {
   return ename + '_' + opname + '_' + (OP_SUFFIX[opname] || 'Match').toLowerCase()
 }
 
 
-// Emit one `@typedoc` + `@type` alias. The alias is always an open
-// string-keyed map; the members are documented in the doc block.
 function emitType(
   typeName: string,
   doc: string,
@@ -79,10 +51,6 @@ const EntityTypes = cmp(function EntityTypes(props: any) {
   const Name = model.const.Name
   const app = model.const.name.toLowerCase()
 
-  // only_active:false — getModelPath DROPS active:false entries by default,
-  // but the consumer scaffold (create-sdkgen Root.ts) iterates the RAW entity
-  // collection, so inactive entities still get generated entity code that
-  // references these typed names. The typed model must cover them too.
   const entity = getModelPath(model, `main.${KIT}.entity`, { only_active: false, required: false })
   // Emit for EVERY entity that gets an entity module: the consumer scaffold
   // (create-sdkgen Root.ts) iterates entities WITHOUT an active filter, and
@@ -93,9 +61,6 @@ const EntityTypes = cmp(function EntityTypes(props: any) {
   // Derive the PascalCase Name up-front — it is set LAZILY by names(), so an
   // entity not yet named would otherwise read `Name = undefined` below.
 
-  // Surface duplicate generated type names (two entities with the same
-  // PascalCase Name) — they would redeclare a type in statically-typed
-  // targets. Detection only; renaming is a model-level decision.
   warnEntityTypeCollisions(entity, log, LANG)
 
   Folder({ name: 'lib' }, () => {
@@ -126,15 +91,12 @@ defmodule ${Name}.Types do
         const fields = (ent.fields ? each(ent.fields) : [])
           .filter((f: any) => f.active !== false)
 
-        // Entity data model: one member per field (`req:false` -> optional).
         emitType(
           ename,
           `${EName} entity data model.`,
           fields.map((f: any) => ({ name: f.name, type: f.type, optional: false === f.req })),
         )
 
-        // Per active op: a request/match type. Members and their optionality
-        // come from the shared partiality policy (opRequestShape).
         const ops = ent.op || {}
         ;['load', 'list', 'create', 'update', 'remove'].forEach((opname: string) => {
           if (null == ops[opname]) {

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

@@ -17,15 +17,13 @@ import {
 
 import { Package } from './Package_elixir'
 import { Config } from './Config_elixir'
+import { Schema } from './Schema_elixir'
 import { PrepareAuth } from './PrepareAuth_elixir'
 import { Gitignore } from './Gitignore_elixir'
 import { MainEntity } from './MainEntity_elixir'
 import { EntityTypes } from './EntityTypes_elixir'
 
 
-// #`-comment hook marker key (gotcha #1: jostraca's built-in #Name-Tag
-// replacement only matches `//` comments, so an Elixir `# #<Name>-Hook`
-// line never matches and the pipeline hook would be silently dropped).
 const HOOK_KEY =
   '/(?<indent>[ \\t]*)#[ \\t]*#(?<name>[A-Za-z0-9]+)-Hook[ \\t]*\\n?/'
 
@@ -54,16 +52,6 @@ const Main = cmp(async function Main(props: any) {
   // Generate the documented typespec module (lib/<app>_types.ex).
   EntityTypes({ target })
 
-  // Copy tm/elixir (with ProjectName/projectname substitution).
-  //
-  // THE RUNTIME DIRECTORY HAS TO CARRY THE APP NAME. Copy substitutes file
-  // CONTENTS, never path components, so a blanket copy shipped the runtime as
-  // lib/projectname/ in every generated SDK. Nothing broke — Elixir resolves
-  // modules by their `defmodule`, not by path, and those were substituted
-  // correctly — so it compiled, tested green, and published looking wrong.
-  //
-  // Copy's `to` prop names the destination, so lib/projectname is copied
-  // explicitly under the app's own name and excluded from the blanket copy.
   Copy({
     from: 'tm/' + target.name,
     exclude: [/src\//, /lib\/projectname\//],
@@ -76,20 +64,6 @@ const Main = cmp(async function Main(props: any) {
     Copy({
       from: 'tm/' + target.name + '/lib/projectname',
       to: model.const.name,
-      // pluginExcludes: the generate-time plugin trim (an INACTIVE plugin
-      // group's vendored files, declared per-target in the feature model).
-      // Rooted HERE, on lib/projectname, because that is this Copy's root
-      // and jostraca matches a candidate against the path relative to it -
-      // which is why the model's elixir plugin paths read
-      // `feature/secrets/sekreto/plugins/<kind>.ex` and not the full
-      // `lib/projectname/...`.
-      //
-      // AND THE TRIM IS INVISIBLE TO THE COMPILER HERE, unlike everywhere
-      // else. mix compiles everything under lib/ and Elixir needs no
-      // import, so a plugin file this exclude failed to remove compiles
-      // silently and SHIPS - where go fails on an unused import, py on a
-      // missing module and ts on an unresolved one. Only the parity and
-      // vendored guards can catch a broken trim in this target.
       exclude: [...pluginExcludes(model)],
       replace: {
         ...stdrep,
@@ -117,7 +91,6 @@ const Main = cmp(async function Main(props: any) {
       )
     })
 
-    // Operation pipeline (hook markers replaced here — gotcha #1).
     File({ name: 'pipeline.' + target.ext }, () => {
       Fragment({
         from: ff + 'Pipeline.fragment.ex',
@@ -157,23 +130,12 @@ end
 `)
     })
 
-    // WHERE THE CREDENTIAL GOES IS GENERATED, NOT COPIED. prepare_auth was
-    // the one pipeline utility whose answer is a fact about the API rather
-    // than about the language, and tm/ can only hold one answer - so it is
-    // extracted out of the copied utility.ex into its own module here. See
-    // PrepareAuth_elixir for the extraction and for why the registration in
-    // utility.ex still binds it.
-    //
-    // CALLED FROM INSIDE THIS `lib` FOLDER, and the component opens only
-    // `<name>`, so the file lands at lib/<name>/prepare_auth.ex - beside the
-    // utility.ex the Copy above puts at lib/<name>/utility.ex. Opening `lib`
-    // in the component too would write lib/lib/<name>/, which mix would
-    // compile anyway (it globs the whole tree) and no test could see.
     PrepareAuth({ target })
   })
 
   // Config module.
   Config({ target })
+  Schema({ target })
 })
 
 

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

@@ -15,12 +15,6 @@ import type {
 } from '@voxgig/apidef'
 
 
-// Generate mix.exs for the Elixir SDK. The vendored struct library has zero
-// third-party runtime deps, so a bare SDK ships with none - but dependencies
-// declared by the model DO flow: the target's own `deps` block plus any
-// feature-declared elixir deps (e.g. the station feature's voxgig_station),
-// via the shared collectDeps helper, exactly like rust/dart/go. A model with
-// no deps emits the byte-identical `defp deps, do: []` it always has.
 const Package = cmp(async function Package(props: any) {
   const ctx$ = props.ctx$
   const target = props.target
@@ -32,13 +26,6 @@ const Package = cmp(async function Package(props: any) {
   const app = String(model.const.name).replace(/-/g, '_')
   const { repoUrl } = repoInfo(model)
 
-  // Render one mix deps entry per collected dependency. Hex package names
-  // share the atom alphabet, but a hyphen in a model dep name is mapped to
-  // '_' rather than emitted broken. Version -> Mix requirement: an explicit
-  // operator is kept (spaced, the mix convention: '>=0.0.1' -> '>= 0.0.1');
-  // a bare version gets hex's customary '~>'; a target dep with no version
-  // accepts anything. kind: 'dev' scopes to [:dev, :test]; 'peer'/'prod'
-  // (and anything else) are runtime deps - mix has no peer notion.
   const entries: string[] = []
   for (const d of collectDeps(model, target.name, target.deps, ctx$.log)) {
     const atom = String(d.name).replace(/-/g, '_')

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

@@ -22,78 +22,10 @@ import {
 } from './utility_elixir'
 
 
-// WHERE THE CREDENTIAL GOES IS A FACT ABOUT THE API, so it is generated
-// rather than templated. The elixir port of cmp/ts/PrepareAuth_ts.ts; see
-// that file for the full account, and cmp/rb/PrepareAuth_rb.ts for the
-// cookie-splice and basic-auth shapes this one follows.
-//
-// apidef has always resolved the scheme's `in` and `name` into
-// `main.kit.info.security` — joplin's says `in: "query", name: "token"` —
-// and generation dropped both. The result was an SDK that sent a header the
-// API does not read and never sent the query parameter it does, so it could
-// not authenticate at all. Four repos in the cedar fleet shipped that way:
-// joplin (`token`), pipedrive (`api_token`), trello (`key`),
-// lm-umbrella (`apiKey`).
-//
-// A template cannot fix this, because the three placements need three
-// different bodies and a template has to pick one. A component emits the
-// branch this API actually uses and nothing else — no dead query code in a
-// bearer-token SDK, and no runtime `if` on a value that is fixed at
-// generation time.
-//
-// ELIXIR IS THE ODD ONE OUT: it had NO prepare_auth template. The logic was
-// embedded in `tm/elixir/lib/projectname/utility.ex` as `prepare_auth_impl/1`,
-// one clause among thirty in the 1670-line runtime module. So this is an
-// EXTRACTION as well as a port, and the extraction is into the function's
-// OWN compilation unit — the PREFERRED shape — because Elixir has no reason
-// to need the fallback:
-//
-//   * mix compiles every `.ex` under `lib/`, with no manifest, include list
-//     or import to keep in step. A new file in lib/<app>/ is compiled by
-//     virtue of existing.
-//   * Elixir resolves modules by their `defmodule`, never by path, so a
-//     module in its own file is indistinguishable at every call site from
-//     the same code inlined elsewhere.
-//   * THE BINDING IS A VALUE, NOT A LEXICAL REFERENCE. utility.ex builds the
-//     utility node by setprop-ing a function into each slot
-//     (`{"prepare_auth", &prepare_auth_impl/1}`), and every caller reaches it
-//     through `u(ctx, "prepare_auth").(ctx)`. A remote capture
-//     `&PrepareAuth.prepare_auth_impl/1` is the same kind of value, so the
-//     registrar, the feature-override contract (a feature setprops over the
-//     slot on the reference-stable node) and the `Utility.prepare_auth/1`
-//     dispatch wrapper are all untouched. `Utility.prepare_auth(ctx)` —
-//     which is what Main.fragment.ex, make_spec_impl, pipeline_test.exs and
-//     primary_utility_test.exs all call — still resolves, still dispatches
-//     through the node, and still honours an override.
 const PrepareAuth = cmp(async function PrepareAuth(props: any) {
   const { target } = props
   const { model } = props.ctx$
 
-  // FOLDER NESTING, worked out from the template's own path rather than
-  // guessed. utility.ex lives at `tm/elixir/lib/projectname/utility.ex`, and
-  // Main_elixir copies that directory with
-  //
-  //   Folder({name:'lib'}, () => Copy({from:'tm/elixir/lib/projectname',
-  //                                    to: model.const.name}))
-  //
-  // so the runtime lands at `lib/<name>/`. This component is CALLED from
-  // inside Main's second `Folder({ name: 'lib' })` block — the one that
-  // writes the generated (as opposed to copied) lib files — so `lib` is
-  // ALREADY OPEN at the call site and only `<name>` is opened here. The
-  // result is `lib/<name>/prepare_auth.ex`, beside the utility.ex that
-  // registers it.
-  //
-  // Opening `lib` again here would write `lib/lib/<name>/prepare_auth.ex`.
-  // That is the ts port's `src/src/utility/` trap, and it is WORSE in elixir
-  // than anywhere else: mix compiles everything under lib/ regardless of
-  // depth, so the module would still compile, still be found by name, and
-  // the mistake would be invisible to every test — only the published tree
-  // would look wrong. (Main_elixir carries the same warning about
-  // lib/projectname/ for the same reason.)
-  //
-  // Main's two `Folder({ name: 'lib' })` blocks are SIBLINGS, not nested:
-  // jostraca folders are scoped to their callback, so both resolve to
-  // `lib/` and this component sees exactly one of them open.
   Folder({ name: model.const.name }, () => {
     File({ name: 'prepare_auth.' + target.ext }, () => {
       Content(render({
@@ -139,8 +71,6 @@ defmodule ${spec.Name}.PrepareAuth do
 
 `
 
-  // NO AUTH AT ALL — the project switched it off. See authSwitchedOn for why
-  // ONLY an explicit switch counts.
   if (!spec.active) {
     return head + `  # This SDK is configured with authentication off, so there is no
   # credential to place. The function stays in the pipeline because
@@ -162,27 +92,8 @@ end
   const query = 'query' === spec.where
   const cookie = 'cookie' === spec.where
 
-  // HTTP Basic is header-only by definition: the scheme is
-  // `Authorization: Basic base64(user:pass)`. It cannot be expressed as a
-  // query parameter or a cookie, so the branch is emitted only where it can
-  // mean something — and only when the model says the scheme IS basic, so an
-  // ordinary bearer SDK carries no dead code and regenerates byte-identical
-  // to what utility.ex produced.
   const basicHere = spec.basic && 'header' === spec.where
 
-  // HEADER NAMES ARE LOWER-CASED; QUERY AND COOKIE NAMES ARE NOT.
-  //
-  // `resolveAuthName` answers 'Authorization' by default, but the whole
-  // elixir runtime spells header names in lower case: the extracted code
-  // said `S.delprop(headers, "authorization")`, feature/secrets.ex rewrites
-  // `headers["authorization"]`, feature/debug.ex masks the same key, the
-  // shared corpus asserts `ctx:spec:headers:authorization`, and
-  // pipeline_test.exs reads it. A struct map key is case-sensitive, so
-  // emitting "Authorization" verbatim would put the credential under a key
-  // nothing reads and leave the secrets feature writing a SECOND header.
-  // HTTP header names are case-insensitive on the wire, so lower-casing
-  // costs nothing. A query parameter and a cookie ARE case-sensitive
-  // (`?Token=` is not `?token=`), so those keep the spec's spelling.
   const credName = query || cookie ? spec.name : spec.name.toLowerCase()
 
   const attrs = `  @cred_name ${elixirString(credName)}
@@ -203,9 +114,6 @@ end
     ? `      query = S.getprop(spec, "query")`
     : `      headers = S.getprop(spec, "headers")`
 
-  // Clearing: a query parameter and a header are a plain delprop, but a
-  // cookie header is SHARED with whatever cookies the caller set, so only
-  // our own pair comes out.
   const clear = query
     ? 'S.delprop(query, @cred_name)'
     : cookie
@@ -266,8 +174,6 @@ ${indent(place(spec, clear), 1)}
 }
 
 
-// The one thing that actually differs between placements: where the
-// credential is written, and whether the prefix travels with it.
 function place(spec: AuthSpec, clear: string): string {
   const guard = `        if (is_binary(apikey) and apikey == @not_found) or apikey == nil or apikey == "" do
           ${clear}
@@ -294,7 +200,6 @@ function place(spec: AuthSpec, clear: string): string {
 `
   }
 
-  // HEADER: the extracted body, unchanged.
   return guard + `          ap = S.getpath(options, "auth.prefix")
           auth_prefix = if is_binary(ap), do: ap, else: ""
           apikey_val = if is_binary(apikey), do: apikey, else: ""
@@ -306,11 +211,6 @@ function place(spec: AuthSpec, clear: string): string {
 }
 
 
-// The private helpers the emitted body needs. `opts_map/1` is the one
-// utility.ex keeps for itself (it is `defp` there, so it could not be
-// called across the module boundary) - eight lines, reproduced rather than
-// made public, because widening a private helper to export one caller is a
-// bigger change to utility.ex than this extraction is.
 function helpers(spec: AuthSpec): string {
   const optsMap = `  # The client's options as a MAP, cloned. The clone is load-bearing: the
   # secrets feature rewrites options.apikey on the live client, and
@@ -383,29 +283,6 @@ function indent(block: string, n: number): string {
 }
 
 
-// NOT `isAuthActive`, AND THE DIFFERENCE IS LOAD-BEARING (the py port found
-// this first; same reasoning, same fix).
-//
-// `isAuthActive` is false whenever the SPEC declares no security scheme
-// (`main.kit.info.auth: false`). That is a statement about the DEFINITION,
-// not a ban on ever sending a credential: apidef writes it for every spec
-// with no securitySchemes block, GitHub's official OpenAPI included, and
-// those SDKs are still expected to honour an `apikey` the caller passes.
-// `optspec` always declares `apikey` and make_options fills `options.auth`
-// from its defaults, so the runtime `S.getprop(options, "auth") == nil`
-// guard never fired and every such SDK has always sent `options.apikey`.
-//
-// Gating the body on `isAuthActive` therefore does not trim dead code, it
-// deletes working authentication - and takes the secrets feature with it,
-// since that resolves a secret into options.apikey and prepare_auth then
-// places nothing. elixir is one of the three targets in generatedcompile's
-// AUTHNULL_STANDALONE list, whose lane (`elixir: the secrets feature runs
-// with the feature active`) runs the shipped secrets suite against a LIVE
-// client on a real mix and names its two auth-nil cases.
-//
-// So the no-op is emitted only when the PROJECT says so: `config.auth.active:
-// false`, an explicit per-SDK switch nobody sets by accident. A spec that is
-// merely silent keeps the credential path it has always had.
 function authSwitchedOn(model: any): boolean {
   const auth = getModelPath(model, `main.${KIT}.config.auth`,
     { only_active: false, required: false })

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

@@ -2,25 +2,6 @@
 import { cmp, Content, File } from '@voxgig/sdkgen'
 
 
-// Emits elixir/test/readme_examples_test.exs — an ExUnit SYNTAX + PRESENCE
-// gate over every ```elixir fenced block in the three docs that ship elixir
-// examples: the repository ROOT README.md, the per-language elixir/README.md,
-// and the per-language elixir/REFERENCE.md.
-//
-// For each block, tagged by (source doc, index), the gate PARSES it with
-// `Code.string_to_quoted/1` — catching malformed examples (a missing `end`, a
-// bad token, an unbalanced `%{}`). It also asserts each doc that exists ships
-// at least one elixir block.
-//
-// SCOPE NOTE: unlike the Python/Lua gates this does NOT execute blocks in a
-// seeded offline subprocess. Elixir's compile model makes running a README
-// fragment against the generated `<Name>` modules substantially heavier (each
-// block would need the SDK compiled and loaded, and the narrative aliases
-// resolved), so this port stops at the syntax gate — a real, useful guard that
-// keeps documented examples parseable as the generator evolves.
-//
-// The emitted Elixir avoids backticks (chr 96 via <<96>>) so this TS template
-// literal stays clean; the only interpolation is the SDK module name.
 const ReadmeExamplesTest = cmp(function ReadmeExamplesTest(props: any) {
   const { ctx$: { model } } = props
 

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

@@ -26,6 +26,7 @@ elixir/
 ├── lib/
 │   ├── ${app}.ex                 -- Main SDK module (entity factories)
 │   ├── config.ex                 -- Resolved configuration
+│   ├── schema.ex                 -- Generated option + entity specs
 │   ├── features.ex               -- Feature factory
 │   ├── pipeline.ex               -- Operation pipeline
 │   └── ${app}/

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

@@ -1,5 +1,5 @@
 
-import { cmp, each, Content, canonToType, File, isAuthActive, entityIdField, opRequestShape } from '@voxgig/sdkgen'
+import { cmp, each, Content, canonToType, File, isAuthActive, entityIdField, opRequestShape , targetFeatures } from '@voxgig/sdkgen'
 import { ReadmeRefFeatures } from '@voxgig/sdkgen'
 
 import {
@@ -41,7 +41,7 @@ const ReadmeRef = cmp(function ReadmeRef(props: any) {
 
   const Name = model.const.Name
   const entity = getModelPath(model, `main.${KIT}.entity`)
-  const feature = getModelPath(model, `main.${KIT}.feature`)
+  const feature = targetFeatures(model, target)
 
   const publishedEntities = each(entity).filter((e: any) => e.active !== false)
 
@@ -323,9 +323,6 @@ sdk = ${Name}.new(${Name}.Helpers.deep(%{
 \`\`\`
 
 `)
-      // The shared feature reference: options, defaults, usage and the
-      // considerations. Model facts, identical in every target, so they are
-      // written once in cmp/ReadmeRefFeatures.ts rather than here.
       ReadmeRefFeatures({ target })
     }
 

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

@@ -0,0 +1,64 @@
+import {
+  Content,
+  File,
+  Folder,
+  cmp,
+  entitySpecMap,
+  optionSpec,
+} from '@voxgig/sdkgen'
+
+
+import {
+  Model,
+} from '@voxgig/apidef'
+
+
+import {
+  elixirString,
+} from './utility_elixir'
+
+
+const Schema = cmp(async function Schema(props: any) {
+  const ctx$ = props.ctx$
+  const target = props.target
+
+  const model: Model = ctx$.model
+  const Name = model.const.Name
+
+  const optspec = optionSpec(model, target.name)
+  const entityspec = entitySpecMap(model, target.name) || {}
+
+  Folder({ name: 'lib' }, () => {
+
+  File({ name: 'schema.ex' }, () => {
+    Content(`# ${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.
+
+defmodule ${Name}.Schema do
+  @optspec_data ${elixirString(JSON.stringify(optspec))}
+
+  @entityspec_data ${elixirString(JSON.stringify(entityspec))}
+
+  # Parsed at COMPILE time and held as a literal: the spec is read on every
+  # client construction and never mutated, so parsing per call would be pure
+  # waste, and elixir terms are immutable so sharing carries no risk at all.
+  @optspec ${Name}.Json.parse(@optspec_data)
+
+  @entityspec ${Name}.Json.parse(@entityspec_data)
+
+  def optspec, do: @optspec
+
+  def entityspec, do: @entityspec
+end
+`)
+  })
+
+  })
+})
+
+
+export {
+  Schema
+}