@voxgig/sdkgen 1.3.7 → 1.3.9

package/project/.sdk/tm/elixir/lib/utility/struct/voxgig_struct.ex

@@ -0,0 +1,2615 @@
+# Copyright (c) 2025-2026 Voxgig Ltd. MIT LICENSE.
+#
+# Voxgig Struct — Elixir port.
+#
+# A faithful port of the canonical TypeScript implementation
+# (typescript/src/StructUtility.ts). The canonical algorithm mutates nodes in
+# place and relies on reference-stable nodes (shared references seen by walk /
+# merge / inject). The BEAM has no mutable, reference-stable native collection,
+# so this port emulates a small mutable heap with ETS (an OTP-stdlib facility,
+# like the JVM heap the Clojure port uses or Rust's Rc<RefCell>): a node is a
+# tagged reference `{:vmap, id}` / `{:vlist, id}` whose contents live in the
+# heap table and are replaced on mutation; the reference is stable, so all
+# holders observe updates.
+#
+# Like the Python / Clojure / Dart ports, Elixir has a single `nil`, so the
+# canonical `undefined` and JSON `null` are both `nil`; the Group A/B rules
+# recover the distinction, and a NOARG sentinel marks "no argument supplied".
+#
+# Zero third-party runtime dependencies (ETS and :re/Regex are OTP stdlib).
+
+defmodule Voxgig.Struct do
+  @moduledoc "Faithful Elixir port of voxgig/struct. See AGENTS.md."
+
+  # ---------------------------------------------------------------------------
+  # Mutable heap (ETS)
+  # ---------------------------------------------------------------------------
+
+  @heap :vox_struct_heap
+
+  defp ensure_heap do
+    case :ets.whereis(@heap) do
+      :undefined ->
+        try do
+          :ets.new(@heap, [:set, :public, :named_table])
+        rescue
+          ArgumentError -> :ok
+        end
+
+        :ok
+
+      _ ->
+        :ok
+    end
+  end
+
+  defp alloc(contents) do
+    ensure_heap()
+    id = :erlang.unique_integer([:positive, :monotonic])
+    :ets.insert(@heap, {id, contents})
+    id
+  end
+
+  defp hget(id) do
+    case :ets.lookup(@heap, id) do
+      [{_, c}] -> c
+      _ -> nil
+    end
+  end
+
+  defp hset(id, contents), do: :ets.insert(@heap, {id, contents})
+
+  defp vmap_new(pairs), do: {:vmap, alloc(pairs)}
+  defp vlist_new(items), do: {:vlist, alloc(items)}
+  defp empty_map, do: vmap_new([])
+  defp empty_list, do: vlist_new([])
+
+  defp map_pairs({:vmap, id}), do: hget(id)
+  defp map_set_pairs({:vmap, id}, pairs), do: hset(id, pairs)
+  defp list_items({:vlist, id}), do: hget(id)
+  defp list_set_items({:vlist, id}, items), do: hset(id, items)
+
+  # Injection cell
+  defp vinj_new(fields), do: {:vinj, alloc(fields)}
+  defp ig({:vinj, id}, k), do: Map.get(hget(id), k)
+
+  defp is_({:vinj, id}, k, v) do
+    hset(id, Map.put(hget(id), k, v))
+    v
+  end
+
+  defp isinj({:vinj, _}), do: true
+  defp isinj(_), do: false
+
+  # ---------------------------------------------------------------------------
+  # Sentinels / constants
+  # ---------------------------------------------------------------------------
+
+  @noarg :vox_noarg
+  def noarg, do: @noarg
+
+  @skip :vox_skip
+  @delete :vox_delete
+  def skip, do: @skip
+  def delete, do: @delete
+  def is_skip(v), do: v == @skip
+  def is_delete(v), do: v == @delete
+
+  @m_keypre "key:pre"
+  @m_keypost "key:post"
+  @m_val "val"
+  def m_keypre, do: 1
+  def m_keypost, do: 2
+  def m_val, do: 4
+
+  defp mode_to_num(@m_keypre), do: 1
+  defp mode_to_num(@m_keypost), do: 2
+  defp mode_to_num(@m_val), do: 4
+  defp mode_to_num(_), do: 0
+
+  @s_dkey "$KEY"
+  @s_banno "`$ANNO`"
+  @s_dtop "$TOP"
+  @s_derrs "$ERRS"
+  @s_dspec "$SPEC"
+  @s_bexact "`$EXACT`"
+  @s_bval "`$VAL`"
+  @s_bkey "`$KEY`"
+  @s_bopen "`$OPEN`"
+  @s_mt ""
+  @s_bt "`"
+  @s_ds "$"
+  @s_cn ":"
+  @s_key "KEY"
+  @s_viz ": "
+
+  @t_any 0x7FFFFFFF
+  @t_noval 0x40000000
+  @t_boolean 0x20000000
+  @t_decimal 0x10000000
+  @t_integer 0x08000000
+  @t_number 0x04000000
+  @t_string 0x02000000
+  @t_function 0x01000000
+  @t_null 0x00400000
+  @t_list 0x00004000
+  @t_map 0x00002000
+  @t_instance 0x00001000
+  @t_scalar 0x00000080
+  @t_node 0x00000040
+
+  def t_any, do: @t_any
+  def t_noval, do: @t_noval
+  def t_boolean, do: @t_boolean
+  def t_decimal, do: @t_decimal
+  def t_integer, do: @t_integer
+  def t_number, do: @t_number
+  def t_string, do: @t_string
+  def t_function, do: @t_function
+  def t_null, do: @t_null
+  def t_list, do: @t_list
+  def t_map, do: @t_map
+  def t_instance, do: @t_instance
+  def t_scalar, do: @t_scalar
+  def t_node, do: @t_node
+
+  @typename {
+    "any", "nil", "boolean", "decimal", "integer", "number", "string", "function",
+    "symbol", "null", "", "", "", "", "", "", "", "list", "map", "instance",
+    "", "", "", "", "scalar", "node"
+  }
+
+  @maxdepth 32
+
+  @r_inject_full ~r/^`(\$[A-Z]+|[^`]*)[0-9]*`$/
+  @r_inject_part ~r/`([^`]*)`/
+  @r_meta_path ~r/^([^$]+)\$([=~])(.+)$/
+  @r_transform_name ~r/`\$([A-Z]+)`/
+  @r_intkey ~r/^-?[0-9]+$/
+
+  # ---------------------------------------------------------------------------
+  # Low-level helpers
+  # ---------------------------------------------------------------------------
+
+  defp is_intish(n) when is_integer(n), do: true
+  defp is_intish(n) when is_float(n), do: n == Float.floor(n)
+  defp is_intish(_), do: false
+
+  defp num_to_string(n) when is_integer(n), do: Integer.to_string(n)
+
+  defp num_to_string(n) when is_float(n) do
+    cond do
+      n == Float.floor(n) and abs(n) < 1.0e16 -> Integer.to_string(trunc(n))
+      true -> shortest_float(n)
+    end
+  end
+
+  defp shortest_float(n) do
+    s = :erlang.float_to_binary(n, [:short])
+    s
+  end
+
+  defp js_string(nil), do: "null"
+  defp js_string(true), do: "true"
+  defp js_string(false), do: "false"
+  defp js_string(v) when is_number(v), do: num_to_string(v)
+  defp js_string(v) when is_binary(v), do: v
+  defp js_string(v) when is_function(v), do: "function"
+  defp js_string(@skip), do: "skip"
+  defp js_string(@delete), do: "delete"
+
+  defp js_string({:vlist, _} = v) do
+    list_items(v)
+    |> Enum.map(fn x -> if x == nil, do: "", else: js_string(x) end)
+    |> Enum.join(",")
+  end
+
+  defp js_string({:vmap, _}), do: "[object Object]"
+  defp js_string(v), do: inspect(v)
+
+  defp mapkey(k) when is_binary(k), do: k
+  defp mapkey(k) when is_number(k), do: num_to_string(k)
+  defp mapkey(k), do: js_string(k)
+
+  defp to_int(k) when is_boolean(k), do: nil
+  defp to_int(k) when is_integer(k), do: k
+  defp to_int(k) when is_float(k), do: trunc(Float.floor(k))
+
+  defp to_int(k) when is_binary(k) do
+    case Integer.parse(String.trim(k)) do
+      {n, ""} -> n
+      _ -> nil
+    end
+  end
+
+  defp to_int(_), do: nil
+
+  defp clz32(n0) do
+    n = Bitwise.band(n0, 0xFFFFFFFF)
+
+    if n == 0 do
+      32
+    else
+      clz_loop(n, 0)
+    end
+  end
+
+  defp clz_loop(n, r) do
+    if Bitwise.band(n, 0x80000000) != 0 do
+      r
+    else
+      clz_loop(Bitwise.band(Bitwise.bsl(n, 1), 0xFFFFFFFF), r + 1)
+    end
+  end
+
+  # ---------------------------------------------------------------------------
+  # Minor utilities
+  # ---------------------------------------------------------------------------
+
+  def isnode({:vmap, _}), do: true
+  def isnode({:vlist, _}), do: true
+  def isnode(_), do: false
+
+  def ismap({:vmap, _}), do: true
+  def ismap(_), do: false
+
+  def islist({:vlist, _}), do: true
+  def islist(_), do: false
+
+  def isfunc(v), do: is_function(v)
+
+  def iskey(k) when is_binary(k), do: k != ""
+  def iskey(k) when is_boolean(k), do: false
+  def iskey(k) when is_number(k), do: true
+  def iskey(_), do: false
+
+  def isempty(v \\ nil) do
+    cond do
+      v == nil -> true
+      v == "" -> true
+      islist(v) -> list_items(v) == []
+      ismap(v) -> map_pairs(v) == []
+      true -> false
+    end
+  end
+
+  def getdef(v, alt), do: if(v == nil, do: alt, else: v)
+
+  def typify(value \\ @noarg) do
+    cond do
+      value == @noarg -> @t_noval
+      value == nil -> Bitwise.bor(@t_scalar, @t_null)
+      is_boolean(value) -> Bitwise.bor(@t_scalar, @t_boolean)
+      is_integer(value) -> Bitwise.bor(Bitwise.bor(@t_scalar, @t_number), @t_integer)
+      is_float(value) -> typify_float(value)
+      is_binary(value) -> Bitwise.bor(@t_scalar, @t_string)
+      is_function(value) -> Bitwise.bor(@t_scalar, @t_function)
+      islist(value) -> Bitwise.bor(@t_node, @t_list)
+      ismap(value) -> Bitwise.bor(@t_node, @t_map)
+      true -> Bitwise.bor(@t_node, @t_instance)
+    end
+  end
+
+  defp typify_float(value) do
+    cond do
+      value != value -> @t_noval
+      value == Float.floor(value) -> Bitwise.bor(Bitwise.bor(@t_scalar, @t_number), @t_integer)
+      true -> Bitwise.bor(Bitwise.bor(@t_scalar, @t_number), @t_decimal)
+    end
+  end
+
+  def typename(t \\ 0) do
+    i = clz32(t)
+    if i >= 0 and i < tuple_size(@typename), do: elem(@typename, i), else: elem(@typename, 0)
+  end
+
+  def size(v \\ nil) do
+    cond do
+      islist(v) -> length(list_items(v))
+      ismap(v) -> length(map_pairs(v))
+      is_binary(v) -> String.length(v)
+      is_boolean(v) -> if v, do: 1, else: 0
+      is_number(v) -> trunc(Float.floor(v / 1))
+      true -> 0
+    end
+  end
+
+  def strkey(key \\ nil) do
+    cond do
+      key == nil -> @s_mt
+      is_binary(key) -> key
+      is_boolean(key) -> @s_mt
+      is_number(key) -> if(is_intish(key), do: num_to_string(key), else: num_to_string(Float.floor(key)))
+      true -> @s_mt
+    end
+  end
+
+  def keysof(v \\ nil) do
+    cond do
+      ismap(v) -> map_pairs(v) |> Enum.map(&elem(&1, 0)) |> Enum.sort()
+      islist(v) -> n = length(list_items(v)); if(n == 0, do: [], else: Enum.map(0..(n - 1), &Integer.to_string/1))
+      true -> []
+    end
+  end
+
+  defp omap_get(pairs, k) do
+    case List.keyfind(pairs, k, 0) do
+      {_, v} -> {:ok, v}
+      nil -> :error
+    end
+  end
+
+  defp omap_put(pairs, k, v) do
+    if List.keymember?(pairs, k, 0) do
+      Enum.map(pairs, fn {kk, vv} -> if kk == k, do: {k, v}, else: {kk, vv} end)
+    else
+      pairs ++ [{k, v}]
+    end
+  end
+
+  defp omap_del(pairs, k), do: Enum.reject(pairs, fn {kk, _} -> kk == k end)
+
+  def getprop(val, key, alt \\ nil) do
+    if val == nil or key == nil do
+      alt
+    else
+      out =
+        cond do
+          ismap(val) ->
+            case omap_get(map_pairs(val), mapkey(key)) do
+              {:ok, v} -> v
+              :error -> nil
+            end
+
+          islist(val) ->
+            ki = to_int(key)
+            items = if ki == nil, do: [], else: list_items(val)
+            if ki != nil and ki >= 0 and ki < length(items), do: Enum.at(items, ki), else: nil
+
+          true ->
+            nil
+        end
+
+      if out == nil, do: alt, else: out
+    end
+  end
+
+  defp lookup_(val, key) do
+    cond do
+      val == nil or key == nil ->
+        nil
+
+      ismap(val) ->
+        case omap_get(map_pairs(val), mapkey(key)) do
+          {:ok, v} -> v
+          :error -> nil
+        end
+
+      islist(val) ->
+        ki = to_int(key)
+        items = if ki == nil, do: [], else: list_items(val)
+        if ki != nil and ki >= 0 and ki < length(items), do: Enum.at(items, ki), else: nil
+
+      true ->
+        nil
+    end
+  end
+
+  def haskey(val \\ nil, key \\ nil), do: getprop(val, key) != nil
+
+  def getelem(val, key, alt \\ nil) do
+    if val == nil or key == nil do
+      alt
+    else
+      out =
+        if islist(val) do
+          ks = cond do; is_binary(key) -> key; is_number(key) -> num_to_string(key); true -> "" end
+
+          if Regex.match?(@r_intkey, ks) do
+            items = list_items(val)
+            len = length(items)
+            nk0 = String.to_integer(ks)
+            nk = if nk0 < 0, do: len + nk0, else: nk0
+            if nk >= 0 and nk < len, do: Enum.at(items, nk), else: nil
+          else
+            nil
+          end
+        else
+          nil
+        end
+
+      if out == nil do
+        if isfunc(alt), do: alt.(), else: alt
+      else
+        out
+      end
+    end
+  end
+
+  defp getprop_raw(v, k) do
+    cond do
+      ismap(v) ->
+        case omap_get(map_pairs(v), k) do
+          {:ok, x} -> x
+          :error -> nil
+        end
+
+      islist(v) ->
+        i = String.to_integer(k)
+        items = list_items(v)
+        if i >= 0 and i < length(items), do: Enum.at(items, i), else: nil
+
+      true ->
+        nil
+    end
+  end
+
+  defp items_pairs(v) do
+    if not isnode(v), do: [], else: Enum.map(keysof(v), fn k -> {k, getprop_raw(v, k)} end)
+  end
+
+  def items(v \\ nil) do
+    vlist_new(Enum.map(items_pairs(v), fn {k, x} -> vlist_new([k, x]) end))
+  end
+
+  defp items_v(v, f), do: vlist_new(Enum.map(items_pairs(v), f))
+
+  def flatten(l, depth \\ 1) do
+    if not islist(l) do
+      l
+    else
+      out =
+        Enum.reduce(list_items(l), [], fn item, acc ->
+          if islist(item) and depth > 0 do
+            acc ++ list_items(flatten(item, depth - 1))
+          else
+            acc ++ [item]
+          end
+        end)
+
+      vlist_new(out)
+    end
+  end
+
+  def filter(val, check) do
+    out = Enum.reduce(items_pairs(val), [], fn {k, x}, acc -> if check.({k, x}), do: acc ++ [x], else: acc end)
+    vlist_new(out)
+  end
+
+  def setprop(parent, key, val) do
+    cond do
+      not iskey(key) ->
+        parent
+
+      ismap(parent) ->
+        map_set_pairs(parent, omap_put(map_pairs(parent), mapkey(key), val))
+        parent
+
+      islist(parent) ->
+        case to_int(key) do
+          nil ->
+            parent
+
+          ki ->
+            items = list_items(parent)
+            len = length(items)
+
+            new =
+              cond do
+                ki >= 0 ->
+                  ki2 = if ki > len, do: len, else: ki
+                  if ki2 >= len, do: items ++ [val], else: List.replace_at(items, ki2, val)
+
+                true ->
+                  [val | items]
+              end
+
+            list_set_items(parent, new)
+            parent
+        end
+
+      true ->
+        parent
+    end
+  end
+
+  def delprop(parent, key) do
+    cond do
+      not iskey(key) ->
+        parent
+
+      ismap(parent) ->
+        map_set_pairs(parent, omap_del(map_pairs(parent), mapkey(key)))
+        parent
+
+      islist(parent) ->
+        case to_int(key) do
+          nil ->
+            parent
+
+          ki ->
+            items = list_items(parent)
+            if ki >= 0 and ki < length(items), do: list_set_items(parent, List.delete_at(items, ki))
+            parent
+        end
+
+      true ->
+        parent
+    end
+  end
+
+  def clone(v \\ nil) do
+    cond do
+      ismap(v) -> vmap_new(Enum.map(map_pairs(v), fn {k, x} -> {k, clone(x)} end))
+      islist(v) -> vlist_new(Enum.map(list_items(v), &clone/1))
+      true -> v
+    end
+  end
+
+  def slice(val, start \\ nil, stop \\ nil, mutate \\ false) do
+    cond do
+      is_number(val) and not is_boolean(val) ->
+        lo = if is_number(start), do: start, else: nil
+        hi = if is_number(stop), do: stop - 1, else: nil
+
+        cond do
+          hi != nil and val > hi -> hi
+          lo != nil and val < lo -> lo
+          true -> val
+        end
+
+      islist(val) or is_binary(val) ->
+        slice_seq(val, start, stop, mutate)
+
+      true ->
+        val
+    end
+  end
+
+  defp slice_seq(val, start, stop, mutate) do
+    vlen = size(val)
+    start = if start == nil and stop != nil, do: 0, else: start
+
+    if start == nil do
+      val
+    else
+      s0 = trunc(start)
+
+      {s, e} =
+        cond do
+          s0 < 0 ->
+            e = vlen + s0
+            {0, if(e < 0, do: 0, else: e)}
+
+          stop != nil ->
+            e0 = trunc(stop)
+
+            cond do
+              e0 < 0 -> ee = vlen + e0; {s0, if(ee < 0, do: 0, else: ee)}
+              vlen < e0 -> {s0, vlen}
+              true -> {s0, e0}
+            end
+
+          true ->
+            {s0, vlen}
+        end
+
+      s = if vlen < s, do: vlen, else: s
+
+      if s > -1 and s <= e and e <= vlen do
+        cond do
+          islist(val) ->
+            sub = Enum.slice(list_items(val), s, e - s)
+            if mutate, do: (list_set_items(val, sub); val), else: vlist_new(sub)
+
+          true ->
+            binary_part(val, s, e - s)
+        end
+      else
+        cond do
+          islist(val) -> if mutate, do: (list_set_items(val, []); val), else: empty_list()
+          true -> @s_mt
+        end
+      end
+    end
+  end
+
+  # ---------------------------------------------------------------------------
+  # Regex helpers (uniform re_* API over :re/Regex)
+  # ---------------------------------------------------------------------------
+
+  defp rx(p) do
+    cond do
+      is_struct(p, Regex) -> p
+      is_binary(p) -> Regex.compile!(p)
+      true -> Regex.compile!(js_string(p))
+    end
+  end
+
+  def re_compile(p, _flags \\ nil), do: rx(p)
+  def re_test(p, input), do: Regex.match?(rx(p), if(is_binary(input), do: input, else: js_string(input)))
+
+  def re_find(p, input) do
+    case Regex.run(rx(p), if(is_binary(input), do: input, else: js_string(input))) do
+      nil -> nil
+      groups -> vlist_new(Enum.map(groups, fn g -> g || "" end))
+    end
+  end
+
+  def re_find_all(p, input) do
+    matches = Regex.scan(rx(p), if(is_binary(input), do: input, else: js_string(input)))
+    vlist_new(Enum.map(matches, fn groups -> vlist_new(Enum.map(groups, fn g -> g || "" end)) end))
+  end
+
+  def re_replace(_p, input, _repl), do: input
+  def re_escape(s), do: escre(s)
+
+  def escre(s \\ nil) do
+    str = cond do; is_binary(s) -> s; s == nil -> @s_mt; true -> js_string(s) end
+
+    str
+    |> String.to_charlist()
+    |> Enum.map(fn c ->
+      ch = <<c::utf8>>
+      if String.contains?(".*+?^${}()|[]\\", ch), do: "\\" <> ch, else: ch
+    end)
+    |> Enum.join("")
+  end
+
+  @url_unreserved "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_.!~*'()"
+
+  def escurl(s \\ nil) do
+    str = cond do; is_binary(s) -> s; s == nil -> @s_mt; true -> js_string(s) end
+
+    :binary.bin_to_list(str)
+    |> Enum.map(fn b ->
+      ch = <<b>>
+      if String.contains?(@url_unreserved, ch) do
+        ch
+      else
+        "%" <> String.upcase(String.pad_leading(Integer.to_string(b, 16), 2, "0"))
+      end
+    end)
+    |> Enum.join("")
+  end
+
+  # ---------------------------------------------------------------------------
+  # JSON-ish serialization / stringify / jsonify
+  # ---------------------------------------------------------------------------
+
+  defp esc_json(s) do
+    inner =
+      s
+      |> String.to_charlist()
+      |> Enum.map(fn c ->
+        case c do
+          ?" -> "\\\""
+          ?\\ -> "\\\\"
+          ?\n -> "\\n"
+          ?\r -> "\\r"
+          ?\t -> "\\t"
+          c when c < 32 -> "\\u" <> String.pad_leading(Integer.to_string(c, 16), 4, "0")
+          c -> <<c::utf8>>
+        end
+      end)
+      |> Enum.join("")
+
+    "\"" <> inner <> "\""
+  end
+
+  defp json_encode(v, sort \\ false, indent \\ nil), do: json_enc(v, sort, indent, 0)
+
+  defp json_enc(v, sort, indent, level) do
+    cond do
+      v == nil -> "null"
+      v == true -> "true"
+      v == false -> "false"
+      is_number(v) -> num_to_string(v)
+      is_binary(v) -> esc_json(v)
+      is_function(v) -> "null"
+      v == @skip or v == @delete -> "null"
+      islist(v) -> json_list(list_items(v), sort, indent, level)
+      ismap(v) -> json_map(map_pairs(v), sort, indent, level)
+      true -> esc_json(js_string(v))
+    end
+  end
+
+  defp json_list([], _sort, _indent, _level), do: "[]"
+
+  defp json_list(items, sort, nil, level) do
+    "[" <> Enum.map_join(items, ",", fn x -> json_enc(x, sort, nil, level + 1) end) <> "]"
+  end
+
+  defp json_list(items, sort, indent, level) do
+    pad = String.duplicate(" ", indent * (level + 1))
+    cpad = String.duplicate(" ", indent * level)
+    body = Enum.map_join(items, ",\n", fn x -> pad <> json_enc(x, sort, indent, level + 1) end)
+    "[\n" <> body <> "\n" <> cpad <> "]"
+  end
+
+  defp json_map(pairs, sort, indent, level) do
+    ks = Enum.map(pairs, &elem(&1, 0))
+    ks = if sort, do: Enum.sort(ks), else: ks
+
+    cond do
+      ks == [] ->
+        "{}"
+
+      indent == nil ->
+        "{" <>
+          Enum.map_join(ks, ",", fn k ->
+            {_, v} = List.keyfind(pairs, k, 0)
+            esc_json(k) <> ":" <> json_enc(v, sort, nil, level + 1)
+          end) <> "}"
+
+      true ->
+        pad = String.duplicate(" ", indent * (level + 1))
+        cpad = String.duplicate(" ", indent * level)
+
+        body =
+          Enum.map_join(ks, ",\n", fn k ->
+            {_, v} = List.keyfind(pairs, k, 0)
+            pad <> esc_json(k) <> ": " <> json_enc(v, sort, indent, level + 1)
+          end)
+
+        "{\n" <> body <> "\n" <> cpad <> "}"
+    end
+  end
+
+  defp has_cycle(v), do: has_cycle(v, MapSet.new())
+
+  defp has_cycle({:vmap, id} = v, seen) do
+    if MapSet.member?(seen, id), do: true, else: Enum.any?(map_pairs(v), fn {_, x} -> has_cycle(x, MapSet.put(seen, id)) end)
+  end
+
+  defp has_cycle({:vlist, id} = v, seen) do
+    if MapSet.member?(seen, id), do: true, else: Enum.any?(list_items(v), fn x -> has_cycle(x, MapSet.put(seen, id)) end)
+  end
+
+  defp has_cycle(_, _), do: false
+
+  def stringify(v \\ @noarg, maxlen \\ nil, pretty \\ nil) do
+    pr = pretty == true
+
+    cond do
+      v == @noarg ->
+        if pr, do: "<>", else: @s_mt
+
+      true ->
+        valstr =
+          cond do
+            is_binary(v) -> v
+            has_cycle(v) -> "__STRINGIFY_FAILED__"
+            true -> String.replace(json_encode(v, true), "\"", "")
+          end
+
+        valstr =
+          if is_number(maxlen) and maxlen > -1 do
+            m = trunc(maxlen)
+
+            if m < String.length(valstr) do
+              String.slice(valstr, 0, max(0, m - 3)) <> "..."
+            else
+              valstr
+            end
+          else
+            valstr
+          end
+
+        if pr, do: stringify_pretty(valstr), else: valstr
+    end
+  end
+
+  defp stringify_pretty(valstr) do
+    colors = [81, 118, 213, 39, 208, 201, 45, 190, 129, 51, 160, 121, 226, 33, 207, 69]
+    c = Enum.map(colors, fn n -> "\e[38;5;" <> Integer.to_string(n) <> "m" end) |> List.to_tuple()
+    r = "\e[0m"
+    clen = tuple_size(c)
+
+    {_, _, t} =
+      String.to_charlist(valstr)
+      |> Enum.reduce({0, elem(c, 0), elem(c, 0)}, fn ch, {d, o, t} ->
+        chs = <<ch::utf8>>
+
+        cond do
+          ch == ?{ or ch == ?[ ->
+            d2 = d + 1
+            o2 = elem(c, rem(d2, clen))
+            {d2, o2, t <> o2 <> chs}
+
+          ch == ?} or ch == ?] ->
+            t2 = t <> o <> chs
+            d2 = d - 1
+            o2 = elem(c, rem(rem(d2, clen) + clen, clen))
+            {d2, o2, t2}
+
+          true ->
+            {d, o, t <> o <> chs}
+        end
+      end)
+
+    t <> r
+  end
+
+  def jsonify(v \\ nil, flags \\ nil) do
+    if v == nil do
+      "null"
+    else
+      indent = getprop(flags, "indent", 2)
+      ind = if is_number(indent), do: trunc(indent), else: 2
+      str = if ind > 0, do: json_encode(v, false, ind), else: json_encode(v)
+      offset = getprop(flags, "offset", 0)
+      off = if is_number(offset), do: trunc(offset), else: 0
+
+      if off > 0 do
+        lines = String.split(str, "\n")
+
+        case lines do
+          [_ | rest] -> "{\n" <> Enum.map_join(rest, "\n", fn l -> String.duplicate(" ", off) <> l end)
+          [] -> str
+        end
+      else
+        str
+      end
+    end
+  end
+
+  def pad(s \\ nil, padding \\ nil, padchar \\ nil) do
+    str = cond do; is_binary(s) -> s; s == nil -> "null"; true -> stringify(s) end
+    p = if is_number(padding), do: trunc(padding), else: 44
+    pc = if is_binary(padchar), do: String.slice(padchar <> " ", 0, 1), else: " "
+
+    if p > -1 do
+      n = p - String.length(str)
+      if n > 0, do: str <> String.duplicate(pc, n), else: str
+    else
+      n = -p - String.length(str)
+      if n > 0, do: String.duplicate(pc, n) <> str, else: str
+    end
+  end
+
+  # ---------------------------------------------------------------------------
+  # join / pathify / replace
+  # ---------------------------------------------------------------------------
+
+  def join(arr, sep \\ nil, url \\ nil) do
+    if not islist(arr) do
+      @s_mt
+    else
+      sepdef = cond do; sep == nil -> ","; is_binary(sep) -> sep; true -> js_string(sep) end
+      single = String.length(sepdef) == 1
+      sc = if single, do: sepdef, else: " "
+      is_url = url == true
+      items = list_items(arr)
+      sarr = length(items)
+
+      out =
+        items
+        |> Enum.with_index()
+        |> Enum.reduce([], fn {s0, idx}, acc ->
+          if is_binary(s0) and s0 != @s_mt do
+            s =
+              if single do
+                cond do
+                  is_url and idx == 0 ->
+                    strip_trailing(s0, sc)
+
+                  true ->
+                    x = if idx > 0, do: strip_leading(s0, sc), else: s0
+                    x = if idx < sarr - 1 or not is_url, do: strip_trailing(x, sc), else: x
+                    collapse(x, sc)
+                end
+              else
+                s0
+              end
+
+            if s != @s_mt, do: acc ++ [s], else: acc
+          else
+            acc
+          end
+        end)
+
+      Enum.join(out, sepdef)
+    end
+  end
+
+  defp strip_trailing(s, sc) do
+    if String.ends_with?(s, sc) and s != "", do: strip_trailing(String.slice(s, 0, String.length(s) - 1), sc), else: s
+  end
+
+  defp strip_leading(s, sc) do
+    if String.starts_with?(s, sc) and s != "", do: strip_leading(String.slice(s, 1, String.length(s) - 1), sc), else: s
+  end
+
+  defp collapse(s, sc) do
+    chars = String.graphemes(s)
+    collapse_loop(chars, sc, [])
+  end
+
+  defp collapse_loop([], _sc, acc), do: Enum.join(Enum.reverse(acc), "")
+
+  defp collapse_loop([ch | rest], sc, acc) do
+    if ch != sc do
+      collapse_loop(rest, sc, [ch | acc])
+    else
+      {run, rest2} = take_run(rest, sc, [ch])
+      before_non = acc != [] and hd(acc) != sc
+      after_non = rest2 != []
+
+      if before_non and after_non do
+        collapse_loop(rest2, sc, [sc | acc])
+      else
+        collapse_loop(rest2, sc, Enum.reverse(run) ++ acc)
+      end
+    end
+  end
+
+  defp take_run([ch | rest], sc, acc) when ch == sc, do: take_run(rest, sc, [ch | acc])
+  defp take_run(rest, _sc, acc), do: {Enum.reverse(acc), rest}
+
+  def joinurl(arr), do: join(arr, "/", true)
+
+  def replace(s, from, to) do
+    ts = typify(s)
+
+    rs =
+      cond do
+        Bitwise.band(@t_string, ts) == 0 -> stringify(s)
+        Bitwise.band(Bitwise.bor(@t_noval, @t_null), ts) > 0 -> @s_mt
+        true -> stringify(s)
+      end
+
+    to_s = if is_binary(to), do: to, else: js_string(to)
+
+    cond do
+      is_binary(from) and from != "" -> String.replace(rs, from, to_s)
+      is_struct(from, Regex) -> Regex.replace(from, rs, to_s)
+      true -> rs
+    end
+  end
+
+  def pathify(v \\ @noarg, startin \\ nil, endin \\ nil) do
+    absent = v == @noarg
+    val = if absent, do: nil, else: v
+
+    path =
+      cond do
+        islist(val) -> list_items(val)
+        iskey(val) -> [val]
+        true -> nil
+      end
+
+    start = if is_number(startin), do: if(startin > -1, do: trunc(startin), else: 0), else: 0
+    endn = if is_number(endin), do: if(endin > -1, do: trunc(endin), else: 0), else: 0
+
+    pathstr =
+      if path != nil and start >= 0 do
+        len = length(path)
+        e = max(0, len - endn)
+        s = if start > len, do: len, else: start
+        sub = if s <= e, do: Enum.slice(path, s, e - s), else: []
+
+        if sub == [] do
+          "<root>"
+        else
+          sub
+          |> Enum.filter(&iskey/1)
+          |> Enum.map(fn p ->
+            cond do
+              is_integer(p) -> num_to_string(p)
+              is_float(p) -> num_to_string(Float.floor(p))
+              true -> String.replace(js_string(p), ".", @s_mt)
+            end
+          end)
+          |> Enum.join(".")
+        end
+      else
+        nil
+      end
+
+    if pathstr == nil do
+      "<unknown-path" <> (if absent, do: @s_mt, else: @s_cn <> stringify(val, 47)) <> ">"
+    else
+      pathstr
+    end
+  end
+
+  # ---------------------------------------------------------------------------
+  # walk / merge
+  # ---------------------------------------------------------------------------
+
+  def walk(val, opts \\ []) do
+    before = Keyword.get(opts, :before)
+    aft = Keyword.get(opts, :after)
+    maxdepth = Keyword.get(opts, :maxdepth)
+    key = Keyword.get(opts, :key)
+    parent = Keyword.get(opts, :parent)
+    path = Keyword.get(opts, :path)
+    path = if path == nil, do: empty_list(), else: path
+    depth = size(path)
+    out = if before == nil, do: val, else: before.(key, val, parent, path)
+    md = if is_number(maxdepth) and maxdepth >= 0, do: trunc(maxdepth), else: @maxdepth
+
+    if md == 0 or (md > 0 and md <= depth) do
+      out
+    else
+      if isnode(out) do
+        prefix = list_items(path)
+
+        Enum.each(items_pairs(out), fn {ckey, child} ->
+          childpath = vlist_new(prefix ++ [ckey])
+
+          result =
+            walk(child, before: before, after: aft, maxdepth: md, key: ckey, parent: out, path: childpath)
+
+          setprop(out, ckey, result)
+        end)
+      end
+
+      if aft == nil, do: out, else: aft.(key, out, parent, path)
+    end
+  end
+
+  defp grow(a, n) do
+    if size(a) <= n do
+      setprop(a, size(a), nil)
+      grow(a, n)
+    end
+  end
+
+  def merge(objs, maxdepth \\ nil) do
+    md = if is_number(maxdepth), do: if(maxdepth < 0, do: 0, else: trunc(maxdepth)), else: @maxdepth
+
+    if not islist(objs) do
+      objs
+    else
+      items = list_items(objs)
+      lenlist = length(items)
+
+      cond do
+        lenlist == 0 ->
+          nil
+
+        lenlist == 1 ->
+          Enum.at(items, 0)
+
+        true ->
+          out0 = getprop(objs, 0, empty_map())
+          out = merge_loop(objs, lenlist, md, out0)
+
+          if md == 0 do
+            o = getprop(objs, lenlist - 1)
+            cond do; islist(o) -> empty_list(); ismap(o) -> empty_map(); true -> o end
+          else
+            out
+          end
+      end
+    end
+  end
+
+  defp merge_loop(_objs, _lenlist, _md, out, oi \\ 1)
+
+  defp merge_loop(objs, lenlist, md, out, oi) do
+    if oi >= lenlist do
+      out
+    else
+      obj = getprop(objs, oi)
+
+      out2 =
+        if not isnode(obj) do
+          obj
+        else
+          cur = vlist_new([out])
+          dst = vlist_new([out])
+
+          before = fn key, val, _parent, path ->
+            pi = size(path)
+
+            cond do
+              md <= pi ->
+                grow(cur, pi)
+                setprop(cur, pi, val)
+                if pi > 0, do: setprop(getelem(cur, pi - 1), key, val)
+                nil
+
+              not isnode(val) ->
+                grow(cur, pi)
+                setprop(cur, pi, val)
+                val
+
+              true ->
+                grow(dst, pi)
+                grow(cur, pi)
+                dnew = if pi > 0, do: getprop(getelem(dst, pi - 1), key), else: getelem(dst, pi)
+                setprop(dst, pi, dnew)
+                tval = getelem(dst, pi)
+
+                cond do
+                  tval == nil ->
+                    setprop(cur, pi, if(islist(val), do: empty_list(), else: empty_map()))
+                    val
+
+                  (islist(val) and islist(tval)) or (ismap(val) and ismap(tval)) ->
+                    setprop(cur, pi, tval)
+                    val
+
+                  true ->
+                    setprop(cur, pi, val)
+                    nil
+                end
+            end
+          end
+
+          aft = fn key, vv, _parent, path ->
+            ci = size(path)
+
+            if ci < 1 do
+              if size(cur) > 0, do: getelem(cur, 0), else: vv
+            else
+              target = if ci - 1 < size(cur), do: getelem(cur, ci - 1), else: nil
+              value = if ci < size(cur), do: getelem(cur, ci), else: nil
+              setprop(target, key, value)
+              value
+            end
+          end
+
+          walk(obj, before: before, after: aft)
+        end
+
+      merge_loop(objs, lenlist, md, out2, oi + 1)
+    end
+  end
+
+  # ---------------------------------------------------------------------------
+  # getpath / setpath
+  # ---------------------------------------------------------------------------
+
+  defp idef(injdef, field) do
+    cond do
+      isinj(injdef) ->
+        case field do
+          "base" -> ig(injdef, :base)
+          "dparent" -> ig(injdef, :dparent)
+          "meta" -> ig(injdef, :meta)
+          "key" -> ig(injdef, :key)
+          "dpath" -> ig(injdef, :dpath)
+          "handler" -> ig(injdef, :handler)
+        end
+
+      injdef == nil ->
+        nil
+
+      true ->
+        getprop(injdef, field)
+    end
+  end
+
+  defp dummy_inj, do: new_inj(nil, vmap_new([{@s_dtop, nil}]))
+
+  def getpath(store, path, injdef \\ nil) do
+    parts =
+      cond do
+        islist(path) -> list_items(path)
+        is_binary(path) -> String.split(path, ".")
+        is_number(path) and not is_boolean(path) -> [strkey(path)]
+        true -> nil
+      end
+
+    if parts == nil do
+      nil
+    else
+      has_inj = injdef != nil
+      base = idef(injdef, "base")
+      dparent = idef(injdef, "dparent")
+      inj_meta = idef(injdef, "meta")
+      inj_key = idef(injdef, "key")
+      dpath = idef(injdef, "dpath")
+      src = if iskey(base), do: getprop(store, base, store), else: store
+      numparts = length(parts)
+
+      val =
+        cond do
+          path == nil or store == nil or (numparts == 1 and Enum.at(parts, 0) == @s_mt) or numparts == 0 ->
+            src
+
+          true ->
+            val0 = if numparts == 1, do: getprop(store, Enum.at(parts, 0)), else: store
+
+            if isfunc(val0) do
+              val0
+            else
+              {val1, parts1} =
+                case if(is_binary(Enum.at(parts, 0)), do: Regex.run(@r_meta_path, Enum.at(parts, 0)), else: nil) do
+                  [_, g1, _, g3] when inj_meta != nil and has_inj ->
+                    {getprop(inj_meta, g1), List.replace_at(parts, 0, g3)}
+
+                  _ ->
+                    {src, parts}
+                end
+
+              getpath_loop(store, parts1, 0, val1, has_inj, inj_key, inj_meta, src, dparent, dpath)
+            end
+        end
+
+      handler = idef(injdef, "handler")
+
+      if has_inj and isfunc(handler) do
+        ref = pathify(path)
+        if isinj(injdef), do: handler.(injdef, val, ref, store), else: handler.(dummy_inj(), val, ref, store)
+      else
+        val
+      end
+    end
+  end
+
+  defp count_ascends(parts, pi, acc) do
+    if pi + 1 < length(parts) and Enum.at(parts, pi + 1) == @s_mt do
+      count_ascends(parts, pi + 1, acc + 1)
+    else
+      {acc, pi}
+    end
+  end
+
+  defp getpath_loop(store, parts, pi, val, has_inj, inj_key, inj_meta, src, dparent, dpath) do
+    numparts = length(parts)
+
+    if val == nil or pi >= numparts do
+      val
+    else
+      raw = Enum.at(parts, pi)
+
+      part0 =
+        cond do
+          has_inj and raw == @s_dkey -> if inj_key != nil, do: inj_key, else: raw
+          is_binary(raw) and String.starts_with?(raw, "$GET:") -> stringify(getpath(src, slice(raw, 5, -1)))
+          is_binary(raw) and String.starts_with?(raw, "$REF:") -> stringify(getpath(getprop(store, @s_dspec), slice(raw, 5, -1)))
+          has_inj and is_binary(raw) and String.starts_with?(raw, "$META:") -> stringify(getpath(inj_meta, slice(raw, 6, -1)))
+          true -> raw
+        end
+
+      part = if is_binary(part0), do: String.replace(part0, "$$", "$"), else: strkey(part0)
+
+      if part == @s_mt do
+        {ascends, pi2} = count_ascends(parts, pi, 0)
+
+        if has_inj and ascends > 0 do
+          ascends2 = if pi2 == numparts - 1, do: ascends - 1, else: ascends
+
+          if ascends2 == 0 do
+            getpath_loop(store, parts, pi2 + 1, dparent, has_inj, inj_key, inj_meta, src, dparent, dpath)
+          else
+            tail = Enum.drop(parts, pi2 + 1)
+            fullpath = flatten(vlist_new([slice(dpath, -ascends2), vlist_new(tail)]))
+            if ascends2 <= size(dpath), do: getpath(store, fullpath), else: nil
+          end
+        else
+          getpath_loop(store, parts, pi2 + 1, dparent, has_inj, inj_key, inj_meta, src, dparent, dpath)
+        end
+      else
+        getpath_loop(store, parts, pi + 1, getprop(val, part), has_inj, inj_key, inj_meta, src, dparent, dpath)
+      end
+    end
+  end
+
+  def setpath(store, path, val, injdef \\ nil) do
+    ptype = typify(path)
+
+    parts =
+      cond do
+        Bitwise.band(@t_list, ptype) > 0 -> vlist_new(list_items(path))
+        Bitwise.band(@t_string, ptype) > 0 -> vlist_new(String.split(path, "."))
+        Bitwise.band(@t_number, ptype) > 0 -> vlist_new([path])
+        true -> nil
+      end
+
+    if parts == nil do
+      nil
+    else
+      base = if injdef != nil, do: idef(injdef, "base"), else: nil
+      numparts = size(parts)
+      parent0 = if iskey(base), do: getprop(store, base, store), else: store
+      parent = setpath_walk(parts, numparts, parent0, 0)
+
+      if is_delete(val) do
+        delprop(parent, getelem(parts, -1))
+      else
+        setprop(parent, getelem(parts, -1), val)
+      end
+
+      parent
+    end
+  end
+
+  defp setpath_walk(parts, numparts, parent, pi) do
+    if pi >= numparts - 1 do
+      parent
+    else
+      pkey = getelem(parts, pi)
+      np0 = getprop(parent, pkey)
+
+      np =
+        if not isnode(np0) do
+          nextpart = getelem(parts, pi + 1)
+          nn = if Bitwise.band(@t_number, typify(nextpart)) > 0, do: empty_list(), else: empty_map()
+          setprop(parent, pkey, nn)
+          nn
+        else
+          np0
+        end
+
+      setpath_walk(parts, numparts, np, pi + 1)
+    end
+  end
+
+  # ---------------------------------------------------------------------------
+  # Injection
+  # ---------------------------------------------------------------------------
+
+  defp new_inj(val, parent) do
+    vinj_new(%{
+      mode: @m_val,
+      full: false,
+      keyi: 0,
+      keys: vlist_new([@s_dtop]),
+      key: @s_dtop,
+      ival: val,
+      parent: parent,
+      path: vlist_new([@s_dtop]),
+      nodes: vlist_new([parent]),
+      handler: &inject_handler/4,
+      errs: empty_list(),
+      meta: empty_map(),
+      dparent: nil,
+      dpath: vlist_new([@s_dtop]),
+      base: @s_dtop,
+      modify: nil,
+      prior: nil,
+      extra: nil,
+      root: nil
+    })
+  end
+
+  defp inj_descend(inj) do
+    meta = ig(inj, :meta)
+
+    if ismap(meta) do
+      d = case getprop(meta, "__d") do; n when is_number(n) -> n; _ -> 0 end
+      setprop(meta, "__d", d + 1)
+    end
+
+    parentkey = getelem(ig(inj, :path), -2)
+
+    cond do
+      ig(inj, :dparent) == nil ->
+        if size(ig(inj, :dpath)) > 1 do
+          is_(inj, :dpath, vlist_new(list_items(ig(inj, :dpath)) ++ [parentkey]))
+        end
+
+      parentkey != nil ->
+        is_(inj, :dparent, getprop(ig(inj, :dparent), parentkey))
+        lastpart = getelem(ig(inj, :dpath), -1)
+
+        if lastpart == "$:" <> js_string(parentkey) do
+          is_(inj, :dpath, slice(ig(inj, :dpath), -1))
+        else
+          is_(inj, :dpath, vlist_new(list_items(ig(inj, :dpath)) ++ [parentkey]))
+        end
+
+      true ->
+        :ok
+    end
+
+    ig(inj, :dparent)
+  end
+
+  defp inj_child(inj, keyi, keys) do
+    key = strkey(getelem(keys, keyi))
+    val = ig(inj, :ival)
+
+    vinj_new(%{
+      mode: ig(inj, :mode),
+      full: ig(inj, :full),
+      keyi: keyi,
+      keys: keys,
+      key: key,
+      ival: getprop(val, key),
+      parent: val,
+      path: vlist_new(list_items(ig(inj, :path)) ++ [key]),
+      nodes: vlist_new(list_items(ig(inj, :nodes)) ++ [val]),
+      handler: ig(inj, :handler),
+      errs: ig(inj, :errs),
+      meta: ig(inj, :meta),
+      base: ig(inj, :base),
+      modify: ig(inj, :modify),
+      prior: inj,
+      dpath: vlist_new(list_items(ig(inj, :dpath))),
+      dparent: ig(inj, :dparent),
+      extra: ig(inj, :extra),
+      root: ig(inj, :root)
+    })
+  end
+
+  defp inj_setval(inj, val, ancestor \\ 1) do
+    {target, key} =
+      if ancestor < 2 do
+        {ig(inj, :parent), ig(inj, :key)}
+      else
+        {getelem(ig(inj, :nodes), -ancestor), getelem(ig(inj, :path), -ancestor)}
+      end
+
+    if val == nil, do: delprop(target, key), else: setprop(target, key, val)
+  end
+
+  # ---------------------------------------------------------------------------
+  # inject
+  # ---------------------------------------------------------------------------
+
+  def inject(val, store, injdef \\ nil) do
+    inj =
+      if isinj(injdef) do
+        injdef
+      else
+        parent = vmap_new([{@s_dtop, val}])
+        i = new_inj(val, parent)
+        is_(i, :dparent, store)
+        is_(i, :errs, getprop(store, @s_derrs, empty_list()))
+        if ismap(ig(i, :meta)), do: setprop(ig(i, :meta), "__d", 0)
+        is_(i, :root, parent)
+
+        if injdef != nil do
+          if getprop(injdef, "modify") != nil, do: is_(i, :modify, getprop(injdef, "modify"))
+          if getprop(injdef, "extra") != nil, do: is_(i, :extra, getprop(injdef, "extra"))
+          if getprop(injdef, "meta") != nil, do: is_(i, :meta, getprop(injdef, "meta"))
+          if getprop(injdef, "handler") != nil, do: is_(i, :handler, getprop(injdef, "handler"))
+        end
+
+        i
+      end
+
+    inj_descend(inj)
+
+    rv =
+      cond do
+        isnode(val) ->
+          nodekeys =
+            if ismap(val) do
+              ks = Enum.map(map_pairs(val), &elem(&1, 0))
+              normal = ks |> Enum.filter(fn k -> not String.contains?(k, @s_ds) end) |> Enum.sort()
+              trans = ks |> Enum.filter(fn k -> String.contains?(k, @s_ds) end) |> Enum.sort()
+              normal ++ trans
+            else
+              n = length(list_items(val))
+              if n == 0, do: [], else: Enum.map(0..(n - 1), &Integer.to_string/1)
+            end
+
+          inject_loop(inj, val, store, nodekeys, 0)
+          val
+
+        is_binary(val) ->
+          is_(inj, :mode, @m_val)
+          nv = injectstr(val, store, inj)
+          if not is_skip(nv), do: inj_setval(inj, nv)
+          nv
+
+        true ->
+          val
+      end
+
+    if ig(inj, :modify) != nil and not is_skip(rv) do
+      mkey = ig(inj, :key)
+      mparent = ig(inj, :parent)
+      mval = getprop(mparent, mkey)
+      ig(inj, :modify).(mval, mkey, mparent, inj)
+    end
+
+    is_(inj, :ival, rv)
+
+    cond do
+      ig(inj, :prior) == nil and ig(inj, :root) != nil and haskey(ig(inj, :root), @s_dtop) ->
+        getprop(ig(inj, :root), @s_dtop)
+
+      ig(inj, :key) == @s_dtop and ig(inj, :parent) != nil and haskey(ig(inj, :parent), @s_dtop) ->
+        getprop(ig(inj, :parent), @s_dtop)
+
+      true ->
+        rv
+    end
+  end
+
+  defp inject_loop(inj, val, store, nodekeys, nki) do
+    if nki >= length(nodekeys) do
+      :ok
+    else
+      childinj = inj_child(inj, nki, vlist_new(nodekeys))
+      nodekey = ig(childinj, :key)
+      is_(childinj, :mode, @m_keypre)
+      prekey = injectstr(js_string(nodekey), store, childinj)
+      nk1 = Enum.map(list_items(ig(childinj, :keys)), &js_string/1)
+
+      nk2 =
+        if prekey != nil do
+          is_(childinj, :ival, getprop(val, prekey))
+          is_(childinj, :mode, @m_val)
+          inject(ig(childinj, :ival), store, childinj)
+          _ = Enum.map(list_items(ig(childinj, :keys)), &js_string/1)
+          is_(childinj, :mode, @m_keypost)
+          injectstr(js_string(nodekey), store, childinj)
+          Enum.map(list_items(ig(childinj, :keys)), &js_string/1)
+        else
+          nk1
+        end
+
+      inject_loop(inj, val, store, nk2, ig(childinj, :keyi) + 1)
+    end
+  end
+
+  defp inject_handler(inj, val, ref, store) do
+    iscmd = isfunc(val) and (ref == nil or (is_binary(ref) and String.starts_with?(ref, @s_ds)))
+
+    cond do
+      iscmd ->
+        val.(inj, val, ref, store)
+
+      ig(inj, :mode) == @m_val and ig(inj, :full) ->
+        inj_setval(inj, val)
+        val
+
+      true ->
+        val
+    end
+  end
+
+  defp injectstr(val, store, inj) do
+    if val == @s_mt do
+      @s_mt
+    else
+      case Regex.run(@r_inject_full, val) do
+        [_, pathref0] ->
+          if inj != nil, do: is_(inj, :full, true)
+
+          pathref =
+            if String.length(pathref0) > 3,
+              do: pathref0 |> String.replace("$BT", @s_bt) |> String.replace("$DS", @s_ds),
+              else: pathref0
+
+          getpath(store, pathref, inj)
+
+        _ ->
+          out =
+            Regex.replace(@r_inject_part, val, fn _whole, ref0 ->
+              ref =
+                if String.length(ref0) > 3,
+                  do: ref0 |> String.replace("$BT", @s_bt) |> String.replace("$DS", @s_ds),
+                  else: ref0
+
+              if inj != nil, do: is_(inj, :full, false)
+              found = getpath(store, ref, inj)
+
+              cond do
+                found == nil -> @s_mt
+                is_binary(found) -> if found == "__NULL__", do: "null", else: found
+                isfunc(found) -> @s_mt
+                true -> try do; json_encode(found); rescue _ -> stringify(found) end
+              end
+            end)
+
+          if inj != nil and isfunc(ig(inj, :handler)) do
+            is_(inj, :full, true)
+            ig(inj, :handler).(inj, out, val, store)
+          else
+            out
+          end
+      end
+    end
+  end
+
+  # ---------------------------------------------------------------------------
+  # transform commands
+  # ---------------------------------------------------------------------------
+
+  defp transform_delete(inj, _v, _r, _s) do
+    delprop(ig(inj, :parent), ig(inj, :key))
+    nil
+  end
+
+  defp transform_copy(inj, _v, _r, _s) do
+    if ig(inj, :mode) == @m_keypre or ig(inj, :mode) == @m_keypost do
+      ig(inj, :key)
+    else
+      out = lookup_(ig(inj, :dparent), ig(inj, :key))
+      inj_setval(inj, out)
+      out
+    end
+  end
+
+  defp transform_key(inj, _v, _r, _s) do
+    if ig(inj, :mode) != @m_val do
+      nil
+    else
+      keyspec = lookup_(ig(inj, :parent), @s_bkey)
+
+      if keyspec != nil do
+        delprop(ig(inj, :parent), @s_bkey)
+        getprop(ig(inj, :dparent), keyspec)
+      else
+        anno = lookup_(ig(inj, :parent), @s_banno)
+        fromanno = lookup_(anno, @s_key)
+        if fromanno != nil, do: fromanno, else: getelem(ig(inj, :path), -2)
+      end
+    end
+  end
+
+  defp transform_anno(inj, _v, _r, _s) do
+    delprop(ig(inj, :parent), @s_banno)
+    nil
+  end
+
+  defp transform_merge(inj, _v, _r, _s) do
+    cond do
+      ig(inj, :mode) == @m_keypre ->
+        ig(inj, :key)
+
+      ig(inj, :mode) == @m_keypost ->
+        args0 = getprop(ig(inj, :parent), ig(inj, :key))
+        args = if islist(args0), do: args0, else: vlist_new([args0])
+        inj_setval(inj, nil)
+        mergelist = flatten(vlist_new([vlist_new([ig(inj, :parent)]), args, vlist_new([clone(ig(inj, :parent))])]))
+        merge(mergelist)
+        ig(inj, :key)
+
+      true ->
+        nil
+    end
+  end
+
+  defp transform_each(inj, _v, _r, store) do
+    if islist(ig(inj, :keys)), do: slice(ig(inj, :keys), 0, 1, true)
+
+    if ig(inj, :mode) != @m_val do
+      nil
+    else
+      parent = ig(inj, :parent)
+      srcpath = if size(parent) > 1, do: getelem(parent, 1), else: nil
+      child_tm = if size(parent) > 2, do: clone(getelem(parent, 2)), else: nil
+      srcstore = getprop(store, ig(inj, :base), store)
+      src = getpath(srcstore, srcpath, inj)
+      tkey = getelem(ig(inj, :path), -2)
+      nodes = ig(inj, :nodes)
+      target = (fn -> t = getelem(nodes, -2); if t == nil, do: getelem(nodes, -1), else: t end).()
+      rval = vlist_new([])
+
+      if isnode(src) do
+        tval_items =
+          cond do
+            islist(src) ->
+              Enum.map(list_items(src), fn _ -> clone(child_tm) end)
+
+            ismap(src) ->
+              Enum.map(map_pairs(src), fn {k, _} ->
+                cc = clone(child_tm)
+                if ismap(cc), do: setprop(cc, @s_banno, vmap_new([{@s_key, k}]))
+                cc
+              end)
+
+            true ->
+              []
+          end
+
+        tval = vlist_new(tval_items)
+
+        tcurrent =
+          cond do
+            ismap(src) -> vlist_new(Enum.map(map_pairs(src), &elem(&1, 1)))
+            islist(src) -> vlist_new(list_items(src))
+            true -> src
+          end
+
+        if tval_items != [] do
+          path = ig(inj, :path)
+          ckey = getelem(path, -2)
+          plist = list_items(path)
+          tpath = if plist == [], do: vlist_new([]), else: vlist_new(Enum.take(plist, length(plist) - 1))
+          dpath0 = [@s_dtop]
+
+          dpath0 =
+            if is_binary(srcpath) and srcpath != @s_mt do
+              dpath0 ++ (String.split(srcpath, ".") |> Enum.filter(&(&1 != @s_mt)))
+            else
+              dpath0
+            end
+
+          dpath0 = if ckey != nil, do: dpath0 ++ ["$:" <> js_string(ckey)], else: dpath0
+          tcur = vmap_new([{js_string(ckey), tcurrent}])
+
+          {tcur, dpath0} =
+            if size(tpath) > 1 do
+              pkey = getelem(path, -3, @s_dtop)
+              {vmap_new([{js_string(pkey), tcur}]), dpath0 ++ ["$:" <> js_string(pkey)]}
+            else
+              {tcur, dpath0}
+            end
+
+          tinj = inj_child(inj, 0, if(ckey != nil, do: vlist_new([ckey]), else: vlist_new([])))
+          is_(tinj, :path, tpath)
+          nlist = list_items(nodes)
+          is_(tinj, :nodes, if(nlist == [], do: vlist_new([]), else: vlist_new(Enum.take(nlist, length(nlist) - 1))))
+          is_(tinj, :parent, if(size(ig(tinj, :nodes)) > 0, do: getelem(ig(tinj, :nodes), -1), else: nil))
+          if ckey != nil and ig(tinj, :parent) != nil, do: setprop(ig(tinj, :parent), ckey, tval)
+          is_(tinj, :ival, tval)
+          is_(tinj, :dpath, vlist_new(dpath0))
+          is_(tinj, :dparent, tcur)
+          inject(tval, store, tinj)
+          rval = ig(tinj, :ival)
+          setprop(target, tkey, rval)
+          if islist(rval) and size(rval) > 0, do: getelem(rval, 0), else: nil
+        else
+          setprop(target, tkey, rval)
+          if islist(rval) and size(rval) > 0, do: getelem(rval, 0), else: nil
+        end
+      else
+        setprop(target, tkey, rval)
+        nil
+      end
+    end
+  end
+
+  defp transform_pack(inj, _v, _r, store) do
+    cond do
+      ig(inj, :mode) != @m_keypre or not is_binary(ig(inj, :key)) ->
+        nil
+
+      true ->
+        parent = ig(inj, :parent)
+        path = ig(inj, :path)
+        nodes = ig(inj, :nodes)
+        args_val = getprop(parent, ig(inj, :key))
+
+        if not islist(args_val) or size(args_val) < 2 do
+          nil
+        else
+          srcpath = getelem(args_val, 0)
+          origchildspec = getelem(args_val, 1)
+          tkey = getelem(path, -2)
+          pathsize = size(path)
+          target = (fn -> t = getelem(nodes, pathsize - 2); if t == nil, do: getelem(nodes, pathsize - 1), else: t end).()
+          srcstore = getprop(store, ig(inj, :base), store)
+          src0 = getpath(srcstore, srcpath, inj)
+
+          src =
+            if not islist(src0) do
+              if ismap(src0) do
+                vlist_new(
+                  Enum.map(items_pairs(src0), fn {k, node} ->
+                    setprop(node, @s_banno, vmap_new([{@s_key, k}]))
+                    node
+                  end)
+                )
+              else
+                nil
+              end
+            else
+              src0
+            end
+
+          if src == nil do
+            nil
+          else
+            keypath = getprop(origchildspec, @s_bkey)
+            childspec = delprop(origchildspec, @s_bkey)
+            child = getprop(childspec, @s_bval, childspec)
+            tval = empty_map()
+
+            Enum.each(items_pairs(src), fn {srckey, srcnode} ->
+              k =
+                cond do
+                  keypath == nil -> srckey
+                  is_binary(keypath) and String.starts_with?(keypath, @s_bt) -> inject(keypath, merge(vlist_new([empty_map(), store, vmap_new([{@s_dtop, srcnode}])]), 1))
+                  true -> getpath(srcnode, keypath, inj)
+                end
+
+              tchild = clone(child)
+              setprop(tval, k, tchild)
+              anno = getprop(srcnode, @s_banno)
+              if anno == nil, do: delprop(tchild, @s_banno), else: setprop(tchild, @s_banno, anno)
+            end)
+
+            rval =
+              if not isempty(tval) do
+                tsrc = empty_map()
+
+                list_items(src)
+                |> Enum.with_index()
+                |> Enum.each(fn {node, i} ->
+                  kn =
+                    cond do
+                      keypath == nil -> i
+                      is_binary(keypath) and String.starts_with?(keypath, @s_bt) -> inject(keypath, merge(vlist_new([empty_map(), store, vmap_new([{@s_dtop, node}])]), 1))
+                      true -> getpath(node, keypath, inj)
+                    end
+
+                  setprop(tsrc, kn, node)
+                end)
+
+                tpath = slice(ig(inj, :path), -1)
+                ckey = getelem(ig(inj, :path), -2)
+                dpath = flatten(vlist_new([@s_dtop, vlist_new(String.split(srcpath, ".")), "$:" <> js_string(ckey)]))
+
+                tcur =
+                  if size(tpath) > 1 do
+                    pkey = getelem(ig(inj, :path), -3, @s_dtop)
+                    setprop(dpath, size(dpath), "$:" <> js_string(pkey))
+                    vmap_new([{js_string(pkey), vmap_new([{js_string(ckey), tsrc}])}])
+                  else
+                    vmap_new([{js_string(ckey), tsrc}])
+                  end
+
+                tinj = inj_child(inj, 0, vlist_new([ckey]))
+                is_(tinj, :path, tpath)
+                is_(tinj, :nodes, slice(ig(inj, :nodes), -1))
+                is_(tinj, :parent, getelem(ig(tinj, :nodes), -1))
+                is_(tinj, :ival, tval)
+                is_(tinj, :dpath, dpath)
+                is_(tinj, :dparent, tcur)
+                inject(tval, store, tinj)
+                ig(tinj, :ival)
+              else
+                empty_map()
+              end
+
+            setprop(target, tkey, rval)
+            nil
+          end
+        end
+    end
+  end
+
+  defp transform_ref(inj, val, _r, store) do
+    if ig(inj, :mode) != @m_val do
+      nil
+    else
+      nodes = ig(inj, :nodes)
+      refpath = lookup_(ig(inj, :parent), 1)
+      is_(inj, :keyi, size(ig(inj, :keys)))
+      spec_func = getprop(store, @s_dspec)
+
+      if not isfunc(spec_func) do
+        nil
+      else
+        spec = spec_func.(inj, nil, "", store)
+        refv = getpath(spec, refpath)
+        flag = vlist_new([false])
+
+        if isnode(refv) do
+          walk(refv, after: fn _k, v2, _p, _path ->
+            if v2 == "`$REF`", do: setprop(flag, 0, true)
+            v2
+          end)
+        end
+
+        has_sub = getelem(flag, 0) == true
+        tref = clone(refv)
+        cpath = slice(ig(inj, :path), 0, size(ig(inj, :path)) - 3)
+        tpath = slice(ig(inj, :path), 0, size(ig(inj, :path)) - 1)
+        tcur = getpath(store, cpath)
+        tval = getpath(store, tpath)
+
+        rval =
+          if refv != nil and (not has_sub or tval != nil) do
+            cs = inj_child(inj, 0, vlist_new([getelem(tpath, -1)]))
+            is_(cs, :path, tpath)
+            is_(cs, :nodes, slice(ig(inj, :nodes), 0, size(ig(inj, :nodes)) - 1))
+            is_(cs, :parent, getelem(nodes, -2))
+            is_(cs, :ival, tref)
+            is_(cs, :dparent, tcur)
+            inject(tref, store, cs)
+            ig(cs, :ival)
+          else
+            nil
+          end
+
+        inj_setval(inj, rval, 2)
+
+        if islist(ig(inj, :parent)) and ig(inj, :prior) != nil do
+          is_(ig(inj, :prior), :keyi, ig(ig(inj, :prior), :keyi) - 1)
+        end
+
+        val
+      end
+    end
+  end
+
+  defp formatter_tbl do
+    %{
+      "identity" => fn _k, v -> v end,
+      "upper" => fn _k, v -> if isnode(v), do: v, else: String.upcase(js_string(v)) end,
+      "lower" => fn _k, v -> if isnode(v), do: v, else: String.downcase(js_string(v)) end,
+      "string" => fn _k, v -> if isnode(v), do: v, else: js_string(v) end,
+      "number" => fn _k, v ->
+        if isnode(v) do
+          v
+        else
+          n = parse_num(js_string(v))
+          if is_intish(n), do: trunc(n), else: n
+        end
+      end,
+      "integer" => fn _k, v -> if isnode(v), do: v, else: trunc(parse_num(js_string(v))) end,
+      "concat" => fn k, v ->
+        if k == nil and islist(v) do
+          join(items_v(v, fn {_, x} -> if isnode(x), do: @s_mt, else: js_string(x) end), @s_mt)
+        else
+          v
+        end
+      end
+    }
+  end
+
+  defp parse_num(s) do
+    case Float.parse(s) do
+      {n, _} -> n
+      :error -> 0
+    end
+  end
+
+  def check_placement(modes, ijname, parent_types, inj) do
+    modenum = mode_to_num(ig(inj, :mode))
+
+    cond do
+      Bitwise.band(modes, modenum) == 0 ->
+        allowed = Enum.filter([1, 2, 4], fn m -> Bitwise.band(modes, m) != 0 end)
+        placements = allowed |> Enum.map(fn m -> if m == 4, do: "value", else: "key" end) |> Enum.join(",")
+        cur = if modenum == 4, do: "value", else: "key"
+        push_err(inj, "$" <> ijname <> ": invalid placement as " <> cur <> ", expected: " <> placements <> ".")
+        false
+
+      not isempty(parent_types) ->
+        ptype = typify(ig(inj, :parent))
+
+        if Bitwise.band(parent_types, ptype) == 0 do
+          push_err(inj, "$" <> ijname <> ": invalid placement in parent " <> typename(ptype) <> ", expected: " <> typename(parent_types) <> ".")
+          false
+        else
+          true
+        end
+
+      true ->
+        true
+    end
+  end
+
+  def injector_args(arg_types, args) do
+    numargs = length(arg_types)
+    found = injector_args_loop(arg_types, args, 0, numargs, List.duplicate(nil, 1 + numargs))
+    vlist_new(found)
+  end
+
+  defp injector_args_loop(arg_types, args, argi, numargs, found) do
+    if argi >= numargs do
+      found
+    else
+      arg = getelem(args, argi)
+      arg_type = typify(arg)
+      at = Enum.at(arg_types, argi)
+
+      if Bitwise.band(at, arg_type) == 0 do
+        List.replace_at(found, 0, "invalid argument: " <> stringify(arg, 22) <> " (" <> typename(arg_type) <> " at position " <> Integer.to_string(1 + argi) <> ") is not of type: " <> typename(at) <> ".")
+      else
+        injector_args_loop(arg_types, args, argi + 1, numargs, List.replace_at(found, 1 + argi, arg))
+      end
+    end
+  end
+
+  def inject_child(child, store, inj) do
+    cinj =
+      if ig(inj, :prior) != nil do
+        prior = ig(inj, :prior)
+
+        if ig(prior, :prior) != nil do
+          c = inj_child(ig(prior, :prior), ig(prior, :keyi), ig(prior, :keys))
+          is_(c, :ival, child)
+          setprop(ig(c, :parent), ig(prior, :key), child)
+          c
+        else
+          c = inj_child(prior, ig(inj, :keyi), ig(inj, :keys))
+          is_(c, :ival, child)
+          setprop(ig(c, :parent), ig(inj, :key), child)
+          c
+        end
+      else
+        inj
+      end
+
+    inject(child, store, cinj)
+    cinj
+  end
+
+  defp transform_format(inj, _v, _r, store) do
+    slice(ig(inj, :keys), 0, 1, true)
+
+    if ig(inj, :mode) != @m_val do
+      nil
+    else
+      name = lookup_(ig(inj, :parent), 1)
+      child = lookup_(ig(inj, :parent), 2)
+      tkey = getelem(ig(inj, :path), -2)
+      target = (fn -> t = getelem(ig(inj, :nodes), -2); if t == nil, do: getelem(ig(inj, :nodes), -1), else: t end).()
+      cinj = inject_child(child, store, inj)
+      resolved = ig(cinj, :ival)
+
+      formatter =
+        if Bitwise.band(@t_function, typify(name)) > 0 do
+          fn k, v -> name.(dummy_inj(), v, js_string(k), nil) end
+        else
+          Map.get(formatter_tbl(), js_string(name))
+        end
+
+      if formatter == nil do
+        push_err(inj, "$FORMAT: unknown format: " <> js_string(name) <> ".")
+        nil
+      else
+        out = walk(resolved, after: fn k, v, _p, _path -> formatter.(k, v) end)
+        setprop(target, tkey, out)
+        out
+      end
+    end
+  end
+
+  defp transform_apply(inj, _v, _r, store) do
+    if not check_placement(4, "APPLY", @t_list, inj) do
+      nil
+    else
+      res = injector_args([@t_function, @t_any], slice(ig(inj, :parent), 1))
+      err = getelem(res, 0)
+      apply_fn = getelem(res, 1)
+      child = if size(res) > 2, do: getelem(res, 2), else: nil
+
+      if err != nil do
+        push_err(inj, "$APPLY: " <> js_string(err))
+        nil
+      else
+        tkey = getelem(ig(inj, :path), -2)
+        target = (fn -> t = getelem(ig(inj, :nodes), -2); if t == nil, do: getelem(ig(inj, :nodes), -1), else: t end).()
+        cinj = inject_child(child, store, inj)
+        resolved = ig(cinj, :ival)
+        out = apply_fn.(resolved, store, cinj)
+        setprop(target, tkey, out)
+        out
+      end
+    end
+  end
+
+  def transform(data, spec0, injdef \\ nil) do
+    origspec = spec0
+    spec = clone(spec0)
+    extra = if injdef != nil, do: getprop(injdef, "extra"), else: nil
+    collect = injdef != nil and getprop(injdef, "errs") != nil
+    errs = if collect, do: getprop(injdef, "errs"), else: empty_list()
+    extra_transforms = empty_map()
+    extra_data = empty_map()
+
+    if extra != nil do
+      Enum.each(items_pairs(extra), fn {k, v} ->
+        if String.starts_with?(k, @s_ds), do: setprop(extra_transforms, k, v), else: setprop(extra_data, k, v)
+      end)
+    end
+
+    data_clone = merge(vlist_new([if(isempty(extra_data), do: nil, else: clone(extra_data)), clone(data)]))
+    store = empty_map()
+    setprop(store, @s_dtop, data_clone)
+    setprop(store, @s_dspec, fn _i, _v, _r, _s -> origspec end)
+    setprop(store, "$BT", fn _i, _v, _r, _s -> @s_bt end)
+    setprop(store, "$DS", fn _i, _v, _r, _s -> @s_ds end)
+    setprop(store, "$WHEN", fn _i, _v, _r, _s -> "1970-01-01T00:00:00.000Z" end)
+    setprop(store, "$DELETE", &transform_delete/4)
+    setprop(store, "$COPY", &transform_copy/4)
+    setprop(store, "$KEY", &transform_key/4)
+    setprop(store, "$ANNO", &transform_anno/4)
+    setprop(store, "$MERGE", &transform_merge/4)
+    setprop(store, "$EACH", &transform_each/4)
+    setprop(store, "$PACK", &transform_pack/4)
+    setprop(store, "$REF", &transform_ref/4)
+    setprop(store, "$FORMAT", &transform_format/4)
+    setprop(store, "$APPLY", &transform_apply/4)
+    Enum.each(items_pairs(extra_transforms), fn {k, v} -> setprop(store, k, v) end)
+    setprop(store, @s_derrs, errs)
+
+    idef = empty_map()
+    if ismap(injdef), do: Enum.each(items_pairs(injdef), fn {k, v} -> setprop(idef, k, v) end)
+    setprop(idef, "errs", errs)
+    out = inject(spec, store, idef)
+    if size(errs) > 0 and not collect, do: raise(Voxgig.Struct.Error, message: join(errs, " | "))
+    out
+  end
+
+  # ---------------------------------------------------------------------------
+  # validate
+  # ---------------------------------------------------------------------------
+
+  defp push_err(inj, msg), do: setprop(ig(inj, :errs), size(ig(inj, :errs)), msg)
+
+  defp invalid_type_msg(path, needtype, vt, v, _whence) do
+    vs = if v == nil, do: "no value", else: stringify(v)
+
+    "Expected " <>
+      (if size(path) > 1, do: "field " <> pathify(path, 1) <> " to be ", else: "") <>
+      needtype <>
+      ", but found " <>
+      (if v != nil, do: typename(vt) <> @s_viz, else: "") <>
+      vs <> "."
+  end
+
+  defp validate_string(inj, _v, _r, _s) do
+    out = lookup_(ig(inj, :dparent), ig(inj, :key))
+    t = typify(out)
+
+    cond do
+      Bitwise.band(@t_string, t) == 0 -> push_err(inj, invalid_type_msg(ig(inj, :path), "string", t, out, "V1010")); nil
+      out == @s_mt -> push_err(inj, "Empty string at " <> pathify(ig(inj, :path), 1)); nil
+      true -> out
+    end
+  end
+
+  defp validate_type(inj, _v, ref, _s) do
+    tname = if is_binary(ref) and String.length(ref) > 1, do: String.downcase(String.slice(ref, 1, String.length(ref) - 1)), else: "any"
+    idx = type_index(tname)
+    typev0 = if idx >= 0, do: Bitwise.bsl(1, 31 - idx), else: 0
+    typev = if tname == "nil", do: Bitwise.bor(typev0, @t_null), else: typev0
+    out = lookup_(ig(inj, :dparent), ig(inj, :key))
+    t = typify(out)
+
+    if Bitwise.band(t, typev) == 0 do
+      push_err(inj, invalid_type_msg(ig(inj, :path), tname, t, out, "V1001"))
+      nil
+    else
+      out
+    end
+  end
+
+  defp type_index(tname) do
+    Enum.find_index(Tuple.to_list(@typename), fn x -> x == tname end) || -1
+  end
+
+  defp validate_any(inj, _v, _r, _s), do: lookup_(ig(inj, :dparent), ig(inj, :key))
+
+  defp validate_child(inj, _v, _r, _s) do
+    parent = ig(inj, :parent)
+    key = ig(inj, :key)
+    path = ig(inj, :path)
+    keys = ig(inj, :keys)
+
+    cond do
+      ig(inj, :mode) == @m_keypre ->
+        childtm = getprop(parent, key)
+        pkey = getelem(path, -2)
+        tval = getprop(ig(inj, :dparent), pkey)
+
+        cond do
+          tval == nil ->
+            Enum.each(keysof(empty_map()), fn ckey -> setprop(parent, ckey, clone(childtm)); setprop(keys, size(keys), ckey) end)
+            delprop(parent, key)
+            nil
+
+          not ismap(tval) ->
+            push_err(inj, invalid_type_msg(slice(path, 0, size(path) - 1), "object", typify(tval), tval, "V0220"))
+            nil
+
+          true ->
+            Enum.each(keysof(tval), fn ckey -> setprop(parent, ckey, clone(childtm)); setprop(keys, size(keys), ckey) end)
+            delprop(parent, key)
+            nil
+        end
+
+      ig(inj, :mode) == @m_val ->
+        childtm = getprop(parent, 1)
+
+        cond do
+          not islist(parent) ->
+            push_err(inj, "Invalid $CHILD as value")
+            nil
+
+          ig(inj, :dparent) == nil ->
+            list_set_items(parent, [])
+            nil
+
+          not islist(ig(inj, :dparent)) ->
+            push_err(inj, invalid_type_msg(slice(path, 0, size(path) - 1), "list", typify(ig(inj, :dparent)), ig(inj, :dparent), "V0230"))
+            is_(inj, :keyi, size(parent))
+            ig(inj, :dparent)
+
+          true ->
+            Enum.each(items_pairs(ig(inj, :dparent)), fn {k, _} -> setprop(parent, k, clone(childtm)) end)
+            n = size(ig(inj, :dparent))
+            list_set_items(parent, Enum.take(list_items(parent), n))
+            is_(inj, :keyi, 0)
+            getprop(ig(inj, :dparent), 0)
+        end
+
+      true ->
+        nil
+    end
+  end
+
+  defp validate_one(inj, _v, _r, store) do
+    if ig(inj, :mode) != @m_val do
+      nil
+    else
+      parent = ig(inj, :parent)
+
+      if not islist(parent) or ig(inj, :keyi) != 0 do
+        push_err(inj, "The $ONE validator at field " <> pathify(ig(inj, :path), 1, 1) <> " must be the first element of an array.")
+        nil
+      else
+        is_(inj, :keyi, size(ig(inj, :keys)))
+        inj_setval(inj, ig(inj, :dparent), 2)
+        is_(inj, :path, slice(ig(inj, :path), 0, size(ig(inj, :path)) - 1))
+        is_(inj, :key, getelem(ig(inj, :path), -1))
+        tvals = slice(parent, 1)
+
+        if size(tvals) == 0 do
+          push_err(inj, "The $ONE validator at field " <> pathify(ig(inj, :path), 1, 1) <> " must have at least one argument.")
+          nil
+        else
+          matched = validate_one_loop(inj, store, list_items(tvals), false)
+
+          if not matched do
+            valdesc = Enum.map_join(list_items(tvals), ", ", &stringify/1)
+            valdesc = Regex.replace(@r_transform_name, valdesc, fn _w, g1 -> String.downcase(g1) end)
+            push_err(inj, invalid_type_msg(ig(inj, :path), (if size(tvals) > 1, do: "one of ", else: "") <> valdesc, typify(ig(inj, :dparent)), ig(inj, :dparent), "V0210"))
+          end
+
+          nil
+        end
+      end
+    end
+  end
+
+  defp validate_one_loop(_inj, _store, [], matched), do: matched
+
+  defp validate_one_loop(inj, store, [tv | rest], matched) do
+    if matched do
+      true
+    else
+      terrs = empty_list()
+      vstore = merge(vlist_new([empty_map(), store]), 1)
+      setprop(vstore, @s_dtop, ig(inj, :dparent))
+      idef = vmap_new([{"extra", vstore}, {"errs", terrs}, {"meta", ig(inj, :meta)}])
+      vcurrent = validate(ig(inj, :dparent), tv, idef)
+      inj_setval(inj, vcurrent, -2)
+      if size(terrs) == 0, do: true, else: validate_one_loop(inj, store, rest, false)
+    end
+  end
+
+  defp validate_exact(inj, _v, _r, _s) do
+    if ig(inj, :mode) != @m_val do
+      delprop(ig(inj, :parent), ig(inj, :key))
+      nil
+    else
+      parent = ig(inj, :parent)
+
+      if not islist(parent) or ig(inj, :keyi) != 0 do
+        push_err(inj, "The $EXACT validator at field " <> pathify(ig(inj, :path), 1, 1) <> " must be the first element of an array.")
+        nil
+      else
+        is_(inj, :keyi, size(ig(inj, :keys)))
+        inj_setval(inj, ig(inj, :dparent), 2)
+        is_(inj, :path, slice(ig(inj, :path), 0, size(ig(inj, :path)) - 1))
+        is_(inj, :key, getelem(ig(inj, :path), -1))
+        tvals = slice(parent, 1)
+
+        if size(tvals) == 0 do
+          push_err(inj, "The $EXACT validator at field " <> pathify(ig(inj, :path), 1, 1) <> " must have at least one argument.")
+          nil
+        else
+          matched = Enum.any?(list_items(tvals), fn tv -> veq(tv, ig(inj, :dparent)) end)
+
+          if not matched do
+            valdesc = Enum.map_join(list_items(tvals), ", ", &stringify/1)
+            valdesc = Regex.replace(@r_transform_name, valdesc, fn _w, g1 -> String.downcase(g1) end)
+            push_err(inj, invalid_type_msg(ig(inj, :path), (if size(ig(inj, :path)) > 1, do: "", else: "value ") <> "exactly equal to " <> (if size(tvals) == 1, do: "", else: "one of ") <> valdesc, typify(ig(inj, :dparent)), ig(inj, :dparent), "V0110"))
+          end
+
+          nil
+        end
+      end
+    end
+  end
+
+  def veq(a, b) do
+    cond do
+      a == nil and b == nil -> true
+      is_boolean(a) or is_boolean(b) -> a == b
+      is_number(a) and is_number(b) -> a == b
+      is_binary(a) and is_binary(b) -> a == b
+      islist(a) and islist(b) -> ia = list_items(a); ib = list_items(b); length(ia) == length(ib) and Enum.all?(Enum.zip(ia, ib), fn {x, y} -> veq(x, y) end)
+      ismap(a) and ismap(b) -> veq_map(a, b)
+      true -> a == b
+    end
+  end
+
+  defp veq_map(a, b) do
+    pa = map_pairs(a)
+    pb = map_pairs(b)
+    length(pa) == length(pb) and Enum.all?(pa, fn {k, v} -> case omap_get(pb, k) do; {:ok, w} -> veq(v, w); :error -> false end end)
+  end
+
+  defp validation(pval, key, parent, inj) do
+    if is_skip(pval) do
+      :ok
+    else
+      exact = getprop(ig(inj, :meta), @s_bexact, false)
+      cval = getprop(ig(inj, :dparent), key)
+      exact_b = exact == true
+
+      if not exact_b and cval == nil do
+        :ok
+      else
+        ptype = typify(pval)
+
+        if Bitwise.band(@t_string, ptype) > 0 and String.contains?(js_string(pval), @s_ds) do
+          :ok
+        else
+          ctype = typify(cval)
+
+          cond do
+            ptype != ctype and pval != nil ->
+              push_err(inj, invalid_type_msg(ig(inj, :path), typename(ptype), ctype, cval, "V0010"))
+
+            ismap(cval) ->
+              if not ismap(pval) do
+                push_err(inj, invalid_type_msg(ig(inj, :path), typename(ptype), ctype, cval, "V0020"))
+              else
+                ckeys = keysof(cval)
+                pkeys = keysof(pval)
+
+                if pkeys != [] and getprop(pval, @s_bopen) != true do
+                  badkeys = Enum.filter(ckeys, fn ck -> lookup_(pval, ck) == nil end)
+                  if badkeys != [], do: push_err(inj, "Unexpected keys at field " <> pathify(ig(inj, :path), 1) <> @s_viz <> Enum.join(badkeys, ", "))
+                else
+                  merge(vlist_new([pval, cval]))
+                  if isnode(pval), do: delprop(pval, @s_bopen)
+                end
+              end
+
+            islist(cval) ->
+              if not islist(pval), do: push_err(inj, invalid_type_msg(ig(inj, :path), typename(ptype), ctype, cval, "V0030"))
+
+            exact_b ->
+              if not veq(cval, pval) do
+                pathmsg = if size(ig(inj, :path)) > 1, do: "at field " <> pathify(ig(inj, :path), 1) <> ": ", else: ""
+                push_err(inj, "Value " <> pathmsg <> js_string(cval) <> " should equal " <> js_string(pval) <> ".")
+              end
+
+            true ->
+              setprop(parent, key, cval)
+          end
+
+          :ok
+        end
+      end
+    end
+  end
+
+  defp validate_handler(inj, val, ref, store) do
+    m = if is_binary(ref), do: Regex.run(@r_meta_path, ref), else: nil
+
+    case m do
+      [_, _, g2, _] ->
+        if g2 == "=", do: inj_setval(inj, vlist_new([@s_bexact, val])), else: inj_setval(inj, val)
+        is_(inj, :keyi, -1)
+        @skip
+
+      _ ->
+        inject_handler(inj, val, ref, store)
+    end
+  end
+
+  def validate(data, spec, injdef \\ nil) do
+    extra = getprop(injdef, "extra")
+    collect = injdef != nil and getprop(injdef, "errs") != nil
+    errs = if collect, do: getprop(injdef, "errs"), else: empty_list()
+    base = empty_map()
+    Enum.each(["$DELETE", "$COPY", "$KEY", "$META", "$MERGE", "$EACH", "$PACK"], fn k -> setprop(base, k, nil) end)
+    setprop(base, "$STRING", &validate_string/4)
+    Enum.each(["$NUMBER", "$INTEGER", "$DECIMAL", "$BOOLEAN", "$NULL", "$NIL", "$MAP", "$LIST", "$FUNCTION", "$INSTANCE"], fn k -> setprop(base, k, &validate_type/4) end)
+    setprop(base, "$ANY", &validate_any/4)
+    setprop(base, "$CHILD", &validate_child/4)
+    setprop(base, "$ONE", &validate_one/4)
+    setprop(base, "$EXACT", &validate_exact/4)
+    store = merge(vlist_new([base, if(extra == nil, do: empty_map(), else: extra), vmap_new([{@s_derrs, errs}])]), 1)
+    meta = getprop(injdef, "meta", empty_map())
+    setprop(meta, @s_bexact, getprop(meta, @s_bexact, false))
+    idef = vmap_new([{"meta", meta}, {"extra", store}, {"modify", &validation/4}, {"handler", &validate_handler/4}, {"errs", errs}])
+    out = transform(data, spec, idef)
+    if size(errs) > 0 and not collect, do: raise(Voxgig.Struct.Error, message: join(errs, " | "))
+    out
+  end
+
+  # ---------------------------------------------------------------------------
+  # select
+  # ---------------------------------------------------------------------------
+
+  defp select_and(inj, _v, _r, store) do
+    if ig(inj, :mode) == @m_keypre do
+      terms = getprop(ig(inj, :parent), ig(inj, :key))
+      ppath = slice(ig(inj, :path), -1)
+      point = getpath(store, ppath)
+      vstore = merge(vlist_new([empty_map(), store]), 1)
+      setprop(vstore, @s_dtop, point)
+
+      Enum.each(items_pairs(terms), fn {_, term} ->
+        terrs = empty_list()
+        validate(point, term, vmap_new([{"extra", vstore}, {"errs", terrs}, {"meta", ig(inj, :meta)}]))
+        if size(terrs) != 0, do: push_err(inj, "AND:" <> pathify(ppath) <> "⨯" <> stringify(point) <> " fail:" <> stringify(terms))
+      end)
+
+      gkey = getelem(ig(inj, :path), -2)
+      gp = getelem(ig(inj, :nodes), -2)
+      setprop(gp, gkey, point)
+    end
+
+    nil
+  end
+
+  defp select_or(inj, _v, _r, store) do
+    if ig(inj, :mode) == @m_keypre do
+      terms = getprop(ig(inj, :parent), ig(inj, :key))
+      ppath = slice(ig(inj, :path), -1)
+      point = getpath(store, ppath)
+      vstore = merge(vlist_new([empty_map(), store]), 1)
+      setprop(vstore, @s_dtop, point)
+      done = select_or_loop(inj, store, vstore, ppath, point, items_pairs(terms))
+      if not done, do: push_err(inj, "OR:" <> pathify(ppath) <> "⨯" <> stringify(point) <> " fail:" <> stringify(terms))
+    end
+
+    nil
+  end
+
+  defp select_or_loop(_inj, _store, _vstore, _ppath, _point, []), do: false
+
+  defp select_or_loop(inj, store, vstore, ppath, point, [{_, term} | rest]) do
+    terrs = empty_list()
+    validate(point, term, vmap_new([{"extra", vstore}, {"errs", terrs}, {"meta", ig(inj, :meta)}]))
+
+    if size(terrs) == 0 do
+      gkey = getelem(ig(inj, :path), -2)
+      gp = getelem(ig(inj, :nodes), -2)
+      setprop(gp, gkey, point)
+      true
+    else
+      select_or_loop(inj, store, vstore, ppath, point, rest)
+    end
+  end
+
+  defp select_not(inj, _v, _r, store) do
+    if ig(inj, :mode) == @m_keypre do
+      term = getprop(ig(inj, :parent), ig(inj, :key))
+      ppath = slice(ig(inj, :path), -1)
+      point = getpath(store, ppath)
+      vstore = merge(vlist_new([empty_map(), store]), 1)
+      setprop(vstore, @s_dtop, point)
+      terrs = empty_list()
+      validate(point, term, vmap_new([{"extra", vstore}, {"errs", terrs}, {"meta", ig(inj, :meta)}]))
+      if size(terrs) == 0, do: push_err(inj, "NOT:" <> pathify(ppath) <> "⨯" <> stringify(point) <> " fail:" <> stringify(term))
+      gkey = getelem(ig(inj, :path), -2)
+      gp = getelem(ig(inj, :nodes), -2)
+      setprop(gp, gkey, point)
+    end
+
+    nil
+  end
+
+  defp num_cmp(a, b, op) do
+    if is_number(a) and is_number(b) do
+      case op do
+        :gt -> a > b
+        :lt -> a < b
+        :gte -> a >= b
+        :lte -> a <= b
+      end
+    else
+      false
+    end
+  end
+
+  defp select_cmp(inj, _v, ref, store) do
+    if ig(inj, :mode) == @m_keypre do
+      term = getprop(ig(inj, :parent), ig(inj, :key))
+      gkey = getelem(ig(inj, :path), -2)
+      ppath = slice(ig(inj, :path), -1)
+      point = getpath(store, ppath)
+
+      pass =
+        cond do
+          ref == "$GT" -> num_cmp(point, term, :gt)
+          ref == "$LT" -> num_cmp(point, term, :lt)
+          ref == "$GTE" -> num_cmp(point, term, :gte)
+          ref == "$LTE" -> num_cmp(point, term, :lte)
+          ref == "$LIKE" -> is_binary(term) and Regex.match?(Regex.compile!(term), stringify(point))
+          true -> false
+        end
+
+      if pass do
+        gp = getelem(ig(inj, :nodes), -2)
+        setprop(gp, gkey, point)
+      else
+        push_err(inj, "CMP: " <> pathify(ppath) <> "⨯" <> stringify(point) <> " fail:" <> js_string(ref) <> " " <> stringify(term))
+      end
+    end
+
+    nil
+  end
+
+  def select(children0, query) do
+    if not isnode(children0) do
+      empty_list()
+    else
+      children =
+        if ismap(children0) do
+          vlist_new(Enum.map(items_pairs(children0), fn {k, n} -> setprop(n, @s_dkey, k); n end))
+        else
+          vlist_new(
+            list_items(children0)
+            |> Enum.with_index()
+            |> Enum.map(fn {n, i} -> if ismap(n), do: (setprop(n, @s_dkey, i); n), else: n end)
+          )
+        end
+
+      results = empty_list()
+      extra = empty_map()
+      setprop(extra, "$AND", &select_and/4)
+      setprop(extra, "$OR", &select_or/4)
+      setprop(extra, "$NOT", &select_not/4)
+      setprop(extra, "$GT", &select_cmp/4)
+      setprop(extra, "$LT", &select_cmp/4)
+      setprop(extra, "$GTE", &select_cmp/4)
+      setprop(extra, "$LTE", &select_cmp/4)
+      setprop(extra, "$LIKE", &select_cmp/4)
+      q = clone(query)
+
+      walk(q, after: fn _k, v, _p, _path ->
+        if ismap(v), do: setprop(v, @s_bopen, getprop(v, @s_bopen, true))
+        v
+      end)
+
+      Enum.each(list_items(children), fn child ->
+        errs = empty_list()
+        meta = empty_map()
+        setprop(meta, @s_bexact, true)
+        idef = vmap_new([{"errs", errs}, {"meta", meta}, {"extra", extra}])
+        validate(child, clone(q), idef)
+        if size(errs) == 0, do: setprop(results, size(results), child)
+      end)
+
+      results
+    end
+  end
+
+  # ---------------------------------------------------------------------------
+  # builders
+  # ---------------------------------------------------------------------------
+
+  def jm(kv) do
+    m = empty_map()
+    n = length(kv)
+    jm_loop(m, kv, n, 0)
+    m
+  end
+
+  defp jm_loop(m, kv, n, i) do
+    if i >= n do
+      m
+    else
+      k0 = Enum.at(kv, i)
+      k = cond do; k0 == nil -> "null"; is_binary(k0) -> k0; true -> stringify(k0) end
+      setprop(m, k, if(i + 1 < n, do: Enum.at(kv, i + 1), else: nil))
+      jm_loop(m, kv, n, i + 2)
+    end
+  end
+
+  def jt(v), do: vlist_new(v)
+
+  def tn(t), do: typename(t)
+end
+
+defmodule Voxgig.Struct.Error do
+  defexception message: "struct error"
+end