@voxgig/sdkgen 1.2.1 → 1.3.2

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,22 +12,39 @@ import type {
 } from '../types'
 
 
-const UpdateIndex = cmp(function UpdateIndex(props: any) {
-  const names = props.names
+// Append `@"<name>.aontu"` 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}.aontu"`
+    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))
 })
 
 
+// Names given to an `add` action: every positional after the subcommand is
+// a name, each possibly comma-separated — `target add ts,py,go` and
+// `target add ts py go` are equivalent (space-separated extras used to be
+// silently dropped).
+function parseAddNames(args: any[]): string[] {
+  return args.slice(2)
+    .flatMap((a: any) => 'string' === typeof a ? a.split(',') : a)
+    .filter((n: any) => null != n && '' !== n)
+}
+
+
 function loadContent(actx: ActionContext, which: string | string[]) {
   which = Array.isArray(which) ? which : [which]
 
@@ -37,7 +54,7 @@ function loadContent(actx: ActionContext, which: string | string[]) {
   const modelfolder = Path.dirname(actx.url)
 
   which.map((w: string) => {
-    const indexfile = Path.join(modelfolder, w, w + '-index.jsonic')
+    const indexfile = Path.join(modelfolder, w, w + '-index.aontu')
     const indexcontent = fs.readFileSync(indexfile, 'utf8')
     content[`${w}_index`] = indexcontent
   })
@@ -49,5 +66,7 @@ function loadContent(actx: ActionContext, which: string | string[]) {
 
 export {
   UpdateIndex,
+  appendIndexEntries,
+  parseAddNames,
   loadContent
 }

package/src/action/feature.ts

@@ -2,7 +2,6 @@
 import Path from 'node:path'
 
 import {
-  Jostraca,
   Project,
   File,
   Folder,
@@ -27,6 +26,7 @@ import { SdkGenError } from '../utility'
 
 import {
   UpdateIndex,
+  parseAddNames,
   loadContent,
 } from './action'
 
@@ -53,18 +53,16 @@ async function action_feature(args: string[], actx: ActionContext): Promise<Acti
 
 
 async function cmd_feature_add(args: string[], actx: ActionContext): Promise<ActionResult> {
-
-  const features_arg = args[2]
-  const features: string[] =
-    'string' === typeof features_arg ? features_arg.split(',') : features_arg
-
-  return feature_add(features, actx)
+  return feature_add(parseAddNames(args), actx)
 }
 
 
 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,
@@ -120,21 +118,21 @@ const FeatureRoot = cmp(function FeatureRoot(props: any) {
       Folder({ name: 'model/feature' }, () => {
         Copy({
           // TODO: these paths needs to be parameterised
-          from: BASE + '/project/.sdk/model/feature/' + fname + '.jsonic',
+          from: BASE + '/project/.sdk/model/feature/' + fname + '.aontu',
           exclude: true
         })
-        File({ name: 'feature-index.jsonic' }, () => UpdateIndex({
+        File({ name: 'feature-index.aontu' }, () => UpdateIndex({
           content: ctx$.meta.content.feature_index,
           names: features,
         }))
       })
 
-      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

@@ -31,6 +31,7 @@ import {
 
 import {
   UpdateIndex,
+  parseAddNames,
   loadContent,
 } from './action'
 
@@ -55,11 +56,7 @@ async function action_target(args: string[], actx: ActionContext): Promise<Actio
 
 
 async function cmd_target_add(args: string[], actx: ActionContext): Promise<ActionResult> {
-  const targets_arg = args[2]
-  const targets: string[] =
-    'string' === typeof targets_arg ? targets_arg.split(',') : targets_arg
-
-  return target_add(targets, actx)
+  return target_add(parseAddNames(args), actx)
 }
 
 
@@ -87,17 +84,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,13 +114,18 @@ 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 
   // const tfolder = 'node_modules/@voxgig/sdkgen/project/.sdk'
 
   Project({}, () => {
+    // Resolved names of every target in this run. The index File is
+    // re-rendered per target and the last render wins, so each render must
+    // carry all names seen so far, not just its own.
+    const tnames: string[] = []
+
     each(targets, (n) => {
       const tref = n.val$
 
@@ -129,6 +136,7 @@ const TargetRoot = cmp(function TargetRoot(props: any) {
       })
 
       const { tname, tfolder, torigname, base } = resolveTarget(tref, ctx$)
+      tnames.push(tname)
       const targetNote = tname + (tname != tref ? ' ref:' + tref : '')
 
       log.info({
@@ -140,16 +148,15 @@ const TargetRoot = cmp(function TargetRoot(props: any) {
 
       Folder({ name: 'model/target' }, () => {
         Copy({
-          from: tfolder + '/model/target/' + torigname + '.jsonic',
+          from: tfolder + '/model/target/' + torigname + '.aontu',
           // exclude: true
           replace: {
             "'BASE'": "'" + base + "'"
           }
         })
-        File({ name: 'target-index.jsonic' }, () => UpdateIndex({
+        File({ name: 'target-index.aontu' }, () => UpdateIndex({
           content: ctx$.meta.content.target_index,
-          // names: targets,
-          names: [tname]
+          names: tnames,
         }))
       })
 
@@ -174,8 +181,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 +266,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
+}

package/src/cmp/Deploy.ts

@@ -0,0 +1,258 @@
+import { cmp, each, Content, File } from 'jostraca'
+
+import {
+  KIT,
+  getModelPath
+} from '../types'
+
+
+// Generate the SDK root deployment Makefile from the model's per-target
+// `publish` sections (see model/sdkgen.aontu):
+//
+//   publish.tag       — git release tag `<prefix>/vX.Y.Z`; every port has
+//                       one, pushed with a token from the aql key vault
+//                       (--for recipe + alias, default github/github).
+//   publish.registry  — package registry details (name, url, vault
+//                       credential recipe or raw env mapping) plus a
+//                       `state` (pending | active | inactive; the legacy
+//                       `active: true` bool is honoured as an alias for
+//                       state === 'active'). While a registry is NOT
+//                       active (publish pending) a real deploy publishes
+//                       the git tag only; the package upload starts when
+//                       state flips to 'active'. Tag-only ports (go
+//                       family) have no registry.
+//
+// Follows the voxgig/struct root Makefile conventions: per-target deploy
+// targets, deliberately no all-targets real deploy (each upload is
+// irreversible), and an everything-at-once DRY run leaning on
+// `aql vault exec --dry-run` filler-token cooperation in each target's
+// publish recipe.
+const Deploy = cmp(function Deploy(props: any) {
+  const { ctx$ } = props
+  const { model } = ctx$
+
+  const targetMap = getModelPath(model, `main.${KIT}.target`) || {}
+  const targets: any[] = []
+  each(targetMap, (t: any) => {
+    if (false !== t.active) targets.push(t)
+  })
+
+  if (0 === targets.length) {
+    return
+  }
+
+  File({ name: 'Makefile' }, () => {
+    Content(makeDeployMakefile(model, targets))
+  })
+
+  ctx$.log.info({
+    point: 'generate-deploy',
+    note: 'targets: ' + targets.map((t: any) =>
+      t.name + (registryOf(t) ? (':' + registryOf(t).name + (regIsActive(registryOf(t)) ? '' : '(publish pending)')) : ':tag-only')
+    ).join(',')
+  })
+})
+
+
+function registryOf(t: any): any | undefined {
+  const reg = t.publish?.registry
+  return (reg && '' !== (reg.name || '')) ? reg : undefined
+}
+
+
+// A registry is active (package really uploaded) when its tri-state
+// `state === 'active'`. The legacy boolean `active: true` is honoured as a
+// back-compat alias. Anything else — 'pending' (the default), 'inactive' —
+// means a deploy publishes the git tag only.
+function regIsActive(reg: any): boolean {
+  if (null == reg) return false
+  if (true === reg.active) return true // legacy alias
+  return 'active' === reg.state
+}
+
+
+function aliasVarName(name: string): string {
+  return name.toUpperCase().replace(/[^A-Z0-9]+/g, '_') + '_ALIAS'
+}
+
+
+// The aql vault exec argument string for a target: `--for=<recipe>=<alias>`
+// flags where a preset recipe exists, or a raw `'alias=ENV_VAR,...'`
+// mapping when any credential lacks a preset (e.g. luarocks). The github
+// token for the tag push is always included.
+function vaultExecArgs(t: any): string {
+  const tagVault = t.publish?.tag?.vault || {}
+  const ghRecipe = tagVault.recipe || 'github'
+  const ghVar = aliasVarName(ghRecipe)
+  const reg = registryOf(t)
+  const regVault = reg?.vault || {}
+  const regVar = reg ? aliasVarName(reg.name) : ''
+
+  if (reg && '' === (regVault.recipe || '') && '' !== (regVault.env || '')) {
+    // Raw env mapping style: every credential as alias=ENV_VAR.
+    return `'$(${regVar})=${regVault.env},$(${ghVar})=GITHUB_TOKEN'`
+  }
+
+  const flags = []
+  if (reg && '' !== (regVault.recipe || '')) {
+    flags.push(`--for=${regVault.recipe}=$(${regVar})`)
+  }
+  flags.push(`--for=${ghRecipe}=$(${ghVar})`)
+  return flags.join(' ')
+}
+
+
+function makeDeployMakefile(model: any, targets: any[]): string {
+  // Alias variables: one per distinct vault credential, defaulting to the
+  // model's alias (or the registry/recipe name).
+  const aliasVars = new Map<string, string>()
+  for (const t of targets) {
+    const tagVault = t.publish?.tag?.vault || {}
+    const ghRecipe = tagVault.recipe || 'github'
+    if (!aliasVars.has(aliasVarName(ghRecipe))) {
+      aliasVars.set(aliasVarName(ghRecipe), tagVault.alias || ghRecipe)
+    }
+    const reg = registryOf(t)
+    if (reg && !aliasVars.has(aliasVarName(reg.name))) {
+      aliasVars.set(aliasVarName(reg.name), reg.vault?.alias || reg.name)
+    }
+  }
+
+  const summary = targets.map((t: any) => {
+    const reg = registryOf(t)
+    const state = reg
+      ? `${reg.name} (${regIsActive(reg) ? 'ACTIVE' : 'publish pending: deploy publishes the git tag only'}) ${reg.url || ''}`.trim()
+      : 'tag-only'
+    return `#   ${t.name.padEnd(8)} ${state}`
+  }).join('\n')
+
+  const deployRules = targets.map((t: any) => {
+    const reg = registryOf(t)
+    // The github token is the only credential a tag-only deploy needs.
+    const tagVault = t.publish?.tag?.vault || {}
+    const ghRecipe = tagVault.recipe || 'github'
+    const ghArgs = `--for=${ghRecipe}=$(${aliasVarName(ghRecipe)})`
+    const args = vaultExecArgs(t)
+
+    const via = t.publish?.tag?.via || 'port'
+
+    if (!reg && 'root' === via) {
+      // Tag-only port with no Makefile of its own (e.g. go-cli): the
+      // root tag-push recipe is the whole deploy.
+      return `
+deploy-${t.name}:
+\t@echo "deploy-${t.name}: tag-only port — publishing the git tag."
+\taql vault exec ${ghArgs} -- $(MAKE) tag-push-${t.name}
+
+deploy-dry-${t.name}:
+\taql vault exec --dry-run ${ghArgs} -- $(MAKE) tag-push-${t.name}
+${tagPushRecipe(t.name, 'tag-only port')}
+`
+    }
+
+    if (reg && !regIsActive(reg)) {
+      // Publish pending: deploying this target publishes its git tag
+      // only. The package upload turns on by flipping
+      // publish.registry.state to 'active' in the model and regenerating.
+      return `
+deploy-${t.name}:
+\t@echo "deploy-${t.name}: ${reg.name} publication is pending — publishing the git tag only."
+\taql vault exec ${ghArgs} -- $(MAKE) tag-push-${t.name}
+
+deploy-dry-${t.name}:
+\taql vault exec --dry-run ${ghArgs} -- $(MAKE) tag-push-${t.name}
+${tagPushRecipe(t.name, reg.name + ' publication pending — tag-only deploy')}
+`
+    }
+
+    return `
+deploy-${t.name}:
+\taql vault exec ${args} -- $(MAKE) -C ${t.name} publish
+
+deploy-dry-${t.name}:
+\taql vault exec --dry-run ${args} -- $(MAKE) -C ${t.name} publish
+`
+  }).join('')
+
+  const varLines = Array.from(aliasVars.entries())
+    .map(([v, def]) => `${v} ?= ${def}`).join('\n')
+
+  return `# ${model.Name} SDK deployment. GENERATED by @voxgig/sdkgen — regenerated
+# on every \`npm run generate\` in .sdk/; publication details live in the
+# model (.sdk/model/target/<target>.aontu, \`publish\` section).
+#
+# Every port gets a git release tag <target>/vX.Y.Z. Ports with an ACTIVE
+# registry also publish a package there. Credentials are injected at exec
+# time by the aql key vault (https://github.com/aql-lang/aql) — never
+# stored on disk or passed on the command line.
+#
+# Publication state (from the model):
+${summary}
+#
+#   make deploy               list per-target deploy commands
+#   make deploy-<target>      deploy ONE target (no deploy-all: each
+#                             registry upload is irreversible); while a
+#                             registry is pending this publishes the
+#                             port's git tag only
+#   make deploy-dry           rehearse EVERY target: aql --dry-run
+#                             injects a filler token that each publish
+#                             recipe detects, so build + test run in full
+#                             but nothing is uploaded and no tag is cut
+#
+# Vault aliases (override per invocation, e.g. make deploy-ts NPM_ALIAS=work:npm):
+
+SHELL := /bin/bash
+
+${varLines}
+
+# Lockstep SDK version, read from the canonical ts manifest.
+VERSION := $(shell node -p "require('./ts/package.json').version" 2>/dev/null || echo 0.0.0)
+AQL_DRY_RUN_FILLER := AQL-DRY-RUN-FILLER-NOT-A-REAL-SECRET
+
+TARGETS := ${targets.map((t: any) => t.name).join(' ')}
+
+.PHONY: deploy deploy-dry \\
+  $(addprefix deploy-,$(TARGETS)) $(addprefix deploy-dry-,$(TARGETS)) \\
+  $(addprefix tag-push-,$(TARGETS))
+
+deploy:
+\t@echo "Deployment is per-target — pick one (each upload is irreversible):"
+\t@echo "  make deploy-<target>    targets: $(TARGETS)"
+\t@echo "Registry state is set in the model (.sdk/model/target/<t>.aontu):"
+${targets.map((t: any) => {
+    const reg = registryOf(t)
+    const state = reg ? `${reg.name} ${regIsActive(reg) ? 'ACTIVE' : 'publish pending (deploy = git tag only)'}` : 'tag-only'
+    return `\t@echo "  deploy-${t.name.padEnd(8)} ${state}"`
+  }).join('\n')}
+\t@echo "Rehearse everything safely first: make deploy-dry"
+
+deploy-dry: $(addprefix deploy-dry-,$(TARGETS))
+\t@echo "deploy-dry: all targets rehearsed OK ($(TARGETS))"
+${deployRules}`
+}
+
+
+
+// The root-level tag creation + push recipe for a target: aql --dry-run
+// filler cooperation, idempotent tag creation, token-authenticated https
+// push (works from an ssh-remote clone without ssh keys).
+function tagPushRecipe(name: string, note: string): string {
+  return `
+tag-push-${name}:
+\t@set -e; tag="${name}/v$(VERSION)"; \\
+\ttoken="\$\${GITHUB_TOKEN:-$$GH_TOKEN}"; \\
+\tif [ "$$token" = "$(AQL_DRY_RUN_FILLER)" ]; then \\
+\t  echo "[dry-run] aql filler token detected: would create (if missing) and push tag $$tag; nothing pushed."; exit 0; fi; \\
+\tif [ -z "$$token" ]; then echo "tag-push-${name}: no GITHUB_TOKEN in env — run via make deploy-${name} (aql vault exec)"; exit 1; fi; \\
+\tif git rev-parse -q --verify "refs/tags/$$tag" >/dev/null; then \\
+\t  echo "tag $$tag already exists — pushing existing tag"; \\
+\telse git tag -a "$$tag" -m "Release $$tag"; fi; \\
+\turl=$$(git remote get-url origin | sed -E 's#^git@github.com:#https://github.com/#'); \\
+\thdr="AUTHORIZATION: basic $$(printf 'x-access-token:%s' "$$token" | base64 | tr -d '\\n')"; \\
+\tgit -c http.extraheader="$$hdr" push "$$url" "$$tag"; \\
+\techo "pushed $$tag (${note})"`
+}
+
+export {
+  Deploy
+}

package/src/cmp/FeatureHook.ts

@@ -1,5 +1,5 @@
 
-import { each, cmp, names, Content } from 'jostraca'
+import { each, cmp } from 'jostraca'
 
 import {
   KIT,
@@ -12,14 +12,12 @@ const FeatureHook = cmp(function FeatureHook(props: any, children: any) {
 
   const feature = getModelPath(model, `main.${KIT}.feature`)
 
-  const hook: any = {}
-  names(hook, props.name)
-
-  // TODO: much better error reporting for invalid feature hook names
+  // A feature need not implement every pipeline stage; only fire the hook
+  // for features that declare it as active. Optional chaining guards
+  // features whose `hook` map omits this stage entirely.
   each(feature)
-    // .map(feature => (console.log(props.name, feature), feature))
-    .filter(feature => feature.active && feature.hook[props.name].active)
-    .map(feature => each(children, { call: true, args: feature }))
+    .filter(feature => feature.active && feature.hook?.[props.name]?.active)
+    .forEach(feature => each(children, { call: true, args: feature }))
 })