@voxgig/sdkgen 4.33.0 → 4.34.1

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

@@ -1,4 +1,4 @@
-import { flowSteps } from '@voxgig/sdkgen'
+import { flowSteps, opReachable } from '@voxgig/sdkgen'
 
 import {
   flatten,
@@ -29,11 +29,52 @@ import {
   serverVariables,
   entityDataIdField, envName, envToken,
   phpEntityAccessor,
+  invalidRequest,
+  liveFlowNeeds, liveStrict, liveStrictNote,
 } from '@voxgig/sdkgen'
 
 import { formatPhpValue } from './utility_php'
 
 
+// The live prologue of a flow built from offline fixtures: blocked without
+// the ids it binds, a create-less load reading the first listed record, and
+// a lenient run observing its checks rather than failing on them.
+function liveFlowGate(entity: any, needs: any, entidEnv: string, accessor: string,
+  strict: boolean): string {
+  let out = ''
+  if (0 < needs.keys.length) {
+    out += `        if (!empty($setup["live"])) {
+            foreach ([${needs.keys.map((k: string) => JSON.stringify(k)).join(', ')}] as $_liveKey) {
+                if (!empty($setup["synthetic_only"]) || null === ($setup["idmap"][$_liveKey] ?? null)) {
+                    Runner::live_miss(self::LIVE_STRICT, "Live entity test blocked: needs " . $_liveKey . " via ${entidEnv}");
+                }
+            }
+        }
+`
+  }
+  if (null != needs.blocked) {
+    out += `        if (!empty($setup["live"])) {
+            Runner::live_miss(self::LIVE_STRICT, "Live entity test blocked: " . ${JSON.stringify(needs.blocked)});
+        }
+`
+  }
+  out += '        $client = $setup["client"];\n'
+  if (null != needs.discover) {
+    const match = Object.entries(needs.discover)
+      .map(([k, v]: any) => `${JSON.stringify(k)} => $setup["idmap"][${JSON.stringify(v)}] ?? null`).join(', ')
+    out += `        if (!empty($setup["live"])) {
+            Runner::live_existing($setup, self::LIVE_STRICT, ${JSON.stringify(entity.name)},
+                fn() => $client->${accessor}(null)->list([${match}], null));
+        }
+`
+  }
+  if (!strict) {
+    out += '        try {\n'
+  }
+  return out
+}
+
+
 type GenCtx = {
   model: Model
   entity: ModelEntity
@@ -52,11 +93,11 @@ const TestEntity = cmp(function TestEntity(props: any) {
   const target = props.target
   const entity: ModelEntity = props.entity
 
-  // The stream test streams the "list" op and asserts a 3-item collection, so
-  // it only applies to entities that declare a list op. Others (e.g. Batch =
-  // create/load) have no list endpoint — make_point errors and the stream
-  // yields nothing — so skip the stream test for them.
-  const hasList = !!(entity.op && (entity.op as any)?.list)
+  // The stream test streams the "list" op with no match and asserts a 3-item
+  // collection, so it only applies to an entity whose list a bare call can
+  // reach: not one without a list (e.g. Batch = create/load), not a nested
+  // list needing its parent's id, and not one whose routes all need an action.
+  const hasList = opReachable((entity.op as any)?.list, [])
 
   const basicflow: ModelEntityFlow | undefined =
     getModelPath(model, `main.${KIT}.flow.Basic${nom(entity, 'Name')}Flow`)
@@ -102,6 +143,10 @@ const TestEntity = cmp(function TestEntity(props: any) {
 
   const genCtx: GenCtx = { model, entity, flow: basicflow, PROJUPPER, accessor }
 
+  const strict = liveStrict(model, target.name)
+  const needs = liveFlowNeeds(entity, basicflow)
+  const entidEnv = PROJUPPER + '_TEST_' + envToken(entity.name) + '_ENTID'
+
   File({ name: entity.Name + 'EntityTest.' + target.ext }, () => {
 
     Content(`<?php
@@ -114,9 +159,12 @@ require_once __DIR__ . '/Runner.php';
 
 use PHPUnit\\Framework\\TestCase;
 use Voxgig\\Struct\\Struct as Vs;
-
+${hasList ? failHookClass(model, entity) : ''}
 class ${entity.Name}EntityTest extends TestCase
 {
+${liveStrictNote(strict, '//', '    ')}
+    private const LIVE_STRICT = ${strict};
+
     public function test_create_instance(): void
     {
         $testsdk = ${model.const.Name}SDK::test(null, null);
@@ -162,7 +210,7 @@ ${hasList ? `
             $this->assertCount(3, $got);
         }
     }
-` : ''}
+${failureTests(model, entity, accessor)}` : ''}${validateTest(model, entity, accessor)}
     public function test_basic_flow(): void
     {
         $setup = ${entity.name}_basic_setup(null);
@@ -175,14 +223,7 @@ ${hasList ? `
                 return;
             }
         }
-        // The basic flow consumes synthetic IDs from the fixture. In live mode
-        // without an *_ENTID env override, those IDs hit the live API and 4xx.
-        if (!empty($setup["synthetic_only"])) {
-            $this->markTestSkipped("live entity test uses synthetic IDs from fixture — set ${PROJUPPER}_TEST_${envToken(entity.name)}_ENTID JSON to run live");
-            return;
-        }
-        $client = $setup["client"];
-
+${liveFlowGate(entity, needs, entidEnv, accessor, strict)}
 `)
 
     // Check if the flow has a create step
@@ -216,7 +257,10 @@ ${hasList ? `
       }
     })
 
-    Content(`    }
+    Content(`${strict ? '' : `        } catch (\\Throwable $e) {
+            Runner::live_observe($e, $setup, self::LIVE_STRICT);
+        }
+`}    }
 }
 
 `)
@@ -246,9 +290,8 @@ ${hasList ? `
 
 `)
 
-    Content(`    // Detect ENTID env override before envOverride consumes it. When live
-    // mode is on without a real override, the basic test runs against synthetic
-    // IDs from the fixture and 4xx's. Surface this so the test can skip.
+    Content(`    // Whether *_ENTID supplied the idmap, read before env_override consumes
+    // it: without it, the ids a live flow binds are the fixture's synthetic ones.
     $entid_env_raw = getenv("${PROJUPPER}_TEST_${envToken(entity.name)}_ENTID");
     $idmap_overridden = $entid_env_raw !== false && str_starts_with(trim($entid_env_raw), "{");
 
@@ -610,6 +653,162 @@ const GENERATE_OP: Record<string, OpGen> = {
 }
 
 
+// A feature whose PreSpec hook throws, counting the PreUnexpected calls it sees.
+function failHookClass(model: Model, entity: ModelEntity): string {
+  const Name = model.const.Name
+  return `
+class ${entity.Name}EntityTestFailHook extends ${Name}BaseFeature
+{
+    public int $unexpected = 0;
+
+    public function __construct()
+    {
+        parent::__construct();
+        $this->name = 'failhook';
+    }
+
+    public function init(${Name}Context $ctx, array $options): void
+    {
+    }
+
+    public function PreSpec(${Name}Context $ctx): void
+    {
+        throw new \\RuntimeException('${entity.name} hook failed');
+    }
+
+    public function PreUnexpected(${Name}Context $ctx): void
+    {
+        $this->unexpected++;
+    }
+}
+`
+}
+
+
+// A failed operation raises from a stream as it does from the operation: a
+// transport failure, and a hook that rejects the call. A throwing hook fires
+// PreUnexpected, and under throw false the call returns null. The caller's
+// ctrl stays its own.
+function failureTests(model: Model, entity: ModelEntity, accessor: string): string {
+  const Name = model.const.Name
+  return `
+    public function test_stream_error(): void
+    {
+        $offline = ["net" => ["offline" => true]];
+        $streamerr = null;
+        try {
+            iterator_to_array(${Name}SDK::test($offline, null)->${accessor}(null)
+                ->stream("list", null, null), false);
+        } catch (\\Throwable $e) {
+            $streamerr = $e;
+        }
+        $this->assertNotNull($streamerr, 'the stream should raise the transport failure');
+        $this->assertStringContainsString('offline', $streamerr->getMessage());
+
+        iterator_to_array(${Name}SDK::test($offline, null)->${accessor}(null)
+            ->stream("list", null, ["ctrl" => ["throw" => false]]), false);
+
+        $cfg = ${Name}Config::shared_config();
+        if (isset($cfg["feature"]["rbac"])) {
+            $denied = ${Name}SDK::test(null, ["feature" => ["rbac" => ["active" => true, "deny" => true]]]);
+            $denyerr = null;
+            try {
+                iterator_to_array($denied->${accessor}(null)->stream("list", null, null), false);
+            } catch (\\Throwable $e) {
+                $denyerr = $e;
+            }
+            $this->assertSame('rbac_denied', $denyerr->sdk_code ?? null);
+        }
+    }
+
+    public function test_stream_ctrl(): void
+    {
+        $ctrl = ["explain" => []];
+        iterator_to_array(${Name}SDK::test(null, null)->${accessor}(null)
+            ->stream("list", null, ["ctrl" => $ctrl]), false);
+        $this->assertSame(["explain"], array_keys($ctrl));
+    }
+
+    public function test_unexpected(): void
+    {
+        $hook = new ${entity.Name}EntityTestFailHook();
+        $client = new ${Name}SDK(["feature" => ["test" => ["active" => true]], "extend" => [$hook]]);
+
+        $err = null;
+        try {
+            $client->${accessor}(null)->list(null, null);
+        } catch (\\Throwable $e) {
+            $err = $e;
+        }
+        $this->assertNotNull($err, 'the throwing hook should fail the operation');
+        $this->assertStringContainsString('hook failed', $err->getMessage());
+        $this->assertGreaterThan(0, $hook->unexpected, 'PreUnexpected did not fire');
+
+        $fired = $hook->unexpected;
+        $this->assertNull($client->${accessor}(null)->list(null, ["throw" => false]));
+        $this->assertGreaterThan($fired, $hook->unexpected, 'PreUnexpected did not fire');
+    }
+
+    public function test_cost_commits_a_throwing_transport(): void
+    {
+        $cfg = ${Name}Config::shared_config();
+        if (!isset($cfg["feature"]["cost"])) {
+            $this->markTestSkipped('feature not present in this SDK: cost');
+        }
+        $client = new ${Name}SDK([
+            "test" => ["active" => true],
+            "feature" => ["cost" => ["active" => true, "unit" => 1]],
+            "utility" => ["fetcher" => function ($ctx, $url, $fetchdef) {
+                throw new \\RuntimeException('${entity.name} transport failed');
+            }],
+        ]);
+
+        $err = null;
+        try {
+            $client->${accessor}(null)->list(null, null);
+        } catch (\\Throwable $e) {
+            $err = $e;
+        }
+        $this->assertInstanceOf(${Name}Error::class, $err);
+        $this->assertStringContainsString('transport failed', $err->getMessage());
+
+        $client->${accessor}(null)->list(null, ["throw" => false]);
+        $this->assertSame(2, $client->_cost["total"]["calls"]);
+        $this->assertSame(2, $client->_cost["total"]["attempts"]);
+    }
+`
+}
+
+
+// An invalid request fails with validate's own error, before it is sent.
+function validateTest(model: Model, entity: ModelEntity, accessor: string): string {
+  const bad = invalidRequest(entity)
+  if (null == bad) {
+    return ''
+  }
+  const Name = model.const.Name
+  const args = Object.entries(bad.args)
+    .map(([k, v]) => JSON.stringify(k) + ' => ' + formatPhpValue(v)).join(', ')
+  return `
+    public function test_validate(): void
+    {
+        $cfg = ${Name}Config::shared_config();
+        if (!isset($cfg["feature"]["validate"])) {
+            $this->markTestSkipped('feature not present in this SDK: validate');
+        }
+        $client = ${Name}SDK::test(null, ["feature" => ["validate" => ["active" => true]]]);
+        $err = null;
+        try {
+            $client->${accessor}(null)->${bad.op}([${args}], null);
+        } catch (\\Throwable $e) {
+            $err = $e;
+        }
+        $this->assertSame('validate_failed', $err->sdk_code ?? null);
+    }
+`
+}
+
+
 export {
   TestEntity
 }

package/project/.sdk/src/cmp/php/fragment/Entity.fragment.php

@@ -191,49 +191,13 @@ class EntyClass
         // The pipeline runs as the caller iterates, so its errors leave
         // through the same catch path as an operation's.
         try {
-            ($utility->feature_hook)($ctx, "PrePoint");
-            [$point, $err] = ($utility->make_point)($ctx);
-            $ctx->out["point"] = $point;
-            if ($err) {
-                return;
-            }
-
-            ($utility->feature_hook)($ctx, "PreSpec");
-            [$spec, $err] = ($utility->make_spec)($ctx);
-            $ctx->out["spec"] = $spec;
-            if ($err) {
-                return;
-            }
-
-            ($utility->feature_hook)($ctx, "PreRequest");
-            [$resp, $err] = ($utility->make_request)($ctx);
-            $ctx->out["request"] = $resp;
-            if ($err) {
-                return;
-            }
-
-            ($utility->feature_hook)($ctx, "PreResponse");
-            [$resp2, $err] = ($utility->make_response)($ctx);
-            $ctx->out["response"] = $resp2;
-            if ($err) {
-                return;
-            }
-
-            ($utility->feature_hook)($ctx, "PreResult");
-            [$result, $err] = ($utility->make_result)($ctx);
-            $ctx->out["result"] = $result;
-            if ($err) {
-                return;
-            }
-
-            ($utility->feature_hook)($ctx, "PreDone");
-
+            $failed = $this->_stream_steps($ctx);
             $result = $ctx->result;
 
             // Inbound: prefer the streaming feature's incremental generator;
             // else fall back to the materialised items so stream always yields.
-            $streamfn = ($result !== null && isset($result->stream) && is_callable($result->stream))
-                ? $result->stream : null;
+            $streamfn = ($failed === null && $result !== null && isset($result->stream)
+                && is_callable($result->stream)) ? $result->stream : null;
             if ($streamfn !== null) {
                 // done() does not run on this path, so its record is cleaned here.
                 ($utility->clean_explain)($ctx);
@@ -246,7 +210,10 @@ class EntyClass
                 return;
             }
 
-            $data = ($utility->done)($ctx);
+            // A failed step leaves through make_error, as an operation's does.
+            $data = $failed === null
+                ? ($utility->done)($ctx)
+                : ($utility->make_error)($ctx, $failed);
             if (is_array($data) && array_is_list($data)) {
                 $items = $data;
             } elseif ($data === null) {
@@ -261,10 +228,64 @@ class EntyClass
                 yield $item;
             }
         } catch (\Throwable $err) {
-            throw $this->_unexpected($ctx, $err);
+            // What a hook throws here must not escape the cleaning below.
+            try {
+                ($utility->feature_hook)($ctx, "PreUnexpected");
+            } catch (\Throwable $hookerr) {
+                $err = $hookerr;
+            }
+            $err = $this->_unexpected($ctx, $err);
+            if ($err !== null) {
+                throw $err;
+            }
         }
     }
 
+    // The steps an operation runs, with their hooks; the first that fails
+    // hands back its error.
+    private function _stream_steps($ctx): mixed
+    {
+        $utility = $this->_utility;
+
+        ($utility->feature_hook)($ctx, "PrePoint");
+        [$point, $err] = ($utility->make_point)($ctx);
+        $ctx->out["point"] = $point;
+        if ($err) {
+            return $err;
+        }
+
+        ($utility->feature_hook)($ctx, "PreSpec");
+        [$spec, $err] = ($utility->make_spec)($ctx);
+        $ctx->out["spec"] = $spec;
+        if ($err) {
+            return $err;
+        }
+
+        ($utility->feature_hook)($ctx, "PreRequest");
+        [$resp, $err] = ($utility->make_request)($ctx);
+        $ctx->out["request"] = $resp;
+        if ($err) {
+            return $err;
+        }
+
+        ($utility->feature_hook)($ctx, "PreResponse");
+        [$resp2, $err] = ($utility->make_response)($ctx);
+        $ctx->out["response"] = $resp2;
+        if ($err) {
+            return $err;
+        }
+
+        ($utility->feature_hook)($ctx, "PreResult");
+        [$result, $err] = ($utility->make_result)($ctx);
+        $ctx->out["result"] = $result;
+        if ($err) {
+            return $err;
+        }
+
+        ($utility->feature_hook)($ctx, "PreDone");
+        return null;
+    }
+
     // #LoadOp
 
     // #ListOp
@@ -273,23 +294,39 @@ class EntyClass
 
     // #UpdateOp
 
+    // #PatchOp
+
     // #RemoveOp
 
     private function _run_op($ctx, callable $post_done): mixed
     {
+        $utility = $this->_utility;
+
         try {
             return $this->_run_steps($ctx, $post_done);
         } catch (\Throwable $err) {
-            throw $this->_unexpected($ctx, $err);
+            // What a hook throws here must not escape the cleaning below.
+            try {
+                // #PreUnexpected-Hook
+            } catch (\Throwable $hookerr) {
+                $err = $hookerr;
+            }
+            $err = $this->_unexpected($ctx, $err);
+            if ($err !== null) {
+                throw $err;
+            }
+            return null;
         }
     }
 
-    // A hook, fetcher or parser threw: make_error never saw it.
-    private function _unexpected($ctx, \Throwable $err): \Throwable
+    // A hook, fetcher or parser threw: make_error never saw it. Null when
+    // the caller switched throwing off.
+    private function _unexpected($ctx, \Throwable $err): ?\Throwable
     {
         $ctx->ctrl->err = $err;
         ($this->_utility->clean_explain)($ctx);
-        return ($this->_utility->clean)($ctx, $err);
+        $cleaned = ($this->_utility->clean)($ctx, $err);
+        return $ctx->ctrl->throw_err === false ? null : $cleaned;
     }
 
     private function _run_steps($ctx, callable $post_done): mixed

package/project/.sdk/src/cmp/php/fragment/EntityPatchOp.fragment.php

@@ -0,0 +1,38 @@
+require_once __DIR__ . '/../utility/struct/Struct.php';
+require_once __DIR__ . '/../core/Helpers.php';
+
+// EJECT-START
+
+    /**
+     * Change part of an existing EntityName: only the fields given are sent.
+     *
+     * @param EntityNamePatchData|array|null $reqdata Body data as an assoc-array;
+     *   a typed EntityNamePatchData names the shape.
+     * @param mixed $ctrl Optional per-call control overrides.
+     * @return EntityName|array The patched EntityName as an assoc-array at the
+     *   SDK boundary; throws ProjectNameError on failure (item-5 convention).
+     */
+    public function patch(?array $reqdata = null, $ctrl = null): mixed
+    {
+        $utility = $this->_utility;
+        $ctx = ($utility->make_context)([
+            "opname" => "patch",
+            "ctrl" => $ctrl,
+            "match" => $this->_match,
+            "data" => $this->_data,
+            "reqdata" => $reqdata,
+        ], $this->_entctx);
+
+        return $this->_run_op($ctx, function () use ($ctx) {
+            if ($ctx->result) {
+                if ($ctx->result->resmatch) {
+                    $this->_match = $ctx->result->resmatch;
+                }
+                if ($ctx->result->resdata) {
+                    $this->_data = ProjectNameHelpers::to_map(Struct::clone($ctx->result->resdata)) ?? [];
+                }
+            }
+        });
+    }
+
+// EJECT-END

package/project/.sdk/src/cmp/php/fragment/Main.fragment.php

@@ -156,7 +156,13 @@ class ProjectNameSDK implements \JsonSerializable
         $path = Struct::getprop($fetchargs, "path") ?? "";
         $path = is_string($path) ? $path : "";
         $method_val = Struct::getprop($fetchargs, "method") ?? "GET";
-        $method_val = is_string($method_val) ? $method_val : "GET";
+        $method_val = strtoupper(is_string($method_val) && '' !== $method_val ? $method_val : "GET");
+        $allow_method = Struct::getpath($opts, "allow.method");
+        if (!ProjectNamePrepareMethod::allowed($allow_method, $method_val)) {
+            return ($utility->make_error)($ctx, $ctx->make_error("spec_method_allow",
+                "Method \"" . $method_val . "\" not allowed by SDK option allow.method value: \"" .
+                (is_string($allow_method) ? $allow_method : "") . "\""));
+        }
         $params = ProjectNameHelpers::to_map(Struct::getprop($fetchargs, "params")) ?? [];
         $query = ProjectNameHelpers::to_map(Struct::getprop($fetchargs, "query")) ?? [];
         $headers = ($utility->prepare_headers)($ctx);
@@ -211,8 +217,7 @@ class ProjectNameSDK implements \JsonSerializable
     // Is this raw-access op permitted by the SDK's allow.op option?
     private function op_allowed(string $op): bool
     {
-        $allow_op = Struct::getpath($this->options, "allow.op");
-        return is_string($allow_op) && str_contains($allow_op, $op);
+        return ProjectNamePrepareMethod::allowed(Struct::getpath($this->options, "allow.op"), $op);
     }
 
     private function op_denied(string $op): array
@@ -275,6 +280,7 @@ class ProjectNameSDK implements \JsonSerializable
             $no_body = $status === 204 || $status === 304 || (string)$content_length === "0";
 
             $json_data = null;
+            $body_err = null;
             if (!$no_body) {
                 $jf = Struct::getprop($fetched, "json");
                 if (is_callable($jf)) {
@@ -285,14 +291,29 @@ class ProjectNameSDK implements \JsonSerializable
                         $json_data = null;
                     }
                 }
+                if (true === Struct::getprop($fetched, "unreadable")) {
+                    $failed = ($status >= 200 && $status < 300) ? null : $ctx->make_error(
+                        "request_status",
+                        "request: {$status}: " . (string)Struct::getprop($fetched, "statusText"));
+                    $sent = $fetchdef["headers"] ?? [];
+                    if (ProjectNameFetcher::usesDefault($ctx)) {
+                        $sent = ProjectNameFetcher::sentHeaders($sent);
+                    }
+                    $body_err = ProjectNameResultBody::unreadable($ctx, $status, $headers,
+                        Struct::getprop($fetched, "body"), $sent, $failed);
+                }
             }
 
-            return [
-                "ok" => $status >= 200 && $status < 300,
+            $out = [
+                "ok" => null === $body_err && $status >= 200 && $status < 300,
                 "status" => $status,
                 "headers" => Struct::getprop($fetched, "headers"),
                 "data" => $json_data,
             ];
+            if (null !== $body_err) {
+                $out["err"] = ($utility->clean)($ctx, $body_err);
+            }
+            return $out;
         }
 
         return [

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

@@ -134,7 +134,7 @@ from typing import TypedDict, Any
       })), log)
 
       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/py/Entity_py.ts

@@ -30,7 +30,7 @@ const Entity = cmp(function Entity(props: any) {
 
   const typeNames = [entity.Name]
   const opnamesAll = Object.keys(entity.op || {})
-  ;['load', 'list', 'create', 'update', 'remove'].forEach((opname: string) => {
+  ;['load', 'list', 'create', 'update', 'patch', 'remove'].forEach((opname: string) => {
     if (opnamesAll.includes(opname)) {
       typeNames.push(opTypeName(entity.Name, opname))
     }
@@ -51,7 +51,7 @@ const Entity = cmp(function Entity(props: any) {
       const opnames = Object.keys(entity.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) ? '' : ({ indent }: any) => {

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

@@ -5,6 +5,7 @@ import {
   cmp, each, names, cmap,
   List, File, Content, Copy, Folder, Fragment, Line, FeatureHook,
   entityClassName, entityCollection,
+  inactiveFeatureExcludes,
   pluginExcludes,
   targetFeatures,
   TEST_CONTROL_EXCLUDE
@@ -52,7 +53,7 @@ const Main = cmp(async function Main(props: any) {
 
   Copy({
     from: 'tm/' + target.name,
-    exclude: [/src\//, /pkg\//, TEST_CONTROL_EXCLUDE],
+    exclude: [/src\//, /pkg\//, TEST_CONTROL_EXCLUDE, ...inactiveFeatureExcludes(props.ctx$, target)],
     replace: {
       ...props.ctx$.stdrep,
     }
@@ -62,7 +63,10 @@ const Main = cmp(async function Main(props: any) {
 
   Copy({
     from: 'tm/' + target.name + '/pkg',
-    exclude: [...pluginExcludes(model)],
+    exclude: [
+      ...inactiveFeatureExcludes(props.ctx$, target, 'tm/' + target.name + '/pkg'),
+      ...pluginExcludes(model),
+    ],
     replace: {
       ...props.ctx$.stdrep,
     }

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

@@ -69,6 +69,13 @@ include = ["${model.const.Name.toLowerCase()}_sdk*"]
 # Ship the PEP 561 py.typed marker(s) so the inline type hints reach consumers.
 [tool.setuptools.package-data]
 "*" = ["py.typed"]
+`)
+  })
+
+  // setuptools puts the readme in the sdist but not the reference it links.
+  // A wheel holds only the package, so the sdist is where the docs travel.
+  File({ name: 'MANIFEST.in' }, () => {
+    Content(`include README.md REFERENCE.md
 `)
   })
 })