@voxgig/sdkgen 3.4.6 → 3.5.0

package/project/.sdk/src/cmp/ocaml/Config_ocaml.ts

@@ -3,8 +3,11 @@ import {
   Content,
   File,
   cmp,
+  configDefinition,
+  configReprSetting,
   each,
   isAuthActive,
+  isConfigData,
   resolveAuthPrefix,
 } from '@voxgig/sdkgen'
 
@@ -17,7 +20,6 @@ import {
 
 
 import {
-  clean,
   formatOcamlValue,
   ocamlString,
 } from './utility_ocaml'
@@ -32,52 +34,52 @@ const Config = cmp(async function Config(props: any) {
 
   const model: Model = ctx$.model
 
-  const entity = getModelPath(model, `main.${KIT}.entity`)
   const feature = getModelPath(model, `main.${KIT}.feature`)
 
-  const headers = getModelPath(model, `main.${KIT}.config.headers`) || {}
+  // The canonical config OBJECT and its JSON, from the shared helper. Both
+  // representations render from the same `def`, so they cannot describe
+  // different configs - and this target picks up `options.server` (the OpenAPI
+  // server-variable defaults), which the hand-rolled build here omitted.
+  const { def: config, json: configJson } = configDefinition(model)
+  const asData = isConfigData(configJson, configReprSetting(model))
 
-  const authActive = isAuthActive(model)
-  const authPrefix = resolveAuthPrefix(model)
+  File({ name: 'sdk_config.' + target.ext }, () => {
 
-  let baseUrl = ''
-  try { baseUrl = getModelPath(model, `main.${KIT}.info.servers.0.url`) } catch (_e) { }
+    // ABOVE THE THRESHOLD: emit the model as DATA.
+    //
+    // The literal is one nested expression the compiler type-checks as a
+    // single item; a string is one token, and `Sdk_json.json_read` builds the
+    // same value tree at runtime. That reader used to live only in the corpus
+    // test harness - this rung is why it now lives in the runtime, and the
+    // harness uses it from there rather than keeping a second copy.
+    //
+    // No number-type question: `json_read` yields `Num (float)` and
+    // `formatOcamlValue` emits `(Num (5.))`, so both branches agree.
+    if (asData) {
+      Content(`(* Generated API configuration (mirrors go core/config.go).
+ *
+ * THE API MODEL, EMBEDDED AS DATA (sdkgen rung L1). Emitted only above a size
+ * threshold, or when main.kit.config.repr pins it: for a small model the
+ * literal is smaller and far easier to read when debugging.
+ *
+ * make_config () — the embedded API model as a voxgig struct value.
+ * make_feature name — the N-feature-safe factory the client uses. *)
 
-  const featureConfig: any = {}
-  each(feature, (f: any) => {
-    featureConfig[f.name] = f.config || {}
-  })
+open Voxgig_struct
+open Sdk_types
+open Sdk_helpers
+open Sdk_features
 
-  const entityOptions: any = {}
-  each(entity, (ent: any) => {
-    entityOptions[ent.name] = {}
-  })
+let config_data = "${ocamlString(configJson)}"
 
-  const options: any = {
-    base: baseUrl,
-    headers,
-    entity: entityOptions,
-  }
-  if (authActive) {
-    options.auth = { prefix: authPrefix }
-  }
-
-  const entityConfig = Object.values(entity || {}).reduce((a: any, n: any) => (
-    a[n.name] = clean({
-      fields: n.fields,
-      name: n.name,
-      op: n.op,
-      relations: n.relations,
-    }, true), a), {})
-
-  const config = {
-    main: { name: model.const.Name },
-    feature: featureConfig,
-    options,
-    entity: entityConfig,
-  }
+let make_config () : value =
+  Sdk_json.json_read config_data
 
-  File({ name: 'sdk_config.' + target.ext }, () => {
+let make_feature (name : string) : feature =
+  match name with
+`)
+    }
+    else {
 
     Content(`(* Generated API configuration (mirrors go core/config.go).
  *
@@ -95,6 +97,7 @@ let make_config () : value =
 let make_feature (name : string) : feature =
   match name with
 `)
+    }
 
     each(feature, (f: any) => {
       if (f.name !== 'base') {

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

@@ -110,6 +110,21 @@ sub make_config {
   return Voxgig::Struct::parse_json($CONFIG_JSON);
 }
 
+# SHARED CONFIG (sdkgen rung L2).
+#
+# 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
+# difference between parsing the embedded JSON once and once per client.
+#
+# The returned structure is SHARED: treat it as read-only. Callers that need to
+# mutate should use make_config, which always parses a fresh copy.
+my $SHARED_CONFIG;
+
+sub shared_config {
+  $SHARED_CONFIG = make_config() unless defined $SHARED_CONFIG;
+  return $SHARED_CONFIG;
+}
+
 sub make_feature {
   my ($name) = @_;
   require(Cwd::abs_path("$__dir/features.pm"));

package/project/.sdk/src/cmp/perl/fragment/Main.fragment.pm

@@ -41,7 +41,9 @@ sub new {
   my $utility = ProjectNameUtility->new;
   $self->{_utility} = $utility;
 
-  my $config = ProjectNameConfig::make_config();
+  # The process-wide config (sdkgen rung L2): read-only on the request path,
+  # so every client shares one rather than rebuilding it.
+  my $config = ProjectNameConfig::shared_config();
 
   $self->{_rootctx} = $utility->{make_context}->({
     'client' => $self,

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

@@ -89,6 +89,28 @@ pub fn make_config() -> Value {
     json_parse(CONFIG_DATA).expect("${model.const.Name}: embedded config is not valid JSON")
 }
 
+// SHARED CONFIG (sdkgen rung L2).
+//
+// 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. Above the
+// size threshold make_config re-parses the whole embedded JSON, so this is the
+// difference between parsing the model once and once per client.
+//
+// THREAD-LOCAL, not a global: Value is Rc/RefCell-backed and so is neither
+// Send nor Sync. One config per thread is the widest scope that is sound here,
+// and the clone is an Rc bump, not a deep copy.
+thread_local! {
+    static SHARED_CONFIG: Value = make_config();
+}
+
+/// The per-thread config, built once on first use.
+///
+/// The returned Value SHARES its nodes: treat it as read-only. Callers that
+/// need to mutate should use make_config, which always returns a fresh copy.
+pub fn shared_config() -> Value {
+    SHARED_CONFIG.with(|c| c.clone())
+}
+
 pub fn make_feature(name: &str) -> FeatureRef {
     match name {
 `)
@@ -107,6 +129,28 @@ pub fn make_config() -> Value {
     ${formatRustValue(config, 1)}
 }
 
+// SHARED CONFIG (sdkgen rung L2).
+//
+// 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. Above the
+// size threshold make_config re-parses the whole embedded JSON, so this is the
+// difference between parsing the model once and once per client.
+//
+// THREAD-LOCAL, not a global: Value is Rc/RefCell-backed and so is neither
+// Send nor Sync. One config per thread is the widest scope that is sound here,
+// and the clone is an Rc bump, not a deep copy.
+thread_local! {
+    static SHARED_CONFIG: Value = make_config();
+}
+
+/// The per-thread config, built once on first use.
+///
+/// The returned Value SHARES its nodes: treat it as read-only. Callers that
+/// need to mutate should use make_config, which always returns a fresh copy.
+pub fn shared_config() -> Value {
+    SHARED_CONFIG.with(|c| c.clone())
+}
+
 pub fn make_feature(name: &str) -> FeatureRef {
     match name {
 `)

package/project/.sdk/src/cmp/rust/fragment/Main.fragment.rs

@@ -3,7 +3,7 @@
 use std::cell::RefCell;
 use std::rc::Rc;
 
-use crate::core::config::{make_config, make_feature};
+use crate::core::config::{make_feature, shared_config};
 use crate::core::context::{Context, CtxSpec};
 use crate::core::error::ProjectNameError;
 use crate::core::helpers::{call_json, get_bool, get_str, getp, getpath, jo, setp, to_int, to_map};
@@ -31,7 +31,9 @@ impl ProjectNameSDK {
             rootctx: RefCell::new(None),
         });
 
-        let config = make_config();
+        // The per-thread config (sdkgen rung L2): read-only on the request
+        // path, so every client shares one rather than rebuilding it.
+        let config = shared_config();
 
         let rootctx = sdk.utility.make_context(
             CtxSpec {

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

@@ -93,6 +93,21 @@ object Config {
   def makeConfig(): JMap[String, Object] =
     Json.parse(configJson()).asInstanceOf[JMap[String, Object]]
 
+  // SHARED CONFIG (sdkgen rung L2).
+  //
+  // 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
+  // difference between parsing the embedded JSON once and once per client.
+  //
+  // A lazy val is initialised once, on first use, under a lock, so
+  // concurrent first calls build it exactly once.
+  //
+  // The returned map is SHARED: treat it as read-only. Callers that need to
+  // mutate should use makeConfig, which always parses a fresh copy.
+  private lazy val sharedConfigVal: JMap[String, Object] = makeConfig()
+
+  def sharedConfig(): JMap[String, Object] = sharedConfigVal
+
   def makeFeature(name: String): Feature = name match {
 `)
 

package/project/.sdk/src/cmp/swift/Config_swift.ts

@@ -101,6 +101,23 @@ ${configJson}
     return (try? JSON.parse(json))?.asMap ?? VMap()
   }
 
+  // SHARED CONFIG (sdkgen rung L2).
+  //
+  // 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
+  // difference between parsing the embedded JSON once and once per client.
+  //
+  // A static let in an enum is lazy and initialised exactly once, thread-safe
+  // via swift_once.
+  //
+  // The result is SHARED: treat it as read-only. Callers that need to mutate
+  // should use makeConfig, which always parses a fresh copy.
+  private static let sharedConfigVal: VMap = makeConfig()
+
+  public static func sharedConfig() -> VMap {
+    return sharedConfigVal
+  }
+
   public static func makeFeature(_ name: String) -> BaseFeature {
     switch name {
 `)

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

@@ -12,7 +12,9 @@ public final class ProjectNameSDK {
   public init(_ optionsIn: VMap? = nil) {
     utility = Utility()
 
-    let config = SdkConfig.makeConfig()
+    // The process-wide config (sdkgen rung L2): read-only on the request path,
+    // so every client shares one rather than rebuilding it.
+    let config = SdkConfig.sharedConfig()
 
     var ctxmap: [String: Any?] = [
       "client": self,

package/project/.sdk/src/cmp/zig/Config_zig.ts

@@ -79,6 +79,28 @@ pub fn make_config() Value {
         @panic("${model.const.Name}: embedded config is not valid JSON");
 }
 
+// SHARED CONFIG (sdkgen rung L2).
+//
+// 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. Above the
+// size threshold make_config re-parses the whole embedded JSON, so this is the
+// difference between parsing the model once and once per client.
+//
+// Value nodes are arena-allocated and reference-stable, so the shared value is
+// genuinely one structure, not a copy.
+var shared_config_val: ?Value = null;
+
+/// The process-wide config, built once on first use.
+///
+/// The returned Value SHARES its nodes: treat it as read-only. Callers that
+/// need to mutate should use make_config, which always returns a fresh copy.
+pub fn shared_config() Value {
+    if (shared_config_val) |c| return c;
+    const c = make_config();
+    shared_config_val = c;
+    return c;
+}
+
 pub fn make_feature(name: []const u8) Feature {
 `)
     }
@@ -96,6 +118,28 @@ pub fn make_config() Value {
     return ${formatZigValue(config, 1)};
 }
 
+// SHARED CONFIG (sdkgen rung L2).
+//
+// 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. Above the
+// size threshold make_config re-parses the whole embedded JSON, so this is the
+// difference between parsing the model once and once per client.
+//
+// Value nodes are arena-allocated and reference-stable, so the shared value is
+// genuinely one structure, not a copy.
+var shared_config_val: ?Value = null;
+
+/// The process-wide config, built once on first use.
+///
+/// The returned Value SHARES its nodes: treat it as read-only. Callers that
+/// need to mutate should use make_config, which always returns a fresh copy.
+pub fn shared_config() Value {
+    if (shared_config_val) |c| return c;
+    const c = make_config();
+    shared_config_val = c;
+    return c;
+}
+
 pub fn make_feature(name: []const u8) Feature {
 `)
     }

package/project/.sdk/src/cmp/zig/TestEntity_zig.ts

@@ -26,8 +26,15 @@ test "${method}_load_smoke" {
     const e = testsdk.${method}(vnull());
     const res = e.load(h.jo(&.{.{ "id", h.vstr("t01") }}), vnull());
     switch (res) {
-        .ok => |data| {
-            try std.testing.expect(std.mem.eql(u8, h.get_str(data, "id") orelse "", "t01"));
+        .ok => |ent| {
+            // EVERY operation resolves to the ENTITY, not the record: the
+            // payload of EntResult.ok is the entity pointer, and the record is
+            // reached through data(). Destructuring it as a Value was a
+            // compile error ("expected type 'struct.JsonValue', found
+            // '*entity.<name>.<Name>Entity'"), so no generated zig SDK with a
+            // loadable entity could build its own test suite.
+            const rec = ent.asEntity().data(null);
+            try std.testing.expect(std.mem.eql(u8, h.get_str(rec, "id") orelse "", "t01"));
         },
         .err => |er| {
             std.debug.print("${method} load failed: {s}\\n", .{er.msg});

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

@@ -22,7 +22,20 @@ const Spec = spec_mod.Spec;
 pub const ProjectNameSDK = struct {
     mode: []const u8 = "live",
     options: Value = .{ .null = {} },
-    utility: *Utility,
+    // NOT named `utility`, and NOT a name `zigVarName` can produce.
+    //
+    // Entity accessors are generated as methods on this same struct
+    // (MainEntity_zig), so an API with an entity called `utility` collided
+    // twice: Zig rejects a local binding that shadows the declaration, and
+    // `sdk.utility` resolves to the FIELD, which made the generated accessor
+    // unreachable.
+    //
+    // `zigVarName` lowercases every name it is given, so a field spelling with
+    // an uppercase letter is one no entity name can ever reach - which is why
+    // this is `sdkUtility` and not, say, `util_rt`, a name an entity called
+    // `util-rt` would map straight onto. The public reader is `get_utility()`,
+    // so this field is internal and free to be spelled this way.
+    sdkUtility: *Utility,
     features: std.ArrayList(Feature),
     rootctx: ?*Context = null,
 
@@ -31,22 +44,24 @@ pub const ProjectNameSDK = struct {
         sdk.* = .{
             .mode = "live",
             .options = h.vnull(),
-            .utility = Utility.new(),
+            .sdkUtility = Utility.new(),
             .features = std.ArrayList(Feature).init(h.A()),
             .rootctx = null,
         };
 
-        const cfg = config.make_config();
+        // The process-wide config (sdkgen rung L2): read-only on the request
+        // path, so every client shares one rather than rebuilding it.
+        const cfg = config.shared_config();
 
-        const rootctx = sdk.utility.make_context(CtxSpec{
+        const rootctx = sdk.sdkUtility.make_context(CtxSpec{
             .client = sdk,
-            .utility = sdk.utility,
+            .utility = sdk.sdkUtility,
             .config = cfg,
             .options = options,
             .shared = h.omap(),
         }, null);
 
-        const opts = sdk.utility.make_options(rootctx);
+        const opts = sdk.sdkUtility.make_options(rootctx);
         sdk.options = opts;
 
         if (h.veq(h.getpath(&.{ "feature", "test", "active" }, opts), h.vbool(true))) {
@@ -71,7 +86,7 @@ pub const ProjectNameSDK = struct {
                 const fopts = h.getp(feature_opts, fname);
                 if (fopts == .object) {
                     if (h.get_bool(fopts, "active") orelse false) {
-                        sdk.utility.feature_add(rootctx, config.make_feature(fname));
+                        sdk.sdkUtility.feature_add(rootctx, config.make_feature(fname));
                     }
                 }
             }
@@ -80,9 +95,9 @@ pub const ProjectNameSDK = struct {
         // Initialize features.
         var snap = std.ArrayList(Feature).init(h.A());
         for (sdk.features.items) |f| snap.append(f) catch {};
-        for (snap.items) |f| sdk.utility.feature_init(rootctx, f);
+        for (snap.items) |f| sdk.sdkUtility.feature_init(rootctx, f);
 
-        sdk.utility.feature_hook(rootctx, "PostConstruct");
+        sdk.sdkUtility.feature_hook(rootctx, "PostConstruct");
 
         return sdk;
     }
@@ -92,7 +107,7 @@ pub const ProjectNameSDK = struct {
     }
 
     pub fn get_utility(self: *ProjectNameSDK) *Utility {
-        return Utility.copy(self.utility);
+        return Utility.copy(self.sdkUtility);
     }
 
     pub fn get_root_ctx(self: *ProjectNameSDK) *Context {
@@ -100,7 +115,6 @@ pub const ProjectNameSDK = struct {
     }
 
     pub fn prepare(self: *ProjectNameSDK, fetchargs_in: Value) E!Value {
-        const utility = self.utility;
 
         const fetchargs: Value = switch (fetchargs_in) {
             .object => fetchargs_in,
@@ -112,7 +126,7 @@ pub const ProjectNameSDK = struct {
             else => h.omap(),
         };
 
-        const ctx = utility.make_context(CtxSpec{
+        const ctx = self.sdkUtility.make_context(CtxSpec{
             .opname = "prepare",
             .ctrl = ctrl,
         }, self.get_root_ctx());
@@ -134,7 +148,7 @@ pub const ProjectNameSDK = struct {
             else => h.omap(),
         };
 
-        const headers = utility.prepare_headers(ctx);
+        const headers = self.sdkUtility.prepare_headers(ctx);
 
         const specmap = h.jo(&.{
             .{ "base", h.getp(options, "base") },
@@ -158,9 +172,9 @@ pub const ProjectNameSDK = struct {
             while (it.next()) |kv| h.setp(spec.headers, kv.key_ptr.*, kv.value_ptr.*);
         }
 
-        _ = try utility.prepare_auth(ctx);
+        _ = try self.sdkUtility.prepare_auth(ctx);
 
-        return utility.make_fetch_def(ctx);
+        return self.sdkUtility.make_fetch_def(ctx);
     }
 
     // Raw endpoint access is operator-controllable, like every entity op.
@@ -200,7 +214,6 @@ pub const ProjectNameSDK = struct {
     // a caller-supplied marker would let anyone opt straight back out of the
     // gate by passing it.
     fn raw_request(self: *ProjectNameSDK, fetchargs_in: Value) Value {
-        const utility = self.utility;
 
         const fetchdef = self.prepare(fetchargs_in) catch {
             return h.jo(&.{
@@ -218,13 +231,13 @@ pub const ProjectNameSDK = struct {
             else => h.omap(),
         };
 
-        const ctx = utility.make_context(CtxSpec{
+        const ctx = self.sdkUtility.make_context(CtxSpec{
             .opname = "direct",
             .ctrl = ctrl,
         }, self.get_root_ctx());
 
         const url = h.get_str(fetchdef, "url") orelse "";
-        const fetched = utility.fetch(ctx, url, fetchdef) catch {
+        const fetched = self.sdkUtility.fetch(ctx, url, fetchdef) catch {
             return h.jo(&.{
                 .{ "ok", h.vbool(false) },
                 .{ "err", h.vstr(if (ctx.pending_err) |e| e.msg else "fetch failed") },

package/project/.sdk/tm/c/core/sdk.h

@@ -445,6 +445,7 @@ voxgig_value* sdk_graphql(ProjectNameSDK* sdk, const char* query,
 
 // Generated config (core/config.c).
 voxgig_value* make_config(void);
+voxgig_value* shared_config(void);
 Feature* make_feature(const char* name);
 
 // ===========================================================================

package/project/.sdk/tm/c/utility/make_options.c

@@ -82,7 +82,11 @@ voxgig_value* make_options_util(Context* ctx) {
   // Preserve system.fetch before merge/validate (validation strips it).
   voxgig_value* sys_fetch = getpath2(opts, "system", "fetch");
 
-  voxgig_value* mergelist = clist(3, v_map(), v_share(cfgopts), v_share(opts));
+  /* CLONE the config side, do not v_share it: `config` is a process-wide
+   * singleton (shared_config) and merge uses its nested maps as merge TARGETS,
+   * so sharing lets one client's options (headers, server, ...) be written into
+   * the shared config and inherited by every client built afterwards. */
+  voxgig_value* mergelist = clist(3, v_map(), voxgig_clone(cfgopts), v_share(opts));
   voxgig_value* merged = voxgig_merge(mergelist, VOXGIG_MAXDEPTH);
   voxgig_value* validated = voxgig_validate(merged, optspec, NULL);
   if (voxgig_is_map(validated)) {

package/project/.sdk/tm/clojure/src/sdk/core.clj

@@ -80,7 +80,16 @@
                   (aset pos 0 (inc (aget pos 0))))
                 (let [tok (subs s start (aget pos 0))]
                   (if (or (.contains tok ".") (.contains tok "e") (.contains tok "E"))
-                    (Double/parseDouble tok) (Long/parseLong tok)))))]
+                    (Double/parseDouble tok)
+                    ;; A JSON integer may exceed the signed 64-bit range - an
+                    ;; OpenAPI `default`/`example` can carry any integer. The
+                    ;; Clojure reader gives the literal branch a BigInt for
+                    ;; such a token, so parseLong alone would make the two
+                    ;; representations disagree by throwing on input the
+                    ;; literal accepts.
+                    (try (Long/parseLong tok)
+                         (catch NumberFormatException _
+                           (bigint (java.math.BigInteger. tok))))))))]
       (parse-val))))
 
 ;; ---------------------------------------------------------------------------
@@ -928,11 +937,50 @@
                    "utility" (vs/jm)
                    "system" (vs/jm)
                    "test" (vs/jm "active" false "entity" (vs/jm "`$OPEN`" true))
-                   "clean" (vs/jm "keys" "key,token,id"))
+                   "clean" (vs/jm "keys" "key,token,id")
+                   ;; Server-variable values for a templated base URL (OpenAPI
+                   ;; server variables): {name} placeholders in "base" are
+                   ;; substituted from this map at construction. Spec defaults
+                   ;; arrive via the generated config; user values override
+                   ;; them. Mirrors go's make_options optspec.
+                   "server" (vs/jm "`$CHILD`" ""))
           sys-fetch (vs/getpath opts0 "system.fetch")
           merged (vs/merge (vs/jt (vs/jm) cfgopts opts0))
           validated (vs/validate merged optspec)
-          opts (if (vs/ismap validated) validated (vs/jm))]
+          opts (if (vs/ismap validated) validated (vs/jm))
+          ;; Resolve a templated base URL (e.g. https://{tenant_id}.hanko.io).
+          ;; Every placeholder must resolve to a non-empty value: from
+          ;; options["server"] (user), else the config default. A placeholder
+          ;; that resolves to "" is a construction ERROR in live mode - the URL
+          ;; cannot work - but in test mode substitutes the deterministic value
+          ;; "test-<name>" so offline tests need no configuration.
+          ;;
+          ;; Accepting `server` in the option spec without this is a trap: the
+          ;; option validates and is then ignored, so a templated URL still
+          ;; reaches the wire with a literal {name} in it.
+          base (vs/getprop opts "base")
+          _ (when (and (string? base) (.contains ^String base "{"))
+              (let [testmode (or (true? (vs/getpath opts "test.active"))
+                                 (true? (vs/getpath opts "feature.test.active")))
+                    server (let [s (vs/getprop opts "server")]
+                             (if (vs/ismap s) s (vs/jm)))
+                    sdkname (let [n (vs/getpath config "main.name")]
+                              (if (and (string? n) (seq n)) n "SDK"))
+                    resolved (clojure.string/replace
+                               base #"\{([A-Za-z0-9_]+)\}"
+                               (fn [[_ name]]
+                                 (let [v (vs/getprop server name)
+                                       v (if (string? v) v "")]
+                                   (cond
+                                     (seq v) v
+                                     testmode (str "test-" name)
+                                     :else
+                                     (throw (IllegalArgumentException.
+                                              (str sdkname ": the server variable '" name
+                                                   "' is required: the API base URL is '" base
+                                                   "' - pass {\"server\" {\"" name "\" \"...\"}}"
+                                                   " in the SDK options")))))))]
+                (vs/setprop opts "base" resolved)))]
       (when sys-fetch
         (when (not (vs/ismap (vs/getprop opts "system"))) (.put ^java.util.Map opts "system" (vs/jm)))
         (.put ^java.util.Map (vs/getprop opts "system") "fetch" sys-fetch))

package/project/.sdk/tm/cpp/core/types.hpp

@@ -53,6 +53,7 @@ using OpMapPtr = std::shared_ptr<OpMap>;
 
 // Generated (core/config.hpp) — the embedded API config + feature factory.
 inline Value makeConfig();
+inline const Value& sharedConfig();
 inline FeaturePtr makeFeature(const std::string& name);
 
 // Defined in utility/pipeline.hpp; wires the Utility function fields.
@@ -781,7 +782,9 @@ inline SdkErrorPtr Context::makeError(const std::string& code, const std::string
 inline SdkClient::SdkClient(const Value& options_) {
   utility = std::make_shared<Utility>();
 
-  Value config = makeConfig();
+  // The process-wide config (sdkgen rung L2): read-only on the request path,
+  // so every client shares one rather than rebuilding it.
+  Value config = sharedConfig();
 
   CtxSpec cs;
   cs.client = this;

package/project/.sdk/tm/cpp/utility/pipeline.hpp

@@ -1095,7 +1095,11 @@ inline Value makeOptions(CtxPtr ctx) {
   // dropped by validate).
   Value sysFetch = Struct::getpath(opts, {"system", "fetch"});
 
-  Value mergeList = vlist({vmap(), cfgopts, opts});
+  // CLONE the config side: `config` is a process-wide singleton (sharedConfig)
+  // and merge uses its nested maps as merge TARGETS, so without this one
+  // client's options (headers, server, ...) are written into the shared config
+  // and inherited by every client constructed afterwards.
+  Value mergeList = vlist({vmap(), Struct::clone(cfgopts), opts});
   Value merged = Struct::merge(mergeList);
 
   Value vopts = vmap();

package/project/.sdk/tm/csharp/test/PipelineTest.cs

@@ -150,6 +150,21 @@ public class PipelineTest
         }
 
         public object? Match(object? match = null) => null;
+
+        // The deletion half of the entity contract, mirroring
+        // ProjectNameEntityBase: `remove` marks the instance, which keeps the
+        // data it held but is no longer a live record.
+        private bool _deleted = false;
+
+        public void MarkDeleted()
+        {
+            this._deleted = true;
+        }
+
+        public bool Deleted()
+        {
+            return this._deleted;
+        }
     }
 
     // --- MakeResponse -------------------------------------------------------