@voxgig/sdkgen 4.20.0 → 4.22.0

package/project/.sdk/src/cmp/php/Schema_php.ts

@@ -0,0 +1,114 @@
+import {
+  Content,
+  File,
+  cmp,
+  entitySpecMap,
+  optionSpec,
+  rawStringLiteral,
+} from '@voxgig/sdkgen'
+
+
+import {
+  Model,
+} from '@voxgig/apidef'
+
+
+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(`<?php
+declare(strict_types=1);
+
+// ${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.
+
+class ${model.const.Name}Schema
+{
+    private const OPTSPEC_DATA = ${rawStringLiteral(JSON.stringify(optspec))};
+
+    private const ENTITYSPEC_DATA = ${rawStringLiteral(JSON.stringify(entityspec))};
+
+    // A UNION, not ?array. schema_decode hands back an empty stdClass for an
+    // EMPTY map - that is the whole point of decoding without the assoc flag,
+    // since php cannot otherwise tell an empty map from an empty list - and
+    // the entity specs are empty for a project with no entities, and whenever
+    // the validate feature is inactive, which is the default. Typed ?array,
+    // the first call to entityspec() threw a TypeError instead of handing
+    // back the empty map every other target returns.
+    private static array|\\stdClass|null $optspec = null;
+
+    private static array|\\stdClass|null $entityspec = null;
+
+    // Decoded ONCE, on first use. The spec is read on every client
+    // construction and never mutated, so decoding per call would be pure
+    // waste — and sharing the array is safe for the same reason:
+    // make_options validates AGAINST it and writes into the options, never
+    // into the spec. (php arrays are copy-on-write, so a caller that did
+    // write would get its own copy rather than corrupt this one.)
+    public static function optspec(): array|\\stdClass
+    {
+        if (self::$optspec === null) {
+            self::$optspec = self::schema_decode(json_decode(self::OPTSPEC_DATA));
+        }
+        return self::$optspec;
+    }
+
+    public static function entityspec(): array|\\stdClass
+    {
+        if (self::$entityspec === null) {
+            self::$entityspec = self::schema_decode(json_decode(self::ENTITYSPEC_DATA));
+        }
+        return self::$entityspec;
+    }
+
+    /**
+     * Decode WITHOUT the assoc flag, then convert — for the one reason
+     * config.php decodes the same way.
+     *
+     * php has a single array type, so json_decode with the assoc flag
+     * renders an empty object and an empty list identically. Struct tells a
+     * map from a list, so every empty map in the spec — utility, a feature's
+     * rates, the OPEN-only entity template — arrived as an empty LIST and
+     * was rejected with "Expected map, but found no value". Decoding to
+     * stdClass keeps the distinction long enough to preserve it.
+     *
+     * config.php patches its two known empty maps by hand afterwards; the
+     * spec has too many to enumerate and would gain one whenever a feature
+     * declares a map option, so this restores every one of them by shape.
+     */
+    private static function schema_decode(mixed $v): mixed
+    {
+        if ($v instanceof \\stdClass) {
+            $vars = get_object_vars($v);
+            if (count($vars) === 0) {
+                return (object)[];
+            }
+            $out = [];
+            foreach ($vars as $k => $c) {
+                $out[$k] = self::schema_decode($c);
+            }
+            return $out;
+        }
+        if (is_array($v)) {
+            return array_map([self::class, 'schema_decode'], $v);
+        }
+        return $v;
+    }
+}
+`)
+  })
+})
+
+
+export {
+  Schema
+}

package/project/.sdk/src/cmp/php/TestEntity_php.ts

@@ -33,9 +33,6 @@ import {
 import { formatPhpValue } from './utility_php'
 
 
-// PHP's GenCtx mirrors the shared shape (see TestEntity_ts.ts) plus an
-// `accessor` slot used to mangle the entity factory name when it collides
-// with PHP's case-insensitive `test()` static constructor.
 type GenCtx = {
   model: Model
   entity: ModelEntity
@@ -66,12 +63,6 @@ const TestEntity = cmp(function TestEntity(props: any) {
     return
   }
 
-  // The accessor may be mangled to avoid colliding with an SDK class member.
-  // This used to carry its own copy of the rule, which only knew about `test`
-  // — so an entity named `graph_ql` emitted `$client->GraphQl(null)` here,
-  // which PHP resolves (case-insensitively) to the SDK's own
-  // `graphql(string $query)` and fails with "Argument #1 must be of type
-  // string, null given". One helper, one answer.
   const entName = nom(entity, 'Name')
   const accessor = phpEntityAccessor(entName)
 

package/project/.sdk/src/cmp/php/utility_php.ts

@@ -67,28 +67,6 @@ function formatPhpValue(val: any, indent: number = 0): string {
 }
 
 
-// Emission-time normalisation of a model subtree (L0).
-//
-// Always drops jostraca's iteration metadata (`$`-suffixed keys: index$,
-// key$, val$). With `dropDefaults`, also drops keys whose value IS the
-// default the runtime already assumes when the key is absent, which is pure
-// payload — see CONFIG_DEFAULT.
-//
-// Rebuilds the tree rather than mutating during a walk. The previous
-// implementation walked a clone calling `delete p[k]`, but walk() assigns its
-// callback's result back over the child (`setprop(out, ckey, walk(...))`), so
-// the delete was undone on the way out and the helper silently did nothing.
-// Returning `undefined` from the callback does not fix it either: setprop
-// stores undefined rather than removing the key, which then emits as a null.
-//
-// `dropDefaults` is opt-in and must be passed ONLY for the entity subtree.
-// `active` means something different in feature config, where absent reads as
-// INACTIVE (see feature_init) — dropping `active: true` there would silently
-// disable the feature.
-// jostraca's iteration metadata, injected by each()/names() while it walks the
-// model. Listed explicitly rather than matched by trailing-dollar suffix: a
-// trailing dollar is not exclusive to jostraca -- Seneca uses entity$ as real
-// data -- so a blanket suffix match can silently drop a legitimate API field.
 const MODEL_META = ['index$', 'key$', 'val$']
 
 // Keys whose value IS the default the runtime already assumes when the key is

package/project/.sdk/src/cmp/py/Config_py.ts

@@ -34,32 +34,11 @@ import {
 } from './utility_py'
 
 
-// PLUGIN DEFINITION IMPORTS AND THE FEATURE_PLUGINS MAP (mirrors
-// cmp/ts/Config_ts.ts).
-//
-// 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 config imports each
-// active plugin's exported definition BY NAME (the model's `def.py` map)
-// and hands the list to the feature through FEATURE_PLUGINS.
-//
-// The `def` map is declared in the model rather than derived from
-// filenames because one module may export several definitions (sekreto's
-// aws.py exports awssecrets AND awsparams). A def value is the module's
-// path under tm/py ('pkg/feature/.../aws.py'); Main copies tm/py/pkg INTO
-// the <name>_sdk package, so the import module is the path with `pkg/`
-// swapped for the package name and slashes for dots.
 function pluginImports(feature: any, pkg: string) {
   each(feature, (f: any) => {
-    // path -> [symbol, ...], so one import line serves a two-definition
-    // module.
     const bypath: Record<string, string[]> = {}
 
     each(f.plugin, (plugin: any) => {
-      // Filter on `active` HERE rather than trusting the feature object
-      // to arrive filtered: getting it wrong in this direction emits an
-      // import for a module the plugin trim just deleted - an SDK that
-      // does not import, rather than one that merely carries too much.
       if (false === plugin.active || null == plugin.active) return
 
       for (const [sym, one] of Object.entries(plugin.def?.py || {})) {
@@ -76,8 +55,6 @@ function pluginImports(feature: any, pkg: string) {
   })
 }
 
-// The FEATURE_PLUGINS entries: one line per feature that has any active
-// plugin definitions, listing the imported symbols.
 function pluginDefs(feature: any) {
   each(feature, (f: any) => {
     const syms: string[] = []
@@ -99,15 +76,11 @@ const Config = cmp(async function Config(props: any) {
   const model: Model = ctx$.model
 
   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)
-  // config.auth.prefix override -> spec-derived info.security.prefix -> 'Bearer'
   const authPrefix = resolveAuthPrefix(model)
   // `in` and `name` travel with the prefix now. They were resolved by
   // apidef all along and dropped here, so an apiKey-in-query API got an
@@ -120,8 +93,6 @@ 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' +
@@ -136,12 +107,6 @@ const Config = cmp(async function Config(props: any) {
             },\n`
     : ''
 
-  // 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 the
-  // target name opts in to the main.slug/version/target identity fields -
-  // the literal path below emits them too, keeping the two reps in step.
   const { def: configDef, json: configJson } = configDefinition(model, target.name)
   const asData = isConfigData(configJson, configReprSetting(model))
 
@@ -193,20 +158,6 @@ def shared_config():
 
 `)
 
-    // ABOVE THE THRESHOLD: emit the model as DATA.
-    //
-    // A dict literal makes CPython build the whole structure opcode by opcode
-    // at import, and the compiler hold the entire literal in memory to produce
-    // that bytecode. A string constant is one object, and `json.loads` (the C
-    // scanner) builds the dict far faster than the equivalent literal.
-    //
-    // `json.loads` yields exactly what the literal did - str keys, int for
-    // whole numbers, True/False/None - so make_config's result is unchanged.
-    //
-    // JSON.stringify output is a valid Python string literal: every escape it
-    // emits (\\", \\\\, \\n, \\uXXXX) means the same thing in Python, it never emits
-    // \\/ (which Python would not treat as an escape), and Python 3 source is
-    // UTF-8 so non-ASCII needs no escaping.
     if (asData) {
       Content(`# THE API MODEL, EMBEDDED AS DATA (sdkgen rung L1).
 #
@@ -227,10 +178,6 @@ def make_config():
       return
     }
 
-    // Identity values from configDefinition's def, not re-derived here, so
-    // the literal rep and the data rep cannot disagree on identity (the
-    // slug is CARRIED, never derived from the camel name - station's
-    // descriptor reads all three; see cmp/ts/Config_ts.ts #MainMeta).
     Content(`def make_config():
     """Build a fresh, fully materialised config dict.
 

package/project/.sdk/src/cmp/py/EntityTypes_py.ts

@@ -1,35 +1,5 @@
 
 
-// Typed-model generator (Python target). Port of EntityTypes_ts.ts.
-//
-// Reads main.<KIT>.entity.<e>.fields[] and per-op params
-// (op.<name>.points[].args.params[]) and emits one module, <sdk>_types.py,
-// with a `class <Name>(TypedDict):` per active entity plus a request/match type
-// per active op. Field/param sentinels ($STRING, $INTEGER, ...) are turned into
-// real Python types by the shared sdkgen helper `canonToType` (source of truth:
-// @voxgig/apidef VALID_CANON).
-//
-// TYPE CHOICE: `TypedDict`, not `@dataclass`. The generated ops return/accept
-// plain runtime dicts (data_get/match_get return `vs.clone(self._data)`; ops
-// take/return dicts), so a `@dataclass` annotation is only aspirational — a
-// strict checker at a call site would see dict-vs-dataclass. A TypedDict *is* a
-// dict shape, so annotating these dict-returning/-accepting ops with TypedDict
-// makes the TYPES MATCH the runtime. Runtime behaviour is unchanged.
-//
-// OPTIONAL FIELDS: a `req:false` field/param is a key that MAY be absent, which
-// is exactly TypedDict `total=False` (key optionality), not `Optional[T]` (a
-// None value). To express required AND optional keys on py>=3.8 WITHOUT a
-// typing_extensions dependency (no `NotRequired`), a type with both splits into
-// a required base `class <Name>Required(TypedDict): ...` and a `total=False`
-// subclass `class <Name>(<Name>Required, total=False): ...` that carries the
-// public name and adds the optional keys. Degenerate shapes collapse to a
-// single class (all-required, all-optional, or empty). The all-optional
-// collapse also serves the match-mirror types (the Python analogue of TS
-// `Partial<${Name}>`).
-//
-// Keep the SAME type-name scheme as every other language: <Name>,
-// <Name>LoadMatch, <Name>ListMatch, <Name>CreateData, <Name>UpdateData,
-// <Name>RemoveMatch.
 
 import {
   cmp, each, names,
@@ -56,25 +26,11 @@ const PY_KEYWORDS = new Set([
 ])
 
 
-// A name usable as a class-syntax TypedDict key (valid identifier, not a
-// keyword). Non-identifier/keyword field names have no safe class-syntax
-// rendering, so they are skipped (they remain reachable via the runtime dict).
 function pyIdent(name: string): boolean {
   return /^[A-Za-z_][A-Za-z0-9_]*$/.test(name) && !PY_KEYWORDS.has(name)
 }
 
 
-// Emit a TypedDict named `typeName` from a list of {name, type, optional}
-// items (optionality already decided by the caller — the shared partiality
-// policy for op types, or `req` for the entity data type). Required items
-// become required keys; optional items become not-required keys via a
-// `total=False` extension.
-//
-// Shape selection (see file header for the rationale):
-//   both required + optional -> `<typeName>Required` base + `total=False` sub
-//   only required            -> single `class <typeName>(TypedDict):`
-//   only optional            -> single `class <typeName>(TypedDict, total=False):`
-//   no usable keys           -> single `class <typeName>(TypedDict): pass`
 function emitTypedDict(typeName: string, items: any[], log?: any): void {
   const usable = items.filter((it: any) => it && null != it.name && pyIdent(it.name))
 
@@ -132,10 +88,6 @@ const EntityTypes = cmp(function EntityTypes(props: any) {
   const target = props.target || {}
   const ext = target.ext || LANG
 
-  // 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 generated entity code: the consumer
   // scaffold (create-sdkgen Root.ts) iterates entities WITHOUT an active
@@ -147,9 +99,6 @@ const EntityTypes = cmp(function EntityTypes(props: any) {
   // entity not yet named (e.g. a fieldless placeholder) would otherwise read
   // `Name = undefined` below. Parity with the go emitter's fix.
 
-  // 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)
 
   File({ name: model.const.Name.toLowerCase() + '_types.' + ext }, () => {
@@ -177,7 +126,6 @@ from typing import TypedDict, Any
       const fields = (ent.fields ? each(ent.fields) : [])
         .filter((f: any) => f.active !== false)
 
-      // Entity data model: one key per field, `req:false` -> optional key.
       Content(`
 
 `)
@@ -185,9 +133,6 @@ from typing import TypedDict, Any
         name: f.name, type: f.type, optional: false === f.req,
       })), log)
 
-      // Per active op: a request/match type. Members and their optionality come
-      // from the shared partiality policy (opRequestShape); this file only
-      // renders them as a TypedDict.
       const ops = ent.op || {}
       ;['load', 'list', 'create', 'update', 'remove'].forEach((opname: string) => {
         if (null == ops[opname]) {

package/project/.sdk/src/cmp/py/Entity_py.ts

@@ -19,10 +19,6 @@ const Entity = cmp(function Entity(props: any) {
   const { model, stdrep } = props.ctx$
   const { target, entity } = props
 
-  // Collision-free entity CLASS name (see entityClassName): normally
-  // `<Name>Entity`, disambiguated when it would clash with another entity's
-  // data-type name. The DATA type stays `<Name>`. The snake-cased source-file
-  // name is unaffected; only the class identifier changes.
   const entityColl = entityCollection(model)
   const cls = entityClassName(entity, entityColl)
 
@@ -32,8 +28,6 @@ const Entity = cmp(function Entity(props: any) {
 
   names(entrep, entity.Name, 'EntityName')
 
-  // Import exactly the typed models this entity references: its data type plus
-  // one request type per ACTIVE op (matches what EntityTypes_py.ts emits).
   const typeNames = [entity.Name]
   const opnamesAll = Object.keys(entity.op || {})
   ;['load', 'list', 'create', 'update', 'remove'].forEach((opname: string) => {
@@ -41,8 +35,6 @@ const Entity = cmp(function Entity(props: any) {
       typeNames.push(opTypeName(entity.Name, opname))
     }
   })
-  // The generated dataclasses live inside the SDK package alongside
-  // everything else, so the import is package-qualified.
   const typesModule = model.const.Name.toLowerCase() + '_sdk.' +
     model.const.Name.toLowerCase() + '_types'
   const typeImport =
@@ -51,9 +43,6 @@ const Entity = cmp(function Entity(props: any) {
 
   const ff = Path.normalize(__dirname + '/../../../src/cmp/py/fragment/')
 
-  // Entity files go to <name>_sdk/entity/ — inside the SDK package, not at
-  // the language root. See the note in Main_py.ts: a top-level `entity`
-  // package is shadowable by any entity.py sitting beside the caller.
   Folder({ name: model.const.Name.toLowerCase() + '_sdk' }, () => {
   Folder({ name: 'entity' }, () => {
 
@@ -77,13 +66,8 @@ const Entity = cmp(function Entity(props: any) {
           EntityName: entity.Name,
           entityname: entity.name,
 
-          // Class token decoupled from the EntityName data-type token in
-          // Entity.fragment.py so the class can be renamed independently.
           EntyClass: cls,
 
-          // Literal-marker slot (jostraca's `#Name` tag pattern is hardcoded to
-          // `//` comments, so Python uses a `# #`-prefixed literal like the op
-          // frag slots) — fills in the typed-model import for this entity.
           '# #TypeImports': typeImport,
 
           // Feature-hook markers. jostraca's built-in `#Name-Tag` pattern is

package/project/.sdk/src/cmp/py/Main_py.ts

@@ -24,6 +24,7 @@ import {
 
 import { Package } from './Package_py'
 import { Config } from './Config_py'
+import { Schema } from './Schema_py'
 import { PrepareAuth } from './PrepareAuth_py'
 import { Gitignore } from './Gitignore_py'
 import { MainEntity } from './MainEntity_py'
@@ -41,20 +42,14 @@ const Main = cmp(async function Main(props: any) {
   // helpers/applicability.
   const feature = targetFeatures(model, target)
 
-  // Does the secrets feature apply here and is it switched on? Both, since
-  // targetFeatures already dropped it for a target with no sekreto port.
   const secrets = null != (feature as any).secrets
 
-  // The one package directory everything the SDK owns lives in.
   const pkgdir = model.const.Name.toLowerCase() + '_sdk'
 
   Package({ target })
 
   Gitignore({})
 
-  // Root-level statics only (Makefile, LICENSE, test/). The runtime
-  // packages live under tm/py/pkg and are copied INSIDE the SDK package
-  // below.
   Copy({
     from: 'tm/' + target.name,
     exclude: [/src\//, /pkg\//, TEST_CONTROL_EXCLUDE],
@@ -63,35 +58,16 @@ const Main = cmp(async function Main(props: any) {
     }
   })
 
-  // Everything the SDK owns lives inside ONE package directory.
-  //
-  // core/, entity/, feature/ and utility/ used to sit at the language root
-  // as top-level importable names. `core`, `entity` and `utility` are all
-  // real PyPI distributions AND common scratch filenames, and Python puts
-  // the working directory first on sys.path — so a single utility.py beside
-  // a notebook shadowed ours and the SDK died on
-  // `No module named 'utility.voxgig_struct'`. Nesting them behind the
-  // model-named package makes that impossible.
-  //
-  // The public import is unchanged: `from <name>_sdk import <Name>SDK`,
-  // because <name>_sdk.py becomes <name>_sdk/__init__.py.
   Folder({ name: pkgdir }, () => {
 
   Copy({
     from: 'tm/' + target.name + '/pkg',
-    // An ACTIVE feature's INACTIVE plugins do not ship. py has no
-    // src/feature layout (srcfeature: false), so this blanket pkg copy is
-    // the one place the generate-time plugin trim can act; the model's
-    // `plugin.<group>.path` entries name their files relative to THIS
-    // copy's root ('feature/secrets/voxgig_sekreto/plugins/<kind>.py').
-    // See helpers/featureSource.pluginExcludes.
     exclude: [...pluginExcludes(model)],
     replace: {
       ...props.ctx$.stdrep,
     }
   })
 
-  // Generate main SDK file
   File({ name: '__init__.' + target.ext }, () => {
 
     Fragment(
@@ -100,22 +76,7 @@ const Main = cmp(async function Main(props: any) {
         replace: {
           ...props.ctx$.stdrep,
 
-          // SECRETS. Both slots are emitted only when the secrets feature
-          // applies to this target AND the model activates it - an
-          // unconditional edit would land in every generated SDK, and with
-          // the feature off the marker line is REMOVED, so the inactive
-          // output is byte-identical to pre-migration. `feature` is
-          // already gated by targetFeatures, so a target that does not
-          // provide 'sekreto' never reaches these.
-          //
-          // CUSTOM-REGEX keys, like Entity_py's hook markers: jostraca's
-          // built-in `#Name` tag pattern is hardcoded to `//` comments,
-          // so a bare '#SecretsAccessor' key would silently never match a
-          // python `# #SecretsAccessor` marker line.
-
-          // The LIVE Sekreto, not a clone: sekreto holds provider and
-          // cache state, so a clone would resolve into a copy that
-          // prepare_auth never sees.
+
           '/(?<indent>[ \\t]*)#[ \\t]*#SecretsAccessor[ \\t]*\\n?/':
             ({ indent }: any) => !secrets ? '' :
               `${indent}def secrets(self):\n` +
@@ -147,7 +108,6 @@ self._utility.feature_hook(self._rootctx, "${name}")
         }
       },
 
-      // Entities - injected at SLOT
       () => {
         each(entity, (entity: ModelEntity) => {
           const entitySDK = getModelPath(model, `main.${KIT}.entity.${entity.name}`)
@@ -176,7 +136,6 @@ if TYPE_CHECKING:
     }
   })
 
-  // Generate the typed-model module (<sdk>_types.py) next to the main SDK file.
   EntityTypes({ target })
 
   // PEP 561 marker so the inline type hints ship to consumers. Emitted at the
@@ -186,23 +145,13 @@ if TYPE_CHECKING:
     Content(``)
   })
 
-  // Generate config module
   Folder({ name: '.' }, () => {
     Config({ target })
+    Schema({ target })
   })
 
-  // GENERATED, NOT COPIED. Where the credential goes is a fact about the
-  // API, and tm/ can only hold one answer. The blanket tm/py/pkg copy above
-  // no longer brings a prepare_auth.py in - it was deleted, since both
-  // writers would claim the same output path. See PrepareAuth_py.
-  //
-  // Called HERE, inside the <name>_sdk package folder and outside any
-  // other, because that is where the deleted template's own path
-  // (tm/py/pkg/utility/prepare_auth.py) put it: the component opens the one
-  // remaining segment, `utility`, itself.
   PrepareAuth({ target })
 
-  // Generate feature factory module
   File({ name: 'features.' + target.ext }, () => {
     Content(`# ${model.const.Name} SDK feature factory
 
@@ -250,11 +199,6 @@ def _has_feature(name):
 `)
   })
 
-  // Generate __init__.py files for sub-packages.
-  // NOTE: deliberately omit __init__.py at the language-root (py/) level —
-  // making py/ a package collides with the third-party `py` module on PyPI
-  // (a single-file `py.py`), which causes pytest to construct test module
-  // paths as `py.test.<file>` and fail with "'py' is not a package".
   Folder({ name: 'core' }, () => {
     File({ name: '__init__.' + target.ext }, () => {
       Content(``)
@@ -265,8 +209,6 @@ def _has_feature(name):
     File({ name: '__init__.' + target.ext }, () => {
       Content(``)
     })
-    // PEP 561 marker inside the type-bearing package so setuptools package-data
-    // ("*" = ["py.typed"]) bundles it into the wheel.
     File({ name: 'py.typed' }, () => {
       Content(``)
     })

package/project/.sdk/src/cmp/py/Package_py.ts

@@ -22,9 +22,6 @@ const Package = cmp(async function Package(props: any) {
 
   const model: Model = ctx$.model
 
-  // PyPI distribution name is namespaced to model.origin (e.g. "voxgig-sdk").
-  // PyPI names can't contain "/", so the parts are hyphen-joined. The import
-  // package (the `${model.name}_sdk/` dir) is unchanged.
   const ns = model.origin || 'voxgig-sdk'
   const pkgBase = ns.endsWith('-sdk') ? model.name : `${model.name}-sdk`
   const distName = packageName(model, target.name)