@voxgig/sdkgen 2.0.1 → 3.0.0

package/project/.sdk/tm/lean/src/SdkUtility.lean

@@ -231,13 +231,13 @@ def prepareQuery (ctx : Value) : SIO Value := do
     if !(isNov v) && !(names.contains k) then sp out k v
   pure out
 
+/-- Assemble the path template from `point.parts`. This is `struct.join` with
+the url flag — NOT a plain intercalate: empty segments are dropped (a doubled
+slash changes the URL and 404s on strict routers) and there is no leading
+slash, because makeUrl joins base/prefix/path/suffix with `joinurl`. -/
 def preparePath (ctx : Value) : SIO String := do
   let point ← gp ctx "point"
-  match (← gp point "parts") with
-  | .list i => do
-    let segs := (← listItems i).map vs
-    pure ("/" ++ String.intercalate "/" segs.toList)
-  | _ => pure ""
+  join (← gp point "parts") (sep := .str "/") (url := true)
 
 /-- The API definition is authoritative: a POST-only or PATCH-based API
 exposes `update` as POST or PATCH, not the PUT the op name implies. Only
@@ -396,9 +396,11 @@ def graphqlBody (ctx : Value) : SIO Value := do
       match spec with
       | .map _ => do
         let name ← gpS spec "name"
-        let from ← gpS spec "from"
+        -- `from` is a Lean keyword, so the binding cannot take the field's
+        -- own name.
+        let varFrom ← gpS spec "from"
         if name != "" then
-          if from == "" then do
+          if varFrom == "" then do
             -- The input object IS the request body. Strip the action
             -- selector, which is an SDK-side point discriminator, not an API
             -- field.
@@ -409,8 +411,8 @@ def graphqlBody (ctx : Value) : SIO Value := do
           else do
             -- Only send variables the caller actually supplied: sending an
             -- explicit null would clear a field on many APIs.
-            let v0 ← gp reqsrc from
-            let v ← if isNullish v0 then gp datasrc from else pure v0
+            let v0 ← gp reqsrc varFrom
+            let v ← if isNullish v0 then gp datasrc varFrom else pure v0
             if !(isNullish v) then sp variables name v
       | _ => pure ()
     newMap #[("query", ← gp gql "doc"), ("variables", variables)]

package/project/.sdk/tm/lean/test/TFeature.lean

@@ -56,30 +56,42 @@ def onOpts (extra : Array (String × Value)) : SIO Value := do
 def bucketOf (client : Value) (name : String) : SIO Value := do
   gp (← gp client "track") name
 
+/-- Does the entity declare this op? -/
+def hasOp (e : Value) (opname : String) : SIO Bool := do
+  match (← gp (← gp e "op") opname) with
+  | .map _ => pure true
+  | _ => pure false
+
 /-- The first entity that has a `list` op AND generated seed data: the feature
-    suite is entity-agnostic, so it discovers its subject from the config. -/
-def findSubject : SIO (Option (String × Value)) := do
+    suite is entity-agnostic, so it discovers its subject from the config.
+    Returns whether the subject also has `create` — the idempotency check is
+    the one case that mutates, and a list-only entity (an API with a read-only
+    collection) has no create ENDPOINT, so calling it raises rather than
+    exercising the feature. Entities carrying both are preferred, so a model
+    that has one keeps the mutating coverage. -/
+def findSubject : SIO (Option (String × Value × Bool)) := do
   let config ← SdkJson.jsonRead SdkConfig.configJson
   let ents ← gp config "entity"
+  let mut fallback : Option (String × Value × Bool) := none
   for name in (← keysof ents) do
     let e ← gp ents name
-    let hasList ← (match (← gp (← gp e "op") "list") with
-      | .map _ => pure true
-      | _ => pure false)
-    if hasList then
+    if ← hasOp e "list" then
       let Name := name.capitalize
       let seedPath := "../.sdk/test/entity/" ++ name ++ "/" ++ Name ++ "TestData.json"
       if ← System.FilePath.pathExists seedPath then
         let seed ← SdkJson.jsonRead (← IO.FS.readFile seedPath)
-        return some (name, seed)
-  pure none
+        if ← hasOp e "create" then
+          return some (name, seed, true)
+        if fallback.isNone then
+          fallback := some (name, seed, false)
+  pure fallback
 
 def main : IO UInt32 := do
   let sctx ← mkCtx
   let go : SIO Unit := do
     match (← findSubject) with
     | none => IO.println "skip - no entity with list op and seed data"
-    | some (ent, seed) => do
+    | some (ent, seed, hasCreate) => do
     let mt ← emptyMap
 
     -- log: counts requests
@@ -141,11 +153,12 @@ def main : IO UInt32 := do
       let _ ← SdkRuntime.opList c ent mt mt
       let b0 ← bucketOf c "idempotency"
       check ((← numAt b0 "issued") == 0.0) "idempotency: no key for a read op"
-      let d ← newMap #[("name", .str "idem")]
-      let _ ← SdkRuntime.opCreate c ent d mt
-      let b ← bucketOf c "idempotency"
-      check ((← numAt b "issued") == 1.0) "idempotency: issues a key for create"
-      check ((← gpS b "last") != "") "idempotency: records the issued key")
+      if hasCreate then
+        let d ← newMap #[("name", .str "idem")]
+        let _ ← SdkRuntime.opCreate c ent d mt
+        let b ← bucketOf c "idempotency"
+        check ((← numAt b "issued") == 1.0) "idempotency: issues a key for create"
+        check ((← gpS b "last") != "") "idempotency: records the issued key")
 
     -- clienttrack: request/session headers and a request count
     (do

package/project/.sdk/tm/lean/test/TPrimaryUtility.lean

@@ -306,9 +306,12 @@ def main : IO UInt32 := do
     -- The remaining corpus sections. They carry no cases in this project's
     -- corpus, but are driven here so any future fixture runs against Lean too.
 
+    -- clean takes (ctx, val), so the fixture supplies `args`, not `in` —
+    -- same shape as param/makeError above.
     runset "clean" (← getSpec primary #["clean", "basic"]) fun entry => do
-      let ctx ← entryCtx entry opts config
-      pure ((← SdkUtility.clean ctx (← SdkUtility.gp entry "in")), none)
+      let args ← SdkUtility.gp entry "args"
+      let ctx ← mapCtx entry (← argAt args 0) opts config
+      pure ((← SdkUtility.clean ctx (← argAt args 1)), none)
 
     runset "makeResult" (← getSpec primary #["makeResult", "basic"]) fun entry => do
       pure ((← SdkUtility.makeResult (← entryCtx entry opts config)), none)

package/project/.sdk/tm/lua/test/runner.lua

@@ -35,8 +35,8 @@ end
 
 
 function runner.env_override(m)
-  local live = runner.getenv("PROJECTNAME_TEST_LIVE")
-  local override = runner.getenv("PROJECTNAME_TEST_OVERRIDE")
+  local live = runner.getenv("PROJECTENV_TEST_LIVE")
+  local override = runner.getenv("PROJECTENV_TEST_OVERRIDE")
 
   if live == "TRUE" or override == "TRUE" then
     for key, _ in pairs(m) do
@@ -56,9 +56,9 @@ function runner.env_override(m)
     end
   end
 
-  local explain = runner.getenv("PROJECTNAME_TEST_EXPLAIN")
+  local explain = runner.getenv("PROJECTENV_TEST_EXPLAIN")
   if explain ~= nil and explain ~= "" then
-    m["PROJECTNAME_TEST_EXPLAIN"] = explain
+    m["PROJECTENV_TEST_EXPLAIN"] = explain
   end
 
   return m

package/project/.sdk/tm/lua/utility/make_error.lua

@@ -57,6 +57,10 @@ local function make_error_util(ctx, err)
   sdk_err.result = ctx.utility.clean(ctx, result)
   sdk_err.spec = ctx.utility.clean(ctx, spec)
 
+  -- Promote the HTTP status to the top level, so a consumer can branch on
+  -- `err.status` instead of reaching into `err.result`.
+  sdk_err.status = result.status or -1
+
   if type(err) == "table" and getmetatable(err) == ProjectNameError then
     sdk_err.code = err.code
   end

package/project/.sdk/tm/ocaml/VERSION

@@ -1 +1 @@
-0.0.1
+PROJECTVERSION

package/project/.sdk/tm/ocaml/sdk_types.ml

@@ -199,11 +199,20 @@ and entity_obj = {
   mutable e_data_get : unit -> value;
   mutable e_match_set : value -> unit;
   mutable e_match_get : unit -> value;
-  mutable e_load : value -> value -> value;
-  mutable e_list : value -> value -> value;
-  mutable e_create : value -> value -> value;
-  mutable e_update : value -> value -> value;
-  mutable e_remove : value -> value -> value;
+  (* Every operation resolves to the ENTITY, not the raw record - e_list to
+   * one per record. The record is reached through e_data_get. `value` is a
+   * closed data union with no slot for an entity, so the CONTRACT lives in
+   * these signatures. See AGENTS.md "Entity operations return ENTITIES". *)
+  mutable e_load : value -> value -> entity_obj;
+  mutable e_list : value -> value -> entity_obj list;
+  mutable e_create : value -> value -> entity_obj;
+  mutable e_update : value -> value -> entity_obj;
+  mutable e_remove : value -> value -> entity_obj;
+  (* e_remove resolves to the entity, marked. The instance KEEPS the data it
+   * held - a caller can still read what was deleted - but it is no longer a
+   * live record. *)
+  mutable e_deleted : bool;
+  mutable e_mark_deleted : unit -> unit;
   (* stream action args callopts -> a lazy Seq over result items. *)
   mutable e_stream : string -> value -> value -> value Seq.t;
 }

package/project/.sdk/tm/ocaml/test/t_pipeline.ml

@@ -37,8 +37,11 @@ let make_factory (cl : sdk_client) (made : value list ref) : entity_obj =
     e_entctx = rootctx; e_make = (fun () -> child ());
     e_data_set = (fun d -> made := !made @ [d]); e_data_get = (fun () -> empty_map ());
     e_match_set = (fun _ -> ()); e_match_get = (fun () -> empty_map ());
-    e_load = (fun _ _ -> Noval); e_list = (fun _ _ -> Noval); e_create = (fun _ _ -> Noval);
-    e_update = (fun _ _ -> Noval); e_remove = (fun _ _ -> Noval);
+    (* Ops resolve to the ENTITY (see Sdk_types); this fake never runs them. *)
+    e_load = (fun _ _ -> failwith "unused"); e_list = (fun _ _ -> []);
+    e_create = (fun _ _ -> failwith "unused");
+    e_update = (fun _ _ -> failwith "unused"); e_remove = (fun _ _ -> failwith "unused");
+    e_deleted = false; e_mark_deleted = (fun () -> ());
     e_stream = (fun _ _ _ -> Seq.empty);
   } in
   child ()

package/project/.sdk/tm/perl/t/runner.pm

@@ -44,8 +44,8 @@ sub getenv {
 
 sub env_override {
   my ($m) = @_;
-  my $live = getenv('PROJECTNAME_TEST_LIVE');
-  my $override = getenv('PROJECTNAME_TEST_OVERRIDE');
+  my $live = getenv('PROJECTENV_TEST_LIVE');
+  my $override = getenv('PROJECTENV_TEST_OVERRIDE');
 
   if ((defined $live && 'TRUE' eq $live)
     || (defined $override && 'TRUE' eq $override)) {
@@ -65,8 +65,8 @@ sub env_override {
     }
   }
 
-  my $explain = getenv('PROJECTNAME_TEST_EXPLAIN');
-  $m->{'PROJECTNAME_TEST_EXPLAIN'} = $explain if defined $explain && '' ne $explain;
+  my $explain = getenv('PROJECTENV_TEST_EXPLAIN');
+  $m->{'PROJECTENV_TEST_EXPLAIN'} = $explain if defined $explain && '' ne $explain;
 
   return $m;
 }

package/project/.sdk/tm/php/VERSION

@@ -1 +1 @@
-0.0.1
+PROJECTVERSION

package/project/.sdk/tm/php/test/Runner.php

@@ -43,8 +43,8 @@ class ProjectNameTestRunner
 
     public static function env_override(array $m): array
     {
-        $live = self::getenv('PROJECTNAME_TEST_LIVE');
-        $override = self::getenv('PROJECTNAME_TEST_OVERRIDE');
+        $live = self::getenv('PROJECTENV_TEST_LIVE');
+        $override = self::getenv('PROJECTENV_TEST_OVERRIDE');
 
         if ($live === 'TRUE' || $override === 'TRUE') {
             foreach (array_keys($m) as $key) {
@@ -63,9 +63,9 @@ class ProjectNameTestRunner
             }
         }
 
-        $explain = self::getenv('PROJECTNAME_TEST_EXPLAIN');
+        $explain = self::getenv('PROJECTENV_TEST_EXPLAIN');
         if ($explain !== null && $explain !== '') {
-            $m['PROJECTNAME_TEST_EXPLAIN'] = $explain;
+            $m['PROJECTENV_TEST_EXPLAIN'] = $explain;
         }
 
         return $m;

package/project/.sdk/tm/php/utility/MakeError.php

@@ -45,6 +45,11 @@ class ProjectNameMakeError
         $sdk_err = new ProjectNameError('', $msg, $ctx);
         $sdk_err->result = ($ctx->utility->clean)($ctx, $result);
         $sdk_err->spec = ($ctx->utility->clean)($ctx, $spec);
+
+        // Promote the HTTP status to the top level, so a consumer can branch
+        // on `err->status` / `err->notFound()` rather than reaching into
+        // `err->result`.
+        $sdk_err->status = null === $result->status ? -1 : (int)$result->status;
         if ($err instanceof ProjectNameError) {
             $sdk_err->sdk_code = $err->sdk_code;
         }

package/project/.sdk/tm/py/pkg/utility/make_error.py

@@ -53,6 +53,10 @@ def make_error_util(ctx, err):
     sdk_err.result = ctx.utility.clean(ctx, result)
     sdk_err.spec = ctx.utility.clean(ctx, spec)
 
+    # Promote the HTTP status to the top level, so a consumer can branch on
+    # `err.status` / `err.not_found` instead of reaching into `err.result`.
+    sdk_err.status = -1 if result.status is None else result.status
+
     if isinstance(err, ProjectNameError):
         sdk_err.code = err.code
 

package/project/.sdk/tm/py/test/runner.py

@@ -38,8 +38,8 @@ class ProjectNameTestRunner:
 
     @staticmethod
     def env_override(m):
-        live = ProjectNameTestRunner.getenv("PROJECTNAME_TEST_LIVE")
-        override = ProjectNameTestRunner.getenv("PROJECTNAME_TEST_OVERRIDE")
+        live = ProjectNameTestRunner.getenv("PROJECTENV_TEST_LIVE")
+        override = ProjectNameTestRunner.getenv("PROJECTENV_TEST_OVERRIDE")
 
         if live == "TRUE" or override == "TRUE":
             for key in list(m.keys()):
@@ -56,9 +56,9 @@ class ProjectNameTestRunner:
                             pass
                     m[key] = envval
 
-        explain = ProjectNameTestRunner.getenv("PROJECTNAME_TEST_EXPLAIN")
+        explain = ProjectNameTestRunner.getenv("PROJECTENV_TEST_EXPLAIN")
         if explain is not None and explain != "":
-            m["PROJECTNAME_TEST_EXPLAIN"] = explain
+            m["PROJECTENV_TEST_EXPLAIN"] = explain
 
         return m
 
@@ -111,6 +111,17 @@ class ProjectNameTestRunner:
         return 500
 
     @staticmethod
+    def entity_data(v):
+        """Extract the data map from an op result.
+
+        Every entity operation resolves to the ENTITY (see AGENTS.md), so a
+        flow test that wants the record takes this hop. A plain dict passes
+        through unchanged.
+        """
+        if hasattr(v, "data_get") and callable(v.data_get):
+            return v.data_get()
+        return v
+
     def entity_list_to_data(lst):
         out = []
         for item in lst:
@@ -134,6 +145,10 @@ def env_override(m):
     return ProjectNameTestRunner.env_override(m)
 
 
+def entity_data(v):
+    return ProjectNameTestRunner.entity_data(v)
+
+
 def entity_list_to_data(lst):
     return ProjectNameTestRunner.entity_list_to_data(lst)
 

package/project/.sdk/tm/rb/test/runner.rb

@@ -23,8 +23,8 @@ module ProjectNameTestRunner
   end
 
   def self.env_override(m)
-    live = getenv("PROJECTNAME_TEST_LIVE")
-    override = getenv("PROJECTNAME_TEST_OVERRIDE")
+    live = getenv("PROJECTENV_TEST_LIVE")
+    override = getenv("PROJECTENV_TEST_OVERRIDE")
 
     if live == "TRUE" || override == "TRUE"
       m.each_key do |key|
@@ -44,8 +44,8 @@ module ProjectNameTestRunner
       end
     end
 
-    explain = getenv("PROJECTNAME_TEST_EXPLAIN")
-    m["PROJECTNAME_TEST_EXPLAIN"] = explain if explain && !explain.empty?
+    explain = getenv("PROJECTENV_TEST_EXPLAIN")
+    m["PROJECTENV_TEST_EXPLAIN"] = explain if explain && !explain.empty?
 
     m
   end

package/project/.sdk/tm/rb/utility/make_error.rb

@@ -32,6 +32,10 @@ module ProjectNameUtilities
     sdk_err = ProjectNameError.new("", msg, ctx)
     sdk_err.result = ctx.utility.clean.call(ctx, result)
     sdk_err.spec = ctx.utility.clean.call(ctx, spec)
+
+    # Promote the HTTP status to the top level, so a consumer can branch on
+    # `err.status` / `err.not_found?` instead of reaching into `err.result`.
+    sdk_err.status = result.status.nil? ? -1 : result.status
     sdk_err.code = err.code if err.is_a?(ProjectNameError)
 
     ctx.ctrl.err = sdk_err

package/project/.sdk/tm/rust/VERSION

@@ -1 +1 @@
-0.0.1
+PROJECTVERSION

package/project/.sdk/tm/rust/core/types.rs

@@ -76,16 +76,32 @@ pub trait Entity {
     fn make(&self) -> Rc<dyn Entity>;
     fn data(&self, args: Option<&Value>) -> Value;
     fn matchv(&self, args: Option<&Value>) -> Value;
+
+    /// `remove` resolves to the entity, marked. The instance KEEPS the data
+    /// it held — a caller can still read what was deleted — but it is no
+    /// longer a live record.
+    fn mark_deleted(&self);
+    fn deleted(&self) -> bool;
 }
 
 /// ProjectNameEntity: the full CRUD contract every generated entity
 /// implements. Ops the API spec doesn't define are runtime-error stubs.
-pub trait ProjectNameEntity: Entity {
-    fn load(&self, reqmatch: Value, ctrl: Value) -> Result<Value, ProjectNameError>;
-    fn list(&self, reqmatch: Value, ctrl: Value) -> Result<Value, ProjectNameError>;
-    fn create(&self, reqdata: Value, ctrl: Value) -> Result<Value, ProjectNameError>;
-    fn update(&self, reqdata: Value, ctrl: Value) -> Result<Value, ProjectNameError>;
-    fn remove(&self, reqmatch: Value, ctrl: Value) -> Result<Value, ProjectNameError>;
+pub trait ProjectNameEntity: Entity + Sized {
+    /// Every operation resolves to the ENTITY, not the raw data — `list` to a
+    /// vector of them, one per record. The record is reached through
+    /// `.data(None)`. See AGENTS.md "Entity operations return ENTITIES".
+    ///
+    /// The receivers are `&Rc<Self>` because the result IS this entity: the
+    /// op absorbs `resdata`/`resmatch` into it and hands the handle back.
+    /// `Value` cannot carry an entity — it is a closed data union
+    /// (Noval|Null|Bool|Num|Str|List|Map|Func|Sentinel) and adding a variant
+    /// to a general-purpose struct library to carry SDK objects would be
+    /// wrong — so the CONTRACT lives in these signatures instead.
+    fn load(self: &Rc<Self>, reqmatch: Value, ctrl: Value) -> Result<Rc<Self>, ProjectNameError>;
+    fn list(self: &Rc<Self>, reqmatch: Value, ctrl: Value) -> Result<Vec<Rc<Self>>, ProjectNameError>;
+    fn create(self: &Rc<Self>, reqdata: Value, ctrl: Value) -> Result<Rc<Self>, ProjectNameError>;
+    fn update(self: &Rc<Self>, reqdata: Value, ctrl: Value) -> Result<Rc<Self>, ProjectNameError>;
+    fn remove(self: &Rc<Self>, reqmatch: Value, ctrl: Value) -> Result<Rc<Self>, ProjectNameError>;
 }
 
 /// Transport: `(ctx, url, fetchdef) -> transport-shaped response map`.

package/project/.sdk/tm/rust/tests/common/mod.rs

@@ -124,12 +124,12 @@ pub fn load_env_local() {
     }
 }
 
-/// env_override (mirrors go): when PROJECTNAME_TEST_LIVE or
-/// PROJECTNAME_TEST_OVERRIDE is TRUE, environment variables replace the
+/// env_override (mirrors go): when PROJECTENV_TEST_LIVE or
+/// PROJECTENV_TEST_OVERRIDE is TRUE, environment variables replace the
 /// defaults in `m` (JSON-shaped values are parsed).
 pub fn env_override(m: Value) -> Value {
-    let live = std::env::var("PROJECTNAME_TEST_LIVE").unwrap_or_default() == "TRUE";
-    let over = std::env::var("PROJECTNAME_TEST_OVERRIDE").unwrap_or_default() == "TRUE";
+    let live = std::env::var("PROJECTENV_TEST_LIVE").unwrap_or_default() == "TRUE";
+    let over = std::env::var("PROJECTENV_TEST_OVERRIDE").unwrap_or_default() == "TRUE";
 
     if live || over {
         if let Value::Map(mm) = &m {
@@ -152,9 +152,9 @@ pub fn env_override(m: Value) -> Value {
         }
     }
 
-    if let Ok(explain) = std::env::var("PROJECTNAME_TEST_EXPLAIN") {
+    if let Ok(explain) = std::env::var("PROJECTENV_TEST_EXPLAIN") {
         if !explain.is_empty() {
-            setp(&m, "PROJECTNAME_TEST_EXPLAIN", Value::str(explain));
+            setp(&m, "PROJECTENV_TEST_EXPLAIN", Value::str(explain));
         }
     }
 

package/project/.sdk/tm/rust/tests/pipeline_test.rs

@@ -68,6 +68,12 @@ impl Entity for PlEntity {
         }
         Value::Noval
     }
+    // Every operation resolves to the entity; `remove` marks it. The fake
+    // has to satisfy the same trait the real entities do.
+    fn mark_deleted(&self) {}
+    fn deleted(&self) -> bool {
+        false
+    }
     fn matchv(&self, _args: Option<&Value>) -> Value {
         Value::Noval
     }

package/project/.sdk/tm/rust/utility/make_error.rs

@@ -63,6 +63,10 @@ pub fn make_error_util(
     sdk_err.result = crate::utility::clean::clean_util(ctx, &result.borrow().to_value());
     sdk_err.spec = crate::utility::clean::clean_util(ctx, &spec_val);
 
+    // Promote the HTTP status to the top level, so a consumer can branch on
+    // `err.status` / `err.not_found()` rather than reaching into `err.result`.
+    sdk_err.status = result.borrow().status;
+
     ctrl.borrow_mut().err = Some(sdk_err.clone());
 
     // Fire PreUnexpected so observability features (metrics, telemetry, audit,

package/project/.sdk/tm/scala/VERSION

@@ -1 +1 @@
-0.0.1
+PROJECTVERSION

package/project/.sdk/tm/swift/VERSION

@@ -1 +1 @@
-0.0.1
+PROJECTVERSION

package/project/.sdk/tm/ts/src/tsconfig.json

@@ -1,5 +1,6 @@
 {
   "compilerOptions": {
+    "skipLibCheck": true,
     "esModuleInterop": true,
     "module": "nodenext",
     "noEmitOnError": true,

package/project/.sdk/tm/ts/src/utility/MakeErrorUtility.ts

@@ -46,6 +46,10 @@ function makeError(ctx: Context, err?: any) {
   err.result = clean(ctx, result)
   err.spec = clean(ctx, spec)
 
+  // Promote the HTTP status to the top level, so a consumer can branch on
+  // `err.status` / `err.notFound` instead of reaching into `err.result`.
+  err.status = null == result.status ? -1 : result.status
+
   ctx.ctrl.err = err
 
   // Fire PreUnexpected so observability features (metrics, telemetry, audit,

package/project/.sdk/tm/ts/test/tsconfig.json

@@ -1,5 +1,6 @@
 {
   "compilerOptions": {
+    "skipLibCheck": true,
     "esModuleInterop": true,
     "module": "nodenext",
     "noEmitOnError": true,

package/project/.sdk/tm/ts/test/utility.ts

@@ -62,8 +62,8 @@ function makeCtrl(explain: boolean) {
 // Overrides configuration values with environment variables if available
 function envOverride(m: Record<string, any>) {
   if (
-    'TRUE' === process.env.PROJECTNAME_TEST_LIVE ||
-    'TRUE' === process.env.PROJECTNAME_TEST_OVERRIDE
+    'TRUE' === process.env.PROJECTENV_TEST_LIVE ||
+    'TRUE' === process.env.PROJECTENV_TEST_OVERRIDE
   ) {
     Object.entries(m).map(n => {
       let envval = process.env[n[0]]
@@ -74,7 +74,7 @@ function envOverride(m: Record<string, any>) {
     })
   }
 
-  m.PROJECTNAME_TEST_EXPLAIN = process.env.PROJECTNAME_TEST_EXPLAIN || m.PROJECTNAME_TEST_EXPLAIN
+  m.PROJECTENV_TEST_EXPLAIN = process.env.PROJECTENV_TEST_EXPLAIN || m.PROJECTENV_TEST_EXPLAIN
 
   return m
 }

package/project/.sdk/tm/zig/VERSION

@@ -1 +1 @@
-0.0.1
+PROJECTVERSION