@voxgig/sdkgen 4.34.0 → 4.34.2

package/project/.sdk/tm/kotlin/utility/Prepare.kt

@@ -27,15 +27,7 @@ private val METHOD_MAP: Map<String, String> = mapOf(
   "patch" to "PATCH",
 )
 
-@Suppress("UNCHECKED_CAST")
 fun param(ctx: Context, paramdef: Any?): Any? {
-  val point = ctx.point
-  val spec = ctx.spec
-  val match = ctx.match
-  val reqmatch = ctx.reqmatch
-  val data = ctx.data
-  val reqdata = ctx.reqdata
-
   val pt = Struct.typify(paramdef)
 
   val key: String
@@ -46,50 +38,94 @@ fun param(ctx: Context, paramdef: Any?): Any? {
     key = if (k is String) k else ""
   }
 
-  var akey = ""
+  val akey = paramAlias(ctx.point, key)
+  val spec = ctx.spec
+  if (spec != null && "" != akey &&
+    Struct.getprop(ctx.reqmatch, key, null) == null && Struct.getprop(ctx.match, key, null) == null
+  ) {
+    spec.alias[akey] = key
+  }
+
+  return paramValue(ctx, ctx.point, key)
+}
+
+// The name a point gives a parameter in the call, if it renames it.
+private fun paramAlias(point: Map<String, Any?>?, key: String): String {
   if (point != null) {
     val alias = Helpers.toMapAny(Struct.getprop(point, "alias"))
     if (alias != null) {
       val ak = Struct.getprop(alias, key)
       if (ak is String) {
-        akey = ak
+        return ak
       }
     }
   }
+  return ""
+}
+
+// The value the call or its entity gives a point's parameter, under its name
+// or the point's alias for it.
+fun paramValue(ctx: Context, point: Map<String, Any?>?, key: String): Any? {
+  val akey = paramAlias(point, key)
 
-  var v = Struct.getprop(reqmatch, key, null)
+  var v = Struct.getprop(ctx.reqmatch, key, null)
 
   if (v == null) {
-    v = Struct.getprop(match, key, null)
+    v = Struct.getprop(ctx.match, key, null)
   }
 
   if (v == null && "" != akey) {
-    if (spec != null) {
-      spec.alias[akey] = key
-    }
-    v = Struct.getprop(reqmatch, akey, null)
+    v = Struct.getprop(ctx.reqmatch, akey, null)
   }
 
   if (v == null) {
-    v = Struct.getprop(reqdata, key, null)
+    v = Struct.getprop(ctx.reqdata, key, null)
   }
 
   if (v == null) {
-    v = Struct.getprop(data, key, null)
+    v = Struct.getprop(ctx.data, key, null)
   }
 
   if (v == null && "" != akey) {
-    v = Struct.getprop(reqdata, akey, null)
+    v = Struct.getprop(ctx.reqdata, akey, null)
     if (v == null) {
-      v = Struct.getprop(data, akey, null)
+      v = Struct.getprop(ctx.data, akey, null)
     }
   }
 
   return v
 }
 
+// One argument a point declares, with the name it travels under and the
+// value the call passes for it.
+internal data class CallArg(val name: String, val wire: String, val v: Any?)
+
+// The arguments a point declares in one location, query or header, each with
+// the name it travels under and the value this call passes in its match or
+// else its data. Unlike a path parameter, the entity's stored match and data
+// never supply one.
+internal fun callArgs(ctx: Context, kind: String): List<CallArg> {
+  val point = ctx.point ?: return emptyList()
+  val defs = Struct.getpath(point, listOf("args", kind)) as? List<*> ?: return emptyList()
+  val out = mutableListOf<CallArg>()
+  for (ad in defs) {
+    val name = Struct.getprop(ad, "name")
+    if (name !is String || name.isEmpty()) {
+      continue
+    }
+    val orig = Struct.getprop(ad, "orig")
+    val wire = if (orig is String && orig.isNotEmpty()) orig else name
+    val v = Struct.getprop(ctx.reqmatch, name, null) ?: Struct.getprop(ctx.reqdata, name, null)
+    out.add(CallArg(name, wire, v))
+  }
+  return out
+}
+
 fun prepareBody(ctx: Context): Any? {
   if ("data" == ctx.op.input) {
+    if (Media.isRawRequest(ctx.point)) {
+      return Media.rawBody(ctx.reqdata)
+    }
     return ctx.utility!!.transformRequest(ctx)
   }
   return null
@@ -100,34 +136,53 @@ fun prepareHeaders(ctx: Context): MutableMap<String, Any?> {
   val options = ctx.client!!.optionsMap()
 
   val headers = Struct.getprop(options, "headers", null)
-  val out: MutableMap<String, Any?> =
-    (if (headers == null) null else Helpers.toMapAny(Struct.clone(headers))) ?: linkedMapOf()
+  val out: MutableMap<String, Any?> = Media.headers(ctx.point,
+    (if (headers == null) null else Helpers.toMapAny(Struct.clone(headers))) ?: linkedMapOf())
+
+  // A header argument replaces a default of the same name, whatever its case.
+  for (arg in callArgs(ctx, "header")) {
+    if (arg.v != null) {
+      val key = arg.wire.lowercase()
+      out.keys.removeAll { it.lowercase() == key }
+      out[key] = Struct.stringify(arg.v)
+    }
+  }
 
-  // A header parameter travels as a header, under the name the definition
-  // gives it, and only from this call's own arguments. It replaces a default
-  // of the same name, whatever its case.
-  val point = ctx.point
-  val hl = if (point == null) null else Struct.getpath(point, listOf("args", "header"))
-  if (hl is List<*>) {
-    for (hd in hl) {
-      val name = Struct.getprop(hd, "name")
-      if (name !is String || name.isEmpty()) {
-        continue
-      }
-      val orig = Struct.getprop(hd, "orig")
-      val wire = if (orig is String && orig.isNotEmpty()) orig else name
-      val v = Struct.getprop(ctx.reqmatch, name, null) ?: Struct.getprop(ctx.reqdata, name, null)
-      if (v != null) {
-        val key = wire.lowercase()
-        out.keys.removeAll { it.lowercase() == key }
-        out[key] = Struct.stringify(v)
-      }
+  // A cookie argument travels in the cookie header, form serialized and
+  // percent-encoded, replacing a cookie of the same name among those the
+  // caller's headers already send.
+  val sent = callArgs(ctx, "cookie").filter { it.v != null }
+  if (sent.isNotEmpty()) {
+    val names = sent.flatMap {
+      if (it.v is Map<*, *>) Struct.keysof(it.v).map { key -> Struct.escurl(key) } else listOf(it.wire)
     }
+    val kept = mutableListOf<String>()
+    for (key in out.keys.filter { it.lowercase() == "cookie" }) {
+      val given = out.remove(key)
+      if (given is String) kept.addAll(cookieKeep(given, names))
+    }
+    for (arg in sent) {
+      val pair = cookiePair(arg.wire, arg.v)
+      if (pair.isNotEmpty()) kept.add(pair)
+    }
+    if (kept.isNotEmpty()) out["cookie"] = kept.joinToString("; ")
   }
 
   return out
 }
 
+// The form style of a cookie parameter: a list repeats the name, a map sends
+// its own keys, and every value is percent-encoded.
+private fun cookiePair(wire: String, v: Any?): String {
+  val esc = { x: Any? -> Struct.escurl(Struct.stringify(x)) }
+  val pairs = when (v) {
+    is List<*> -> v.map { wire + "=" + esc(it) }
+    is Map<*, *> -> Struct.keysof(v).map { Struct.escurl(it) + "=" + esc(Struct.getprop(v, it)) }
+    else -> listOf(wire + "=" + esc(v))
+  }
+  return pairs.joinToString("; ")
+}
+
 fun prepareMethod(ctx: Context): String? {
   val opname = ctx.op.name
 
@@ -216,13 +271,19 @@ fun prepareQuery(ctx: Context): MutableMap<String, Any?> {
         }
       }
     }
-    // A header parameter travels in the headers, which prepareHeaders fills.
-    val hl = Struct.getpath(point, listOf("args", "header"))
-    if (hl is List<*>) {
-      for (hd in hl) {
-        val name = Struct.getprop(hd, "name")
-        if (name is String) {
-          params.add(name)
+    // A header or cookie parameter travels in the headers, which prepareHeaders
+    // fills, unless a query parameter shares its name: then both are sent.
+    val declared = (Struct.getpath(point, listOf("args", "query")) as? List<*>)
+      ?.map { Struct.getprop(it, "name") } ?: emptyList()
+    val located = listOf(Struct.getpath(point, listOf("args", "header")),
+      Struct.getpath(point, listOf("args", "cookie")))
+    for (hl in located) {
+      if (hl is List<*>) {
+        for (hd in hl) {
+          val name = Struct.getprop(hd, "name")
+          if (name is String && name !in declared) {
+            params.add(name)
+          }
         }
       }
     }
@@ -253,6 +314,13 @@ fun prepareQuery(ctx: Context): MutableMap<String, Any?> {
     }
   }
 
+  // A create or update passes its query arguments in its data.
+  for (arg in callArgs(ctx, "query")) {
+    if (arg.v != null && !containsStr(params, arg.name)) {
+      out[arg.wire] = arg.v
+    }
+  }
+
   return out
 }
 
@@ -264,3 +332,14 @@ private fun containsStr(list: List<Any?>, s: String): Boolean {
   }
   return false
 }
+
+// The caller's cookie pieces with the named cookies removed: a cookie is one
+// ;-delimited piece, whatever its value holds.
+internal fun cookieKeep(header: String, names: List<String>): MutableList<String> {
+  val kept = mutableListOf<String>()
+  for (piece in header.split(";")) {
+    val cookie = piece.trim()
+    if (cookie.isNotEmpty() && cookie.substringBefore("=").trim() !in names) kept.add(cookie)
+  }
+  return kept
+}

package/project/.sdk/tm/kotlin/utility/ResultTransform.kt

@@ -37,6 +37,10 @@ fun resultBody(ctx: Context): KOTLINPACKAGE.core.Result {
     if (response != null && response.jsonFunc != null && response.body != null) {
       result.body = response.jsonFunc!!.get()
     }
+    if (response != null && response.unreadable) {
+      result.err = KOTLINPACKAGE.core.Response.unreadableBody(ctx, result.status, result.headers,
+        response.body, ctx.spec?.headers, result.err)
+    }
   }
 
   return result!!
@@ -62,12 +66,19 @@ fun resultHeaders(ctx: Context): KOTLINPACKAGE.core.Result {
 // the body is a copy without it. The caller's map is left untouched.
 private fun stripAction(reqdata: Any?): Any? = omitKeys(reqdata, listOf("\$action"))
 
-// A header argument travels as a header, which prepareHeaders sends, so the
-// body is built from the request data without it.
-private fun headerArgNames(ctx: Context): List<String> {
-  val point = ctx.point ?: return emptyList()
-  val hl = Struct.getpath(point, listOf("args", "header")) as? List<*> ?: return emptyList()
-  return hl.mapNotNull { hd -> (Struct.getprop(hd, "name", null) as? String)?.takeIf { it.isNotEmpty() } }
+// A header, cookie or query argument travels where prepareHeaders or
+// prepareQuery sends it, so the body is built from the request data without
+// it, unless the point marks it as a field the body keeps.
+private fun routedArgNames(ctx: Context): List<String> =
+  (callArgs(ctx, "header") + callArgs(ctx, "cookie") + callArgs(ctx, "query")).map { it.name }
+    .filter { !fieldArg(ctx, it) }
+
+private fun fieldArg(ctx: Context, name: String): Boolean {
+  val point = ctx.point ?: return false
+  return listOf("header", "cookie", "query").any { kind ->
+    val defs = Struct.getpath(point, listOf("args", kind)) as? List<*> ?: emptyList<Any?>()
+    defs.any { name == Struct.getprop(it, "name") && true == Struct.getprop(it, "field") }
+  }
 }
 
 private fun omitKeys(reqdata: Any?, names: List<String>): Any? {
@@ -88,7 +99,7 @@ fun transformRequest(ctx: Context): Any? {
     ctx.spec!!.step = "reqform"
   }
 
-  val reqdata = omitKeys(ctx.reqdata, headerArgNames(ctx))
+  val reqdata = omitKeys(ctx.reqdata, routedArgNames(ctx))
 
   val transform = Helpers.toMapAny(Struct.getprop(ctx.point, "transform"))
     ?: return stripAction(reqdata)

package/project/.sdk/tm/lua/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) $$const.year$$ Voxgig
+Copyright (c) $$const.year$$ PROJECTPUBLISHER
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/project/.sdk/tm/lua/core/context.lua

@@ -189,7 +189,7 @@ function Context:resolve_op(opname)
   local opcfg = vs.getpath(self.config, "entity." .. entname .. ".op." .. opname)
 
   local input = "match"
-  if opname == "update" or opname == "create" then
+  if opname == "update" or opname == "create" or opname == "patch" then
     input = "data"
   end
 

package/project/.sdk/tm/lua/core/helpers.lua

@@ -1,5 +1,7 @@
 -- ProjectName SDK helpers
 
+local vs = require("utility.struct.struct")
+
 local helpers = {}
 
 
@@ -27,4 +29,105 @@ function helpers.get_ctx_prop(m, key)
 end
 
 
+-- The name a point gives a parameter in the call, if it renames it.
+function helpers.param_alias(point, key)
+  local alias = point ~= nil and helpers.to_map(vs.getprop(point, "alias")) or nil
+  local ak = alias ~= nil and vs.getprop(alias, key) or nil
+  return type(ak) == "string" and ak or ""
+end
+
+
+-- The value the call or its entity gives a point's parameter, under its name
+-- or the point's alias for it.
+function helpers.param_value(ctx, point, key)
+  local akey = helpers.param_alias(point, key)
+
+  local val = vs.getprop(ctx.reqmatch, key)
+
+  if val == nil then
+    val = vs.getprop(ctx.match, key)
+  end
+
+  if val == nil and akey ~= "" then
+    val = vs.getprop(ctx.reqmatch, akey)
+  end
+
+  if val == nil then
+    val = vs.getprop(ctx.reqdata, key)
+  end
+
+  if val == nil then
+    val = vs.getprop(ctx.data, key)
+  end
+
+  if val == nil and akey ~= "" then
+    val = vs.getprop(ctx.reqdata, akey)
+    if val == nil then
+      val = vs.getprop(ctx.data, akey)
+    end
+  end
+
+  return val
+end
+
+
+-- The arguments a point declares in one location, query or header, each as
+-- { name, wire, val }: the name it travels under and the value this call
+-- passes in its match or else its data. Unlike a path parameter, the entity's
+-- stored match and data never supply one.
+function helpers.call_args(ctx, kind)
+  local out = {}
+  local defs = ctx.point ~= nil and vs.getpath(ctx.point, "args." .. kind) or nil
+  if type(defs) ~= "table" then
+    return out
+  end
+  for _, ad in ipairs(defs) do
+    local name = vs.getprop(ad, "name")
+    if type(name) == "string" and name ~= "" then
+      local wire = vs.getprop(ad, "orig")
+      if type(wire) ~= "string" or wire == "" then
+        wire = name
+      end
+      local val = vs.getprop(ctx.reqmatch or {}, name)
+      if val == nil then
+        val = vs.getprop(ctx.reqdata or {}, name)
+      end
+      out[#out + 1] = { name = name, wire = wire, val = val }
+    end
+  end
+  return out
+end
+
+
+-- The caller's cookie pieces with the named cookies removed: a cookie is one
+-- ;-delimited piece, whatever its value holds.
+function helpers.cookie_keep(header, names)
+  local kept = {}
+  for piece in string.gmatch(header .. ";", "([^;]*);") do
+    local cookie = piece:match("^%s*(.-)%s*$")
+    local name = cookie:match("^([^=]*)"):match("^%s*(.-)%s*$")
+    if cookie ~= "" and not names[name] then
+      kept[#kept + 1] = cookie
+    end
+  end
+  return kept
+end
+
+
+
+-- Whether a comma-separated allow option names the item: whole names, any case.
+function helpers.allowed(names, item)
+  if type(item) ~= "string" or item == "" or type(names) ~= "string" then
+    return false
+  end
+  local want = string.upper(item)
+  for name in string.gmatch(names, "[^,]+") do
+    if string.upper((name:gsub("^%s+", ""):gsub("%s+$", ""))) == want then
+      return true
+    end
+  end
+  return false
+end
+
+
 return helpers

package/project/.sdk/tm/lua/core/response.lua

@@ -32,6 +32,9 @@ function Response.new(resmap)
 
   self.body = vs.getprop(resmap, "body")
 
+  -- Set by a transport that could not read a non-blank body as JSON.
+  self.unreadable = vs.getprop(resmap, "unreadable") == true
+
   self.err = nil
   local e = vs.getprop(resmap, "err")
   if e ~= nil then

package/project/.sdk/tm/lua/core/spec.lua

@@ -21,6 +21,9 @@ function Spec.new(specmap)
   self.body = specmap.body
   self.url = specmap.url or ""
   self.path = specmap.path or ""
+  -- The query parameters prepare_auth placed: the credential, which the
+  -- request sends and the entity's match leaves out.
+  self.authquery = specmap.authquery or {}
 
   return self
 end

package/project/.sdk/tm/lua/feature/test_feature.lua

@@ -19,6 +19,31 @@ function TestFeature.new()
 end
 
 
+-- The key a list's response transform
+-- {"`$EACH`", "body", {["`$MERGE`"] = "`.<key>`"}} reads each item's record under.
+local function item_envelope_key(restf)
+  if type(restf) ~= "table" or #restf ~= 3 or restf[1] ~= "`$EACH`" or restf[2] ~= "body" then
+    return nil
+  end
+  local child = restf[3]
+  local merge = type(child) == "table" and child["`$MERGE`"] or nil
+  if type(merge) ~= "string" then
+    return nil
+  end
+  return string.match(merge, "^`%.([^.`$]+)`$")
+end
+
+-- The record the mock keeps: the request data without `$body`, which only the
+-- wire carries.
+local function record(reqdata)
+  if type(reqdata) ~= "table" then return reqdata end
+  local out = {}
+  for k, v in pairs(reqdata) do
+    if k ~= "$body" then out[k] = v end
+  end
+  return out
+end
+
 function TestFeature:init(ctx, options)
   self.client = ctx.client
   self.options = options
@@ -58,6 +83,14 @@ function TestFeature:init(ctx, options)
         return data
       end
       local restf = transform.res
+      local key = item_envelope_key(restf)
+      if key ~= nil and type(data) == "table" then
+        local out = setmetatable({}, getmetatable(data))
+        for i, item in ipairs(data) do
+          out[i] = { [key] = item }
+        end
+        return out
+      end
       if type(restf) ~= "string" then
         return data
       end
@@ -144,7 +177,7 @@ function TestFeature:init(ctx, options)
       local out = vs.clone(found)
       return respond(200, out, nil)
 
-    elseif op.name == "update" then
+    elseif op.name == "update" or op.name == "patch" then
       -- Match the existing entity by id only (or its alias). reqdata also
       -- contains the new field values, which would otherwise cause select
       -- to filter out the entity we want to update. When reqdata has no id,
@@ -172,7 +205,7 @@ function TestFeature:init(ctx, options)
         return respond(404, nil, { statusText = "Not found" })
       end
       if type(ent) == "table" and type(fctx.reqdata) == "table" then
-        vs.merge({ ent, fctx.reqdata })
+        vs.merge({ ent, record(fctx.reqdata) })
       end
       vs.delprop(ent, "$KEY")
       local out = vs.clone(ent)
@@ -199,7 +232,7 @@ function TestFeature:init(ctx, options)
           math.random(0, 0xFFFF), math.random(0, 0xFFFF))
       end
 
-      local ent = vs.clone(fctx.reqdata)
+      local ent = vs.clone(record(fctx.reqdata))
       if type(ent) == "table" then
         ent["id"] = id
         if type(id) == "string" then

package/project/.sdk/tm/lua/feature/validate_feature.lua

@@ -254,6 +254,8 @@ function ValidateFeature:_payload(ctx, opname)
   -- fields will never name it -- and under `strict` every custom-action call
   -- would be rejected for the one key that made it reachable.
   out["$action"] = nil
+  -- Nor is `$body`, the raw request body.
+  out["$body"] = nil
 
   return out
 end

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

@@ -98,7 +98,7 @@ end
 
 local function default_method(opname)
   if opname == "create" then return "POST" end
-  if opname == "update" then return "PATCH" end
+  if opname == "update" or opname == "patch" then return "PATCH" end
   if opname == "remove" then return "DELETE" end
   return "GET"
 end

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

@@ -197,4 +197,111 @@ function runner.live_delay_ms()
 end
 
 
+
+-- A live check that did not pass, as main.kit.test.live.strict decides:
+-- strict fails the test, lenient skips it with the same reason. A test
+-- passes in busted's pending, which skips only from inside the test.
+function runner.live_miss(pending, strict, reason)
+  if strict then
+    error(reason, 0)
+  end
+  pending(reason)
+end
+
+
+-- An account holding no record for the test to read skips either way.
+function runner.live_empty(pending, reason)
+  pending(reason)
+end
+
+
+local function is_list(t)
+  if type(t) ~= "table" then
+    return false
+  end
+  local mt = getmetatable(t)
+  return t[1] ~= nil or (mt ~= nil and mt.__jsontype == "array") or next(t) == nil
+end
+
+
+-- A live list response's records: the body, or the first list an
+-- envelope holds.
+function runner.live_list(data)
+  if is_list(data) then
+    return data
+  end
+  if type(data) ~= "table" then
+    return nil
+  end
+  local keys = {}
+  for k, _ in pairs(data) do
+    keys[#keys + 1] = tostring(k)
+  end
+  table.sort(keys)
+  for _, k in ipairs(keys) do
+    if type(data[k]) == "table" and is_list(data[k]) then
+      return data[k]
+    end
+  end
+  return nil
+end
+
+
+-- A live response for a message: the SDK's error, or else its status and
+-- content type, never its body.
+function runner.live_describe(result, err)
+  if err ~= nil then
+    return tostring(err)
+  end
+  if type(result) ~= "table" then
+    return "no response"
+  end
+  if result["err"] ~= nil then
+    return tostring(result["err"])
+  end
+  local ctype = nil
+  for k, v in pairs(result["headers"] or {}) do
+    if string.lower(tostring(k)) == "content-type" then
+      ctype = (tostring(v):match("^[^;]*"):gsub("%s+$", ""))
+    end
+  end
+  return "HTTP " .. tostring(result["status"]) .. (ctype and (" " .. ctype) or "")
+end
+
+
+-- The record a create-less flow reads live: the first its list returns,
+-- put where the flow reads the fixture's existing records.
+function runner.live_existing(pending, setup, strict, name, list)
+  local ok, found, err = pcall(list)
+  if not ok then
+    runner.live_miss(pending, strict, "Live list discovery failed: " .. tostring(found))
+  end
+  if err ~= nil then
+    runner.live_miss(pending, strict, "Live list discovery failed: " .. tostring(err))
+  end
+  if type(found) ~= "table" then
+    runner.live_miss(pending, strict, "Live list discovery returned no list")
+  end
+  if found[1] == nil then
+    runner.live_empty(pending, "The account has no " .. name .. " record to load")
+  end
+  local record = found[1]
+  if type(record) == "table" and type(record.data_get) == "function" then
+    record = record:data_get()
+  end
+  setup.data.existing = setup.data.existing or {}
+  setup.data.existing[name] = { live01 = record }
+end
+
+
+-- In a lenient live run a failing check skips, observing the live API.
+function runner.live_observe(pending, err, setup, strict)
+  local mt = getmetatable(err)
+  if strict or type(setup) ~= "table" or not setup.live or (mt ~= nil and mt.__type == "pending") then
+    error(err, 0)
+  end
+  pending("live run, main.kit.test.live.strict is false: " .. tostring(err))
+end
+
+
 return runner

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

@@ -60,8 +60,14 @@ local function default_http_fetch(fullurl, fetchdef)
   end
 
   local json_body = nil
-  if #body > 0 then
-    json_body = json.decode(body)
+  local unreadable = false
+  if string.find(body, "%S") then
+    local decoded, pos, err = json.decode(body)
+    if err ~= nil or string.find(body, "%S", pos) then
+      unreadable = true
+    else
+      json_body = decoded
+    end
   end
 
   local status_text = "OK"
@@ -75,6 +81,7 @@ local function default_http_fetch(fullurl, fetchdef)
     headers = resp_headers,
     json = function() return json_body end,
     body = body,
+    unreadable = unreadable,
   }, nil
 end