@voxgig/sdkgen 1.2.0 → 1.3.1

package/project/.sdk/tm/php/core/Context.php

@@ -100,16 +100,22 @@ class ProjectNameContext
 
     public function resolve_op(string $opname): ProjectNameOperation
     {
-        if (isset($this->opmap[$opname])) {
-            return $this->opmap[$opname];
+        // Cache key is `<entity>:<opname>` so two entities with the same op
+        // (e.g. both have a "list") get distinct cached Operations. Keying
+        // on opname alone caused the first-resolved entity's points to be
+        // served to every subsequent entity's call.
+        $entname = (is_object($this->entity) && method_exists($this->entity, 'get_name'))
+            ? $this->entity->get_name()
+            : '_';
+        $cacheKey = $entname . ':' . $opname;
+
+        if (isset($this->opmap[$cacheKey])) {
+            return $this->opmap[$cacheKey];
         }
         if ($opname === '') {
             return new ProjectNameOperation([]);
         }
 
-        $entname = (is_object($this->entity) && method_exists($this->entity, 'get_name'))
-            ? $this->entity->get_name()
-            : '_';
         $opcfg = \Voxgig\Struct\Struct::getpath($this->config, "entity.{$entname}.op.{$opname}");
 
         $input = ($opname === 'update' || $opname === 'create') ? 'data' : 'match';
@@ -128,7 +134,7 @@ class ProjectNameContext
             'input' => $input,
             'points' => $points,
         ]);
-        $this->opmap[$opname] = $op;
+        $this->opmap[$cacheKey] = $op;
         return $op;
     }
 

package/project/.sdk/tm/php/test/PrimaryUtilityTest.php

@@ -405,7 +405,11 @@ class PrimaryUtilityTest extends TestCase
             $ctxmap = $entry['ctx'] ?? [];
             $ctx = self::make_ctx_from_map($ctxmap, $client, $utility);
             self::fixctx($ctx, $client);
-            return ($utility->done)($ctx);
+            // done now returns the bare result data (or raises on error, which
+            // runset catches). Re-wrap success into a (result, err) tuple so the
+            // data-driven spec matcher keeps working.
+            $out = ($utility->done)($ctx);
+            return [$out, null];
         });
     }
 
@@ -437,7 +441,11 @@ class PrimaryUtilityTest extends TestCase
                 $err = self::err_from_map($args[1]);
             }
 
-            return ($utility->make_error)($ctx, $err);
+            // make_error now RAISES the constructed exception (default throw
+            // path); runset catches it. On the no-throw path it returns the
+            // bare result data, which we re-wrap into a (result, err) tuple.
+            $out = ($utility->make_error)($ctx, $err);
+            return [$out, null];
         });
     }
 
@@ -455,8 +463,9 @@ class PrimaryUtilityTest extends TestCase
             'resdata' => ['id' => 'safe01'],
         ]);
 
-        [$out, $err] = ($utility->make_error)($ctx, $ctx->make_error('test_code', 'test message'));
-        $this->assertNull($err, 'expected no error');
+        // throw_err === false: make_error returns the bare result data instead
+        // of raising (the result-object / no-throw escape hatch).
+        $out = ($utility->make_error)($ctx, $ctx->make_error('test_code', 'test message'));
         $this->assertIsArray($out);
         $this->assertEquals('safe01', $out['id']);
     }

package/project/.sdk/tm/php/utility/Done.php

@@ -5,7 +5,7 @@ declare(strict_types=1);
 
 class ProjectNameDone
 {
-    public static function call(ProjectNameContext $ctx): array
+    public static function call(ProjectNameContext $ctx): mixed
     {
         if ($ctx->ctrl->explain) {
             $ctx->ctrl->explain = ($ctx->utility->clean)($ctx, $ctx->ctrl->explain);
@@ -19,7 +19,7 @@ class ProjectNameDone
             if (is_object($resdata)) {
                 $resdata = (array)$resdata;
             }
-            return [$resdata, null];
+            return $resdata;
         }
         return ($ctx->utility->make_error)($ctx, null);
     }

package/project/.sdk/tm/php/utility/MakeError.php

@@ -9,7 +9,7 @@ require_once __DIR__ . '/../core/Error.php';
 
 class ProjectNameMakeError
 {
-    public static function call(?ProjectNameContext $ctx, mixed $err): array
+    public static function call(?ProjectNameContext $ctx, mixed $err): mixed
     {
         if ($ctx === null) {
             require_once __DIR__ . '/../core/Context.php';
@@ -52,8 +52,8 @@ class ProjectNameMakeError
         $ctx->ctrl->err = $sdk_err;
 
         if ($ctx->ctrl->throw_err === false) {
-            return [$result->resdata, null];
+            return $result->resdata;
         }
-        return [null, $sdk_err];
+        throw $sdk_err;
     }
 }

package/project/.sdk/tm/py/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) $$const.year$$ $$const.Name$$
+Copyright (c) $$const.year$$ Voxgig
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/project/.sdk/tm/py/Makefile

@@ -1,4 +1,4 @@
-.PHONY: test build clean
+.PHONY: test build clean publish
 
 test:
 	python -m pytest test/
@@ -8,3 +8,36 @@ build:
 
 clean:
 	find . -name __pycache__ -exec rm -rf {} + 2>/dev/null; true
+
+# --- Release: publish to PyPI ---------------------------------------------
+# Publish this package to PyPI, then tag py/vX.Y.Z. Run headless under the aql
+# key vault, which injects the PyPI + GitHub tokens as environment variables
+# (never written to disk or argv):
+#   aql vault exec --for=pypi=<alias> --for=github=<alias> -- make publish
+# aql `--dry-run` injects a filler token we detect to rehearse: builds the dist
+# but performs no upload, tag, or push. set -e + tag-last: a failed upload never
+# leaves a tag behind. Needs python `build` + `twine` (pip install build twine).
+VERSION := $(shell sed -nE 's/^version *= *"([^"]+)".*/\1/p' pyproject.toml | head -1)
+TAG := py/v$(VERSION)
+AQL_DRY_RUN_FILLER := AQL-DRY-RUN-FILLER-NOT-A-REAL-SECRET
+publish: test
+	@if git rev-parse -q --verify "refs/tags/$(TAG)" >/dev/null; then \
+	  echo "tag $(TAG) already exists — bump pyproject.toml version first"; exit 1; fi
+	@set -e; \
+	token="$${GITHUB_TOKEN:-$$GH_TOKEN}"; \
+	rm -rf dist; \
+	python3 -m build; \
+	if [ "$$token" = "$(AQL_DRY_RUN_FILLER)" ] || [ "$$TWINE_PASSWORD" = "$(AQL_DRY_RUN_FILLER)" ]; then \
+	  echo "[dry-run] aql filler token detected: built the dist; would upload to PyPI and tag $(TAG); nothing pushed."; \
+	  exit 0; \
+	fi; \
+	python3 -m twine upload dist/*; \
+	git tag -a "$(TAG)" -m "py v$(VERSION)"; \
+	url=$$(git remote get-url origin | sed -E 's#^git@github.com:#https://github.com/#'); \
+	if [ -n "$$token" ] && printf '%s' "$$url" | grep -q '^https://github.com/'; then \
+	  hdr="AUTHORIZATION: basic $$(printf 'x-access-token:%s' "$$token" | base64 | tr -d '\n')"; \
+	  git -c http.extraheader="$$hdr" push "$$url" "$(TAG)"; \
+	else \
+	  git push origin "$(TAG)"; \
+	fi; \
+	echo "Published to PyPI + tag $(TAG)."

package/project/.sdk/tm/py/core/context.py

@@ -163,15 +163,20 @@ class ProjectNameContext:
         self.op = self.resolve_op(opname)
 
     def resolve_op(self, opname):
-        if opname in self.opmap:
-            return self.opmap[opname]
-
-        if opname == "":
-            return ProjectNameOperation({})
-
+        # Cache key is `<entity>:<opname>` so two entities with the same op
+        # (e.g. both have a "list") get distinct cached Operations. Keying
+        # on opname alone caused the first-resolved entity's points to be
+        # served to every subsequent entity's call.
         entname = "_"
         if self.entity is not None and hasattr(self.entity, "get_name") and callable(self.entity.get_name):
             entname = self.entity.get_name()
+        cache_key = entname + ":" + opname
+
+        if cache_key in self.opmap:
+            return self.opmap[cache_key]
+
+        if opname == "":
+            return ProjectNameOperation({})
 
         opcfg = vs.getpath(self.config, "entity." + entname + ".op." + opname)
 
@@ -192,7 +197,7 @@ class ProjectNameContext:
             "points": points,
         })
 
-        self.opmap[opname] = op
+        self.opmap[cache_key] = op
         return op
 
     def make_error(self, code, msg):

package/project/.sdk/tm/py/test/test_primary_utility.py

@@ -329,7 +329,12 @@ class TestPrimaryUtility:
                 ctxmap = {}
             ctx = _make_ctx_from_map(ctxmap, client, utility)
             _fixctx(ctx, client)
-            return utility.done(ctx)
+            # done() returns the bare result data on success and raises on
+            # error. Adapt to the (result, err) shape the runner expects.
+            try:
+                return utility.done(ctx), None
+            except ProjectNameError as e:
+                return None, e
 
         _runset(_get_spec(primary, "done", "basic"), subject)
 
@@ -356,7 +361,12 @@ class TestPrimaryUtility:
                 if isinstance(err_map, dict):
                     err = _err_from_map(err_map)
 
-            return utility.make_error(ctx, err)
+            # make_error() raises the constructed exception on the default
+            # (throw) path. Adapt to the (result, err) shape the runner expects.
+            try:
+                return utility.make_error(ctx, err), None
+            except ProjectNameError as e:
+                return None, e
 
         _runset(_get_spec(primary, "makeError", "basic"), subject)
 
@@ -370,8 +380,9 @@ class TestPrimaryUtility:
             "resdata": {"id": "safe01"},
         })
 
-        out, err = utility.make_error(ctx, ctx.make_error("test_code", "test message"))
-        assert err is None
+        # throw_err is False: make_error returns the bare result data instead
+        # of raising (the result-object / no-throw escape hatch).
+        out = utility.make_error(ctx, ctx.make_error("test_code", "test message"))
         assert isinstance(out, dict)
         assert out["id"] == "safe01"
 

package/project/.sdk/tm/py/utility/done.py

@@ -9,6 +9,8 @@ def done_util(ctx):
             explain_result.pop("err", None)
 
     if ctx.result is not None and ctx.result.ok:
-        return ctx.result.resdata, None
+        return ctx.result.resdata
 
+    # make_error raises on the default (throw) path; only returns bare
+    # resdata when throw_err is explicitly disabled.
     return ctx.utility.make_error(ctx, None)

package/project/.sdk/tm/py/utility/make_error.py

@@ -59,6 +59,6 @@ def make_error_util(ctx, err):
     ctx.ctrl.err = sdk_err
 
     if ctx.ctrl.throw_err is False:
-        return result.resdata, None
+        return result.resdata
 
-    return None, sdk_err
+    raise sdk_err

package/project/.sdk/tm/rb/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) $$const.year$$ $$const.Name$$
+Copyright (c) $$const.year$$ Voxgig
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/project/.sdk/tm/rb/Makefile

@@ -1,4 +1,4 @@
-.PHONY: test build clean
+.PHONY: test build clean publish
 
 test:
 	ruby -Ilib test/exists_test.rb
@@ -8,3 +8,35 @@ build:
 
 clean:
 	@echo "No clean step for Ruby"
+
+# --- Release: publish to RubyGems -----------------------------------------
+# Build the gem and push it to RubyGems, then tag rb/vX.Y.Z. Run headless under
+# the aql key vault, which injects GEM_HOST_API_KEY + the GitHub token (never on
+# disk or argv):
+#   aql vault exec --for=gem=<alias> --for=github=<alias> -- make publish
+# aql `--dry-run` injects a filler token we detect to rehearse (build only, no
+# push/tag). set -e + tag-last: a failed push never leaves a tag behind.
+VERSION := $(shell sed -nE 's/.*\.version *= *"([^"]+)".*/\1/p' *.gemspec | head -1)
+TAG := rb/v$(VERSION)
+AQL_DRY_RUN_FILLER := AQL-DRY-RUN-FILLER-NOT-A-REAL-SECRET
+publish: test
+	@if git rev-parse -q --verify "refs/tags/$(TAG)" >/dev/null; then \
+	  echo "tag $(TAG) already exists — bump the gemspec version first"; exit 1; fi
+	@set -e; \
+	token="$${GITHUB_TOKEN:-$$GH_TOKEN}"; \
+	rm -f *.gem; \
+	gem build *.gemspec; \
+	if [ "$$token" = "$(AQL_DRY_RUN_FILLER)" ] || [ "$$GEM_HOST_API_KEY" = "$(AQL_DRY_RUN_FILLER)" ]; then \
+	  echo "[dry-run] aql filler token detected: built the gem; would push to RubyGems and tag $(TAG); nothing pushed."; \
+	  exit 0; \
+	fi; \
+	gem push *.gem; \
+	git tag -a "$(TAG)" -m "rb v$(VERSION)"; \
+	url=$$(git remote get-url origin | sed -E 's#^git@github.com:#https://github.com/#'); \
+	if [ -n "$$token" ] && printf '%s' "$$url" | grep -q '^https://github.com/'; then \
+	  hdr="AUTHORIZATION: basic $$(printf 'x-access-token:%s' "$$token" | base64 | tr -d '\n')"; \
+	  git -c http.extraheader="$$hdr" push "$$url" "$(TAG)"; \
+	else \
+	  git push origin "$(TAG)"; \
+	fi; \
+	echo "Published to RubyGems + tag $(TAG)."

package/project/.sdk/tm/rb/core/context.rb

@@ -75,10 +75,15 @@ class ProjectNameContext
   end
 
   def resolve_op(opname)
-    return @opmap[opname] if @opmap[opname]
+    # Cache key is `<entity>:<opname>` so two entities with the same op
+    # (e.g. both have a "list") get distinct cached Operations. Keying
+    # on opname alone caused the first-resolved entity's points to be
+    # served to every subsequent entity's call.
+    entname = @entity&.respond_to?(:get_name) ? @entity.get_name : "_"
+    cache_key = "#{entname}:#{opname}"
+    return @opmap[cache_key] if @opmap[cache_key]
     return ProjectNameOperation.new({}) if opname.empty?
 
-    entname = @entity&.respond_to?(:get_name) ? @entity.get_name : "_"
     opcfg = VoxgigStruct.getpath(@config, "entity.#{entname}.op.#{opname}")
 
     input = (opname == "update" || opname == "create") ? "data" : "match"
@@ -95,7 +100,7 @@ class ProjectNameContext
       "input" => input,
       "points" => points,
     })
-    @opmap[opname] = op
+    @opmap[cache_key] = op
     op
   end
 

package/project/.sdk/tm/rb/test/primary_utility_test.rb

@@ -101,8 +101,8 @@ class PrimaryUtilityTest < Minitest::Test
       "resdata" => { "id" => "safe01" },
     })
 
-    out, err = @utility.make_error.call(ctx, ctx.make_error("test_code", "test message"))
-    assert_nil err, "expected no error"
+    # Opt-out path: throw_err disabled -> returns the bare result data, no raise.
+    out = @utility.make_error.call(ctx, ctx.make_error("test_code", "test message"))
     assert out.is_a?(Hash), "expected hash result, got: #{out.class}"
     assert_equal "safe01", out["id"], "expected id=safe01"
   end

package/project/.sdk/tm/rb/utility/done.rb

@@ -7,8 +7,10 @@ module ProjectNameUtilities
       er.delete("err") if er.is_a?(Hash)
     end
     if ctx.result && ctx.result.ok
-      return ctx.result.resdata, nil
+      return ctx.result.resdata
     end
+    # On error, make_error raises the exception (or, when throw_err is
+    # disabled, returns the bare result data). Propagate its value.
     ctx.utility.make_error.call(ctx, nil)
   }
 end

package/project/.sdk/tm/rb/utility/make_error.rb

@@ -36,9 +36,12 @@ module ProjectNameUtilities
 
     ctx.ctrl.err = sdk_err
 
+    # Opt-out escape hatch: when throwing is explicitly disabled, return the
+    # bare result data instead of raising.
     if ctx.ctrl.throw_err == false
-      return result.resdata, nil
+      return result.resdata
     end
-    return nil, sdk_err
+    # Default idiomatic path: raise the already-constructed exception.
+    raise sdk_err
   }
 end

package/project/.sdk/tm/ts/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) $$const.year$$ $$const.Name$$
+Copyright (c) $$const.year$$ Voxgig
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/project/.sdk/tm/ts/Makefile

@@ -0,0 +1,42 @@
+.PHONY: test build clean publish
+
+# tsc emits to dist/ + dist-test/; the test runner reads dist-test/, so build first.
+test: build
+	npm test
+
+build:
+	npm run build
+
+clean:
+	rm -rf dist dist-test node_modules
+
+# --- Release: publish to npm ----------------------------------------------
+# Compile, then publish this package to npm and tag ts/vX.Y.Z. Run headless
+# under the aql key vault, which injects the npm auth token + the GitHub token
+# (never on disk or argv):
+#   aql vault exec --for=npm=<alias> --for=github=<alias> -- make publish
+# aql `--dry-run` injects a filler token we detect to rehearse (build only, no
+# publish/tag). set -e + tag-last: a failed publish never leaves a tag behind.
+SHELL := /bin/bash
+VERSION := $(shell node -p "require('./package.json').version")
+TAG := ts/v$(VERSION)
+AQL_DRY_RUN_FILLER := AQL-DRY-RUN-FILLER-NOT-A-REAL-SECRET
+publish: test
+	@if git rev-parse -q --verify "refs/tags/$(TAG)" >/dev/null; then \
+	  echo "tag $(TAG) already exists — bump package.json version first"; exit 1; fi
+	@set -e; \
+	token="$${GITHUB_TOKEN:-$$GH_TOKEN}"; \
+	if [ "$$token" = "$(AQL_DRY_RUN_FILLER)" ]; then \
+	  echo "[dry-run] aql filler token detected: would publish to npm and tag $(TAG); nothing pushed."; \
+	  exit 0; \
+	fi; \
+	npm publish --access public --registry https://registry.npmjs.org; \
+	git tag -a "$(TAG)" -m "ts v$(VERSION)"; \
+	url=$$(git remote get-url origin | sed -E 's#^git@github.com:#https://github.com/#'); \
+	if [ -n "$$token" ] && printf '%s' "$$url" | grep -q '^https://github.com/'; then \
+	  hdr="AUTHORIZATION: basic $$(printf 'x-access-token:%s' "$$token" | base64 | tr -d '\n')"; \
+	  git -c http.extraheader="$$hdr" push "$$url" "$(TAG)"; \
+	else \
+	  git push origin "$(TAG)"; \
+	fi; \
+	echo "Published to npm + tag $(TAG)."

package/project/.sdk/tm/ts/src/Context.ts

@@ -86,10 +86,15 @@ class Context {
 
 
   resolveOp(opname: string): Operation {
-    let op: Operation = getprop(this.opmap, opname)
+    // Cache key is `<entity>:<opname>` so two entities with the same op
+    // (e.g. both have a "list") get distinct cached Operations. Keying on
+    // opname alone caused the first-resolved entity's points to be served
+    // to every subsequent entity's call.
+    const entname = getprop(this.entity, 'name', '')
+    const cacheKey = entname + ':' + opname
+    let op: Operation = getprop(this.opmap, cacheKey)
 
     if (null == op && null != opname) {
-      const entname = getprop(this.entity, 'name', '')
       const opcfg = getpath(this.config, ['entity', entname, 'op', opname])
       let input = 'match'
 
@@ -104,7 +109,7 @@ class Context {
         points: getprop(opcfg, 'points', [])
       })
 
-      setprop(this.opmap, opname, op)
+      setprop(this.opmap, cacheKey, op)
     }
 
     return op

package/src/action/action.ts

@@ -12,19 +12,25 @@ import type {
 } from '../types'
 
 
-const UpdateIndex = cmp(function UpdateIndex(props: any) {
-  const names = props.names
+// Append `@"<name>.jsonic"` import lines for each name not already present in
+// the index content. Checking against the accumulating result (not the
+// original) means duplicate names in the same call are added at most once.
+function appendIndexEntries(content: string, names: string[]): string {
+  let out = content
+
+  for (const n of names) {
+    const entry = `@"${n}.jsonic"`
+    if (!out.includes(entry)) {
+      out += '\n' + entry
+    }
+  }
 
-  let oldcontent = props.content
-  let newcontent = oldcontent
+  return out
+}
 
-  names.map((n: string) => {
-    if (!oldcontent.includes(`@"${n}.jsonic"`)) {
-      newcontent += `\n@"${n}.jsonic"`
-    }
-  })
 
-  Content(newcontent)
+const UpdateIndex = cmp(function UpdateIndex(props: any) {
+  Content(appendIndexEntries(props.content, props.names))
 })
 
 
@@ -49,5 +55,6 @@ function loadContent(actx: ActionContext, which: string | string[]) {
 
 export {
   UpdateIndex,
+  appendIndexEntries,
   loadContent
 }

package/src/action/feature.ts

@@ -2,7 +2,6 @@
 import Path from 'node:path'
 
 import {
-  Jostraca,
   Project,
   File,
   Folder,
@@ -64,7 +63,10 @@ async function cmd_feature_add(args: string[], actx: ActionContext): Promise<Act
 
 async function feature_add(features: string[], actx: ActionContext): Promise<ActionResult> {
 
-  const jostraca = Jostraca()
+  // Reuse the caller's Jostraca instance so feature generation honours the
+  // shared controls (notably `dryrun`). A fresh Jostraca() defaults dryrun
+  // to false and would write files during a dry run.
+  const jostraca = actx.jostraca
 
   const opts = {
     fs: actx.fs,
@@ -129,12 +131,12 @@ const FeatureRoot = cmp(function FeatureRoot(props: any) {
         }))
       })
 
-      each(target, (target) =>
-        Folder({ name: 'tm/' + target.name + '/src/feature/' + fname }, () => {
+      each(target, (t) =>
+        Folder({ name: 'tm/' + t.name + '/src/feature/' + fname }, () => {
           const from = Path.join(
-            (target.base || Path.join(BASE, '/project/.sdk')),
+            (t.base || Path.join(BASE, '/project/.sdk')),
             'tm',
-            target.name,
+            t.name,
             '/src/feature/',
             fname
           )

package/src/action/target.ts

@@ -87,17 +87,22 @@ async function target_add(targets: string[], actx: ActionContext): Promise<Actio
   })
 
 
-  const jres = await jostraca.generate(opts, () => TargetRoot({ targets, actx }))
-
-  showChanges(opts.log, 'target-result', jres)
-
   // The `test` feature is required by every generated target (SDK.test()
   // depends on it), so ensure it is added even if the model does not yet
   // declare it.
   const features = Array.from(new Set([
     'test',
-    ...Object.keys(actx.model.main[KIT].feature),
+    ...Object.keys(actx.model.main[KIT]?.feature ?? {}),
   ]))
+
+  const jres = await jostraca.generate(opts, () =>
+    TargetRoot({ targets, features, actx }))
+
+  showChanges(opts.log, 'target-result', jres)
+
+  // feature_add copies feature templates for targets already registered in
+  // the model. The targets added above are not in the in-memory model yet,
+  // so TargetRoot copies their feature templates itself.
   await feature_add(features, actx)
 
   opts.log.info({
@@ -112,7 +117,7 @@ async function target_add(targets: string[], actx: ActionContext): Promise<Actio
 
 
 const TargetRoot = cmp(function TargetRoot(props: any) {
-  const { ctx$, targets } = props
+  const { ctx$, targets, features } = props
   const { model, log } = ctx$
 
   // TODO: jostraca - make from value easier to specify 
@@ -174,8 +179,11 @@ const TargetRoot = cmp(function TargetRoot(props: any) {
         Folder({ name: 'src/feature' }, () => {
           Copy({ from: tfolder + '/tm/' + torigname + '/src/feature/README.md' })
 
-          Folder({ name: 'base' }, () => {
-            Copy({ from: tfolder + '/tm/' + torigname + '/src/feature/base' })
+          each(Array.from(new Set(['base', ...(features ?? [])])), (f: any) => {
+            const fname = f.val$
+            Folder({ name: fname }, () => {
+              Copy({ from: tfolder + '/tm/' + torigname + '/src/feature/' + fname })
+            })
           })
         })
       })
@@ -256,4 +264,5 @@ function resolveTarget(tref: string, ctx$: any) {
 export {
   action_target,
   target_add,
+  resolveTarget,
 }

package/src/cmp/Changelog.ts

@@ -0,0 +1,34 @@
+import { cmp, Content, File } from 'jostraca'
+
+
+// Root CHANGELOG.md seed. Generated as an initial "Keep a Changelog" skeleton;
+// the version reflects the lockstep SDK version at generation time. (Publish
+// history is carried by the git release tags <target>/vX.Y.Z.)
+const Changelog = cmp(function Changelog(props: any) {
+  const { ctx$ } = props
+  const { model } = ctx$
+
+  const name = model.Name || model.name
+
+  File({ name: 'CHANGELOG.md' }, () => {
+    Content(`# Changelog
+
+All notable changes to the generated ${name} SDK are documented here.
+This project follows [Keep a Changelog](https://keepachangelog.com) and
+[Semantic Versioning](https://semver.org).
+
+## [Unreleased]
+
+## [0.0.1]
+
+- Initial generated release of the ${name} SDK (TypeScript, Python, PHP, Go,
+  Ruby, and Lua, plus CLI and MCP surfaces), generated from the upstream
+  OpenAPI specification by @voxgig/sdkgen.
+`)
+  })
+})
+
+
+export {
+  Changelog
+}