@voxgig/sdkgen 4.34.0 → 4.34.1

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

@@ -7,6 +7,8 @@ import {
   isHttpBasicAuth,
   resolveAuthIn,
   resolveAuthName,
+  elixirAccessor,
+  entityCollection,
 } from '@voxgig/sdkgen'
 
 
@@ -33,7 +35,7 @@ const TestClean = cmp(function TestClean(props: any) {
 
 
 const OP_ORDER: Record<string, number> = { list: 0, load: 1 }
-const OPS = ['list', 'load', 'create', 'update', 'remove']
+const OPS = ['list', 'load', 'create', 'update', 'patch', 'remove']
 
 
 // The path parameters an operation's points declare, as the runtime config
@@ -54,14 +56,14 @@ function pointParams(opdef: any): string[] {
 
 // The operations to try, list and load first: a required path parameter is
 // what usually stops a candidate, and the read ops need none.
-function candidates(Name: string, entity: any[]): string {
+function candidates(Name: string, entity: any[], model: any): string {
   const rows: { rank: number, text: string }[] = []
   each(entity, (e: any) => {
     for (const op of Object.keys(e.op || {})) {
       if (!OPS.includes(op)) continue
       rows.push({
         rank: OP_ORDER[op] ?? 2,
-        text: `      {${elixirString(e.name + '.' + op)}, fn sdk -> ${Name}.${e.name}(sdk) end,
+        text: `      {${elixirString(e.name + '.' + op)}, fn sdk -> ${Name}.${elixirAccessor(e, entityCollection(model))}(sdk) end,
        fn ent, match, ctrl -> ${Name}.Entity.${e.Name}.${op}(ent, args(match), ctrl) end,
        [${pointParams(e.op[op]).map((p) => elixirString(p)).join(', ')}]}`,
       })
@@ -238,7 +240,22 @@ defmodule ${Name}.CleanTest do
     ]
   end
 
-  defp make_sdk(respond, sinks, cleanopts, extra \\\\ []) do
+  # Offline, as every generated suite is: the test OPTION resolves a required
+  # server variable to test-<name>, and installs no transport.
+  defp offline(opts), do: S.setprop(opts, "test", S.jm(["active", true]))
+
+  # A client the sweep cannot build leaves nothing swept: a harness error, not
+  # a leak.
+  defp construct(opts) do
+    ${Name}.new(offline(opts))
+  rescue
+    e ->
+      reraise "clean harness: the client could not be constructed, so nothing was swept: " <>
+                Exception.message(e),
+              __STACKTRACE__
+  end
+
+  defp make_sdk(respond, sinks, cleanopts, extra \\\\ [], auth \\\\ nil) do
     capture = fn name -> fn rec -> add(sinks, data_forms(name, rec)) end end
     feature = S.jm([])
 
@@ -257,7 +274,7 @@ defmodule ${Name}.CleanTest do
     clean = S.jm(["values", @canary.value])
     Enum.each(cleanopts, fn {k, v} -> S.setprop(clean, k, v) end)
 
-    ${Name}.new(
+    opts =
       S.jm([
         "apikey", @canary.apikey,
         "secret", @canary.secret,
@@ -267,7 +284,9 @@ defmodule ${Name}.CleanTest do
         "extend", S.jt([capture_feature(sinks) | extra]),
         "utility", S.jm(["fetcher", fn _ctx, url, fd -> respond.(url, fd) end])
       ])
-    )
+
+    if auth != nil, do: S.setprop(opts, "auth", auth)
+    construct(opts)
   end
 
   # A fresh struct node of the match, since an operation may keep what it is
@@ -277,7 +296,7 @@ defmodule ${Name}.CleanTest do
   # The operations this SDK generated, read ops first.
   defp candidates do
     [
-${candidates(Name, entity)}
+${candidates(Name, entity, model)}
     ]
   end
 
@@ -285,7 +304,7 @@ ${candidates(Name, entity)}
   # arguments, else with every path parameter its points declare filled in.
   defp usable_op do
     plain =
-      ${Name}.new(
+      construct(
         S.jm([
           "apikey", @canary.apikey,
           "utility", S.jm(["fetcher", fn _c, _u, _f -> {response(200, S.jm(["id", "i1"]), []), nil} end])
@@ -395,6 +414,8 @@ ${candidates(Name, entity)}
 
     if err != nil, do: add(sinks, error_forms(err))
     if out != nil, do: add(sinks, result_forms(out))
+    # Raw, as a caller copying the match into another query reads it.
+    add(sinks, data_forms("match", ${Name}.EntityBase.match_get(ent)))
     explain = S.getprop(ctrl, "explain")
     if explain != nil, do: add(sinks, data_forms("explain", explain))
     if held != nil and held != explain, do: add(sinks, data_forms("explain:held", held))
@@ -442,11 +463,16 @@ ${candidates(Name, entity)}
         end)
       end)
 
+    # A name given at run time replaces the declared one: the match leaves
+    # out whichever name prepare_auth placed.
+    [{_ok, ok_respond} | _] = scenarios()
+    drive(make_sdk(ok_respond, sinks, [], [], S.jm(["name", "zzcred"])), target, S.jm([]), sinks)
+
     # A credential mistyped as a map is rejected by validation, whose message
     # quotes the value it rejected.
     rejected =
       try do
-        ${Name}.new(S.jm(["apikey", S.jm(["value", @canary.apikey]), "clean", S.jm(["values", @canary.value])]))
+        ${Name}.new(offline(S.jm(["apikey", S.jm(["value", @canary.apikey]), "clean", S.jm(["values", @canary.value])])))
         nil
       rescue
         e -> e
@@ -501,7 +527,7 @@ ${candidates(Name, entity)}
     [_ok, {_nf, notfound_respond} | _] = scenarios()
 
     bare =
-      ${Name}.new(
+      construct(
         S.jm([
           "apikey", @canary.apikey,
           "secret", @canary.secret,
@@ -601,17 +627,19 @@ ${candidates(Name, entity)}
 
   # A feature's name is not a field name: a feature called secrets does not
   # make its settings secret, though a sensitive field inside it still is. An
-  # entity block, of entity settings or seeded records, is not read at all.
+  # entity block, of entity settings or seeded records, is not read at all, and
+  # nor are rbac's rules, keyed by entity and operation names.
   test "a feature's name is read as a name" do
     record = S.jm(["zztoken", S.jm(["ZZTOKEN01", S.jm(["note", "PLAINRECORD-t5r3e1w9"])])])
 
     client =
-      ${Name}.new(
+      construct(
         S.jm([
           "apikey", @canary.apikey,
           "feature",
           S.jm([
             "secrets", S.jm(["active", false, "name", "ZZNAME-feat123", "token", "ZZTOKEN-feat456"]),
+            "rbac", S.jm(["active", false, "rules", S.jm(["zztoken.load", "PLAINRULE-k7j5h3g1"])]),
             "test", S.jm(["active", false, "entity", record])
           ]),
           "entity", S.jm(["zztoken", S.jm(["alias", S.jm(["zzkey", "PLAINALIAS-m2n4b6v8"])])])
@@ -622,6 +650,7 @@ ${candidates(Name, entity)}
     assert ${Name}.Utility.clean_impl(ctx, "ZZNAME-feat123 ZZTOKEN-feat456") == "ZZNAME-feat123 " <> @mask
     assert ${Name}.Utility.clean_impl(ctx, "record PLAINRECORD-t5r3e1w9") == "record PLAINRECORD-t5r3e1w9"
     assert ${Name}.Utility.clean_impl(ctx, "alias PLAINALIAS-m2n4b6v8") == "alias PLAINALIAS-m2n4b6v8"
+    assert ${Name}.Utility.clean_impl(ctx, "rule PLAINRULE-k7j5h3g1") == "rule PLAINRULE-k7j5h3g1"
   end
 
   test "the generated config's own clean block is honoured" do

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

@@ -10,6 +10,10 @@ import {
   Content,
   File,
   cmp,
+  elixirAccessor,
+  entityCollection,
+  invalidRequest,
+  opReachable,
 } from '@voxgig/sdkgen'
 
 
@@ -24,25 +28,24 @@ const TestEntity = cmp(function TestEntity(props: any) {
   const Name = model.const.Name
   const EName = entity.Name
   const ename = entity.name
+  const accessor = elixirAccessor(entity, entityCollection(model))
 
-  const opnames = Object.keys(entity.op || {})
-  const hasLoad = opnames.includes('load')
-  const hasList = opnames.includes('list')
-  const hasCreate = opnames.includes('create')
+  // Each test calls with only what it shows, so a bare call must reach a
+  // route: an id for load, nothing for list, a name for create.
+  const ops: any = entity.op || {}
+  const hasLoad = opReachable(ops.load, ['id'])
+  const hasList = opReachable(ops.list, [])
+  const hasCreate = opReachable(ops.create, ['name'])
 
   const fixture = `../.sdk/test/entity/${ename}/${EName}TestData.json`
-
-  File({ name: ename + '_entity_test.exs' }, () => {
-
-    Content(`# ${EName} entity test (offline, mock transport)
-
-defmodule ${Name}.${EName}EntityTest do
-  use ExUnit.Case
-
-  alias Voxgig.Struct, as: S
-  alias ${Name}.Helpers, as: H
-  alias ${Name}.Json
-
+  const bad = invalidRequest(entity)
+
+  // Only what the emitted tests call: elixir warns on an unused alias or
+  // private function.
+  const seeded = hasList || hasLoad
+  const head = [
+    ...(seeded || hasCreate || null != bad ? ['  alias Voxgig.Struct, as: S'] : []),
+    ...(seeded ? [`  alias ${Name}.Helpers, as: H`, `  alias ${Name}.Json`, `
   defp fixture do
     Json.parse(File.read!(${JSON.stringify(fixture)}))
   end
@@ -50,17 +53,25 @@ defmodule ${Name}.${EName}EntityTest do
   defp mk_sdk do
     existing = H.or_(S.getpath(fixture(), "existing"), S.jm([]))
     ${Name}.test(S.jm(["entity", existing]))
-  end
-
+  end`] : []),
+    ...(hasLoad ? [`
   defp first_id do
     existing = H.or_(S.getpath(fixture(), "existing.${ename}"), S.jm([]))
     keys = S.keysof(existing)
     if keys == [], do: nil, else: hd(keys)
-  end
+  end`] : []),
+  ]
 
+  File({ name: ename + '_entity_test.exs' }, () => {
+
+    Content(`# ${EName} entity test (offline, mock transport)
+
+defmodule ${Name}.${EName}EntityTest do
+  use ExUnit.Case
+${0 < head.length ? '\n' + head.join('\n') + '\n' : ''}
   test "should create instance" do
     sdk = ${Name}.test()
-    ent = ${Name}.${ename}(sdk)
+    ent = ${Name}.${accessor}(sdk)
     assert ent != nil
   end
 `)
@@ -69,7 +80,7 @@ defmodule ${Name}.${EName}EntityTest do
       Content(`
   test "should list records" do
     sdk = mk_sdk()
-    ent = ${Name}.${ename}(sdk)
+    ent = ${Name}.${accessor}(sdk)
     # The op resolves to one ENTITY per record; the record is reached with
     # data_get. See AGENTS.md "Entity operations return ENTITIES".
     result = ${Name}.Entity.${EName}.list(ent, S.jm([]))
@@ -90,7 +101,7 @@ defmodule ${Name}.${EName}EntityTest do
 
     if id != nil do
       sdk = mk_sdk()
-      ent = ${Name}.${ename}(sdk)
+      ent = ${Name}.${accessor}(sdk)
       loaded = ${Name}.Entity.${EName}.load(ent, S.jm(["id", id]))
       rec = ${Name}.EntityBase.data_get(loaded)
       assert S.ismap(rec)
@@ -104,7 +115,7 @@ defmodule ${Name}.${EName}EntityTest do
       Content(`
   test "should create then read back" do
     sdk = ${Name}.test(S.jm(["entity", S.jm(["${ename}", S.jm([])])]))
-    ent = ${Name}.${ename}(sdk)
+    ent = ${Name}.${accessor}(sdk)
     created = ${Name}.Entity.${EName}.create(ent, S.jm(["name", "test-create"]))
     made = ${Name}.EntityBase.data_get(created)
     assert S.ismap(made)
@@ -113,6 +124,124 @@ defmodule ${Name}.${EName}EntityTest do
 `)
     }
 
+    if (hasList) {
+      Content(`
+  test "should report a failed stream" do
+    offline = S.jm(["net", S.jm(["offline", true])])
+
+    err =
+      assert_raise ${Name}.Error, fn ->
+        Enum.to_list(${Name}.EntityBase.stream(${Name}.${accessor}(${Name}.test(offline)), "list"))
+      end
+
+    assert String.contains?(Exception.message(err), "offline")
+
+    quiet = S.jm(["ctrl", S.jm(["throw", false])])
+    Enum.to_list(${Name}.EntityBase.stream(${Name}.${accessor}(${Name}.test(offline)), "list", nil, quiet))
+
+    if ${Name}.FeatureHarness.has_feature("rbac") do
+      denied = ${Name}.test(nil, S.jm(["feature", S.jm(["rbac", S.jm(["active", true, "deny", true])])]))
+
+      err =
+        assert_raise ${Name}.Error, fn ->
+          Enum.to_list(${Name}.EntityBase.stream(${Name}.${accessor}(denied), "list"))
+        end
+
+      assert err.code == "rbac_denied"
+    end
+  end
+
+  test "should leave the caller's ctrl" do
+    explain = S.jm([])
+    ctrl = S.jm(["explain", explain])
+    Enum.to_list(${Name}.EntityBase.stream(${Name}.${accessor}(${Name}.test()), "list", nil, S.jm(["ctrl", ctrl])))
+    assert S.keysof(ctrl) == ["explain"]
+    assert S.size(explain) > 0
+  end
+
+  test "should end a stream whose source fails as the operation would" do
+    seen = S.jm(["n", 0])
+
+    hook =
+      S.jm([
+        "name", "lazyhook", "version", "0.0.1", "active", true, "options", S.jm([]),
+        "init", fn _ctx, _opts -> nil end,
+        "PreDone", fn ctx ->
+          S.setprop(S.getprop(ctx, "result"), "stream",
+            fn -> Stream.map([1], fn _ -> raise "${ename} source failed" end) end)
+        end,
+        "PreUnexpected", fn _ctx -> S.setprop(seen, "n", S.getprop(seen, "n") + 1) end
+      ])
+
+    client = ${Name}.new(S.jm(["feature", S.jm(["test", S.jm(["active", true])]), "extend", S.jt([hook])]))
+
+    err =
+      try do
+        Enum.to_list(${Name}.EntityBase.stream(${Name}.${accessor}(client), "list"))
+        nil
+      rescue
+        e -> e
+      end
+
+    assert err != nil and String.contains?(Exception.message(err), "source failed")
+    assert S.getprop(seen, "n") > 0
+
+    fired = S.getprop(seen, "n")
+    quiet = S.jm(["ctrl", S.jm(["throw", false])])
+    assert Enum.to_list(${Name}.EntityBase.stream(${Name}.${accessor}(client), "list", nil, quiet)) == []
+    assert S.getprop(seen, "n") > fired
+  end
+
+  test "should fire PreUnexpected" do
+    seen = S.jm(["n", 0])
+
+    hook =
+      S.jm([
+        "name", "failhook", "version", "0.0.1", "active", true, "options", S.jm([]),
+        "init", fn _ctx, _opts -> nil end,
+        "PreSpec", fn _ctx -> raise "${ename} hook failed" end,
+        "PreUnexpected", fn _ctx -> S.setprop(seen, "n", S.getprop(seen, "n") + 1) end
+      ])
+
+    client = ${Name}.new(S.jm(["feature", S.jm(["test", S.jm(["active", true])]), "extend", S.jt([hook])]))
+
+    err =
+      try do
+        ${Name}.Entity.${EName}.list(${Name}.${accessor}(client), S.jm([]))
+        nil
+      rescue
+        e -> e
+      end
+
+    assert err != nil and String.contains?(Exception.message(err), "hook failed")
+    assert S.getprop(seen, "n") > 0
+
+    fired = S.getprop(seen, "n")
+    assert ${Name}.Entity.${EName}.list(${Name}.${accessor}(client), S.jm([]), S.jm(["throw", false])) == nil
+    assert S.getprop(seen, "n") > fired
+  end
+`)
+    }
+
+    if (null != bad) {
+      const args = Object.entries(bad.args)
+        .map(([k, v]) => JSON.stringify(k) + ', ' + JSON.stringify(v)).join(', ')
+      Content(`
+  test "should refuse an invalid request" do
+    if ${Name}.FeatureHarness.has_feature("validate") do
+      client = ${Name}.test(nil, S.jm(["feature", S.jm(["validate", S.jm(["active", true])])]))
+
+      err =
+        assert_raise ${Name}.Error, fn ->
+          ${Name}.Entity.${EName}.${bad.op}(${Name}.${accessor}(client), S.jm([${args}]))
+        end
+
+      assert err.code == "validate_failed"
+    end
+  end
+`)
+    }
+
     Content(`end
 `)
   })

package/project/.sdk/src/cmp/elixir/fragment/Entity.fragment.ex

@@ -1,13 +1,11 @@
 # ProjectName SDK EntityName entity
 #
 # Per-entity module. Generic construction/data/match operations delegate to
-# EntityBase; each active op (load/list/create/update/remove) builds a ctx
+# EntityBase; each active op (load/list/create/update/patch/remove) builds a ctx
 # and drives it through ProjectName.Pipeline.run_op.
 
 defmodule ProjectName.Entity.EntityName do
-  alias Voxgig.Struct, as: S
-  alias ProjectName.Helpers, as: H
-  alias ProjectName.{EntityBase, Context, Pipeline}
+  # #Aliases
 
   def new(client, entopts \\ nil) do
     EntityBase.construct(__MODULE__, client, "entityname", entopts)
@@ -33,5 +31,7 @@ defmodule ProjectName.Entity.EntityName do
 
   # #UpdateOp
 
+  # #PatchOp
+
   # #RemoveOp
 end

package/project/.sdk/src/cmp/elixir/fragment/EntityPatchOp.fragment.ex

@@ -0,0 +1,35 @@
+# EJECT-START
+
+  # Returns the patched entityname entity map (ProjectName.Types.entityname/0)
+  # on success; pipeline errors surface as the error value built by
+  # Utility.make_error (shape is utility-configurable), hence term().
+  @spec patch(map(), ProjectName.Types.entityname_patch_data() | nil, map() | nil) :: term()
+  def patch(ent, reqdata, ctrl \\ nil) do
+    ctx =
+      Context.new(
+        S.jm([
+          "opname", "patch",
+          "ctrl", ctrl,
+          "match", S.getprop(ent, "_match"),
+          "data", S.getprop(ent, "_data"),
+          "reqdata", reqdata
+        ]),
+        S.getprop(ent, "_entctx")
+      )
+
+    post_done = fn ->
+      result = S.getprop(ctx, "result")
+
+      if result != nil do
+        rm = S.getprop(result, "resmatch")
+        if rm != nil, do: S.setprop(ent, "_match", rm)
+        rd = S.getprop(result, "resdata")
+        if rd != nil, do: S.setprop(ent, "_data", H.or_(H.to_map(S.clone(rd)), S.jm([])))
+      end
+    end
+
+    out = Pipeline.run_op(ctx, post_done)
+    EntityBase.op_return(ent, ctx, out)
+  end
+
+# EJECT-END

package/project/.sdk/src/cmp/elixir/fragment/Main.fragment.ex

@@ -109,8 +109,15 @@ defmodule ProjectName do
 
     path0 = H.or_(S.getprop(fetchargs, "path"), "")
     path = if is_binary(path0), do: path0, else: ""
-    method0 = H.or_(S.getprop(fetchargs, "method"), "GET")
-    method = if is_binary(method0), do: method0, else: "GET"
+    method = String.upcase(H.str_or(S.getprop(fetchargs, "method"), "GET"))
+    allow_method = S.getpath(options, "allow.method")
+
+    if not Utility.allowed?(allow_method, method) do
+      raise Context.make_error(ctx, "spec_method_allow",
+              "Method \"" <> method <> "\" not allowed by SDK option allow.method value: \"" <>
+                H.str_or(allow_method, "") <> "\"")
+    end
+
     params = H.or_(H.to_map(S.getprop(fetchargs, "params")), S.jm([]))
     query = H.or_(H.to_map(S.getprop(fetchargs, "query")), S.jm([]))
 
@@ -166,8 +173,7 @@ defmodule ProjectName do
 
   # Is this raw-access op permitted by the SDK's allow.op option?
   defp op_allowed?(client, op) do
-    allow = S.getpath(S.getprop(client, "options"), "allow.op")
-    is_binary(allow) and String.contains?(allow, op)
+    Utility.allowed?(S.getpath(S.getprop(client, "options"), "allow.op"), op)
   end
 
   defp op_denied(client, op) do
@@ -240,7 +246,25 @@ defmodule ProjectName do
                 end
               end
 
-            S.jm(["ok", status >= 200 and status < 300, "status", status, "headers", headers, "data", json_data])
+            body_err =
+              if not no_body and S.getprop(fetched, "unreadable") == true do
+                failed =
+                  if status >= 200 and status < 300,
+                    do: nil,
+                    else:
+                      Context.make_error(ctx, "request_status",
+                        "request: " <> to_string(status) <> ": " <> to_string(H.or_(S.getprop(fetched, "statusText"), "")))
+
+                Utility.unreadable_body(ctx, status, headers, S.getprop(fetched, "body"),
+                  S.getprop(fetchdef, "headers"), failed)
+              end
+
+            out =
+              S.jm(["ok", body_err == nil and status >= 200 and status < 300,
+                    "status", status, "headers", headers, "data", json_data])
+
+            if body_err != nil, do: S.setprop(out, "err", Utility.clean(ctx, body_err))
+            out
 
           true ->
             S.jm(["ok", false, "err", Context.make_error(ctx, "direct_invalid", "invalid response type")])

package/project/.sdk/src/cmp/elixir/fragment/Pipeline.fragment.ex

@@ -51,24 +51,31 @@ defmodule ProjectName.Pipeline do
 
       Utility.done(ctx)
     rescue
-      e ->
-        st = __STACKTRACE__
-
-        # What a hook raises here must not escape the cleaning below.
-        {e, st} =
-          try do
-            # #PreUnexpected-Hook
-
-            {e, st}
-          rescue
-            hookerr -> {hookerr, __STACKTRACE__}
-          end
-
-        # An error a hook raised never passed through make_error.
-        Utility.clean_explain(ctx)
-        reraise(Utility.clean_exception(ctx, e), st)
+      e -> unexpected(ctx, e, __STACKTRACE__)
     catch
       {:sdk_ret, v} -> v
     end
   end
+
+  # The catch path every entity call leaves through: an error a hook raised
+  # never passed through make_error. Nil when the caller switched throwing off.
+  def unexpected(ctx, e, st) do
+    # What a hook raises here must not escape the cleaning below.
+    {e, st} =
+      try do
+        # #PreUnexpected-Hook
+
+        {e, st}
+      rescue
+        hookerr -> {hookerr, __STACKTRACE__}
+      end
+
+    Utility.clean_explain(ctx)
+
+    if S.getprop(S.getprop(ctx, "ctrl"), "throw_err") == false do
+      nil
+    else
+      reraise(Utility.clean_exception(ctx, e), st)
+    end
+  end
 end

package/project/.sdk/src/cmp/go/EntityTypes_go.ts

@@ -161,7 +161,7 @@ type ${Name} struct {
 `)
 
         const ops = ent.op || {}
-        ;['load', 'list', 'create', 'update', 'remove'].forEach((opname: string) => {
+        ;['load', 'list', 'create', 'update', 'patch', 'remove'].forEach((opname: string) => {
           if (null == ops[opname]) {
             return
           }

package/project/.sdk/src/cmp/go/Entity_go.ts

@@ -46,7 +46,7 @@ const Entity = cmp(function Entity(props: any) {
       // ProjectNameEntity interface (so the package compiles) but errors
       // at runtime if the caller invokes an unsupported op.
       const opfrags =
-        (['load', 'list', 'create', 'update', 'remove']
+        (['load', 'list', 'create', 'update', 'patch', 'remove']
           .reduce((a: any, opname: string) =>
           (a['// #' + camelify(opname) + 'Op'] =
             !opnames.includes(opname) ?

package/project/.sdk/src/cmp/go/Main_go.ts

@@ -4,6 +4,7 @@ import * as Path from 'node:path'
 import {
   cmp, each, names, cmap,
   List, File, Content, Copy, Folder, Fragment, Line, FeatureHook,
+  inactiveFeatureExcludes,
   entityClassName, entityCollection, goModule, goPackageIdent, pluginExcludes,
   targetFeatures,
   TEST_CONTROL_EXCLUDE
@@ -55,13 +56,10 @@ const Main = cmp(async function Main(props: any) {
 
   Copy({
     from: 'tm/' + target.name,
-    // pluginExcludes: the generate-time plugin trim (an INACTIVE plugin
-    // group's declared files stay out of the tree - the model's `path`
-    // entries are target-root-relative, which is this Copy's root). The
-    // FEATURE-level trim for go stays an add-time concern (vendor-tag
-    // rollout, Decision 5).
+    // The generate-time trim: a declared feature that is off, and an inactive
+    // plugin group, whose `path` entries are relative to this Copy's root.
     exclude: [/src\//, /utility\/struct\/go\.mod$/, TEST_CONTROL_EXCLUDE,
-      ...pluginExcludes(model)],
+      ...inactiveFeatureExcludes(props.ctx$, target), ...pluginExcludes(model)],
     replace: {
       ...props.ctx$.stdrep,
       GOMODULE: gomodule,
@@ -156,6 +154,7 @@ type Utility = core.Utility
 type Feature = core.Feature
 type Entity = core.Entity
 type ${model.const.Name}Entity = core.${model.const.Name}Entity
+type StreamItem = core.StreamItem
 type FetcherFunc = core.FetcherFunc
 type Spec = core.Spec
 type Result = core.Result