@voxgig/sdkgen 3.4.7 → 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

@@ -49,7 +49,9 @@ pub const ProjectNameSDK = struct {
             .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.sdkUtility.make_context(CtxSpec{
             .client = sdk,

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 -------------------------------------------------------

package/project/.sdk/tm/csharp/utility/MakeOptions.cs

@@ -1,12 +1,20 @@
 // ProjectName SDK utility: makeOptions - merge, validate and derive the
 // client options.
 
+using System.Text.RegularExpressions;
+
 using Voxgig.Struct;
 
 namespace ProjectNameSdk.Util;
 
 public static partial class SdkUtility
 {
+    // {name} placeholders in a templated server URL (OpenAPI server
+    // variables). Compiled once: MakeOptions runs per client construction.
+    private static readonly Regex ServerVarRe =
+        new(@"\{([A-Za-z0-9_]+)\}", RegexOptions.Compiled);
+
+
     internal static Dictionary<string, object?> MakeOptionsUtil(Context ctx)
     {
         var options = ctx.Options ?? new Dictionary<string, object?>();
@@ -73,6 +81,14 @@ public static partial class SdkUtility
             {
                 ["`$CHILD`"] = "`$STRING`",
             },
+            // OpenAPI server-variable defaults, carried by the generated
+            // config whenever the spec's server URL is templated. Accepted
+            // here so validation does not reject the SDK's own config; the
+            // {name} substitution into base is a separate concern.
+            ["server"] = new Dictionary<string, object?>
+            {
+                ["`$CHILD`"] = "",
+            },
             ["allow"] = new Dictionary<string, object?>
             {
                 ["method"] = "GET,PUT,POST,PATCH,DELETE,OPTIONS",
@@ -118,12 +134,62 @@ public static partial class SdkUtility
         var merged = StructUtils.Merge(new List<object?>
         {
             new Dictionary<string, object?>(),
-            cfgopts,
+            // CLONE the config side. `config` is a process-wide singleton
+            // (SdkConfig.SharedConfig), and Merge uses its nested maps as
+            // merge TARGETS - without this, one client's options (headers,
+            // server, ...) are written into the shared config and inherited by
+            // every client constructed afterwards.
+            StructUtils.Clone(cfgopts),
             opts,
         });
         var validated = StructUtils.Validate(merged, optspec);
         opts = validated as Dictionary<string, object?> ?? new Dictionary<string, object?>();
 
+        // 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. The SDK
+        // constructor has no error return, so a missing required variable
+        // THROWS: this is construction-time misconfiguration.
+        if (opts.TryGetValue("base", out var baseRaw) && baseRaw is string baseUrl &&
+            baseUrl.Contains('{'))
+        {
+            var testmode =
+                StructUtils.GetPath(opts, StructUtils.Jt("test", "active")) is bool ta && ta ||
+                StructUtils.GetPath(opts, StructUtils.Jt("feature", "test", "active"))
+                    is bool fa && fa;
+
+            var server = opts.TryGetValue("server", out var sv) &&
+                sv is Dictionary<string, object?> svm
+                ? svm : new Dictionary<string, object?>();
+
+            var sdkname = StructUtils.GetPath(config, StructUtils.Jt("main", "name"))
+                is string mn && mn != "" ? mn : "SDK";
+
+            opts["base"] = ServerVarRe.Replace(baseUrl, m =>
+            {
+                var name = m.Groups[1].Value;
+                var val = server.TryGetValue(name, out var v) && v is string s ? s : "";
+                if (val == "")
+                {
+                    if (testmode)
+                    {
+                        return "test-" + name;
+                    }
+                    throw new ProjectNameError("server_var_required",
+                        sdkname + ": the server variable '" + name + "' is required: " +
+                        "the API base URL is '" + baseUrl + "' - pass " +
+                        "new Dictionary<string, object?> { [\"server\"] = new " +
+                        "Dictionary<string, object?> { [\"" + name + "\"] = \"...\" } } " +
+                        "in the SDK options",
+                        ctx);
+                }
+                return val;
+            });
+        }
+
         // Restore system.fetch.
         if (sysFetch != null)
         {