@voxgig/sdkgen 2.0.2 → 3.1.0

package/model/sdkgen.aontu

@@ -13,6 +13,124 @@ main: def: {
 # `<sdk>/.sdk/model/config.aontu`.
 main: kit: config: docs_order: *['ts','py','php','go','rb','lua'] | [&: string]
 
+# How the generated test suites behave.
+main: kit: test: {
+
+  live: {
+    # Whether a live run ASSERTS or merely observes.
+    #
+    # false (the default, and the right answer for a fleet SDK generated
+    # against an arbitrary third-party API): a non-2xx in live mode is an
+    # early return, not a failure. Synthetic IDs 4xx constantly and list
+    # response shapes vary wildly, so asserting would mean permanent red.
+    #
+    # true: live assertions match the offline ones — a non-2xx FAILS, and a
+    # missing idmap entry fails rather than skipping. Set this when the
+    # project OWNS the server it tests against; otherwise a live suite passes
+    # with nothing listening on the port, which is what it did.
+    #
+    # Overridable per target:
+    #   main: kit: target: go: test: live: strict: true
+    strict: *false | boolean
+
+    # The base URL a live run points at. '' derives it from the spec's first
+    # declared server, but ONLY when that is a loopback address.
+    #
+    # For an OpenAPI-derived model `servers[0].url` is the PRODUCTION host of
+    # a third-party API, and a generated live suite runs under `npm test` on
+    # every CI push. Inferring the base from the spec therefore pointed CI at
+    # a stranger's API — unauthenticated, on three operating systems, on every
+    # push — and pointed the generated write scripts there too. A live target
+    # is now taken only when it is unambiguously ours: declared here, or
+    # loopback, which nobody else can be behind.
+    base: *'' | string
+
+    # Whether the SDK's own repo ships a runnable companion server under
+    # `app/`. NOTHING in an API definition says so — it is a property of the
+    # sibling project — so it cannot be inferred, and inferring it put an
+    # unconditional `git clone && cd app && npm install && npm run build` into
+    # a generated provider's CI, which fails the job for any repo without one.
+    app: *false | boolean
+  }
+}
+
+
+# ---------------------------------------------------------------------------
+# SDK IDENTITY
+#
+# The root `name` slug is FOUR different things wearing one name. Each is
+# derived from the slug by default; each can differ, and in practice does:
+#
+#   1. IDENTIFIERS   class names (AcmeSDK, AcmeError), entity classes, the Go
+#                    root package identifier, the test env-var prefix.
+#                    Source: `name`. No override — this IS what the slug is.
+#
+#   2. SOURCE        where the code lives: the repo URL, and the base of the
+#                    Go module path.        -> main: kit: repo: path
+#
+#   3. PUBLISHED     what a consumer installs: the npm/PyPI/... package name.
+#                    -> main: kit: target: <t>: publish: registry: package
+#
+#   4. GO PACKAGE    the `package x` identifier in the generated Go root file.
+#                    -> main: kit: target: <t>: module: package
+#
+# Conflating them is not theoretical. A project whose repo was named
+# `<org>-<product>-sdk` rather than `<slug>-sdk` had only one lever — rename
+# the slug — and renaming it to fix (2) silently renamed (1), doubled the org
+# prefix in (4) (`package voxgigvoxgigsolardemosdk`), and would have orphaned
+# (3) had the package already been published. Each override below exists
+# because a real project needed those four values to differ.
+#
+# Set `name` to what the SDK IS. Override the other three when the world
+# disagrees with the derivation.
+# ---------------------------------------------------------------------------
+
+# Where this SDK's source repository lives.
+#
+# `<origin>/<name>-sdk` is only the DEFAULT. A project whose repo is named
+# anything else had no way to say so, and got a go module path that 404s on
+# `go get` plus homepage/repository/bugs URLs pointing at a repo that does
+# not exist. The only escape was renaming `name`, which also renames the SDK
+# classes — a public-API break, and no help to a project already published.
+main: kit: repo: {
+  # '<org>/<repo>' under the host. '' -> '<origin>/<name>-sdk'.
+  path: *'' | string
+
+  host: *'github.com' | string
+}
+
+
+# WHO WROTE THIS PACKAGE — the manifest's `author` and `contributors`.
+#
+# Generated output is overwritten, so attribution hand-edited into a
+# package.json is silently DELETED on the next regeneration. That is exactly
+# what happened the first time the seneca-provider target regenerated a
+# hand-written provider repo: the manifest's author and its two named
+# contributors were dropped, and nothing failed to warn about it — credit is
+# not something a build can miss.
+#
+# So it is declared here, like every other value a project owns about itself.
+# Unset means the PUBLISHER (Voxgig), which is what a generated SDK carries
+# and what a project that has never thought about it should get.
+#
+#   main: kit: author: { name: 'Ada Lovelace', url: 'https://example.com' }
+#   main: kit: contributor: 'ada': { name: 'Ada Lovelace', url: '...' }
+#
+# `contributor` is a MAP, not a list, because aontu unifies maps by key: a
+# project can add one contributor without restating the others, and a
+# duplicate key is a conflict rather than a silent second entry. Emitters
+# render it in sorted-key order, so the manifest is byte-stable.
+main: kit: author: {
+  name: *'' | string
+  url: *'' | string
+}
+
+main: kit: contributor: &: {
+  name: string
+  url: *'' | string
+}
+
+
 main: kit: target: &: {
   name: key()
   active: *true | boolean
@@ -20,12 +138,53 @@ main: kit: target: &: {
   comment: line: string
   module: {
     name: string
+
+    # Go family only. Full module path, overriding
+    # '<repo.host>/<repo.path>/<target>'. Set this when the module path
+    # cannot be derived — e.g. a repo whose name is not '<slug>-sdk'.
+    path: *'' | string
+
+    # Go family only. The root package IDENTIFIER — `package acmesdk` — not
+    # an import path. Go requires a plain identifier here, so it is
+    # concatenated from the slug rather than taken from the repo.
+    #
+    # '' derives '<origin><slug>sdk', dropping a leading origin prefix the
+    # slug already carries: slug 'voxgig-solardemo' under origin 'voxgig-sdk'
+    # gives 'voxgigsolardemosdk', not 'voxgigvoxgigsolardemosdk'.
+    package: *'' | string
+
+    # Go family only. The `go` directive written into go.mod. Defaults to
+    # 1.21 — the release that introduced `log/slog`, which sdkgen's own
+    # `log` feature template imports. go-cli and go-mcp carry higher
+    # floors imposed by their dependencies.
+    goversion: *'' | string
   }
   deps: &: {
     active: *false | boolean
     version: *'*' | string
   }
 
+  # How `target add` trims this target's feature source down to the
+  # features the model actually selects. Where that source LIVES is
+  # discovered by walking the template tree (helpers/featureSource), so
+  # nothing here describes layout — this is only about what a target can
+  # survive having removed.
+  feature: {
+    # Whether the feature set may be trimmed at all. A target whose
+    # templates statically reference every shipped feature from a file
+    # that cannot simply be dropped (zig's `root.zig`, scala's
+    # `SdkTestMain.scala`) must say false until those files are driven
+    # from the model — otherwise a trimmed project will not compile.
+    trim: *true | boolean
+
+    # Templates that only compile with the COMPLETE feature set, as paths
+    # relative to the target template root. These are the cross-feature
+    # test suites: they construct every shipped feature type by name, so a
+    # trimmed project drops them along with the features they exercise.
+    # A project carrying the full set keeps them.
+    fullset: *[] | [&: string]
+  }
+
   # Publication: how (and whether) this port is released. Credentials are
   # always injected by the aql key vault (never on disk or argv).
   #
@@ -38,7 +197,93 @@ main: kit: target: &: {
   # Tag-only ports (the go family: the Go proxy resolves from GitHub
   # tags) simply leave `registry` unset — they are implicitly pending
   # until their `<target>/vX.Y.Z` tag exists.
+  # WHERE this target's files are written.
+  #
+  # Empty (the default) means the ordinary place: `<sdk-repo>/<target>/`,
+  # a folder inside the SDK repo, which is what every language target wants.
+  #
+  # A target that generates a SEPARATE, independently released package needs
+  # somewhere else. The Seneca provider is the case: it is its own npm
+  # package in its own repo (`@seneca/<name>-provider`), depends on the ts
+  # SDK as a normal published dependency, and carries a repo's worth of
+  # furniture — LICENSE, CI workflow, doc/ — that must not land inside the
+  # SDK repo.
+  #
+  # Relative paths resolve against the SDK repo root, so a sibling checkout
+  # is `'../<repo>'`. Absolute paths are taken as given.
+  #
+  # Files are written at the ROOT of that path, NOT under a `<target>/`
+  # subfolder: the destination IS the package.
+  #
+  # Generation into it is a SEPARATE pass, so the repo receives only what
+  # this target emits — none of the SDK repo's own root files (README,
+  # AGENTS.md, the build scaffold) follow it out.
+  output: {
+    path: *'' | string
+
+    # Write into a destination that already holds content this generator did
+    # not write.
+    #
+    # Generation OVERWRITES, jostraca creates missing parent directories, and
+    # the path is taken verbatim from the model — so a typo ('.', '..', a
+    # target name) fabricates a package tree somewhere arbitrary, or replaces
+    # an unrelated repo's package.json, README, LICENSE and CI workflow in
+    # place. Generation therefore refuses a destination that is neither
+    # absent, nor empty, nor carrying the `.jostraca` bookkeeping a previous
+    # generation left there.
+    #
+    # A repo seeded with its own README/LICENCE before the first generation
+    # is the legitimate case that trips the guard. Say so here, once: the
+    # point is that the destination is a DECISION, not a typo.
+    adopt: *false | boolean
+
+    # The path from the destination BACK to the SDK project — what the
+    # target's own docs, scripts and live tests name when they reach for
+    # something the SDK repo distributes only in source (the companion test
+    # server in `app/`).
+    #
+    # '' derives it by inverting the resolved `path`, which is exact only
+    # while the walk back crosses nothing this model names — true for
+    # '../<repo>', false for anything ascending further. A project declaring
+    # '../../seneca/solardemo-provider' derived
+    # '../../voxgig-sdk/voxgig-solardemo-sdk', where `voxgig-sdk` is the name
+    # of the WORKSPACE DIRECTORY holding the checkout on ONE machine — and
+    # that string is committed into the destination's README and test files,
+    # so the next developer's layout regenerates a spurious diff and an
+    # instruction path that is wrong for everyone else. Declare it here when
+    # the destination is more than one level away; generation warns until you
+    # do.
+    sdkrel: *'' | string
+
+    # '<org>/<repo>' for the repo the files land in, under `main: kit: repo:
+    # host`. A target generating out of tree is usually released from that
+    # repo too, so its manifest's homepage/repository/bugs must point there
+    # and NOT at the SDK's own repo, which is what they would otherwise
+    # derive from.
+    #
+    # '' lets the target decide: a target that knows its convention (the
+    # Seneca provider's is `senecajs/seneca-<name>-provider`) supplies its
+    # own default, and falls back to the SDK's repo when it has none.
+    repo: *'' | string
+  }
+
   publish: {
+    # The SDK's OWN release version — what the generated manifest declares
+    # and what the port's Makefile tags (`<target>/v<version>`).
+    #
+    # Generated output is overwritten, so a version hand-edited into
+    # package.json / pyproject.toml / VERSION is lost on the next
+    # regeneration. It was, repeatedly: every manifest emitter hardcoded
+    # '0.0.1', so a project that had published 0.0.2 got its manifest reset
+    # and only the 3-way merge (which sdkgen turns off, see
+    # docs/explanation/regeneration-overwrite.md) was hiding it. Declare the
+    # version here and every port reads the same value.
+    #
+    # Per TARGET, not per SDK: ports publish to different registries on
+    # different clocks, and a Python release should not have to move the
+    # npm version.
+    version: *'0.0.1' | string
+
     # Git release tag (all ports).
     tag: {
       active: *true | boolean

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voxgig/sdkgen",
-  "version": "2.0.2",
+  "version": "3.1.0",
   "main": "dist/sdkgen.js",
   "type": "commonjs",
   "engines": {
@@ -55,17 +55,19 @@
     "@types/node": "26.2.0",
     "json-schema-to-ts": "3.1.1",
     "memfs": "4.68.1",
+    "pino": "10.3.1",
+    "pino-pretty": "13.1.3",
     "sucrase": "3.35.1",
     "typescript": "7.0.2"
   },
   "peerDependencies": {
     "@tabnas/jsonic": "0.6.0",
+    "@tabnas/parser": "0.8.0",
     "@voxgig/apidef": ">=0",
     "@voxgig/struct": ">=0",
     "@voxgig/util": ">=0",
     "aontu": ">=0",
     "jostraca": ">=0",
-    "shape": ">=0",
-    "@tabnas/parser": "0.8.0"
+    "shape": ">=0"
   }
 }

package/project/.sdk/model/target/c.aontu

@@ -25,13 +25,38 @@ main: kit: feature: &: target: c: deps: &: {
 
 
 # Publication: C has no central registry — publishing IS the git tag.
+#
+# `target add <t>` OVERWRITES this file, so a project must never set its
+# publication values here — voxgig-solardemo-sdk lost its pinned npm package
+# name exactly that way. Set them in the project's own model
+# (`model/sdk.aontu`), where they survive a resync.
+#
+# For that to work this file must LEAVE THOSE KEYS UNSET: in aontu a concrete
+# value does not yield to another concrete value, it CONFLICTS, and two
+# defaults conflict too. The schema (@voxgig/sdkgen/model/sdkgen.aontu)
+# already defaults `tag.active`, `registry.state`, `registry.active` and
+# `registry.package`, so a project's concrete value wins over the default and
+# repeating them here would only take that away.
+#
+# What remains below is per-target registry IDENTITY, which is not a project
+# choice and stays concrete.
 main: kit: target: c: publish: {
-  tag: { active: true }
   registry: {
-    state: 'pending'
-    active: false
     name: 'none'
     url: ''
     vault: { alias: 'none', env: 'NONE' }
   }
 }
+
+
+# Feature source may be trimmed to the model's selection. Two templates need
+# the COMPLETE set, so both are dropped alongside the features they exercise
+# whenever the set is trimmed:
+#   tests/feature_test.c      — calls every feature_*_new()
+#   tests/sdk_pipeline_test.c — drives the retry feature by NAME through the
+#                               options map, so it fails at RUNTIME rather
+#                               than at link time when retry is absent
+main: kit: target: c: feature: {
+  trim: true
+  fullset: ['tests/feature_test.c', 'tests/sdk_pipeline_test.c']
+}

package/project/.sdk/model/target/clojure.aontu

@@ -24,13 +24,34 @@ main: kit: feature: &: target: clojure: deps: &: {
 
 
 # Publication: Clojars registry (declared, publish pending — git-tag only).
+#
+# `target add <t>` OVERWRITES this file, so a project must never set its
+# publication values here — voxgig-solardemo-sdk lost its pinned npm package
+# name exactly that way. Set them in the project's own model
+# (`model/sdk.aontu`), where they survive a resync.
+#
+# For that to work this file must LEAVE THOSE KEYS UNSET: in aontu a concrete
+# value does not yield to another concrete value, it CONFLICTS, and two
+# defaults conflict too. The schema (@voxgig/sdkgen/model/sdkgen.aontu)
+# already defaults `tag.active`, `registry.state`, `registry.active` and
+# `registry.package`, so a project's concrete value wins over the default and
+# repeating them here would only take that away.
+#
+# What remains below is per-target registry IDENTITY, which is not a project
+# choice and stays concrete.
 main: kit: target: clojure: publish: {
-  tag: { active: true }
   registry: {
-    state: 'pending'
-    active: false
     name: 'clojars'
     url: 'https://clojars.org'
     vault: { alias: 'clojars' }
   }
 }
+
+
+# Feature source is NOT trimmed to the model's selection here: every
+# feature lives inside a single generated module (src/sdk/features.clj),
+# not in per-feature source files, so there is nothing per-feature to
+# leave out. Trimming waits on that module becoming model-driven.
+main: kit: target: clojure: feature: {
+  trim: false
+}

package/project/.sdk/model/target/cpp.aontu

@@ -24,12 +24,34 @@ main: kit: feature: &: target: cpp: deps: &: {
 
 
 # Publication: header-only; publishing is the git tag cpp/vX.Y.Z (no registry).
+#
+# `target add <t>` OVERWRITES this file, so a project must never set its
+# publication values here — voxgig-solardemo-sdk lost its pinned npm package
+# name exactly that way. Set them in the project's own model
+# (`model/sdk.aontu`), where they survive a resync.
+#
+# For that to work this file must LEAVE THOSE KEYS UNSET: in aontu a concrete
+# value does not yield to another concrete value, it CONFLICTS, and two
+# defaults conflict too. The schema (@voxgig/sdkgen/model/sdkgen.aontu)
+# already defaults `tag.active`, `registry.state`, `registry.active` and
+# `registry.package`, so a project's concrete value wins over the default and
+# repeating them here would only take that away.
+#
+# What remains below is per-target registry IDENTITY, which is not a project
+# choice and stays concrete.
 main: kit: target: cpp: publish: {
-  tag: { active: true }
   registry: {
-    state: 'pending'
-    active: false
     name: 'none'
     url: ''
   }
 }
+
+
+# Feature source may be trimmed to the model's selection. The one template
+# needing the COMPLETE set is the cross-feature test suite, which includes
+# every feature/<name>.hpp — so it is dropped alongside the features it
+# exercises whenever the set is trimmed.
+main: kit: target: cpp: feature: {
+  trim: true
+  fullset: ['test/feature_test.cpp']
+}

package/project/.sdk/model/target/csharp.aontu

@@ -23,13 +23,35 @@ main: kit: feature: &: target: csharp: deps: &: {
 
 
 # Publication: NuGet registry (declared, publish pending — git-tag only).
+#
+# `target add <t>` OVERWRITES this file, so a project must never set its
+# publication values here — voxgig-solardemo-sdk lost its pinned npm package
+# name exactly that way. Set them in the project's own model
+# (`model/sdk.aontu`), where they survive a resync.
+#
+# For that to work this file must LEAVE THOSE KEYS UNSET: in aontu a concrete
+# value does not yield to another concrete value, it CONFLICTS, and two
+# defaults conflict too. The schema (@voxgig/sdkgen/model/sdkgen.aontu)
+# already defaults `tag.active`, `registry.state`, `registry.active` and
+# `registry.package`, so a project's concrete value wins over the default and
+# repeating them here would only take that away.
+#
+# What remains below is per-target registry IDENTITY, which is not a project
+# choice and stays concrete.
 main: kit: target: csharp: publish: {
-  tag: { active: true }
   registry: {
-    state: 'pending'
-    active: false
     name: 'nuget'
     url: 'https://www.nuget.org'
     vault: { alias: 'nuget', env: 'NUGET_API_KEY' }
   }
 }
+
+
+# Feature source may be trimmed to the model's selection. The one template
+# needing the COMPLETE set is the cross-feature test suite, which
+# constructs every *Feature class — so it is dropped alongside the
+# features it exercises whenever the set is trimmed.
+main: kit: target: csharp: feature: {
+  trim: true
+  fullset: ['test/FeatureTest.cs']
+}

package/project/.sdk/model/target/dart.aontu

@@ -22,11 +22,23 @@ main: kit: feature: &: target: dart: deps: &: {
 
 
 # Publication: pub.dev registry (declared, publish pending — git-tag only).
+#
+# `target add <t>` OVERWRITES this file, so a project must never set its
+# publication values here — voxgig-solardemo-sdk lost its pinned npm package
+# name exactly that way. Set them in the project's own model
+# (`model/sdk.aontu`), where they survive a resync.
+#
+# For that to work this file must LEAVE THOSE KEYS UNSET: in aontu a concrete
+# value does not yield to another concrete value, it CONFLICTS, and two
+# defaults conflict too. The schema (@voxgig/sdkgen/model/sdkgen.aontu)
+# already defaults `tag.active`, `registry.state`, `registry.active` and
+# `registry.package`, so a project's concrete value wins over the default and
+# repeating them here would only take that away.
+#
+# What remains below is per-target registry IDENTITY, which is not a project
+# choice and stays concrete.
 main: kit: target: dart: publish: {
-  tag: { active: true }
   registry: {
-    state: 'pending'
-    active: false
     name: 'pub.dev'
     url: 'https://pub.dev'
     vault: { alias: 'pubdev', env: 'PUB_CREDENTIALS' }

package/project/.sdk/model/target/elixir.aontu

@@ -21,11 +21,23 @@ main: kit: feature: &: target: elixir: deps: &: {
 
 
 # Publication: hex registry (declared, publish pending — git-tag only).
+#
+# `target add <t>` OVERWRITES this file, so a project must never set its
+# publication values here — voxgig-solardemo-sdk lost its pinned npm package
+# name exactly that way. Set them in the project's own model
+# (`model/sdk.aontu`), where they survive a resync.
+#
+# For that to work this file must LEAVE THOSE KEYS UNSET: in aontu a concrete
+# value does not yield to another concrete value, it CONFLICTS, and two
+# defaults conflict too. The schema (@voxgig/sdkgen/model/sdkgen.aontu)
+# already defaults `tag.active`, `registry.state`, `registry.active` and
+# `registry.package`, so a project's concrete value wins over the default and
+# repeating them here would only take that away.
+#
+# What remains below is per-target registry IDENTITY, which is not a project
+# choice and stays concrete.
 main: kit: target: elixir: publish: {
-  tag: { active: true }
   registry: {
-    state: 'pending'
-    active: false
     name: 'hex'
     url: 'https://hex.pm'
     vault: { recipe: 'hex', alias: 'hex' }

package/project/.sdk/model/target/go-cli.aontu

@@ -43,6 +43,21 @@ main: kit: feature: &: target: 'go-cli': deps: &: {
 
 # Publication: tag-only — the Go module proxy resolves versions from the
 # go-cli/vX.Y.Z GitHub tag; there is no package registry to upload to.
+#
+# `target add <t>` OVERWRITES this file, so a project must never set its
+# publication values here — voxgig-solardemo-sdk lost its pinned npm package
+# name exactly that way. Set them in the project's own model
+# (`model/sdk.aontu`), where they survive a resync.
+#
+# For that to work this file must LEAVE THOSE KEYS UNSET: in aontu a concrete
+# value does not yield to another concrete value, it CONFLICTS, and two
+# defaults conflict too. The schema (@voxgig/sdkgen/model/sdkgen.aontu)
+# already defaults `tag.active`, `registry.state`, `registry.active` and
+# `registry.package`, so a project's concrete value wins over the default and
+# repeating them here would only take that away.
+#
+# What remains below is per-target registry IDENTITY, which is not a project
+# choice and stays concrete.
 main: kit: target: 'go-cli': publish: {
-  tag: { active: true, via: 'root' }
+  tag: { via: 'root' }
 }

package/project/.sdk/model/target/go-mcp.aontu

@@ -37,6 +37,21 @@ main: kit: feature: &: target: 'go-mcp': deps: &: {
 
 # Publication: tag-only — the Go module proxy resolves versions from the
 # go-mcp/vX.Y.Z GitHub tag; there is no package registry to upload to.
+#
+# `target add <t>` OVERWRITES this file, so a project must never set its
+# publication values here — voxgig-solardemo-sdk lost its pinned npm package
+# name exactly that way. Set them in the project's own model
+# (`model/sdk.aontu`), where they survive a resync.
+#
+# For that to work this file must LEAVE THOSE KEYS UNSET: in aontu a concrete
+# value does not yield to another concrete value, it CONFLICTS, and two
+# defaults conflict too. The schema (@voxgig/sdkgen/model/sdkgen.aontu)
+# already defaults `tag.active`, `registry.state`, `registry.active` and
+# `registry.package`, so a project's concrete value wins over the default and
+# repeating them here would only take that away.
+#
+# What remains below is per-target registry IDENTITY, which is not a project
+# choice and stays concrete.
 main: kit: target: 'go-mcp': publish: {
-  tag: { active: true, via: 'root' }
+  tag: { via: 'root' }
 }

package/project/.sdk/model/target/go.aontu

@@ -21,8 +21,18 @@ main: kit: feature: &: target: go: deps: &: {
 }
 
 
-# Publication: tag-only — the Go module proxy resolves versions from the
-# go/vX.Y.Z GitHub tag; there is no package registry to upload to.
-main: kit: target: go: publish: {
-  tag: { active: true }
+# Publication: a go/vX.Y.Z GitHub tag only — the Go proxy resolves from tags,
+# so there is no package registry to upload to. Nothing is set here: every
+# value is defaulted by the schema, and a project that needs to change one
+# sets it in its own model (`model/sdk.aontu`), which `target add <t>` does
+# not overwrite.
+
+
+# Feature source may be trimmed to the model's selection. The one template
+# needing the COMPLETE set is the cross-feature test suite, which
+# constructs every feature.New*Feature — so it is dropped alongside the
+# features it exercises whenever the set is trimmed.
+main: kit: target: go: feature: {
+  trim: true
+  fullset: ['test/feature_test.go']
 }

package/project/.sdk/model/target/haskell.aontu

@@ -38,13 +38,34 @@ main: kit: feature: &: target: haskell: deps: &: {
 
 
 # Publication: Hackage registry (declared, publish pending — git-tag only).
+#
+# `target add <t>` OVERWRITES this file, so a project must never set its
+# publication values here — voxgig-solardemo-sdk lost its pinned npm package
+# name exactly that way. Set them in the project's own model
+# (`model/sdk.aontu`), where they survive a resync.
+#
+# For that to work this file must LEAVE THOSE KEYS UNSET: in aontu a concrete
+# value does not yield to another concrete value, it CONFLICTS, and two
+# defaults conflict too. The schema (@voxgig/sdkgen/model/sdkgen.aontu)
+# already defaults `tag.active`, `registry.state`, `registry.active` and
+# `registry.package`, so a project's concrete value wins over the default and
+# repeating them here would only take that away.
+#
+# What remains below is per-target registry IDENTITY, which is not a project
+# choice and stays concrete.
 main: kit: target: haskell: publish: {
-  tag: { active: true }
   registry: {
-    state: 'pending'
-    active: false
     name: 'hackage'
     url: 'https://hackage.haskell.org'
     vault: { alias: 'hackage', env: 'HACKAGE_TOKEN' }
   }
 }
+
+
+# Feature source is NOT trimmed to the model's selection here: every
+# feature lives inside a single generated module (src/SdkFeatures.hs), not
+# in per-feature source files, so there is nothing per-feature to leave
+# out. Trimming waits on that module becoming model-driven.
+main: kit: target: haskell: feature: {
+  trim: false
+}

package/project/.sdk/model/target/java.aontu

@@ -25,13 +25,35 @@ main: kit: feature: &: target: java: deps: &: {
 
 # Publication: tag-only for now (tag java/vX.Y.Z) — Maven Central
 # publication via the Sonatype Central Portal is declared but pending.
+#
+# `target add <t>` OVERWRITES this file, so a project must never set its
+# publication values here — voxgig-solardemo-sdk lost its pinned npm package
+# name exactly that way. Set them in the project's own model
+# (`model/sdk.aontu`), where they survive a resync.
+#
+# For that to work this file must LEAVE THOSE KEYS UNSET: in aontu a concrete
+# value does not yield to another concrete value, it CONFLICTS, and two
+# defaults conflict too. The schema (@voxgig/sdkgen/model/sdkgen.aontu)
+# already defaults `tag.active`, `registry.state`, `registry.active` and
+# `registry.package`, so a project's concrete value wins over the default and
+# repeating them here would only take that away.
+#
+# What remains below is per-target registry IDENTITY, which is not a project
+# choice and stays concrete.
 main: kit: target: java: publish: {
-  tag: { active: true }
   registry: {
-    state: 'pending'
-    active: false
     name: 'maven-central'
     url: 'https://central.sonatype.com'
     vault: { recipe: 'maven', alias: 'central' }
   }
 }
+
+
+# Feature source may be trimmed to the model's selection. The one template
+# needing the COMPLETE set is the cross-feature test suite, which
+# constructs every *Feature class — so it is dropped alongside the
+# features it exercises whenever the set is trimmed.
+main: kit: target: java: feature: {
+  trim: true
+  fullset: ['test/FeatureTest.java']
+}