@voxgig/sdkgen 3.3.2 → 3.4.2

package/project/.sdk/src/cmp/perl/utility_perl.ts

@@ -14,13 +14,64 @@ function projectPath(suffix?: string): string {
 
 // Strip model-internal keys (ending in `$`) so generated config JSON only
 // carries API-shaped data.
-function clean(o: any) {
-  return walk(clone(o), (k: any, v: any, p: any) => {
-    if (null != k && k.endsWith('$')) {
-      delete p[k]
+// Emission-time normalisation of a model subtree (L0).
+//
+// Always drops jostraca's iteration metadata (`$`-suffixed keys: index$,
+// key$, val$). With `dropDefaults`, also drops keys whose value IS the
+// default the runtime already assumes when the key is absent, which is pure
+// payload — see CONFIG_DEFAULT.
+//
+// Rebuilds the tree rather than mutating during a walk. The previous
+// implementation walked a clone calling `delete p[k]`, but walk() assigns its
+// callback's result back over the child (`setprop(out, ckey, walk(...))`), so
+// the delete was undone on the way out and the helper silently did nothing.
+// Returning `undefined` from the callback does not fix it either: setprop
+// stores undefined rather than removing the key, which then emits as a null.
+//
+// `dropDefaults` is opt-in and must be passed ONLY for the entity subtree.
+// `active` means something different in feature config, where absent reads as
+// INACTIVE (see feature_init) — dropping `active: true` there would silently
+// disable the feature.
+// jostraca's iteration metadata, injected by each()/names() while it walks the
+// model. Listed explicitly rather than matched by trailing-dollar suffix: a
+// trailing dollar is not exclusive to jostraca -- Seneca uses entity$ as real
+// data -- so a blanket suffix match can silently drop a legitimate API field.
+const MODEL_META = ['index$', 'key$', 'val$']
+
+// Keys whose value IS the default the runtime already assumes when the key is
+// absent, so emitting them is pure payload.
+const CONFIG_DEFAULT: Record<string, any> = {
+  active: true,
+  req: false,
+  reqd: false,
+}
+
+// Subtrees carrying user payload rather than schema. An active:true inside an
+// OpenAPI example is DATA, not a default, so default-pruning stops at these
+// keys and everything below them is passed through untouched.
+const PAYLOAD_KEYS = ['default', 'example', 'examples']
+
+function clean(o: any, dropDefaults?: boolean): any {
+  const prune = (node: any, defaults: boolean): any => {
+    if (Array.isArray(node)) {
+      return node.map((n: any) => prune(n, defaults))
+    }
+    if (null != node && 'object' === typeof node) {
+      const out: any = {}
+      for (const k of Object.keys(node)) {
+        if (MODEL_META.includes(k)) {
+          continue
+        }
+        if (defaults && k in CONFIG_DEFAULT && CONFIG_DEFAULT[k] === node[k]) {
+          continue
+        }
+        out[k] = prune(node[k], defaults && !PAYLOAD_KEYS.includes(k))
+      }
+      return out
     }
-    return v
-  })
+    return node
+  }
+  return prune(o, true === dropDefaults)
 }
 
 

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

@@ -72,6 +72,29 @@ declare(strict_types=1);
 
 class ${model.const.Name}Config
 {
+    /** @var array<string,mixed>|null */
+    private static ?array $shared_config = null;
+
+    /**
+     * Return the process-wide config, built once on first use. The SDK reads
+     * the config on every request and never writes to it, so one instance is
+     * shared by every client rather than rebuilt per client.
+     *
+     * PHP arrays are copy-on-write, so callers that do mutate the result get
+     * their own copy and cannot disturb the shared one.
+     */
+    public static function shared_config(): array
+    {
+        if (self::$shared_config === null) {
+            self::$shared_config = self::make_config();
+        }
+        return self::$shared_config;
+    }
+
+    /**
+     * Build a fresh, fully materialised config array. Every call rebuilds the
+     * whole structure, so prefer shared_config unless you need a private copy.
+     */
     public static function make_config(): array
     {
         return [
@@ -122,7 +145,7 @@ ${serverBlock}${authBlock}                "headers" => ${formatPhpArray(headers,
         name: n.name,
         op: n.op,
         relations: n.relations,
-      }), a), {}), 3)},
+      }, true), a), {}), 3)},
         ];
 `)
     }

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

@@ -137,7 +137,7 @@ ${hasList ? `
         $this->assertCount(3, $seen);
 
         // Inbound: streaming active -> yields each item from the feature.
-        $cfg = ${model.const.Name}Config::make_config();
+        $cfg = ${model.const.Name}Config::shared_config();
         if (isset($cfg["feature"]) && is_array($cfg["feature"]) && isset($cfg["feature"]["streaming"])) {
             $sdk = ${model.const.Name}SDK::test($seed, ["feature" => ["streaming" => ["active" => true]]]);
             $got = [];

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

@@ -17,6 +17,7 @@ class EntyClass
     private array $_data;
     private array $_match;
     private $_entctx;
+    private bool $_deleted = false;
 
     public function __construct($client, ?array $entopts = null)
     {
@@ -49,6 +50,27 @@ class EntyClass
         return $this->_name;
     }
 
+    /**
+     * A `remove` marks the entity deleted. The instance KEEPS the data it
+     * held — a caller can still read what was removed — but it is no longer a
+     * live record. See AGENTS.md "Entity operations return ENTITIES".
+     *
+     * The remove path below already called markDeleted(); php was the one
+     * target that never declared it (cpp and swift both do), so any SDK whose
+     * entities have a `remove` op raised "Call to undefined method
+     * <Entity>::markDeleted()" the first time a remove succeeded. Nothing
+     * caught it because the fatal only fires when that path actually runs.
+     */
+    public function markDeleted(): void
+    {
+        $this->_deleted = true;
+    }
+
+    public function deleted(): bool
+    {
+        return $this->_deleted;
+    }
+
     public function make(): self
     {
         $opts = $this->_entopts;

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

@@ -40,7 +40,7 @@ class ProjectNameSDK
         $utility = new ProjectNameUtility();
         $this->_utility = $utility;
 
-        $config = ProjectNameConfig::make_config();
+        $config = ProjectNameConfig::shared_config();
 
         $this->_rootctx = ($utility->make_context)([
             "client" => $this,

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

@@ -67,13 +67,64 @@ function formatPhpValue(val: any, indent: number = 0): string {
 }
 
 
-function clean(o: any) {
-  return walk(clone(o), (k: any, v: any, p: any) => {
-    if (null != k && k.endsWith('$')) {
-      delete p[k]
+// Emission-time normalisation of a model subtree (L0).
+//
+// Always drops jostraca's iteration metadata (`$`-suffixed keys: index$,
+// key$, val$). With `dropDefaults`, also drops keys whose value IS the
+// default the runtime already assumes when the key is absent, which is pure
+// payload — see CONFIG_DEFAULT.
+//
+// Rebuilds the tree rather than mutating during a walk. The previous
+// implementation walked a clone calling `delete p[k]`, but walk() assigns its
+// callback's result back over the child (`setprop(out, ckey, walk(...))`), so
+// the delete was undone on the way out and the helper silently did nothing.
+// Returning `undefined` from the callback does not fix it either: setprop
+// stores undefined rather than removing the key, which then emits as a null.
+//
+// `dropDefaults` is opt-in and must be passed ONLY for the entity subtree.
+// `active` means something different in feature config, where absent reads as
+// INACTIVE (see feature_init) — dropping `active: true` there would silently
+// disable the feature.
+// jostraca's iteration metadata, injected by each()/names() while it walks the
+// model. Listed explicitly rather than matched by trailing-dollar suffix: a
+// trailing dollar is not exclusive to jostraca -- Seneca uses entity$ as real
+// data -- so a blanket suffix match can silently drop a legitimate API field.
+const MODEL_META = ['index$', 'key$', 'val$']
+
+// Keys whose value IS the default the runtime already assumes when the key is
+// absent, so emitting them is pure payload.
+const CONFIG_DEFAULT: Record<string, any> = {
+  active: true,
+  req: false,
+  reqd: false,
+}
+
+// Subtrees carrying user payload rather than schema. An active:true inside an
+// OpenAPI example is DATA, not a default, so default-pruning stops at these
+// keys and everything below them is passed through untouched.
+const PAYLOAD_KEYS = ['default', 'example', 'examples']
+
+function clean(o: any, dropDefaults?: boolean): any {
+  const prune = (node: any, defaults: boolean): any => {
+    if (Array.isArray(node)) {
+      return node.map((n: any) => prune(n, defaults))
     }
-    return v
-  })
+    if (null != node && 'object' === typeof node) {
+      const out: any = {}
+      for (const k of Object.keys(node)) {
+        if (MODEL_META.includes(k)) {
+          continue
+        }
+        if (defaults && k in CONFIG_DEFAULT && CONFIG_DEFAULT[k] === node[k]) {
+          continue
+        }
+        out[k] = prune(node[k], defaults && !PAYLOAD_KEYS.includes(k))
+      }
+      return out
+    }
+    return node
+  }
+  return prune(o, true === dropDefaults)
 }
 
 

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

@@ -66,7 +66,30 @@ const Config = cmp(async function Config(props: any) {
     Content(`# ${model.const.Name} SDK configuration
 
 
+_shared_config = None
+
+
+def shared_config():
+    """Return the process-wide config, built once on first use.
+
+    The SDK reads the config on every request and never writes to it, so one
+    instance is shared by every client rather than rebuilt per client.
+
+    The returned dict is shared: treat it as read-only. Callers that need to
+    mutate should use make_config, which always returns a fresh copy.
+    """
+    global _shared_config
+    if _shared_config is None:
+        _shared_config = make_config()
+    return _shared_config
+
+
 def make_config():
+    """Build a fresh, fully materialised config dict.
+
+    Every call rebuilds the whole structure, so prefer shared_config unless
+    you need a private copy you intend to mutate.
+    """
     return {
         "main": {
             "name": "${model.const.Name}",
@@ -100,7 +123,7 @@ ${serverBlock}${authBlock}            "headers": ${formatPyDict(headers, 3)},
         name: n.name,
         op: n.op,
         relations: n.relations,
-      }), a), {}), 2)},
+      }, true), a), {}), 2)},
     }
 `)
   })

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

@@ -130,8 +130,8 @@ ${hasList ? `
         assert len(seen) == 3
 
         # Inbound: streaming active -> yields each item from the feature.
-        from ${model.const.Name.toLowerCase()}_sdk.config import make_config
-        cfg = make_config()
+        from ${model.const.Name.toLowerCase()}_sdk.config import shared_config
+        cfg = shared_config()
         if isinstance(cfg.get("feature"), dict) and "streaming" in cfg["feature"]:
             sdk = ${model.const.Name}SDK.test(
                 seed, {"feature": {"streaming": {"active": True}}})

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

@@ -23,8 +23,8 @@ class ProjectNameSDK:
         utility = ProjectNameUtility()
         self._utility = utility
 
-        from projectname_sdk.config import make_config
-        config = make_config()
+        from projectname_sdk.config import shared_config
+        config = shared_config()
 
         self._rootctx = utility.make_context({
             "client": self,

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

@@ -66,13 +66,64 @@ function formatPyValue(val: any, indent: number = 0): string {
 }
 
 
-function clean(o: any) {
-  return walk(clone(o), (k: any, v: any, p: any) => {
-    if (null != k && k.endsWith('$')) {
-      delete p[k]
+// Emission-time normalisation of a model subtree (L0).
+//
+// Always drops jostraca's iteration metadata (`$`-suffixed keys: index$,
+// key$, val$). With `dropDefaults`, also drops keys whose value IS the
+// default the runtime already assumes when the key is absent, which is pure
+// payload — see CONFIG_DEFAULT.
+//
+// Rebuilds the tree rather than mutating during a walk. The previous
+// implementation walked a clone calling `delete p[k]`, but walk() assigns its
+// callback's result back over the child (`setprop(out, ckey, walk(...))`), so
+// the delete was undone on the way out and the helper silently did nothing.
+// Returning `undefined` from the callback does not fix it either: setprop
+// stores undefined rather than removing the key, which then emits as a null.
+//
+// `dropDefaults` is opt-in and must be passed ONLY for the entity subtree.
+// `active` means something different in feature config, where absent reads as
+// INACTIVE (see feature_init) — dropping `active: true` there would silently
+// disable the feature.
+// jostraca's iteration metadata, injected by each()/names() while it walks the
+// model. Listed explicitly rather than matched by trailing-dollar suffix: a
+// trailing dollar is not exclusive to jostraca -- Seneca uses entity$ as real
+// data -- so a blanket suffix match can silently drop a legitimate API field.
+const MODEL_META = ['index$', 'key$', 'val$']
+
+// Keys whose value IS the default the runtime already assumes when the key is
+// absent, so emitting them is pure payload.
+const CONFIG_DEFAULT: Record<string, any> = {
+  active: true,
+  req: false,
+  reqd: false,
+}
+
+// Subtrees carrying user payload rather than schema. An active:true inside an
+// OpenAPI example is DATA, not a default, so default-pruning stops at these
+// keys and everything below them is passed through untouched.
+const PAYLOAD_KEYS = ['default', 'example', 'examples']
+
+function clean(o: any, dropDefaults?: boolean): any {
+  const prune = (node: any, defaults: boolean): any => {
+    if (Array.isArray(node)) {
+      return node.map((n: any) => prune(n, defaults))
     }
-    return v
-  })
+    if (null != node && 'object' === typeof node) {
+      const out: any = {}
+      for (const k of Object.keys(node)) {
+        if (MODEL_META.includes(k)) {
+          continue
+        }
+        if (defaults && k in CONFIG_DEFAULT && CONFIG_DEFAULT[k] === node[k]) {
+          continue
+        }
+        out[k] = prune(node[k], defaults && !PAYLOAD_KEYS.includes(k))
+      }
+      return out
+    }
+    return node
+  }
+  return prune(o, true === dropDefaults)
 }
 
 

package/project/.sdk/src/cmp/rb/Config_rb.ts

@@ -68,6 +68,20 @@ const Config = cmp(async function Config(props: any) {
     Content(`# ${model.const.Name} SDK configuration
 
 module ${model.const.Name}Config
+  # Return the process-wide config, built once on first use. The SDK reads
+  # the config on every request and never writes to it, so one instance is
+  # shared by every client rather than rebuilt per client.
+  #
+  # The returned hash is shared: treat it as read-only. Callers that need to
+  # mutate should use make_config, which always returns a fresh copy.
+  def self.shared_config
+    @shared_config ||= make_config
+  end
+
+
+  # Build a fresh, fully materialised config hash. Every call rebuilds the
+  # whole structure, so prefer shared_config unless you need a private copy
+  # you intend to mutate.
   def self.make_config
     {
       "main" => {
@@ -102,7 +116,7 @@ ${serverBlock}${authBlock}        "headers" => ${formatRubyHash(headers, 4)},
         name: n.name,
         op: n.op,
         relations: n.relations,
-      }), a), {}), 3)},
+      }, true), a), {}), 3)},
     }
   end
 

package/project/.sdk/src/cmp/rb/TestEntity_rb.ts

@@ -117,7 +117,7 @@ ${hasList ? `
     assert_equal 3, seen.length
 
     # Inbound: streaming active -> yields each item from the feature.
-    cfg = ${model.const.Name}Config.make_config
+    cfg = ${model.const.Name}Config.shared_config
     if cfg["feature"].is_a?(Hash) && cfg["feature"].key?("streaming")
       sdk = ${model.const.Name}SDK.test(seed, { "feature" => { "streaming" => { "active" => true } } })
       got = []

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

@@ -28,7 +28,7 @@ class ProjectNameSDK
     utility = ProjectNameUtility.new
     @_utility = utility
 
-    config = ProjectNameConfig.make_config
+    config = ProjectNameConfig.shared_config
 
     @_rootctx = utility.make_context.call({
       "client" => self,

package/project/.sdk/src/cmp/rb/utility_rb.ts

@@ -66,13 +66,64 @@ function formatRubyValue(val: any, indent: number = 0): string {
 }
 
 
-function clean(o: any) {
-  return walk(clone(o), (k: any, v: any, p: any) => {
-    if (null != k && k.endsWith('$')) {
-      delete p[k]
+// Emission-time normalisation of a model subtree (L0).
+//
+// Always drops jostraca's iteration metadata (`$`-suffixed keys: index$,
+// key$, val$). With `dropDefaults`, also drops keys whose value IS the
+// default the runtime already assumes when the key is absent, which is pure
+// payload — see CONFIG_DEFAULT.
+//
+// Rebuilds the tree rather than mutating during a walk. The previous
+// implementation walked a clone calling `delete p[k]`, but walk() assigns its
+// callback's result back over the child (`setprop(out, ckey, walk(...))`), so
+// the delete was undone on the way out and the helper silently did nothing.
+// Returning `undefined` from the callback does not fix it either: setprop
+// stores undefined rather than removing the key, which then emits as a null.
+//
+// `dropDefaults` is opt-in and must be passed ONLY for the entity subtree.
+// `active` means something different in feature config, where absent reads as
+// INACTIVE (see feature_init) — dropping `active: true` there would silently
+// disable the feature.
+// jostraca's iteration metadata, injected by each()/names() while it walks the
+// model. Listed explicitly rather than matched by trailing-dollar suffix: a
+// trailing dollar is not exclusive to jostraca -- Seneca uses entity$ as real
+// data -- so a blanket suffix match can silently drop a legitimate API field.
+const MODEL_META = ['index$', 'key$', 'val$']
+
+// Keys whose value IS the default the runtime already assumes when the key is
+// absent, so emitting them is pure payload.
+const CONFIG_DEFAULT: Record<string, any> = {
+  active: true,
+  req: false,
+  reqd: false,
+}
+
+// Subtrees carrying user payload rather than schema. An active:true inside an
+// OpenAPI example is DATA, not a default, so default-pruning stops at these
+// keys and everything below them is passed through untouched.
+const PAYLOAD_KEYS = ['default', 'example', 'examples']
+
+function clean(o: any, dropDefaults?: boolean): any {
+  const prune = (node: any, defaults: boolean): any => {
+    if (Array.isArray(node)) {
+      return node.map((n: any) => prune(n, defaults))
     }
-    return v
-  })
+    if (null != node && 'object' === typeof node) {
+      const out: any = {}
+      for (const k of Object.keys(node)) {
+        if (MODEL_META.includes(k)) {
+          continue
+        }
+        if (defaults && k in CONFIG_DEFAULT && CONFIG_DEFAULT[k] === node[k]) {
+          continue
+        }
+        out[k] = prune(node[k], defaults && !PAYLOAD_KEYS.includes(k))
+      }
+      return out
+    }
+    return node
+  }
+  return prune(o, true === dropDefaults)
 }
 
 

package/project/.sdk/src/cmp/rust/Config_rust.ts

@@ -70,7 +70,7 @@ const Config = cmp(async function Config(props: any) {
       name: n.name,
       op: n.op,
       relations: n.relations,
-    }), a), {})
+    }, true), a), {})
 
   const config = {
     main: { name: model.const.Name },

package/project/.sdk/src/cmp/rust/utility_rust.ts

@@ -85,13 +85,64 @@ function formatRustValue(val: any, indent: number = 0): string {
 
 
 // Deep-remove meta keys (`foo$`) from a model subtree (twin of go's clean).
-function clean(o: any) {
-  return walk(clone(o), (k: any, v: any, p: any) => {
-    if (null != k && k.endsWith('$')) {
-      delete p[k]
+// Emission-time normalisation of a model subtree (L0).
+//
+// Always drops jostraca's iteration metadata (`$`-suffixed keys: index$,
+// key$, val$). With `dropDefaults`, also drops keys whose value IS the
+// default the runtime already assumes when the key is absent, which is pure
+// payload — see CONFIG_DEFAULT.
+//
+// Rebuilds the tree rather than mutating during a walk. The previous
+// implementation walked a clone calling `delete p[k]`, but walk() assigns its
+// callback's result back over the child (`setprop(out, ckey, walk(...))`), so
+// the delete was undone on the way out and the helper silently did nothing.
+// Returning `undefined` from the callback does not fix it either: setprop
+// stores undefined rather than removing the key, which then emits as a null.
+//
+// `dropDefaults` is opt-in and must be passed ONLY for the entity subtree.
+// `active` means something different in feature config, where absent reads as
+// INACTIVE (see feature_init) — dropping `active: true` there would silently
+// disable the feature.
+// jostraca's iteration metadata, injected by each()/names() while it walks the
+// model. Listed explicitly rather than matched by trailing-dollar suffix: a
+// trailing dollar is not exclusive to jostraca -- Seneca uses entity$ as real
+// data -- so a blanket suffix match can silently drop a legitimate API field.
+const MODEL_META = ['index$', 'key$', 'val$']
+
+// Keys whose value IS the default the runtime already assumes when the key is
+// absent, so emitting them is pure payload.
+const CONFIG_DEFAULT: Record<string, any> = {
+  active: true,
+  req: false,
+  reqd: false,
+}
+
+// Subtrees carrying user payload rather than schema. An active:true inside an
+// OpenAPI example is DATA, not a default, so default-pruning stops at these
+// keys and everything below them is passed through untouched.
+const PAYLOAD_KEYS = ['default', 'example', 'examples']
+
+function clean(o: any, dropDefaults?: boolean): any {
+  const prune = (node: any, defaults: boolean): any => {
+    if (Array.isArray(node)) {
+      return node.map((n: any) => prune(n, defaults))
     }
-    return v
-  })
+    if (null != node && 'object' === typeof node) {
+      const out: any = {}
+      for (const k of Object.keys(node)) {
+        if (MODEL_META.includes(k)) {
+          continue
+        }
+        if (defaults && k in CONFIG_DEFAULT && CONFIG_DEFAULT[k] === node[k]) {
+          continue
+        }
+        out[k] = prune(node[k], defaults && !PAYLOAD_KEYS.includes(k))
+      }
+      return out
+    }
+    return node
+  }
+  return prune(o, true === dropDefaults)
 }
 
 

package/project/.sdk/src/cmp/scala/Config_scala.ts

@@ -70,7 +70,7 @@ const Config = cmp(async function Config(props: any) {
       name: n.name,
       op: n.op,
       relations: n.relations,
-    }), a), {})
+    }, true), a), {})
 
   const config = {
     main: { name: model.const.Name },

package/project/.sdk/src/cmp/scala/utility_scala.ts

@@ -65,13 +65,64 @@ function scalaVarName(name: string): string {
 
 
 // Strip model bookkeeping keys (ending in $) from a config subtree.
-function cleanModel(o: any) {
-  return walk(clone(o), (k: any, v: any, p: any) => {
-    if (null != k && k.endsWith('$')) {
-      delete p[k]
+// Emission-time normalisation of a model subtree (L0).
+//
+// Always drops jostraca's iteration metadata (`$`-suffixed keys: index$,
+// key$, val$). With `dropDefaults`, also drops keys whose value IS the
+// default the runtime already assumes when the key is absent, which is pure
+// payload — see CONFIG_DEFAULT.
+//
+// Rebuilds the tree rather than mutating during a walk. The previous
+// implementation walked a clone calling `delete p[k]`, but walk() assigns its
+// callback's result back over the child (`setprop(out, ckey, walk(...))`), so
+// the delete was undone on the way out and the helper silently did nothing.
+// Returning `undefined` from the callback does not fix it either: setprop
+// stores undefined rather than removing the key, which then emits as a null.
+//
+// `dropDefaults` is opt-in and must be passed ONLY for the entity subtree.
+// `active` means something different in feature config, where absent reads as
+// INACTIVE (see feature_init) — dropping `active: true` there would silently
+// disable the feature.
+// jostraca's iteration metadata, injected by each()/names() while it walks the
+// model. Listed explicitly rather than matched by trailing-dollar suffix: a
+// trailing dollar is not exclusive to jostraca -- Seneca uses entity$ as real
+// data -- so a blanket suffix match can silently drop a legitimate API field.
+const MODEL_META = ['index$', 'key$', 'val$']
+
+// Keys whose value IS the default the runtime already assumes when the key is
+// absent, so emitting them is pure payload.
+const CONFIG_DEFAULT: Record<string, any> = {
+  active: true,
+  req: false,
+  reqd: false,
+}
+
+// Subtrees carrying user payload rather than schema. An active:true inside an
+// OpenAPI example is DATA, not a default, so default-pruning stops at these
+// keys and everything below them is passed through untouched.
+const PAYLOAD_KEYS = ['default', 'example', 'examples']
+
+function cleanModel(o: any, dropDefaults?: boolean): any {
+  const prune = (node: any, defaults: boolean): any => {
+    if (Array.isArray(node)) {
+      return node.map((n: any) => prune(n, defaults))
+    }
+    if (null != node && 'object' === typeof node) {
+      const out: any = {}
+      for (const k of Object.keys(node)) {
+        if (MODEL_META.includes(k)) {
+          continue
+        }
+        if (defaults && k in CONFIG_DEFAULT && CONFIG_DEFAULT[k] === node[k]) {
+          continue
+        }
+        out[k] = prune(node[k], defaults && !PAYLOAD_KEYS.includes(k))
+      }
+      return out
     }
-    return v
-  })
+    return node
+  }
+  return prune(o, true === dropDefaults)
 }