diff --git a/CMakeLists.txt b/CMakeLists.txt
index aa6af8f6..a41e31e8 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -22,7 +22,6 @@ endif()
 
 
 ###############################################################################
-RAGEL_TARGET(json-flat json/flat.cpp.rl ${CMAKE_CURRENT_BINARY_DIR}/json/flat.cpp COMPILE_FLAGS -G2)
 RAGEL_TARGET(uri uri.cpp.rl ${CMAKE_CURRENT_BINARY_DIR}/uri.cpp COMPILE_FLAGS -G2)
 RAGEL_TARGET(version version.cpp.rl ${CMAKE_CURRENT_BINARY_DIR}/version.cpp)
 RAGEL_TARGET(format.cpp format.cpp.rl ${CMAKE_CURRENT_BINARY_DIR}/format.cpp)
@@ -291,46 +290,6 @@ list (
     job/dispatch.hpp
     job/queue.cpp
     job/queue.hpp
-    json/fwd.hpp
-    json/except.cpp
-    json/except.hpp
-    ${CMAKE_CURRENT_BINARY_DIR}/json/flat.cpp
-    json/flat.hpp
-    json/pointer.cpp
-    json/pointer.hpp
-    json/schema.cpp
-    json/schema.hpp
-    json/constraint/fwd.hpp
-    json/constraint/base.cpp
-    json/constraint/base.hpp
-    json/constraint/combine.cpp
-    json/constraint/combine.hpp
-    json/constraint/enum.cpp
-    json/constraint/enum.hpp
-    json/constraint/except.hpp
-    json/constraint/introspection.hpp
-    json/constraint/length.cpp
-    json/constraint/length.hpp
-    json/constraint/inequality.cpp
-    json/constraint/inequality.hpp
-    json/constraint/properties.cpp
-    json/constraint/properties.hpp
-    json/constraint/type.cpp
-    json/constraint/type.hpp
-    json/tree.cpp
-    json/tree.hpp
-    json2/fwd.hpp
-    json2/event.hpp
-    json2/event.cpp
-    json2/except.hpp
-    json2/personality/base.cpp
-    json2/personality/base.hpp
-    json2/personality/jsonish.cpp
-    json2/personality/jsonish.hpp
-    json2/personality/rfc7519.cpp
-    json2/personality/rfc7519.hpp
-    json2/tree.cpp
-    json2/tree.hpp
     kmeans.hpp
     library.hpp
     log.cpp
@@ -481,7 +440,7 @@ target_link_libraries(cruft-util dl)
 
 
 ###############################################################################
-foreach (tool cpuid json-clean json-schema json-validate json-compare json-pointer poisson macro scratch)
+foreach (tool cpuid poisson macro scratch)
     add_executable (util_${tool} tools/${tool}.cpp)
     set_target_properties (util_${tool} PROPERTIES OUTPUT_NAME ${tool})
     target_link_libraries (util_${tool} cruft-util)
@@ -542,8 +501,6 @@ if (TESTS)
         introspection
         iterator
         job/queue
-        json_types
-        json2/event
         kmeans
         maths
         maths/fast
@@ -596,18 +553,6 @@ if (TESTS)
         set_tests_properties(util_${name} PROPERTIES FAIL_REGULAR_EXPRESSION "not ok -")
     endforeach(t)
 
-    foreach (jtest compare schema pointer)
-        configure_file ("test/json/${jtest}.py.in" "util_test_json_${jtest}.py" @ONLY)
-        add_test(NAME "util_test_json_${jtest}" COMMAND "util_test_json_${jtest}.py")
-        set_property(TEST "util_test_json_${jtest}" APPEND PROPERTY DEPENDS "util_json-${jtest}")
-        set_tests_properties(util_test_json_${jtest} PROPERTIES FAIL_REGULAR_EXPRESSION "not ok -")
-    endforeach()
-
-    configure_file (test/json-parse.sh.in util_test_json_parse.sh @ONLY)
-    add_test(NAME util_test_json_parse COMMAND util_test_json_parse.sh)
-    set_property(TEST util_test_json_parse APPEND PROPERTY DEPENDS util_json-validate)
-    set_tests_properties(util_test_json_parse PROPERTIES FAIL_REGULAR_EXPRESSION "not ok -")
-
     configure_file (test/cpp.sh.in util_test_cpp.sh @ONLY)
     add_test (NAME util_test_cpp COMMAND util_test_cpp.sh)
     set_property (TEST util_test_cpp APPEND PROPERTY DEPENDS util_macro)
diff --git a/json/constraint/base.cpp b/json/constraint/base.cpp
deleted file mode 100644
index dc6d61a7..00000000
--- a/json/constraint/base.cpp
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Copyright 2018 Danny Robson <danny@nerdcruft.net>
- */
-
-#include "base.hpp"
-
-#include "type.hpp"
-#include "length.hpp"
-#include "inequality.hpp"
-#include "properties.hpp"
-#include "enum.hpp"
-
-using util::json::schema::constraint::base;
-
-
-///////////////////////////////////////////////////////////////////////////////
-std::unique_ptr<base>
-base::instantiate (std::string const &name, ::json::tree::node const &def)
-{
-    if (name == "type")                 return std::make_unique<type> (def);
-    if (name == "minLength")            return std::make_unique<min_length> (def);
-    if (name == "maxLength")            return std::make_unique<max_length> (def);
-    if (name == "minimum")              return std::make_unique<minimum> (def);
-    if (name == "exclusiveMaximum")     return std::make_unique<exclusive_maximum> (def);
-    if (name == "exclusiveMinimum")     return std::make_unique<exclusive_minimum> (def);
-    if (name == "multipleOf")           return std::make_unique<multiple_of > (def);
-    if (name == "maximum")              return std::make_unique<maximum> (def);
-    if (name == "properties")           return std::make_unique<properties> (def);
-    if (name == "patternProperties")    return std::make_unique<pattern_properties> (def);
-    if (name == "additionalProperties") return std::make_unique<additional_properties> (def);
-    if (name == "enum")                 return std::make_unique<enumeration> (def);
-
-    throw unknown_constraint (name);
-}
diff --git a/json/constraint/base.hpp b/json/constraint/base.hpp
deleted file mode 100644
index 5d2c0e59..00000000
--- a/json/constraint/base.hpp
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Copyright 2018 Danny Robson <danny@nerdcruft.net>
- */
-
-#pragma once
-
-#include "except.hpp"
-
-#include <string>
-#include <vector>
-#include <iosfwd>
-
-
-namespace util::json::schema::constraint {
-    struct failure {
-        constraint::base const &rule;
-        ::json::tree::node const &target;
-    };
-
-
-    class base {
-    public:
-        using output_container = std::vector<failure>;
-        using output_iterator = std::back_insert_iterator<output_container>;
-
-        base () = default;
-        base (base &&) = default;
-        base& operator= (base &&) = default;
-        base (base const&) = delete;
-        base& operator= (base const&) = delete;
-        virtual ~base () = default;
-
-        virtual output_iterator validate (output_iterator res, ::json::tree::node &) const noexcept = 0;
-        virtual std::ostream& describe (std::ostream&) const = 0;
-
-        static std::unique_ptr<base> instantiate (std::string const &name, ::json::tree::node const&);
-    };
-
-
-    inline std::ostream&
-    operator<< (std::ostream &os, base const &obj)
-    {
-        return obj.describe (os);
-    }
-}
diff --git a/json/constraint/combine.cpp b/json/constraint/combine.cpp
deleted file mode 100644
index 9cb27ee7..00000000
--- a/json/constraint/combine.cpp
+++ /dev/null
@@ -1,95 +0,0 @@
-/*
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Copyright 2018 Danny Robson <danny@nerdcruft.net>
- */
-
-#include "combine.hpp"
-
-#include "properties.hpp"
-
-#include "../tree.hpp"
-
-#include "../../iterator.hpp"
-#include "../../cast.hpp"
-
-using util::json::schema::constraint::combine;
-
-
-///////////////////////////////////////////////////////////////////////////////
-combine::combine (::json::tree::node const &def)
-{
-    for (auto const &[key,val]: def.as_object ()) {
-        if (key == "$schema") {
-            m_version = val->as_string ();
-            continue;
-        }
-
-        if (key == "default") {
-            m_default = val->clone ();
-            continue;
-        }
-
-        m_constraints.push_back (instantiate (key, *val));
-
-        if (key == "additionalProperties") {
-            m_additional = util::cast::known<additional_properties> (m_constraints.back ().get ());
-            m_additional->use (m_properties);
-            m_additional->use (m_patterns);
-        } else if (key == "properties") {
-            m_properties = util::cast::known<properties> (m_constraints.back().get ());
-            if (m_additional)
-                m_additional->use (m_properties);
-        } else if (key == "patternProperties") {
-            m_patterns = util::cast::known<pattern_properties> (m_constraints.back ().get ());
-            if (m_additional)
-                m_additional->use (m_patterns);
-        }
-    }
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-combine::output_iterator
-combine::validate (output_iterator res, ::json::tree::node &data) const noexcept
-{
-    for (auto const &i: m_constraints)
-        res = i->validate (res, data);
-    return res;
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-std::ostream&
-combine::describe (std::ostream &os) const
-{
-    return os << "{ combine: [ ";
-    for (auto const &i: m_constraints)
-        os << *i << ", ";
-    return os << " ] }";
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-bool
-combine::has_default (void) const
-{
-    return !!m_default;
-}
-
-//-----------------------------------------------------------------------------
-std::unique_ptr<::json::tree::node>
-combine::default_value (void) const
-{
-    return m_default->clone ();
-}
diff --git a/json/constraint/combine.hpp b/json/constraint/combine.hpp
deleted file mode 100644
index e192d190..00000000
--- a/json/constraint/combine.hpp
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Copyright 2018 Danny Robson <danny@nerdcruft.net>
- */
-
-#pragma once
-
-#include "base.hpp"
-
-#include "fwd.hpp"
-#include "../tree.hpp"
-
-#include <memory>
-#include <vector>
-
-
-///////////////////////////////////////////////////////////////////////////////
-namespace util::json::schema::constraint {
-    class combine final : public base {
-    public:
-        combine (::json::tree::node const &def);
-
-        combine (combine const&) = delete;
-        combine& operator= (combine const&) = delete;
-
-        combine (combine &&) = default;
-        combine& operator= (combine &&) = default;
-
-        virtual ~combine () = default;
-
-        output_iterator validate (output_iterator res, ::json::tree::node &) const noexcept override;
-        std::ostream& describe (std::ostream&) const override;
-
-        bool has_default (void) const;
-        std::unique_ptr<::json::tree::node> default_value (void) const;
-
-    private:
-        std::string m_version;
-        std::unique_ptr<::json::tree::node> m_default;
-
-        properties *m_properties = nullptr;
-        pattern_properties *m_patterns = nullptr;
-        additional_properties *m_additional = nullptr;
-
-        std::vector<std::unique_ptr<base>> m_constraints;
-    };
-}
\ No newline at end of file
diff --git a/json/constraint/enum.cpp b/json/constraint/enum.cpp
deleted file mode 100644
index 22a1b896..00000000
--- a/json/constraint/enum.cpp
+++ /dev/null
@@ -1,39 +0,0 @@
-#include "enum.hpp"
-
-#include "../tree.hpp"
-
-using util::json::schema::constraint::enumeration;
-
-
-///////////////////////////////////////////////////////////////////////////////
-enumeration::enumeration (::json::tree::node const &def)
-{
-    for (auto const &i: def.as_array ())
-        m_values.push_back (i.clone ());
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-enumeration::output_iterator
-enumeration::validate (util::json::schema::constraint::base::output_iterator res,
-                       ::json::tree::node &target) const noexcept
-{
-    for (auto const &i: m_values)
-        if (target == *i)
-            return res;
-
-    return *res++ = { .rule = *this, .target = target };
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-std::ostream&
-enumeration::describe (std::ostream &os) const
-{
-    os << "{ enumeration: [ ";
-
-    for (auto const &i: m_values)
-        os << *i << ", ";
-
-    return os << " ] }";
-}
diff --git a/json/constraint/enum.hpp b/json/constraint/enum.hpp
deleted file mode 100644
index 98794db5..00000000
--- a/json/constraint/enum.hpp
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Copyright 2018 Danny Robson <danny@nerdcruft.net>
- */
-
-#pragma once
-
-#include "base.hpp"
-
-#include "../fwd.hpp"
-
-#include <memory>
-
-namespace util::json::schema::constraint {
-    class enumeration final : public base {
-    public:
-        enumeration (::json::tree::node const &def);
-
-        virtual ~enumeration () = default;
-
-        output_iterator validate (output_iterator res, ::json::tree::node &) const noexcept override;
-        std::ostream& describe (std::ostream&) const override;
-
-    private:
-        std::vector<std::unique_ptr<::json::tree::node>> m_values;
-    };
-}
\ No newline at end of file
diff --git a/json/constraint/except.hpp b/json/constraint/except.hpp
deleted file mode 100644
index 8fa23c45..00000000
--- a/json/constraint/except.hpp
+++ /dev/null
@@ -1,64 +0,0 @@
-/*
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Copyright 2018 Danny Robson <danny@nerdcruft.net>
- */
-
-#pragma once
-
-#include "fwd.hpp"
-#include "introspection.hpp"
-#include "../fwd.hpp"
-
-#include <exception>
-
-
-///////////////////////////////////////////////////////////////////////////////
-namespace util::json::schema {
-    class error : public std::exception { };
-
-
-    template <typename T>
-    class constraint_error : public error {
-    public:
-        virtual ~constraint_error () = default;
-        constraint_error (::json::tree::node const &_def):
-            def (_def)
-        { ; }
-
-        char const* what (void) const noexcept override
-        {
-            return util::type_name_v<T>;
-        }
-
-        ::json::tree::node const &def;
-    };
-
-
-    class unknown_constraint : public error {
-    public:
-        unknown_constraint (std::string const &name):
-            m_name (name)
-        { ; }
-
-        virtual ~unknown_constraint () = default;
-
-        char const* what (void) const noexcept override
-        {
-            return m_name.c_str ();
-        }
-
-    private:
-        std::string m_name;
-    };
-}
diff --git a/json/constraint/fwd.hpp b/json/constraint/fwd.hpp
deleted file mode 100644
index 3a082073..00000000
--- a/json/constraint/fwd.hpp
+++ /dev/null
@@ -1,32 +0,0 @@
-/*
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Copyright 2018 Danny Robson <danny@nerdcruft.net>
- */
-
-#pragma once
-
-
-namespace util::json::schema::constraint {
-    struct failure;
-
-    class base;
-
-    class type;
-    class combine;
-    template <typename> class length;
-    template <template <typename> class> class inequality;
-    class properties;
-    class pattern_properties;
-    class additional_properties;
-}
\ No newline at end of file
diff --git a/json/constraint/inequality.cpp b/json/constraint/inequality.cpp
deleted file mode 100644
index 48833662..00000000
--- a/json/constraint/inequality.cpp
+++ /dev/null
@@ -1,90 +0,0 @@
-/*
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Copyright 2018 Danny Robson <danny@nerdcruft.net>
- */
-
-#include "inequality.hpp"
-
-#include "../tree.hpp"
-
-using util::json::schema::constraint::inequality;
-
-
-///////////////////////////////////////////////////////////////////////////////
-template <template <typename> class ComparatorT>
-inequality<ComparatorT>::inequality (::json::tree::node const &def)
-{
-    if (!def.is_number ())
-        throw constraint_error<inequality> (def);
-
-    auto const &val = def.as_number ();
-    switch (val.repr ()) {
-    case ::json::tree::number::UINT: m_value = val.uint (); break;
-    case ::json::tree::number::SINT: m_value = val.sint (); break;
-    case ::json::tree::number::REAL: m_value = val.real (); break;
-    }
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-template <template <typename> class ComparatorT>
-typename inequality<ComparatorT>::output_iterator
-inequality<ComparatorT>::validate (util::json::schema::constraint::base::output_iterator res,
-                                  ::json::tree::node &target) const noexcept
-{
-    if (!target.is_number ()) {
-        return *res++ = failure { .rule = *this, .target = target };
-    }
-
-    // HACK: this shouldn't be casting to double for the comparison, but it
-    // greatly simplifies the logic.
-    auto const &value = target.as_number ();
-    std::visit([&,this] (auto const &inner) noexcept {
-        if (!ComparatorT<double>{} (value.as<double> (), inner))
-           *res++ = failure { .rule = *this, .target = target };
-    }, m_value);
-
-    return res;
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-template <template <typename> class ComparatorT>
-std::ostream&
-inequality<ComparatorT>::describe (std::ostream &os) const
-{
-    os << "{ " << util::type_name_v<inequality> << ": ";
-    std::visit ([&os] (auto const &i) -> void { os << i; }, m_value);
-    return os << " }";
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-template class util::json::schema::constraint::inequality<std::less_equal>;
-template class util::json::schema::constraint::inequality<std::greater_equal>;
-template class util::json::schema::constraint::inequality<std::less>;
-template class util::json::schema::constraint::inequality<std::greater>;
-
-
-///////////////////////////////////////////////////////////////////////////////
-template <>
-bool
-util::json::schema::constraint::is_multiple<double>::operator() (double a, double b) const noexcept
-{
-    return std::fmod (a, b) <= 1e-8;
-}
-
-
-//-----------------------------------------------------------------------------
-template class util::json::schema::constraint::inequality<util::json::schema::constraint::is_multiple>;
diff --git a/json/constraint/inequality.hpp b/json/constraint/inequality.hpp
deleted file mode 100644
index 0168c7c4..00000000
--- a/json/constraint/inequality.hpp
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Copyright 2018 Danny Robson <danny@nerdcruft.net>
- */
-
-#pragma once
-
-#include "base.hpp"
-
-#include "../tree.hpp"
-
-#include <functional>
-#include <variant>
-
-
-///////////////////////////////////////////////////////////////////////////////
-namespace util::json::schema::constraint {
-    template <template <typename> class ComparatorT>
-    class inequality final : public base {
-    public:
-        inequality (::json::tree::node const&);
-        virtual ~inequality () = default;
-
-        output_iterator validate (output_iterator, ::json::tree::node &target) const noexcept override;
-        std::ostream& describe (std::ostream&) const override;
-
-    private:
-        using uint_t = ::json::tree::number::uint_t;
-        using sint_t = ::json::tree::number::sint_t;
-        using real_t = ::json::tree::number::real_t;
-
-        std::variant<uint_t,sint_t,real_t> m_value;
-    };
-
-
-    using minimum = inequality<std::greater_equal>;
-    using maximum = inequality<std::less_equal>;
-    using exclusive_minimum = inequality<std::greater>;
-    using exclusive_maximum = inequality<std::less>;
-
-
-    // this is not technically an inequality, but the implementation fits in
-    // nicely here.
-    template <typename T>
-    struct is_multiple {
-        bool operator() (T, T) const noexcept;
-    };
-
-    using multiple_of = inequality<is_multiple>;
-}
diff --git a/json/constraint/introspection.hpp b/json/constraint/introspection.hpp
deleted file mode 100644
index d1707dd3..00000000
--- a/json/constraint/introspection.hpp
+++ /dev/null
@@ -1,35 +0,0 @@
-#pragma once
-
-#include "../../introspection.hpp"
-
-#include "fwd.hpp"
-
-namespace util {
-    #define SCHEMA_INTROSPECTION(K)                                 \
-    namespace detail {                                              \
-        struct type_name_cruft_json_schema_constraint_##K {         \
-            static constexpr const char value[] = #K;               \
-        };                                                          \
-    }                                                               \
-                                                                    \
-    template <>                                                     \
-    struct type_name<::util::json::schema::constraint::K> :         \
-        public detail::type_name_cruft_json_schema_constraint_##K   \
-    { };
-
-
-    template <template <typename> class OperatorT>
-    struct type_name<::util::json::schema::constraint::inequality<OperatorT>> {
-        static constexpr const char value[] = "inequality";
-    };
-
-    template <typename OperatorT>
-    struct type_name<::util::json::schema::constraint::length<OperatorT>> {
-        static constexpr const char value[] = "length";
-    };
-
-
-    MAP0(SCHEMA_INTROSPECTION, type, combine, properties, pattern_properties, additional_properties)
-
-    #undef SCHEMA_INTROSPECTION
-}
diff --git a/json/constraint/length.cpp b/json/constraint/length.cpp
deleted file mode 100644
index bd4d95ff..00000000
--- a/json/constraint/length.cpp
+++ /dev/null
@@ -1,83 +0,0 @@
-/*
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Copyright 2018 Danny Robson <danny@nerdcruft.net>
- */
-
-#include "length.hpp"
-
-#include "../tree.hpp"
-
-using util::json::schema::constraint::length;
-
-
-///////////////////////////////////////////////////////////////////////////////
-namespace {
-    template <typename ComparatorT>
-    struct field_name { };
-
-
-    template <>
-    struct field_name<std::greater_equal<std::size_t>> {
-        static constexpr char const *const value = "minLength";
-    };
-
-
-    template <>
-    struct field_name<std::less_equal<std::size_t>> {
-        static constexpr char const *const value = "maxLength";
-    };
-
-
-    template <typename ComparatorT>
-    static constexpr auto field_name_v = field_name<ComparatorT>::value;
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-template <typename ComparatorT>
-length<ComparatorT>::length(::json::tree::node const &def):
-    m_length(def.as<std::size_t> ())
-{ ; }
-
-
-
-///////////////////////////////////////////////////////////////////////////////
-template <typename ComparatorT>
-typename length<ComparatorT>::output_iterator
-length<ComparatorT>::validate (output_iterator res, ::json::tree::node &target) const noexcept
-{
-    if (!target.is_string ()) {
-        return *res++ = failure { .rule = *this, .target = target };
-    }
-
-    auto const &val = target.as_string ();
-    if (!ComparatorT{}(val.size (), m_length))
-        *res++ = failure { .rule = *this, .target = target };
-
-    return res;
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-template <typename ComparatorT>
-std::ostream&
-length<ComparatorT>::describe (std::ostream &os) const
-{
-    return os << "{ " << ::field_name_v<ComparatorT> << ": " << m_length << " }";
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-template class util::json::schema::constraint::length<std::less_equal<std::size_t>>;
-template class util::json::schema::constraint::length<std::greater_equal<std::size_t>>;
diff --git a/json/constraint/length.hpp b/json/constraint/length.hpp
deleted file mode 100644
index 133ffcfb..00000000
--- a/json/constraint/length.hpp
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Copyright 2018 Danny Robson <danny@nerdcruft.net>
- */
-
-#pragma once
-
-#include "base.hpp"
-
-#include <functional>
-
-
-///////////////////////////////////////////////////////////////////////////////
-namespace util::json::schema::constraint {
-    template <typename ComparatorT>
-    class length final : public base {
-    public:
-        length (::json::tree::node const&);
-        virtual ~length () = default;
-
-        output_iterator validate (output_iterator, ::json::tree::node &target) const noexcept override;
-        std::ostream& describe (std::ostream&) const override;
-
-    private:
-        std::size_t m_length;
-    };
-
-
-    using max_length = length<std::less_equal<std::size_t>>;
-    using min_length = length<std::greater_equal<std::size_t>>;
-}
diff --git a/json/constraint/properties.cpp b/json/constraint/properties.cpp
deleted file mode 100644
index 4ba8c40c..00000000
--- a/json/constraint/properties.cpp
+++ /dev/null
@@ -1,217 +0,0 @@
-/*
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Copyright 2018 Danny Robson <danny@nerdcruft.net>
- */
-
-#include "properties.hpp"
-
-#include "../tree.hpp"
-
-using util::json::schema::constraint::properties;
-using util::json::schema::constraint::pattern_properties;
-using util::json::schema::constraint::additional_properties;
-
-
-///////////////////////////////////////////////////////////////////////////////
-properties::properties (::json::tree::node const &def)
-{
-    if (!def.is_object ())
-        throw constraint_error<properties> (def);
-
-    for (auto const &[key,val]: def.as_object ()) {
-        m_properties.emplace (key, *val);
-    }
-}
-
-
-//-----------------------------------------------------------------------------
-properties::output_iterator
-properties::validate (output_iterator res, ::json::tree::node &target) const noexcept
-{
-    if (!target.is_object ())
-        return *res++ = { .rule = *this, .target = target };
-
-    auto &obj = target.as_object ();
-
-    // validate the keys that are present against the property schemas
-    for (const auto &[key,val]: obj) {
-        auto const pos = m_properties.find (key);
-        if (pos == m_properties.end ())
-            continue;
-
-        res = pos->second.validate (res, *val);
-    }
-
-    // check if there's a key in the schema that isn't present but has a default
-    for (auto const &[key,doc]: m_properties) {
-        if (!doc.has_default ())
-            continue;
-
-        auto pos = obj.find (key);
-        if (pos == obj.end ())
-            obj.insert (key, doc.default_value ());
-    }
-
-    return res;
-}
-
-
-//-----------------------------------------------------------------------------
-bool
-properties::has (std::string const &key) const noexcept
-{
-    return m_properties.cend () != m_properties.find (key);
-}
-
-
-//-----------------------------------------------------------------------------
-std::ostream&
-properties::describe (std::ostream &os) const
-{
-    os << "{ properties: [ ";
-
-    for (auto const &[key,val]: m_properties) {
-        os << key << ": ";
-        val.describe (os);
-        os << ", ";
-    }
-
-    return os << " ] }";
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-pattern_properties::pattern_properties (::json::tree::node const &def)
-{
-    if (!def.is_object ())
-        throw constraint_error<pattern_properties> (def);
-
-    for (auto const &[key,val]: def.as_object ()) {
-        m_patterns.push_back (pattern_t {
-            .pattern = key,
-            .matcher = std::regex (key),
-            .validator = *val
-        });
-    }
-}
-
-
-//-----------------------------------------------------------------------------
-pattern_properties::output_iterator
-pattern_properties::validate (output_iterator res,
-                              ::json::tree::node &target) const noexcept
-{
-    if (!target.is_object ())
-        return *res++ = { .rule = *this, .target = target };
-
-    // validate each key and value in turn
-    for (auto &[key, val]: target.as_object ()) {
-        // find any regex matches and forward the validation onwards
-        for (auto const &[pattern,regex,validator]: m_patterns) {
-            if (std::regex_search (key, regex)) {
-                res = validator.validate (res, *val);
-            }
-        }
-    }
-
-    return res;
-}
-
-
-//-----------------------------------------------------------------------------
-bool
-pattern_properties::has (std::string const &key) const noexcept
-{
-    return std::any_of (
-        m_patterns.begin (),
-        m_patterns.end (),
-        [&key] (auto const &i)
-    {
-        return std::regex_search (key, i.matcher);
-    });
-}
-
-
-//-----------------------------------------------------------------------------
-std::ostream&
-pattern_properties::describe (std::ostream &os) const
-{
-    os << "{ pattern_properties: { ";
-    for (auto const &[pattern,regex,validator]: m_patterns)
-        os << '"' << pattern << '"' << ": " << validator << ", ";
-    return os << " } }";
-};
-
-
-///////////////////////////////////////////////////////////////////////////////
-additional_properties::additional_properties (
-    ::json::tree::node const &def,
-    properties *_properties,
-    pattern_properties *_patterns
-)
-: m_fallback (def)
-, m_properties (_properties)
-, m_patterns (_patterns)
-{ ; }
-
-
-//-----------------------------------------------------------------------------
-additional_properties::additional_properties (::json::tree::node const &def):
-    additional_properties (def, nullptr, nullptr)
-{ }
-
-
-//-----------------------------------------------------------------------------
-void
-additional_properties::use (properties *ptr)
-{
-    m_properties = ptr;
-}
-
-//-----------------------------------------------------------------------------
-void
-additional_properties::use (pattern_properties *ptr)
-{
-    m_patterns = ptr;
-}
-
-
-//-----------------------------------------------------------------------------
-additional_properties::output_iterator
-additional_properties::validate (output_iterator res,
-                                 ::json::tree::node &target) const noexcept
-{
-    if (!target.is_object ())
-        return *res++ = { .rule = *this, .target = target };
-
-    for (auto &[key,val]: target.as_object ()) {
-        // don't check properties that are handled elsewhere
-        if (m_patterns && m_patterns->has (key))
-            continue;
-        if (m_properties && m_properties->has (key))
-            continue;
-
-        res = m_fallback.validate (res, *val);
-    }
-
-    return res;
-}
-
-
-//-----------------------------------------------------------------------------
-std::ostream&
-additional_properties::describe (std::ostream &os) const
-{
-    return os << "{ additional_properties: " << m_fallback << " }";
-}
diff --git a/json/constraint/properties.hpp b/json/constraint/properties.hpp
deleted file mode 100644
index c6ab4f5c..00000000
--- a/json/constraint/properties.hpp
+++ /dev/null
@@ -1,83 +0,0 @@
-/*
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Copyright 2018 Danny Robson <danny@nerdcruft.net>
- */
-
-#pragma once
-
-#include "base.hpp"
-#include "combine.hpp"
-
-#include <map>
-#include <string>
-#include <memory>
-#include <regex>
-
-
-///////////////////////////////////////////////////////////////////////////////
-namespace util::json::schema::constraint {
-    class properties : public base {
-    public:
-        properties (::json::tree::node const&);
-        virtual ~properties () = default;
-
-        output_iterator validate (output_iterator, ::json::tree::node &target) const noexcept override;
-        std::ostream& describe (std::ostream&) const override;
-
-        bool has (std::string const &key) const noexcept;
-
-    private:
-        std::map<std::string,combine> m_properties;
-    };
-
-
-    class pattern_properties : public base {
-    public:
-        pattern_properties (::json::tree::node const&);
-
-        output_iterator validate (output_iterator, ::json::tree::node &target) const noexcept override;
-        std::ostream& describe (std::ostream&) const override;
-
-        bool has (std::string const &key) const noexcept;
-
-    private:
-        struct pattern_t {
-            std::string pattern;
-            std::regex matcher;
-            combine validator;
-        };
-
-        std::vector<pattern_t> m_patterns;
-    };
-
-
-    class additional_properties : public base {
-    public:
-        additional_properties (::json::tree::node const&, properties*, pattern_properties*);
-        additional_properties (::json::tree::node const&);
-
-        virtual ~additional_properties () = default;
-
-        void use (properties*);
-        void use (pattern_properties*);
-
-        output_iterator validate (output_iterator, ::json::tree::node &target) const noexcept override;
-        std::ostream& describe (std::ostream&) const override;
-
-    private:
-        combine m_fallback;
-        properties *m_properties = nullptr;
-        pattern_properties *m_patterns = nullptr;
-    };
-}
diff --git a/json/constraint/type.cpp b/json/constraint/type.cpp
deleted file mode 100644
index aae31297..00000000
--- a/json/constraint/type.cpp
+++ /dev/null
@@ -1,128 +0,0 @@
-/*
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Copyright 2018 Danny Robson <danny@nerdcruft.net>
- */
-
-#include "type.hpp"
-
-#include "except.hpp"
-
-#include "../../parse.hpp"
-
-using util::json::schema::constraint::type;
-
-
-///////////////////////////////////////////////////////////////////////////////
-template <>
-util::json::schema::constraint::type::type_t
-util::parse<util::json::schema::constraint::type::type_t> (util::view<const char*> str)
-{
-    if (str == "integer")  return ::util::json::schema::constraint::type::INTEGER;
-    if (str == "number")   return ::util::json::schema::constraint::type::NUMBER;
-    if (str == "string")   return ::util::json::schema::constraint::type::STRING;
-    if (str == "object")   return ::util::json::schema::constraint::type::OBJECT;
-    if (str == "array")    return ::util::json::schema::constraint::type::ARRAY;
-    if (str == "boolean")  return ::util::json::schema::constraint::type::BOOLEAN;
-    if (str == "null")     return ::util::json::schema::constraint::type::NONE;
-
-    throw std::invalid_argument (std::string (str.begin (), str.end ()));
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-namespace util::json::schema::constraint {
-    std::string const&
-    to_string (type::type_t t)
-    {
-        switch (t) {
-        case type::INTEGER: { static std::string s_name = "integer"; return s_name; }
-        case type::NUMBER:  { static std::string s_name = "number";  return s_name; }
-        case type::STRING:  { static std::string s_name = "string";  return s_name; }
-        case type::OBJECT:  { static std::string s_name = "object";  return s_name; }
-        case type::ARRAY:   { static std::string s_name = "array";   return s_name; }
-        case type::BOOLEAN: { static std::string s_name = "boolean"; return s_name; }
-        case type::NONE:    { static std::string s_name = "none";    return s_name; }
-        }
-
-        unreachable ();
-    }
-}
-
-
-static type::type_t
-valid_types (::json::tree::node const &def)
-{
-    if (def.is_string ()) {
-        return util::parse<type::type_t> (def.as_string ());
-    } else if (def.is_array ()) {
-        std::underlying_type_t<type::type_t> accum = 0;
-        for (auto const &i: def.as_array ())
-            accum |= util::parse<type::type_t> (i.as_string ());
-        return type::type_t (accum);
-    } else {
-        throw util::json::schema::constraint_error<type> (def);
-    }
-}
-
-
-
-///////////////////////////////////////////////////////////////////////////////
-type::type (::json::tree::node const &def):
-    m_type (valid_types (def))
-{ ; }
-
-
-///////////////////////////////////////////////////////////////////////////////
-static bool
-is_valid (type::type_t t, ::json::tree::node const &target) noexcept
-{
-    switch (target.type ()) {
-    case ::json::tree::STRING:  return t & type::STRING;
-    case ::json::tree::OBJECT:  return t & type::OBJECT;
-    case ::json::tree::ARRAY:   return t & type::ARRAY;
-    case ::json::tree::BOOLEAN: return t & type::BOOLEAN;
-    case ::json::tree::NONE:    return t & type::NONE;
-
-    case ::json::tree::NUMBER:
-        if (t & type::NUMBER)
-            return true;
-
-        switch (target.as_number ().repr ()) {
-        case ::json::tree::number::UINT:
-        case ::json::tree::number::SINT:
-            return t & type::INTEGER;
-
-        case ::json::tree::number::REAL:
-            return false;
-        }
-    }
-
-    unreachable ();
-}
-
-
-type::output_iterator
-type::validate (output_iterator res, ::json::tree::node &target) const noexcept
-{
-    if (!is_valid (m_type, target))
-        *res++ = failure { .rule = *this, .target = target };
-    return res;
-}
-
-
-std::ostream&
-type::describe (std::ostream &os) const
-{
-    return os << "{type: " << to_string (m_type) << " }";
-}
diff --git a/json/constraint/type.hpp b/json/constraint/type.hpp
deleted file mode 100644
index e729aadb..00000000
--- a/json/constraint/type.hpp
+++ /dev/null
@@ -1,47 +0,0 @@
-/*
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Copyright 2018 Danny Robson <danny@nerdcruft.net>
- */
-
-#pragma once
-
-#include "base.hpp"
-
-#include "../tree.hpp"
-
-
-///////////////////////////////////////////////////////////////////////////////
-namespace util::json::schema::constraint {
-    class type final : public base {
-    public:
-        enum type_t {
-            INTEGER  = 1 << 0,
-            NUMBER   = 1 << 1,
-            STRING   = 1 << 2,
-            OBJECT   = 1 << 3,
-            ARRAY    = 1 << 4,
-            BOOLEAN  = 1 << 5,
-            NONE     = 1 << 6,
-        };
-
-        type (::json::tree::node const &definition);
-        virtual ~type () = default;
-
-        output_iterator validate (output_iterator, ::json::tree::node &target) const noexcept override;
-        std::ostream& describe (std::ostream&) const override;
-
-    private:
-        type_t const m_type;
-    };
-}
diff --git a/json/except.cpp b/json/except.cpp
deleted file mode 100644
index bb85fd1a..00000000
--- a/json/except.cpp
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Copyright 2015 Danny Robson <danny@nerdcruft.net>
- */
-
-#include "except.hpp"
-
-#include "../format.hpp"
-
-
-///////////////////////////////////////////////////////////////////////////////
-json::parse_error::parse_error (const std::string &_what, size_t _line):
-    error (_what),
-    line  (_line),
-    desc  (_what + " at line " + std::to_string (_line))
-{ ; }
-
-
-//-----------------------------------------------------------------------------
-const char*
-json::parse_error::what (void) const noexcept
-{
-    return desc.c_str ();
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-json::key_error::key_error (std::string _key):
-    error (to_string (util::format::printf ("missing key '%s'", _key))),
-    key (std::move (_key))
-{ ; }
diff --git a/json/except.hpp b/json/except.hpp
deleted file mode 100644
index 4a1e69fe..00000000
--- a/json/except.hpp
+++ /dev/null
@@ -1,68 +0,0 @@
-/*
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Copyright 2015 Danny Robson <danny@nerdcruft.net>
- */
-
-#ifndef __UTIL_JSON_EXCEPT_HPP
-#define __UTIL_JSON_EXCEPT_HPP
-
-#include <stdexcept>
-#include <string>
-#include <cstdlib>
-
-namespace json {
-    /// The base class for all exceptions throw directly by the json namespace.
-    struct error : public std::runtime_error {
-        explicit error (const std::string &what):
-            runtime_error (what)
-        { ; }
-    };
-
-
-    /// Base class for all type conversion errors
-    struct type_error : public error {
-        explicit type_error (const std::string &what):
-            error (what)
-        { ; }
-    };
-
-
-    /// Base class for errors thrown during parsing
-    struct parse_error : public error {
-        explicit parse_error (const std::string &_what, size_t _line = 0);
-
-        const char* what (void) const noexcept override;
-
-        size_t line;
-        std::string desc;
-    };
-
-
-    /// Base class for errors thrown during schema validation
-    struct schema_error : public error {
-        explicit schema_error (const std::string &what):
-            error (what)
-        { ; }
-    };
-
-
-    /// Exception class for invalid object indexing
-    struct key_error : public error {
-        explicit key_error (std::string);
-
-        std::string key;
-    };
-}
-
-#endif
diff --git a/json/flat.cpp.rl b/json/flat.cpp.rl
deleted file mode 100644
index f48b5461..00000000
--- a/json/flat.cpp.rl
+++ /dev/null
@@ -1,213 +0,0 @@
-/*
- * This file is part of libgim.
- *
- * libgim is free software: you can redistribute it and/or modify it under the
- * terms of the GNU General Public License as published by the Free Software
- * Foundation, either version 3 of the License, or (at your option) any later
- * version.
- *
- * libgim is distributed in the hope that it will be useful, but WITHOUT ANY
- * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
- * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
- * details.
- *
- * You should have received a copy of the GNU General Public License
- * along with libgim.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Copyright 2010-2017 Danny Robson <danny@nerdcruft.net>
- */
-
-#include "json/flat.hpp"
-
-#include "debug.hpp"
-#include "json/except.hpp"
-#include "preprocessor.hpp"
-
-#include <deque>
-#include <iostream>
-
-// We generate some really old style C code via ragel here, so we have to
-// disable some noisy warnings (doubly so given -Werror)
-#pragma GCC diagnostic ignored "-Wold-style-cast"
-
-
-///////////////////////////////////////////////////////////////////////////////
-%%{
-    # JSON (rfc7159)
-    machine json;
-
-    action trace { if (false) std::cerr << *p; }
-    action success { __success = true; }
-    action failure { }
-
-    action new_line { ++line; }
-
-    action first { parsed.push_back ({ type::UNKNOWN, p, p}); }
-    action last  { parsed.back ().last  = p; }
-
-    action tag_nul     { parsed.back ().tag = type::NUL; }
-    action tag_boolean { parsed.back ().tag = type::BOOLEAN; }
-    action tag_string  { parsed.back ().tag = type::STRING; }
-    action tag_integer { parsed.back ().tag = type::INTEGER; }
-    action tag_real    { parsed.back ().tag = type::REAL; }
-
-    action tag_object_begin { parsed.push_back ({ type::OBJECT_BEGIN,   p, p + 1 }); }
-    action tag_object_end   { parsed.push_back ({ type::OBJECT_END,     p, p + 1 }); }
-    action tag_array_begin  { parsed.push_back ({ type::ARRAY_BEGIN,    p, p + 1 }); }
-    action tag_array_end    { parsed.push_back ({ type::ARRAY_END,      p, p + 1 }); }
-
-    # Line counter
-    lines = (
-          any | '\n' @new_line
-    )*;
-
-    # UTF-8 (rfc3629)
-    utf8_tail = 0x80..0xbf;
-
-    utf8_1 =      0x00..0x7f;
-    utf8_2 =      0xc2..0xdf utf8_tail;
-    utf8_3 = 0xe0 0xa0..0xbf utf8_tail      |
-                  0xe1..0xec utf8_tail{2}   |
-             0xed 0x80..0x9f utf8_tail      |
-                  0xee..0xef utf8_tail{2};
-    utf8_4 = 0xf0 0x90..0xbf utf8_tail{2}   |
-                  0xf1..0xf3 utf8_tail{3}   |
-             0xf4 0x80..0x8f utf8_tail{2};
-
-
-    utf8 = utf8_1 | utf8_2 | utf8_3 | utf8_4;
-
-    # Utility
-    ws = 0x20 | 0x09 | 0x0A | 0x0D;
-    array_start  = '[';
-    array_end    = ']';
-    object_start = '{';
-    object_end   = '}';
-
-    # Strings
-    char =
-          (utf8 - ["\\])
-        | "\\" (
-              [\\"/bfnrt]
-            | "u" xdigit{4}
-        )
-    ;
-
-    string = ('"' char* '"') >first >tag_string %*last;
-
-    # numbers
-    int = '0' | [1-9] digit*;
-
-    frac = '.' digit+;
-    e    = 'e'i[+\-]?;
-    exp  = e digit+;
-
-    number = (
-        '-'?
-        int
-        (frac >tag_real)?
-        exp?
-    ) >tag_integer;
-
-    # wrapper types
-    array  = array_start  @{ fhold; fcall array_members;  } array_end;
-    object = object_start @{ fhold; fcall object_members; } object_end;
-
-    # simple types; case sensitive literals
-    bool = ("true" | "false") >tag_boolean;
-    nul  = "null" >tag_nul;
-    literal = bool | nul;
-
-    value = object | array | (number | string | literal) >first %last;
-
-    # Complex
-    member  = string ws* ':' ws* value;
-
-    array_members  := ((
-        array_start >tag_array_begin ws* (value  ws* (',' ws* value  ws*)*)? array_end >tag_array_end
-    ) & lines)
-    @{ fhold; fret; } $trace $!failure;
-
-    object_members := ((
-        object_start >tag_object_begin ws* (member ws* (',' ws* member ws*)*)? object_end >tag_object_end
-    ) & lines)
-    @{ fhold; fret; } $trace $!failure;
-
-    # meta types
-    document := ((ws* value ws*) & lines)
-    %success
-    $!failure
-    $trace;
-
-    variable stack ragelstack;
-    prepush { ragelstack.push_back (0); }
-    postpop { ragelstack.pop_back (); }
-
-    write data;
-}%%
-
-
-//-----------------------------------------------------------------------------
-template <typename T>
-std::vector<json::flat::item<T>>
-json::flat::parse (const util::view<T> src)
-{
-    auto p   = src.cbegin ();
-    auto pe  = src.cend   ();
-    auto eof = pe;
-
-    std::deque<int> ragelstack;
-    std::vector<item<T>> parsed;
-
-    size_t line = 0;
-    int cs, top;
-    bool __success = false;
-
-    %%write init;
-    %%write exec;
-
-    if (!__success)
-        throw json::parse_error ("parse error", line);
-
-    return parsed;
-}
-
-#define INSTANTIATE(KLASS)              \
-template                                \
-std::vector<json::flat::item<KLASS>>    \
-json::flat::parse (util::view<KLASS>);
-
-MAP0(INSTANTIATE,
-    std::string::iterator,
-    std::string::const_iterator,
-    const char*,
-    char *
-)
-
-#undef INSTANTIATE
-
-
-//-----------------------------------------------------------------------------
-std::ostream&
-json::flat::operator<< (std::ostream &os, json::flat::type t)
-{
-    using T = json::flat::type;
-
-    switch (t) {
-    case T::STRING:  return os << "STRING";
-    case T::NUL:     return os << "NUL";
-    case T::BOOLEAN: return os << "BOOLEAN";
-    case T::INTEGER: return os << "INTEGER";
-    case T::REAL:    return os << "REAL";
-
-    case T::OBJECT_BEGIN:    return os << "OBJECT_BEGIN";
-    case T::OBJECT_END:      return os << "OBJECT_END";
-    case T::ARRAY_BEGIN:     return os << "ARRAY_BEGIN";
-    case T::ARRAY_END:       return os << "ARRAY_END";
-
-    case T::UNKNOWN: ;
-        // fall out
-    }
-    unreachable ();
-}
-
diff --git a/json/flat.hpp b/json/flat.hpp
deleted file mode 100644
index a555cc26..00000000
--- a/json/flat.hpp
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Copyright 2010-2015 Danny Robson <danny@nerdcruft.net>
- */
-
-#ifndef __UTIL_JSON_FLAT_HPP
-#define __UTIL_JSON_FLAT_HPP
-
-#include <iosfwd>
-#include <vector>
-
-#include "../view.hpp"
-
-
-///////////////////////////////////////////////////////////////////////////////
-namespace json::flat {
-    enum class type {
-        UNKNOWN,
-
-        NUL,
-        BOOLEAN,
-        STRING,
-        INTEGER,
-        REAL,
-
-        OBJECT_BEGIN,
-        OBJECT_END,
-
-        ARRAY_BEGIN,
-        ARRAY_END
-    };
-
-    template <typename T>
-    struct item {
-        type tag;
-        T first;
-        T last;
-
-        template <typename U>
-        U as (void) const;
-    };
-
-    template <typename T>
-    std::vector<item<T>>
-    parse (util::view<T> data);
-
-    std::ostream& operator<< (std::ostream&, type);
-}
-
-#endif
diff --git a/json/fwd.hpp b/json/fwd.hpp
deleted file mode 100644
index 40e764df..00000000
--- a/json/fwd.hpp
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Copyright 2015 Danny Robson <danny@nerdcruft.net>
- */
-
-#ifndef __UTIL_JSON_FWD_HPP
-#define __UTIL_JSON_FWD_HPP
-
-namespace json {
-    namespace tree {
-        class node;
-        class object;
-        class array;
-        class string;
-        class number;
-        class boolean;
-        class null;
-    }
-
-    struct error;
-    struct type_error;
-    struct parse_error;
-    struct schema_error;
-    struct key_error;
-}
-
-#endif
diff --git a/json/pointer.cpp b/json/pointer.cpp
deleted file mode 100644
index 8855e9d1..00000000
--- a/json/pointer.cpp
+++ /dev/null
@@ -1,60 +0,0 @@
-#include "pointer.hpp"
-
-#include "tree.hpp"
-#include "../parse.hpp"
-
-#include <algorithm>
-#include <stdexcept>
-
-
-///////////////////////////////////////////////////////////////////////////////
-::json::tree::node&
-util::json::pointer::resolve (std::string const &path,
-                              ::json::tree::node &root)
-{
-    // we only handle fragment represenations currently, which start with a '#'
-    auto cursor = path.begin ();
-    if (cursor == path.end () || *cursor != '#')
-        throw std::invalid_argument ("must be fragment representation");
-    ++cursor;
-
-    auto obj = &root;
-
-    // * step over each path segment
-    // * index into the current node
-    // * advance the node
-    // * repeat until we reach the end of the query string
-    for ( ; cursor != path.end (); ) {
-        // step over the delimiting '/'
-        if (*cursor != '/')
-            break;
-        ++cursor;
-
-        // find the start of the next segment (or the end of the string)
-        // and extract the key.
-        auto next = std::find (cursor, path.end (), '/');
-        std::string const key { cursor, next };
-
-        // try to index into the node and advance the node we're operating on
-        switch (obj->type ()) {
-        case ::json::tree::OBJECT:
-            obj = &(*obj)[key];
-            break;
-
-        case ::json::tree::ARRAY:
-            obj = &(*obj)[util::parse<size_t> (key)];
-            break;
-
-        case ::json::tree::STRING:
-        case ::json::tree::NUMBER:
-        case ::json::tree::BOOLEAN:
-        case ::json::tree::NONE:
-            throw std::invalid_argument ("indexing into wrong type");
-        }
-
-        // step to the beginning of the next component
-        cursor = next;
-    }
-
-    return *obj;
-}
\ No newline at end of file
diff --git a/json/pointer.hpp b/json/pointer.hpp
deleted file mode 100644
index 57fe8bb1..00000000
--- a/json/pointer.hpp
+++ /dev/null
@@ -1,26 +0,0 @@
-/*
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Copyright 2018 Danny Robson <danny@nerdcruft.net>
- */
-
-#pragma once
-
-#include "fwd.hpp"
-
-#include <string>
-
-namespace util::json::pointer {
-    ::json::tree::node&
-    resolve (std::string const &path, ::json::tree::node &root);
-}
diff --git a/json/schema.cpp b/json/schema.cpp
deleted file mode 100644
index 56285d2b..00000000
--- a/json/schema.cpp
+++ /dev/null
@@ -1,568 +0,0 @@
-/*
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Copyright 2015-2018 Danny Robson <danny@nerdcruft.net>
- */
-
-#include "schema.hpp"
-
-#include "tree.hpp"
-#include "except.hpp"
-
-#include "../debug.hpp"
-#include "../io.hpp"
-#include "../maths.hpp"
-
-#include <regex>
-
-
-///////////////////////////////////////////////////////////////////////////////
-struct length_error : public json::schema_error {
-    length_error (const std::string &what):
-        schema_error (what)
-    { ; }
-};
-
-
-//-----------------------------------------------------------------------------
-struct format_error : public json::schema_error {
-    format_error (const std::string &what):
-        schema_error (what)
-    { ; }
-};
-
-
-///////////////////////////////////////////////////////////////////////////////
-static void validate (json::tree::node&, const json::tree::object&);
-
-
-///////////////////////////////////////////////////////////////////////////////
-static void
-validate (json::tree::object &node,
-          const json::tree::object &schema)
-{
-    auto properties = schema.find ("properties");
-    auto additional = schema.find ("additionalProperties");
-    auto pattern    = schema.find ("patternProperties");
-
-    if (properties != schema.cend ()) {
-        for (const auto &kv: properties->second->as_object ()) {
-            auto p = node.find (kv.first);
-            if (p != node.cend ())
-                validate (*p->second, kv.second->as_object ());
-            else {
-                try {
-                    node.insert (kv.first, (*kv.second)["default"].clone ());
-                    validate (node[kv.first], kv.second->as_object ());
-                    continue;
-                } catch (const json::key_error&)
-                { ; }
-
-                if (additional != schema.cend ()) {
-                    if (additional->second->is_boolean () && !additional->second->as_bool ())
-                        throw json::schema_error ("additionalProperties");
-
-                    validate (*p->second, additional->second->as_object ());
-                }
-            }
-        }
-    }
-
-    if (pattern != schema.cend ()) {
-        for (auto &cond: pattern->second->as_object ()) {
-            std::regex expr (cond.first, std::regex_constants::ECMAScript);
-
-            for (auto &props: node) {
-                if (std::regex_search (props.first, expr))
-                    validate (*props.second, cond.second->as_object ());
-            }
-        }
-    }
-
-    if (schema.has ("dependencies"))
-        not_implemented ();
-
-    // properties must be checked after the 'properties' check has a chance to
-    // create the defaulted entries.
-    auto maxProperties = schema.find ("maxProperties");
-    if (maxProperties != schema.cend ())
-        if (node.size () > maxProperties->second->as_uint ())
-            throw json::schema_error ("maxProperties");
-
-    auto minProperties = schema.find ("minProperties");
-    if (minProperties != schema.cend ())
-        if (node.size () < minProperties->second->as_uint ())
-            throw json::schema_error ("minProperties");
-
-    auto required = schema.find ("required");
-    if (required != schema.cend ())
-        for (const auto &i: required->second->as_array ())
-            if (!node.has (i.as_string ()))
-                throw json::schema_error ("required");
-}
-
-
-//-----------------------------------------------------------------------------
-static void
-validate (json::tree::array &node,
-          const json::tree::object &schema)
-{
-    // attempt to match the item and additionalItem schemas
-    auto items = schema.find ("items");
-    auto additional = schema.find ("additionalItems");
-
-    if (items != schema.cend ()) {
-        // items is an object, test all elements with it as a schema
-        if (items->second->is_object ()) {
-            for (auto &i: node)
-                validate (i, items->second->as_object ());
-        // items is a list of schemas, test n-elements with it as a schema
-        } else if (items->second->is_array ()) {
-            const auto &itemArray = items->second->as_array ();
-
-            size_t i = 0;
-            for (; i < itemArray.size () && i < node.size (); ++i)
-                validate (node[i], itemArray[i].as_object ());
-
-            // we've exhausted the schema list, use the additional schema
-            if (i == itemArray.size ()) {
-                if (additional->second->is_boolean ()) {
-                    if (!additional->second->as_boolean ())
-                        throw json::schema_error ("additional");
-                } else if (additional->second->is_object ()) {
-                    for ( ; i < node.size (); ++i)
-                        validate (node[i], additional->second->as_object ());
-                } else {
-                    throw json::schema_error ("items");
-                }
-            }
-        }
-    }
-
-    auto maxItems = schema.find ("maxItems");
-    if (maxItems != schema.cend ())
-        if (node.size () > maxItems->second->as_uint ())
-            throw json::schema_error ("maxItems");
-
-    auto minItems = schema.find ("minItems");
-    if (minItems != schema.cend ())
-        if (node.size () < minItems->second->as_uint ())
-            throw json::schema_error ("minItems");
-
-    // check all element are unique
-    // XXX: uses a naive n^2 brute force search on equality because it's 2am
-    // and I don't want to write a type aware comparator for the sort.
-    auto unique = schema.find ("uniqueItems");
-    if (unique != schema.cend () && unique->second->as_boolean ())
-        for (size_t a = 0; a < node.size (); ++a)
-            for (size_t b = a + 1; b < node.size (); ++b)
-                if (node[a] == node[b])
-                    throw json::schema_error ("uniqueItems");
-}
-
-
-//-----------------------------------------------------------------------------
-static void
-validate (json::tree::string &node,
-          const json::tree::object &schema)
-{
-    const auto &val = node.native ();
-
-    // check length is less than a maximum
-    auto maxLength = schema.find ("maxLength");
-    if (maxLength != schema.cend ()) {
-        auto cmp = maxLength->second->as_number ().uint ();
-        if (!util::is_integer (cmp))
-            throw length_error ("maxLength");
-
-        if (val.size () > cmp)
-            throw length_error ("maxLength");
-    }
-
-    // check length is greater than a maximum
-    auto minLength = schema.find ("minLength");
-    if (minLength != schema.cend ()) {
-        auto cmp = minLength->second->as_number ().uint ();
-        if (!util::is_integer (cmp))
-            throw length_error ("minLength");
-
-        if (val.size () < cmp)
-            throw length_error ("minLength");
-    }
-
-    // check the string conforms to a regex
-    // Note: this uses the c++11 regex engine which slightly differs from ECMA 262
-    auto pattern = schema.find ("pattern");
-    if (pattern != schema.cend ()) {
-        std::regex r (pattern->second->as_string ().native (),
-                      std::regex_constants::ECMAScript);
-        if (!std::regex_search (val, r))
-            throw format_error ("pattern");
-    }
-}
-
-
-//-----------------------------------------------------------------------------
-template <typename T>
-static void
-validate_number (T val, const json::tree::object &schema) {
-    using R = json::tree::number::repr_t;
-
-    // check strictly positive integer multiple
-    auto mult = schema.find ("multipleOf");
-    if (mult != schema.cend ()) {
-        const auto &div = mult->second->as_number ();
-
-        switch (div.repr ()) {
-            case R::REAL:  if (util::exactly_zero (std::fmod (val, div.real ()))) throw json::schema_error ("multipleOf"); break;
-            case R::SINT:  if (util::exactly_zero (std::fmod (val, div.sint ()))) throw json::schema_error ("multipleOf"); break;
-            case R::UINT:  if (util::exactly_zero (std::fmod (val, div.uint ()))) throw json::schema_error ("multipleOf"); break;
-        }
-    }
-
-    // check maximum holds. exclusive requires max condition.
-    auto max = schema.find ("maximum");
-    auto exclusiveMax = schema.find ("exclusiveMaximum");
-    if (max != schema.end ()) {
-        const auto &cmp = max->second->as_number ();
-
-        if (exclusiveMax != schema.end () && exclusiveMax->second->as_boolean ()) {
-            switch (cmp.repr ()) {
-            case R::REAL:
-                if (T(val) >= cmp.real ())
-                    throw json::schema_error ("exclusiveMax");
-                break;
-
-            case R::SINT:
-                if (json::tree::number::sint_t(std::numeric_limits<T>::max ()) >= cmp.sint () &&
-                    val >= T(cmp.sint ()))
-                {
-                    throw json::schema_error ("exclusiveMax");
-                }
-                break;
-
-            case R::UINT:
-                if (json::tree::number::uint_t(std::numeric_limits<T>::max ()) >= cmp.uint () &&
-                    val >= T(cmp.uint ()))
-                {
-                    throw json::schema_error ("exclusiveMax");
-                }
-                break;
-            }
-        } else {
-            switch (cmp.repr ()) {
-            case R::REAL:
-                if (T(val) > cmp.real ())
-                    throw json::schema_error ("maximum");
-                break;
-            case R::SINT:
-                if (json::tree::number::sint_t(std::numeric_limits<T>::max ()) >= cmp.sint () &&
-                    val >= T(cmp.sint ()))
-                {
-                    throw json::schema_error ("maximum");
-                }
-                break;
-            case R::UINT:
-                if (json::tree::number::uint_t(std::numeric_limits<T>::max ()) >= cmp.uint () &&
-                    val >= T(cmp.uint ()))
-                {
-                    throw json::schema_error ("maximum");
-                }
-                break;
-            }
-        }
-    } else {
-        if (exclusiveMax != schema.cend ())
-            throw json::schema_error ("exclusiveMax");
-    }
-
-    // check minimum holds. exclusive requires min condition
-    auto min = schema.find ("minimum");
-    auto exclusiveMin = schema.find ("exclusiveMinimum");
-    if (min != schema.end ()) {
-        const auto &cmp = min->second->as_number ();
-
-        if (exclusiveMin != schema.end () && exclusiveMin->second->as_boolean ()) {
-            switch (cmp.repr ()) {
-            case R::REAL:
-                if (T(val) < cmp.real ())
-                    throw json::schema_error ("exclusiveMin");
-                break;
-            case R::SINT:
-                if (cmp.sint () > json::tree::number::sint_t(std::numeric_limits<T>::min ()) &&
-                    val < T(cmp.sint ()))
-                {
-                    throw json::schema_error ("exclusiveMin");
-                }
-                break;
-            case R::UINT:
-                if (cmp.uint () > json::tree::number::uint_t(std::numeric_limits<T>::min ()) &&
-                    val < T(cmp.uint ()))
-                {
-                    throw json::schema_error ("exclusiveMin");
-                }
-                break;
-            }
-        } else {
-            switch (cmp.repr ()) {
-            case R::REAL:
-                if (T(val) <= cmp.real ())
-                    throw json::schema_error ("minimum");
-                break;
-
-            case R::SINT:
-                if (cmp.sint () >= json::tree::number::sint_t(std::numeric_limits<T>::min ()) &&
-                    val <= T(cmp.sint ()))
-                {
-                    throw json::schema_error ("minimum");
-                }
-                break;
-
-            case R::UINT:
-                if (cmp.uint () >= json::tree::number::uint_t(std::numeric_limits<T>::min ()) &&
-                    val <= T(cmp.uint ()))
-                {
-                    throw json::schema_error ("minimum");
-                }
-                break;
-            }
-        }
-    } else {
-        if (exclusiveMin != schema.cend ())
-            throw json::schema_error ("exclusiveMin");
-    }
-
-}
-
-
-//-----------------------------------------------------------------------------
-static void
-validate (json::tree::number &node,
-          const json::tree::object &schema)
-{
-    using N = json::tree::number;
-    using R = N::repr_t;
-
-    switch (node.repr ()) {
-    case R::REAL: validate_number<N::real_t> (node.real (), schema); break;
-    case R::SINT: validate_number<N::sint_t> (node.sint (), schema); break;
-    case R::UINT: validate_number<N::uint_t> (node.uint (), schema); break;
-    }
-}
-
-
-//-----------------------------------------------------------------------------
-static void
-validate (json::tree::boolean&,
-          const json::tree::object&)
-{ ; }
-
-
-//-----------------------------------------------------------------------------
-static void
-validate (json::tree::null&,
-          const json::tree::object&)
-{ ; }
-
-
-//-----------------------------------------------------------------------------
-static std::string
-to_string (json::tree::type_t t)
-{
-    switch (t) {
-        case json::tree::OBJECT:    return "object";
-        case json::tree::ARRAY:     return "array";
-        case json::tree::STRING:    return "string";
-        case json::tree::NUMBER:    return "number";
-        case json::tree::BOOLEAN:   return "boolean";
-        case json::tree::NONE:      return "null";
-    }
-
-    unreachable ();
-}
-
-
-//-----------------------------------------------------------------------------
-static bool
-is_type_valid (const json::tree::node &node, const std::string &type)
-{
-    if (type == "integer")  return node.is_integer ();
-    if (type == "number")   return node.is_number ();
-    if (type == "string")   return node.is_string ();
-    if (type == "object")   return node.is_object ();
-    if (type == "array")    return node.is_array ();
-    if (type == "boolean")  return node.is_boolean ();
-    if (type == "null")     return node.is_null ();
-
-    return false;
-}
-
-
-//-----------------------------------------------------------------------------
-static void
-validate (json::tree::node &node,
-          const json::tree::object &schema)
-{
-    // check the value is in the prescribed list
-    auto enumPos = schema.find ("enum");
-    if (enumPos != schema.cend ()) {
-        auto pos = std::find (enumPos->second->as_array ().cbegin (),
-                              enumPos->second->as_array ().cend (),
-                              node);
-        if (pos == enumPos->second->as_array ().cend ())
-            throw json::schema_error ("enum");
-    }
-
-    // check the value is the correct type
-    auto type = schema.find ("type");
-    if (type != schema.cend ()) {
-        // check against a single named type
-        if (type->second->is_string ()) {
-            if (!is_type_valid (node, type->second->as_string ()))
-                throw json::schema_error ("type");
-        // check against an array of types
-        } else if (type->second->is_array ()) {
-            auto pos = std::find_if (type->second->as_array ().begin (),
-                                     type->second->as_array ().end (),
-                                     [&] (const auto &i) { return i.as_string () == to_string (node.type ()); });
-            if (pos == type->second->as_array ().end ())
-                throw json::schema_error ("type");
-        } else
-            throw json::schema_error ("type");
-    }
-
-    auto allOf = schema.find ("allOf");
-    if (allOf != schema.cend ()) {
-        for (const auto &i: allOf->second->as_array ())
-            validate (node, i.as_object ());
-    }
-
-    auto anyOf = schema.find ("anyOf");
-    if (anyOf != schema.cend ()) {
-        bool success = false;
-        for (const auto &i: anyOf->second->as_array ()) {
-            try {
-                validate (node, i.as_object ());
-                success = true;
-                break;
-            } catch (const json::schema_error&)
-            { continue; }
-        }
-
-        if (!success)
-            throw json::schema_error ("anyOf");
-    }
-
-    auto oneOf = schema.find ("oneOf");
-    if (oneOf != schema.cend ()) {
-        unsigned count = 0;
-
-        for (const auto &i: oneOf->second->as_array ()) {
-            try {
-                validate (node, i.as_object ());
-                count++;
-            } catch (const json::schema_error&)
-            { ; }
-
-            if (count > 1)
-                throw json::schema_error ("oneOf");
-        }
-
-        if (count != 1)
-            throw json::schema_error ("oneOf");
-    }
-
-    auto notSchema = schema.find ("not");
-    if (notSchema != schema.cend ()) {
-        for (const auto &i: notSchema->second->as_array ()) {
-            bool valid = false;
-            try {
-                validate (node, i.as_object ());
-                valid = true;
-            } catch (const json::schema_error&)
-            { ; }
-
-            if (valid)
-                throw json::schema_error ("not");
-        }
-    }
-
-    switch (node.type ()) {
-        case json::tree::OBJECT:    validate (node.as_object (),     schema); return;
-        case json::tree::ARRAY:     validate (node.as_array (),      schema); return;
-        case json::tree::STRING:    validate (node.as_string (),     schema); return;
-        case json::tree::NUMBER:    validate (node.as_number (),     schema); return;
-        case json::tree::BOOLEAN:   validate (node.as_boolean (),    schema); return;
-        case json::tree::NONE:      validate (node.as_null (),       schema); return;
-    }
-
-    unreachable ();
-}
-
-
-//-----------------------------------------------------------------------------
-void
-json::schema::validate (json::tree::node &data,
-                        const json::tree::object &schema)
-{
-    auto title = schema.find ("title");
-    if (title != schema.cend ())
-        if (!title->second->is_string ())
-            throw json::schema_error ("title");
-
-    auto description = schema.find ("description");
-    if (description != schema.cend ())
-        if (!description->second->is_string ())
-            throw json::schema_error ("description");
-
-    return ::validate (data, schema.as_object ());
-}
-
-
-//-----------------------------------------------------------------------------
-void
-json::schema::validate (json::tree::node &data,
-                        const std::experimental::filesystem::path &schema_path)
-{
-    const util::mapped_file schema_data (schema_path);
-    auto schema_object = json::tree::parse (util::view(schema_data).cast<const char*> ());
-    validate (data, schema_object->as_object ());
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-#include "constraint/except.hpp"
-#include "constraint/base.hpp"
-
-#include "../io.hpp"
-#include "../view.hpp"
-
-#include <map>
-
-json::schema::validator::validator(std::experimental::filesystem::path const &path):
-    validator (*json::tree::parse (path))
-{ ; }
-
-
-json::schema::validator::validator (json::tree::node const &definition):
-    m_base (definition)
-{ ; }
-
-
-bool
-json::schema::validator::validate (json::tree::node &data) const
-{
-    std::vector<util::json::schema::constraint::failure> res;
-    m_base.validate (std::back_inserter(res), data);
-    return res.empty ();
-}
diff --git a/json/schema.hpp b/json/schema.hpp
deleted file mode 100644
index 270c276b..00000000
--- a/json/schema.hpp
+++ /dev/null
@@ -1,51 +0,0 @@
-/*
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Copyright 2015 Danny Robson <danny@nerdcruft.net>
- */
-
-#ifndef __UTIL_JSON_SCHEMA_HPP
-#define __UTIL_JSON_SCHEMA_HPP
-
-#include "fwd.hpp"
-#include "constraint/combine.hpp"
-
-#include <experimental/filesystem>
-
-
-///////////////////////////////////////////////////////////////////////////////
-namespace json::schema {
-    class validator {
-    public:
-        validator (json::tree::node const &definition);
-        validator (std::experimental::filesystem::path const&);
-
-        bool validate (json::tree::node &data) const;
-
-    private:
-        std::string m_version;
-
-        util::json::schema::constraint::combine m_base;
-    };
-
-
-    // Validate the json tree using the provide schema object or path.
-    //
-    // Note that the data object being validated may be altered in the process
-    // of validation. If a value is not present but the schema specifies a
-    // default, it will be realised in the data object.
-    void validate (json::tree::node &data, const json::tree::object &schema);
-    void validate (json::tree::node &data, const std::experimental::filesystem::path &schema);
-}
-
-#endif
diff --git a/json/tree.cpp b/json/tree.cpp
deleted file mode 100644
index 80f53847..00000000
--- a/json/tree.cpp
+++ /dev/null
@@ -1,1073 +0,0 @@
-/*
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Copyright 2010-2018 Danny Robson <danny@nerdcruft.net>
- */
-
-
-#include "tree.hpp"
-
-#include "except.hpp"
-#include "flat.hpp"
-
-#include "../debug.hpp"
-#include "../io.hpp"
-#include "../iterator.hpp"
-#include "../maths.hpp"
-#include "../stream.hpp"
-
-#include "preprocessor.hpp"
-
-#include <algorithm>
-#include <cstdlib>
-#include <iomanip>
-
-
-///////////////////////////////////////////////////////////////////////////////
-using json::tree::node;
-using json::tree::object;
-using json::tree::array;
-using json::tree::string;
-using json::tree::number;
-using json::tree::boolean;
-using json::tree::null;
-
-
-///////////////////////////////////////////////////////////////////////////////
-namespace util {
-    bool
-    is_integer (const json::tree::number &node)
-    {
-        using R = json::tree::number::repr_t;
-
-        switch (node.repr ()) {
-        case R::REAL:
-               return is_integer (node.real ());
-
-        case R::SINT:
-        case R::UINT:
-               return true;
-        }
-
-        unreachable ();
-    }
-
-
-    //-----------------------------------------------------------------------------
-    bool
-    is_integer (const json::tree::node &node)
-    {
-        return node.is_number () && is_integer (node.as_number ());
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-template <typename T>
-static
-typename std::vector<json::flat::item<T>>::const_iterator
-parse (typename std::vector<json::flat::item<T>>::const_iterator first,
-       typename std::vector<json::flat::item<T>>::const_iterator last,
-       std::unique_ptr<json::tree::node> &output);
-
-
-//-----------------------------------------------------------------------------
-template <typename T>
-static
-typename std::vector<json::flat::item<T>>::const_iterator
-parse (typename std::vector<json::flat::item<T>>::const_iterator first,
-       typename std::vector<json::flat::item<T>>::const_iterator last,
-       json::tree::array &parent)
-{
-    for (auto cursor = first; cursor != last; ) {
-        if (cursor->tag == json::flat::type::ARRAY_END)
-            return cursor + 1;
-
-        std::unique_ptr<json::tree::node> value;
-        cursor = ::parse<T> (cursor, last, value);
-        parent.insert (std::move (value));
-    }
-
-    unreachable ();
-}
-
-
-//-----------------------------------------------------------------------------
-template <typename T>
-static
-typename std::vector<json::flat::item<T>>::const_iterator
-parse (typename std::vector<json::flat::item<T>>::const_iterator first,
-       typename std::vector<json::flat::item<T>>::const_iterator last,
-       json::tree::object &parent)
-{
-    for (auto cursor = first; cursor != last; ) {
-        if (cursor->tag == json::flat::type::OBJECT_END)
-            return cursor + 1;
-
-        CHECK_EQ (cursor->tag, json::flat::type::STRING);
-
-        std::string key (cursor->first + 1, cursor->last - 1);
-        ++cursor;
-
-        std::unique_ptr<json::tree::node> val;
-        cursor = ::parse<T> (cursor, last, val);
-
-        parent.insert (key, std::move (val));
-    }
-
-    unreachable ();
-}
-
-
-//-----------------------------------------------------------------------------
-template <typename T>
-static
-typename std::vector<json::flat::item<T>>::const_iterator
-parse (typename std::vector<json::flat::item<T>>::const_iterator first,
-       typename std::vector<json::flat::item<T>>::const_iterator last,
-       std::unique_ptr<json::tree::node> &output)
-{
-    CHECK (first != last);
-    CHECK (output.get () == nullptr);
-
-    using F = json::flat::type;
-
-    switch (first->tag) {
-        case F::NUL:
-            output.reset (new json::tree::null ());
-            return first + 1;
-
-        case F::BOOLEAN:
-            CHECK (*first->first == 't' || *first->first == 'f');
-            output.reset (new json::tree::boolean (*first->first == 't'));
-            return first + 1;
-
-        case F::STRING:
-            CHECK_NEQ (&*first->first, &*first->last);
-            output.reset (new json::tree::string (first->first + 1, first->last - 1));
-            return first + 1;
-
-        case F::INTEGER: {
-            T start = first->first;
-            bool negative = *start == '-';
-            if (negative)
-                ++start;
-
-            T finish = start;
-            uintmax_t v = 0;
-            while (isdigit (*finish))
-                v *= 10, v += *finish - '0', ++finish;
-
-            if (finish == start || finish > first->last)
-                throw json::parse_error ("invalid integer");
-
-            if (negative)
-                output.reset (new json::tree::number (-intmax_t(v)));
-            else
-                output.reset (new json::tree::number (v));
-
-            return first + 1;
-        }
-
-        case F::REAL: {
-            std::string str (first->first, first->last);
-            output.reset (new json::tree::number (std::atof (str.c_str())));
-            return first + 1;
-        }
-
-        case F::ARRAY_BEGIN: {
-            auto value = std::make_unique<json::tree::array> ();
-            auto cursor = ::parse<T> (first + 1, last, *value);
-            output = std::move (value);
-            return cursor;
-        }
-
-        case F::OBJECT_BEGIN: {
-            auto value = std::make_unique<json::tree::object> ();
-            auto cursor = ::parse<T> (first + 1, last, *value);
-            output = std::move (value);
-            return cursor;
-        }
-
-        case F::UNKNOWN:
-        case F::OBJECT_END:
-        case F::ARRAY_END:
-            unreachable ();
-    }
-
-    unreachable ();
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-template <typename T>
-std::unique_ptr<json::tree::node>
-json::tree::parse (const util::view<T> &src)
-{
-    std::unique_ptr<json::tree::node> output;
-    auto data = json::flat::parse (src);
-    auto end  = ::parse<T> (data.cbegin (), data.cend (), output);
-
-    CHECK (end == data.cend ());
-    (void)end;
-
-    return output;
-}
-
-#define INSTANTIATE(KLASS)          \
-template                            \
-std::unique_ptr<json::tree::node>   \
-json::tree::parse (const util::view<KLASS>&);
-
-MAP0(INSTANTIATE,
-    std::string::iterator,
-    std::string::const_iterator,
-    const char*,
-    char *
-);
-
-#undef INSTANTIATE
-
-
-//-----------------------------------------------------------------------------
-std::unique_ptr<json::tree::node>
-json::tree::parse (const std::experimental::filesystem::path &src)
-{
-    const util::mapped_file data (src);
-    return parse (util::view{data}.cast<const char*> ());
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-void
-json::tree::write (const json::tree::node &node, std::ostream &os)
-{
-    node.write (os);
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-// Type conversion
-
-const json::tree::object&
-json::tree::node::as_object  (void) const&
-    { throw json::type_error ("node is not an object"); }
-
-
-//-----------------------------------------------------------------------------
-const json::tree::array&
-json::tree::node::as_array   (void) const&
-    { throw json::type_error ("node is not an array"); }
-
-
-//-----------------------------------------------------------------------------
-const json::tree::string&
-json::tree::node::as_string  (void) const&
-    { throw json::type_error ("node is not a string"); }
-
-
-//-----------------------------------------------------------------------------
-const json::tree::number&
-json::tree::node::as_number  (void) const&
-    { throw json::type_error ("node is not a number"); }
-
-
-//-----------------------------------------------------------------------------
-const json::tree::boolean&
-json::tree::node::as_boolean (void) const&
-    { throw json::type_error ("node is not a boolean"); }
-
-
-//-----------------------------------------------------------------------------
-const json::tree::null&
-json::tree::node::as_null (void) const&
-    { throw json::type_error ("node is not a null"); }
-
-
-///////////////////////////////////////////////////////////////////////////////
-json::tree::object&
-json::tree::node::as_object  (void)&
-{ throw json::type_error ("node is not an object"); }
-
-
-//-----------------------------------------------------------------------------
-json::tree::array&
-json::tree::node::as_array   (void)&
-    { throw json::type_error ("node is not an array"); }
-
-
-//-----------------------------------------------------------------------------
-json::tree::string&
-json::tree::node::as_string  (void)&
-    { throw json::type_error ("node is not a string"); }
-
-
-//-----------------------------------------------------------------------------
-json::tree::number&
-json::tree::node::as_number  (void)&
-    { throw json::type_error ("node is not a number"); }
-
-
-//-----------------------------------------------------------------------------
-json::tree::boolean&
-json::tree::node::as_boolean (void)&
-    { throw json::type_error ("node is not a boolean"); }
-
-
-//-----------------------------------------------------------------------------
-json::tree::null&
-json::tree::node::as_null (void)&
-    { throw json::type_error ("node is not a null"); }
-
-
-///////////////////////////////////////////////////////////////////////////////
-bool
-json::tree::node::as_bool (void) const
-{
-    return !!as_boolean ();
-}
-
-
-//-----------------------------------------------------------------------------
-float
-json::tree::node::as_float (void) const
-{
-    return static_cast<float> (as_number ().real ());
-}
-
-
-//-----------------------------------------------------------------------------
-double
-json::tree::node::as_double (void) const
-{
-    return as_number ().real ();
-}
-
-
-//-----------------------------------------------------------------------------
-uintmax_t
-json::tree::node::as_uint (void) const
-{
-    return as_number ().uint ();
-}
-
-
-//-----------------------------------------------------------------------------
-intmax_t
-json::tree::node::as_sint (void) const
-{
-    return as_number ().sint ();
-}
-
-
-//-----------------------------------------------------------------------------
-const char*
-json::tree::node::as_chars (void) const&
-{
-    return as_string ().native ().c_str ();
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-namespace json::tree {
-#if defined(__clang__)
-#elif defined(__GNUC__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wuseless-cast"
-#endif
-    template <>
-    bool node::as (void) const
-    {
-        return as_bool ();
-    }
-
-
-//-----------------------------------------------------------------------------
-    template <>
-    float json::tree::node::as (void) const
-    {
-        return as_float ();
-    }
-
-
-//-----------------------------------------------------------------------------
-    template <>
-    double
-    json::tree::node::as (void) const
-    {
-        return as_double ();
-    }
-
-
-//-----------------------------------------------------------------------------
-    template <>
-    uint32_t
-    json::tree::node::as (void) const
-    {
-        return static_cast<uint32_t> (as_uint ());
-    }
-
-
-//-----------------------------------------------------------------------------
-    template <>
-    uint64_t
-    json::tree::node::as (void) const
-    {
-        return static_cast<uint64_t> (as_uint ());
-    }
-
-
-//-----------------------------------------------------------------------------
-    template <>
-    int32_t
-    json::tree::node::as (void) const
-    {
-        return static_cast<int32_t> (as_sint ());
-    }
-
-
-//-----------------------------------------------------------------------------
-    template <>
-    int64_t
-    json::tree::node::as (void) const
-    {
-        return static_cast<int64_t> (as_sint ());
-    }
-
-
-    //-------------------------------------------------------------------------
-    template <>
-    const std::string&
-    json::tree::node::as (void) const
-    {
-        return as_string ().native ();
-    }
-#if defined(__clang__)
-#elif defined(__GNUC__)
-#pragma GCC diagnostic pop
-#endif
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-// Global operatoers
-bool
-json::tree::node::operator!= (const node &rhs) const
-    { return !(*this == rhs); }
-
-
-//-----------------------------------------------------------------------------
-bool json::tree::node::operator==(const char *rhs) const
-{
-    try {
-        return as_string ().native () == rhs;
-    } catch (const json::type_error&) {
-        return false;
-    }
-}
-
-
-//-----------------------------------------------------------------------------
-json::tree::node&
-json::tree::node::operator[] (const std::string &key)&
-    { return as_object ()[key]; }
-
-
-//-----------------------------------------------------------------------------
-json::tree::node&
-json::tree::node::operator[] (size_t idx)&
-    { return as_array()[idx]; }
-
-
-//-----------------------------------------------------------------------------
-const json::tree::node&
-json::tree::node::operator[] (const std::string &key) const&
-    { return as_object ()[key]; }
-
-
-//-----------------------------------------------------------------------------
-const json::tree::node&
-json::tree::node::operator[] (size_t idx) const&
-    { return as_array()[idx]; }
-
-
-///////////////////////////////////////////////////////////////////////////////
-// Object
-json::tree::object::~object ()
-    { ; }
-
-
-//-----------------------------------------------------------------------------
-std::unique_ptr<json::tree::node>
-json::tree::object::clone (void) const
-{
-    auto obj = std::make_unique<json::tree::object> ();
-
-    for (auto &i: *this)
-        obj->insert (i.first, i.second->clone ());
-
-    return std::move (obj);
-}
-
-
-//-----------------------------------------------------------------------------
-bool
-json::tree::object::operator== (const json::tree::object &rhs) const
-{
-    if (rhs.size () != size ())
-        return false;
-
-    for (auto const &[i,j]: util::zip (m_values, rhs.m_values)) {
-        if (i.first != j.first)
-            return false;
-
-        if (*i.second != *j.second)
-            return false;
-    }
-
-    return true;
-}
-
-
-//-----------------------------------------------------------------------------
-void
-json::tree::object::insert (const std::string &_key, std::unique_ptr<json::tree::node> &&value)
-{
-    m_values[_key] = move(value);
-}
-
-
-//-----------------------------------------------------------------------------
-json::tree::node&
-json::tree::object::operator[](const std::string &key)&
-{
-    auto value = m_values.find (key);
-    if (value == m_values.end ())
-        throw json::key_error (key);
-
-    return *value->second;
-}
-
-
-//-----------------------------------------------------------------------------
-const json::tree::node&
-json::tree::object::operator[](const std::string &key) const&
-{
-    auto value = m_values.find (key);
-    if (value == m_values.end ())
-        throw json::key_error (key);
-
-    return *value->second;
-}
-
-
-//-----------------------------------------------------------------------------
-bool
-json::tree::object::has (const std::string &key) const
-{
-    return m_values.find (key) != m_values.end ();
-}
-
-
-//-----------------------------------------------------------------------------
-json::tree::object::const_iterator
-json::tree::object::find (const std::string &key) const
-{
-    return m_values.find (key);
-}
-
-
-//-----------------------------------------------------------------------------
-json::tree::object::const_iterator
-json::tree::object::begin (void) const
-    { return m_values.begin (); }
-
-
-//-----------------------------------------------------------------------------
-json::tree::object::const_iterator
-json::tree::object::end (void) const
-    { return m_values.end (); }
-
-
-//-----------------------------------------------------------------------------
-size_t
-json::tree::object::size (void) const
-{
-    return m_values.size ();
-}
-
-
-//-----------------------------------------------------------------------------
-void
-json::tree::object::clear (void)
-{
-    m_values.clear ();
-}
-
-
-//-----------------------------------------------------------------------------
-void
-json::tree::object::erase (const std::string &key)
-{
-    auto pos = m_values.find (key);
-    if (pos == m_values.end ())
-        throw json::error ("erasing invalid key");
-
-    m_values.erase (key);
-}
-
-
-//-----------------------------------------------------------------------------
-std::ostream&
-json::tree::object::write (std::ostream &os) const
-{
-    os << "{\n";
-    {
-        util::indenter raii(os);
-
-        for (auto i = m_values.begin (); i != m_values.end ();) {
-            os << '"' << i->first << "\" : " << *i->second;
-
-            if (++i != m_values.end ())
-                os << ",\n";
-        }
-    }
-
-    os << "\n}";
-    return os;
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-// Array
-
-json::tree::array::~array()
-{
-    m_values.clear ();
-}
-
-
-//-----------------------------------------------------------------------------
-std::unique_ptr<json::tree::node>
-json::tree::array::clone (void) const
-{
-    auto ret = std::make_unique<array> ();
-
-    for (const auto &i: *this)
-        ret->insert (i.clone ());
-
-    return std::move (ret);
-}
-
-
-//-----------------------------------------------------------------------------
-void
-json::tree::array::insert (std::unique_ptr<json::tree::node> &&_value)
-{
-    m_values.push_back (move (_value));
-}
-
-
-//-----------------------------------------------------------------------------
-bool
-json::tree::array::operator==(const json::tree::array &rhs) const
-{
-    if (rhs.size () != size ())
-        return false;
-
-    for (auto const &[i,j]: util::zip (m_values, rhs.m_values))
-        if (*i != *j)
-            return false;
-
-    return true;
-}
-
-
-//-----------------------------------------------------------------------------
-bool
-json::tree::array::operator== (const node &rhs) const
-{
-    return rhs == *this;
-}
-
-
-//-----------------------------------------------------------------------------
-size_t
-json::tree::array::size (void) const
-{
-    return m_values.size ();
-}
-
-
-//-----------------------------------------------------------------------------
-json::tree::node&
-json::tree::array::operator[] (size_t idx)&
-{
-    return *m_values[idx];
-}
-
-
-//-----------------------------------------------------------------------------
-const json::tree::node&
-json::tree::array::operator[] (size_t idx) const&
-{
-    return *m_values[idx];
-}
-
-
-//-----------------------------------------------------------------------------
-json::tree::array::iterator
-json::tree::array::begin (void)
-{
-    return iterator (m_values.begin ());
-}
-
-
-
-//-----------------------------------------------------------------------------
-json::tree::array::iterator
-json::tree::array::end (void)
-{
-    return iterator (m_values.end ());
-}
-
-
-
-//-----------------------------------------------------------------------------
-json::tree::array::const_iterator
-json::tree::array::begin (void) const
-{
-    return const_iterator (m_values.begin ());
-}
-
-
-
-//-----------------------------------------------------------------------------
-json::tree::array::const_iterator
-json::tree::array::end (void) const
-{
-    return const_iterator (m_values.end ());
-}
-
-
-
-//-----------------------------------------------------------------------------
-json::tree::array::const_iterator
-json::tree::array::cbegin (void) const
-{
-    return const_iterator (m_values.cbegin ());
-}
-
-
-//-----------------------------------------------------------------------------
-json::tree::array::const_iterator
-json::tree::array::cend (void) const
-{
-    return const_iterator (m_values.cend ());
-}
-
-
-//-----------------------------------------------------------------------------
-std::ostream&
-json::tree::array::write (std::ostream &os) const {
-    os << "[\n";
-    {
-        util::indenter raii(os);
-
-        for (auto i = m_values.begin (); i != m_values.end (); ++i) {
-            (*i)->write (os);
-
-            if (i != m_values.end () - 1)
-                os << ",\n";
-        }
-    }
-    os << "\n]";
-    return os;
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-// String
-
-std::unique_ptr<json::tree::node>
-json::tree::string::clone (void) const
-{
-    return std::make_unique<json::tree::string> (m_value);
-}
-
-
-//-----------------------------------------------------------------------------
-std::ostream&
-json::tree::string::write (std::ostream &os) const
-{
-    os << '"' << m_value << '"';
-    return os;
-}
-
-
-//-----------------------------------------------------------------------------
-bool
-json::tree::string::operator== (const json::tree::string &rhs) const
-    { return rhs.m_value == m_value; }
-
-
-//-----------------------------------------------------------------------------
-bool
-json::tree::string::operator== (const char *rhs) const
-    { return rhs == m_value; }
-
-
-//-----------------------------------------------------------------------------
-bool
-json::tree::string::operator== (const std::string &rhs) const
-    { return rhs == m_value; }
-
-///////////////////////////////////////////////////////////////////////////////
-// Number
-
-std::unique_ptr<json::tree::node>
-json::tree::number::clone (void) const
-{
-    switch (m_repr) {
-    case REAL: return std::make_unique<json::tree::number> (m_value.r);
-    case SINT: return std::make_unique<json::tree::number> (m_value.s);
-    case UINT: return std::make_unique<json::tree::number> (m_value.u);
-    }
-
-    unreachable ();
-}
-
-
-//-----------------------------------------------------------------------------
-std::ostream&
-json::tree::number::write (std::ostream &os) const
-{
-    util::stream::scoped::precision p (os);
-
-    switch (m_repr) {
-    case REAL: return os << std::setprecision (std::numeric_limits<real_t>::digits10) << m_value.r;
-    case SINT: return os << std::setprecision (std::numeric_limits<sint_t>::digits10) << m_value.s;
-    case UINT: return os << std::setprecision (std::numeric_limits<uint_t>::digits10) << m_value.u;
-    }
-
-    unreachable ();
-}
-
-
-//-----------------------------------------------------------------------------
-bool
-json::tree::number::operator ==(const json::tree::number &rhs) const {
-    if (repr () != rhs.repr ())
-        return false;
-
-    switch (repr ()) {
-    case REAL: return util::almost_equal (real (), rhs.real ());
-    case SINT: return util::almost_equal (sint (), rhs.sint ());
-    case UINT: return util::almost_equal (uint (), rhs.uint ());
-    }
-
-    unreachable ();
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-json::tree::number::real_t
-json::tree::number::real (void) const
-{
-    switch (repr ()) {
-    case REAL:
-        return m_value.r;
-
-    case UINT:
-        if (uint_t (real_t (m_value.u)) != m_value.u)
-            throw type_error ("number is not a real");
-        return m_value.u;
-
-    case SINT:
-        if (sint_t (real_t (m_value.s)) != m_value.s)
-            throw type_error ("number is not a real");
-        return m_value.s;
-    }
-
-    unreachable ();
-}
-
-
-//-----------------------------------------------------------------------------
-json::tree::number::sint_t
-json::tree::number::sint (void) const
-{
-    switch (repr ()) {
-    case SINT:
-        return m_value.s;
-
-    case REAL:
-        if (!::util::equal (real_t (sint_t (m_value.r)), m_value.r))
-            throw type_error ("number is not a sint");
-        return sint_t (m_value.r);
-
-    case UINT:
-        if (uint_t (sint_t (m_value.u)) != m_value.u)
-            throw type_error ("number is not a sint");
-        return m_value.s;
-    }
-
-    unreachable ();
-}
-
-
-//-----------------------------------------------------------------------------
-json::tree::number::uint_t
-json::tree::number::uint (void) const
-{
-    switch (repr ()) {
-    case UINT:
-        return m_value.u;
-
-    case REAL:
-        if (!::util::equal (real_t (uint_t (m_value.r)), m_value.r))
-            throw type_error ("number is not a uint");
-        return uint_t (m_value.r);
-
-    case SINT:
-        if (sint_t (uint_t (m_value.s)) != m_value.s)
-            throw type_error ("number is not a uint");
-        return m_value.s;
-    }
-
-    unreachable ();
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-json::tree::number::operator json::tree::number::real_t (void) const
-{
-    return real ();
-}
-
-
-//-----------------------------------------------------------------------------
-json::tree::number::operator json::tree::number::sint_t (void) const
-{
-    return sint ();
-}
-
-
-//-----------------------------------------------------------------------------
-json::tree::number::operator json::tree::number::uint_t (void) const
-{
-    return uint ();
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-// Boolean
-
-std::unique_ptr<json::tree::node>
-json::tree::boolean::clone (void) const
-{
-    return std::make_unique<json::tree::boolean> (m_value);
-}
-
-
-//-----------------------------------------------------------------------------
-std::ostream&
-json::tree::boolean::write (std::ostream &os) const
-{
-    os << (m_value ? "true" : "false");
-    return os;
-}
-
-
-//-----------------------------------------------------------------------------
-bool
-json::tree::boolean::operator ==(const json::tree::boolean &rhs) const
-    { return rhs.m_value == m_value; }
-
-
-///////////////////////////////////////////////////////////////////////////////
-// Null
-
-std::unique_ptr<json::tree::node>
-json::tree::null::clone (void) const
-{
-    return std::make_unique<json::tree::null> ();
-}
-
-
-//-----------------------------------------------------------------------------
-std::ostream&
-json::tree::null::write (std::ostream &os) const
-{
-    os << "null";
-    return os;
-}
-
-
-//-----------------------------------------------------------------------------
-std::ostream&
-json::tree::operator<< (std::ostream &os, const json::tree::node &n)
-    { return n.write (os); }
-
-
-//-----------------------------------------------------------------------------
-// to_json
-
-namespace json::tree {
-    template <>
-    std::unique_ptr<node>
-    io<bool>::serialise (const bool &b) {
-        return std::unique_ptr<node> (new boolean (b));
-    }
-
-    template <>
-    std::unique_ptr<node>
-    io<std::nullptr_t>::serialise (const std::nullptr_t &) {
-        return std::unique_ptr<node> (new null ());
-    }
-
-    template <>
-    std::unique_ptr<node>
-    io<std::string>::serialise (const std::string &s) {
-        return std::unique_ptr<node> (new string (s));
-    }
-
-    template <>
-    std::unique_ptr<node>
-    io<int32_t>::serialise (const int32_t &i) {
-        return std::unique_ptr<node> (new number (intmax_t {i}));
-    }
-
-    template <>
-    std::unique_ptr<node>
-    io<int64_t>::serialise (const int64_t &i) {
-        return std::unique_ptr<node> (new number (intmax_t {i}));
-    }
-
-    template <>
-    std::unique_ptr<node>
-    io<uint32_t>::serialise (const uint32_t &i) {
-        return std::unique_ptr<node> (new number (uintmax_t {i}));
-    }
-
-    template <>
-    std::unique_ptr<node>
-    io<uint64_t>::serialise (const uint64_t &i) {
-        return std::unique_ptr<node> (new number (uintmax_t {i}));
-    }
-
-    template <>
-    std::unique_ptr<node>
-    io<float>::serialise (const float &f) {
-        return std::unique_ptr<node> (new number (f));
-    }
-}
diff --git a/json/tree.hpp b/json/tree.hpp
deleted file mode 100644
index 7f32a5f3..00000000
--- a/json/tree.hpp
+++ /dev/null
@@ -1,397 +0,0 @@
-/*
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Copyright 2010-2018 Danny Robson <danny@nerdcruft.net>
- */
-
-#ifndef __UTIL_JSON_TREE_HPP
-#define __UTIL_JSON_TREE_HPP
-
-#include "flat.hpp"
-#include "fwd.hpp"
-
-#include "../iterator.hpp"
-#include "../view.hpp"
-
-#include <iosfwd>
-#include <map>
-#include <memory>
-#include <string>
-#include <vector>
-
-#include <experimental/filesystem>
-
-
-///////////////////////////////////////////////////////////////////////////////
-namespace json::tree {
-    enum type_t {
-        OBJECT,
-        ARRAY,
-        STRING,
-        NUMBER,
-        BOOLEAN,
-        NONE
-    };
-
-    /// Parse an encoded form of JSON into a tree structure
-    template <typename T>
-    std::unique_ptr<node>
-    parse (const util::view<T> &data);
-
-    std::unique_ptr<node>
-    parse (const std::experimental::filesystem::path &);
-
-    extern void write (const json::tree::node&, std::ostream&);
-
-    /// Abstract base for all JSON values
-    class node {
-        public:
-            node (const node&) = delete;
-            virtual ~node () { ; }
-            virtual std::unique_ptr<node> clone (void) const = 0;
-
-            virtual const object&  as_object  (void) const&;
-            virtual const array&   as_array   (void) const&;
-            virtual const string&  as_string  (void) const&;
-            virtual const number&  as_number  (void) const&;
-            virtual const boolean& as_boolean (void) const&;
-            virtual const null&    as_null    (void) const&;
-
-            virtual object&  as_object  (void)&;
-            virtual array&   as_array   (void)&;
-            virtual string&  as_string  (void)&;
-            virtual number&  as_number  (void)&;
-            virtual boolean& as_boolean (void)&;
-            virtual null&    as_null    (void)&;
-
-            // we don't provide operators for conversion due to ambiguities
-            // introduced when using indexing operators with pointer
-            // arguments.
-            virtual bool   as_bool   (void) const;
-            virtual float  as_float  (void) const;
-            virtual double as_double (void) const;
-            virtual intmax_t  as_sint   (void) const;
-            virtual uintmax_t as_uint   (void) const;
-            virtual const char* as_chars (void) const&;
-
-            template <typename T>
-            T as (void) const;
-
-            virtual bool is_object  (void) const { return false; }
-            virtual bool is_array   (void) const { return false; }
-            virtual bool is_string  (void) const { return false; }
-            virtual bool is_number  (void) const { return false; }
-            virtual bool is_integer (void) const { return false; }
-            virtual bool is_boolean (void) const { return false; }
-            virtual bool is_null    (void) const { return false; }
-
-            virtual type_t type (void) const = 0;
-
-            virtual bool operator==(const node &rhs) const = 0;
-            virtual bool operator!=(const node &rhs) const;
-            virtual bool operator==(const object  &) const { return false; }
-            virtual bool operator==(const array   &) const { return false; }
-            virtual bool operator==(const string  &) const { return false; }
-            virtual bool operator==(const number  &) const { return false; }
-            virtual bool operator==(const boolean &) const { return false; }
-            virtual bool operator==(const null    &) const { return false; }
-
-            virtual bool operator==(const char *rhs) const;
-            virtual bool operator!=(const char *rhs) const { return !(*this == rhs); }
-
-            virtual node& operator[] (const std::string&)&;
-            virtual node& operator[] (size_t)&;
-            virtual const node& operator[] (const std::string&) const&;
-            virtual const node& operator[] (size_t) const&;
-
-            virtual std::ostream& write (std::ostream &os) const = 0;
-
-        protected:
-            node () = default;
-    };
-
-
-    /// Represents a JSON object, and contains its children.
-    class object final : public node {
-        private:
-            using value_store = std::map<std::string, std::unique_ptr<node>>;
-
-        public:
-            typedef value_store::iterator       iterator;
-            typedef value_store::const_iterator const_iterator;
-
-
-        public:
-            virtual ~object ();
-            virtual std::unique_ptr<node> clone (void) const override;
-
-            virtual const object& as_object  (void) const& override { return *this; }
-            virtual       object& as_object  (void)      & override { return *this; }
-            virtual bool          is_object  (void) const  override { return  true; }
-            virtual type_t type (void) const override { return OBJECT; }
-
-            virtual bool operator==(const object &rhs) const override;
-            virtual bool operator==(const node   &rhs) const override
-                { return rhs == *this; }
-
-            virtual void insert (const std::string &key, std::unique_ptr<node>&& value);
-            virtual const node& operator[] (const std::string &key) const& override;
-            virtual node& operator[] (const std::string &key)& override;
-            virtual bool has (const std::string&) const;
-
-            virtual const_iterator find (const std::string&) const;
-
-            virtual const_iterator begin (void) const;
-            virtual const_iterator end   (void) const;
-            virtual const_iterator cbegin (void) const { return begin (); }
-            virtual const_iterator cend   (void) const { return end   (); }
-
-            virtual size_t size (void) const;
-
-            virtual void clear (void);
-            virtual void erase (const std::string &key);
-
-            virtual std::ostream& write (std::ostream &os) const override;
-
-        private:
-            value_store m_values;
-    };
-
-
-    /// Represents a JSON array, and contains its children.
-    class array final : public node {
-        protected:
-            typedef std::vector<std::unique_ptr<node>>::iterator       pointer_array_iterator;
-            typedef std::vector<std::unique_ptr<node>>::const_iterator const_pointer_array_iterator;
-
-        public:
-            typedef referencing_iterator<pointer_array_iterator>       iterator;
-            typedef referencing_iterator<const_pointer_array_iterator> const_iterator;
-
-        protected:
-            std::vector<std::unique_ptr<node>> m_values;
-
-        public:
-            virtual ~array();
-            virtual std::unique_ptr<node> clone (void) const override;
-
-            virtual const array&  as_array   (void) const& override { return *this; }
-            virtual       array&  as_array   (void)      & override { return *this; }
-            virtual bool          is_array   (void) const  override { return  true; }
-            virtual type_t type (void) const override { return ARRAY; }
-
-            virtual bool operator==(const array &rhs) const override;
-            virtual bool operator==(const node  &rhs) const override;
-
-            virtual size_t size (void) const;
-            virtual node& operator[] (size_t idx)& override;
-            virtual const node& operator[] (size_t idx) const& override;
-
-            virtual iterator begin (void);
-            virtual iterator end   (void);
-            virtual const_iterator begin (void) const;
-            virtual const_iterator end   (void) const;
-            virtual const_iterator cbegin (void) const;
-            virtual const_iterator cend   (void) const;
-
-            virtual void insert (std::unique_ptr<json::tree::node> &&_value);
-
-            virtual std::ostream& write (std::ostream &os) const override;
-    };
-
-
-    /// Represents a JSON string literal.
-    class string final : public node {
-        protected:
-            std::string m_value;
-
-        public:
-            template <typename T>
-            string (T first, T last): m_value (first, last) { ; }
-
-            explicit string (const std::string &_value): m_value (_value) { ; }
-            explicit string (const char        *_value): m_value (_value) { ; }
-            string (const char *_first, const char *_last): m_value (_first, _last) { ; }
-            virtual std::unique_ptr<node> clone (void) const override;
-
-            virtual const string& as_string  (void) const& override { return *this; }
-            virtual       string& as_string  (void)      & override { return *this; }
-            virtual bool          is_string  (void) const  override { return  true; }
-
-            virtual type_t type (void) const override { return STRING; }
-
-            virtual bool operator==(const char   *rhs) const override;
-            virtual bool operator==(const string &rhs) const override;
-            virtual bool operator==(const std::string &rhs) const;
-            virtual bool operator==(const node   &rhs) const override
-                { return rhs == *this; }
-
-            virtual bool operator!= (const std::string &rhs) const { return !(*this == rhs); }
-
-            virtual size_t size (void) const { return m_value.size (); }
-
-            operator const std::string&(void) const { return m_value; }
-            const std::string& native (void) const  { return m_value; }
-
-            virtual std::ostream& write (std::ostream &os) const override;
-    };
-
-
-    /// Represents a JSON integer/float literal.
-    class number final : public node {
-        public:
-            enum repr_t {
-                REAL,
-                SINT,
-                UINT
-            };
-
-            using real_t = double;
-            using sint_t = intmax_t;
-            using uint_t = uintmax_t;
-
-
-            explicit number (real_t _value): m_repr (REAL) { m_value.r = _value; }
-            explicit number (sint_t _value): m_repr (SINT) { m_value.s = _value; }
-            explicit number (uint_t _value): m_repr (UINT) { m_value.u = _value; }
-            virtual std::unique_ptr<node> clone (void) const override;
-
-            virtual const number& as_number  (void) const& override { return *this; }
-            virtual       number& as_number  (void)      & override { return *this; }
-            virtual bool          is_number  (void) const  override { return  true; }
-            virtual bool          is_integer (void) const  override { return repr () == UINT || repr () == SINT; }
-
-            virtual type_t type (void) const override { return NUMBER; }
-            virtual repr_t repr (void) const { return m_repr; }
-
-            virtual bool operator==(const number &rhs) const override;
-            virtual bool operator==(const node   &rhs) const override
-                { return rhs == *this; }
-
-            operator real_t (void) const;
-            operator sint_t (void) const;
-            operator uint_t (void) const;
-
-            real_t real (void) const;
-            sint_t sint (void) const;
-            uint_t uint (void) const;
-
-            virtual std::ostream& write (std::ostream &os) const override;
-
-        private:
-            union {
-                real_t r;
-                sint_t s;
-                uint_t u;
-            } m_value;
-
-            repr_t m_repr;
-    };
-
-
-    /// Represents a JSON boolean literal.
-    class boolean final : public node {
-        protected:
-            bool m_value;
-
-        public:
-            explicit boolean (bool _value): m_value (_value) { ; }
-            virtual std::unique_ptr<node> clone (void) const override;
-
-            virtual const boolean& as_boolean (void) const& override { return *this; }
-            virtual       boolean& as_boolean (void)      & override { return *this; }
-            virtual bool           is_boolean (void) const  override { return  true; }
-
-            virtual type_t type (void) const override { return BOOLEAN; }
-
-            virtual bool operator==(const boolean &rhs) const override;
-            virtual bool operator==(const node   &rhs) const override
-                { return rhs == *this; }
-
-            operator bool (void) const { return m_value; }
-            bool native (void) const { return m_value; }
-
-            virtual std::ostream& write (std::ostream &os) const override;
-    };
-
-
-    /// Represents a JSON null value.
-    class null final : public node {
-        public:
-            virtual type_t type (void) const override { return NONE; }
-            virtual std::unique_ptr<node> clone (void) const override;
-
-            virtual bool operator==(const null&) const override { return true; }
-            virtual bool operator==(const node   &rhs) const override
-                { return rhs == *this; }
-
-            virtual const null& as_null (void) const& override { return *this; }
-            virtual       null& as_null (void)      & override { return *this; }
-            virtual bool        is_null (void) const  override { return  true; }
-
-            virtual std::ostream& write (std::ostream &os) const override;
-    };
-
-
-    std::ostream&
-    operator <<(std::ostream &os, const json::tree::node &n);
-
-
-    // Instantiate this template for the type you wish to output. We use a
-    // helper class here to avoid partial template specialisation of a
-    // function (eg, for templated types).
-    template <typename T, typename ...Args>
-    struct io {
-        static std::unique_ptr<json::tree::node>
-        serialise (const T&, Args &&...args);
-
-        static T
-        deserialise (const json::tree::node&, Args &&...args);
-    };
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-template <typename T, class ...Args>
-std::unique_ptr<json::tree::node>
-to_json (const T &t, Args&&... args)
-{
-    return json::tree::io<T,Args...>::serialise (
-        t, std::forward<Args>(args)...
-    );
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-template <typename T, class ...Args>
-T
-from_json (const json::tree::node &n, Args&&... args)
-{
-    return json::tree::io<T,Args...>::deserialise (
-        n, std::forward<Args>(args)...
-    );
-}
-
-
-//-----------------------------------------------------------------------------
-template <typename T, class ...Args>
-T
-from_json (const std::experimental::filesystem::path &src, Args &&...args)
-{
-    return from_json<T,Args...> (
-        *json::tree::parse (src),
-        std::forward<Args> (args)...
-    );
-}
-
-#endif
diff --git a/json2/event.cpp b/json2/event.cpp
deleted file mode 100644
index b2170d3b..00000000
--- a/json2/event.cpp
+++ /dev/null
@@ -1,94 +0,0 @@
-/*
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Copyright 2017 Danny Robson <danny@nerdcruft.net>
- */
-
-#include "./event.hpp"
-#include "./except.hpp"
-
-#include "../debug.hpp"
-
-using util::json2::event::packet;
-
-
-///////////////////////////////////////////////////////////////////////////////
-util::json2::event::type_t
-packet::type (void) const noexcept
-{
-    CHECK_NEQ (first, last);
-
-    const auto &c = *first;
-
-    switch (c) {
-    case '{': return type_t::OBJECT_BEGIN;
-    case '}': return type_t::OBJECT_END;
-    case '[': return type_t::ARRAY_BEGIN;
-    case ']': return type_t::ARRAY_END;
-    case '"': return type_t::STRING;
-    case 'n': return type_t::NONE;
-
-    case 't':
-    case 'f':
-        return type_t::BOOLEAN;
-
-    // TODO: leading plus isn't valid json, but other similar formats support
-    // this syntax and it's easier to claim it as a number globally here until
-    // we do a little refactoring.
-    case '-':
-    case '+':
-    case '0'...'9':
-        return type_t::NUMBER;
-    }
-
-    unhandled (c);
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-#include "./personality/rfc7519.hpp"
-#include "./personality/jsonish.hpp"
-
-template <typename PersonalityT>
-const char*
-util::json2::event::parse (const std::function<util::json2::callback_t> &cb,
-                           const char *first,
-                           const char *last)
-{
-    auto cursor = first;
-
-    PersonalityT p {};
-    cursor = p.consume_whitespace (cursor, last);
-    cursor = p.parse_value (cb, cursor, last);
-    cursor = p.consume_whitespace (cursor, last);
-
-    return cursor;
-}
-
-
-//-----------------------------------------------------------------------------
-template
-const char* util::json2::event::parse<util::json2::personality::rfc7159> (
-    const std::function<util::json2::callback_t> &,
-    const char*,
-    const char*
-);
-
-
-//-----------------------------------------------------------------------------
-template
-const char* util::json2::event::parse<util::json2::personality::jsonish> (
-    const std::function<util::json2::callback_t> &,
-    const char*,
-    const char*
-);
diff --git a/json2/event.hpp b/json2/event.hpp
deleted file mode 100644
index 245f3656..00000000
--- a/json2/event.hpp
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Copyright 2017 Danny Robson <danny@nerdcruft.net>
- */
-#ifndef CRUFT_JSON2_EVENT_HPP
-#define CRUFT_JSON2_EVENT_HPP
-
-#include "./fwd.hpp"
-
-#include <functional>
-
-
-namespace util::json2::event {
-    // It is important that scalars come after compound types because it
-    // simplifies categorisation as we can use a simple '>' to classify the
-    // types.
-    //
-    // the value of the enumerants isn't important, but they might make it
-    // fractionally easier to visualise in a debugger on some occasions.
-    enum class type_t {
-        OBJECT_BEGIN = '{',
-        OBJECT_END = '}',
-        ARRAY_BEGIN  = '[',
-        ARRAY_END  = ']',
-
-        STRING = '"',
-        NUMBER = '1',
-        BOOLEAN = 't',
-        NONE = 'n',
-    };
-
-    struct packet {
-        type_t type (void) const noexcept;
-
-        const char *first;
-        const char *last;
-    };
-
-    template <typename PersonalityT = personality::rfc7159>
-    const char*
-    parse (const std::function<callback_t>&, const char *first, const char *last);
-};
-
-#endif
\ No newline at end of file
diff --git a/json2/except.hpp b/json2/except.hpp
deleted file mode 100644
index 4896f6f9..00000000
--- a/json2/except.hpp
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Copyright 2017 Danny Robson <danny@nerdcruft.net>
- */
-
-#ifndef CRUFT_UTIL_JSON2_EXCEPT_HPP
-#define CRUFT_UTIL_JSON2_EXCEPT_HPP
-
-#include <exception>
-
-
-namespace util::json2 {
-    struct error : public std::exception {};
-
-
-    struct parse_error : public error {
-        parse_error (const char *_position):
-            position (_position)
-        { ; }
-
-        const char *position;
-    };
-
-
-    struct overrun_error : public parse_error {
-        using parse_error::parse_error;
-    };
-}
-#endif
diff --git a/json2/fwd.hpp b/json2/fwd.hpp
deleted file mode 100644
index 2111aded..00000000
--- a/json2/fwd.hpp
+++ /dev/null
@@ -1,47 +0,0 @@
-/*
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Copyright 2017 Danny Robson <danny@nerdcruft.net>
- */
-
-#ifndef CRUFT_UTIL_JSON2_FWD_HPP
-#define CRUFT_UTIL_JSON2_FWD_HPP
-
-#include "../preprocessor.hpp"
-
-namespace util::json2 {
-    namespace personality {
-        template <typename> struct base;
-
-        struct rfc7159;
-        struct jsonish;
-
-        #define MAP_JSON2_PERSONALITY_TYPES(FUNC) \
-        MAP0(FUNC, \
-            util::json2::personality::rfc7159,\
-            util::json2::personality::jsonish)
-    }
-
-    namespace event {
-        enum class type_t;
-        struct packet;
-    }
-
-    using callback_t = void(const event::packet&);
-
-    struct error;
-    struct parse_error;
-    struct overrun_error;
-}
-
-#endif
\ No newline at end of file
diff --git a/json2/personality/base.cpp b/json2/personality/base.cpp
deleted file mode 100644
index a8e00d81..00000000
--- a/json2/personality/base.cpp
+++ /dev/null
@@ -1,332 +0,0 @@
-/*
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Copyright 2017 Danny Robson <danny@nerdcruft.net>
- */
-#include "./base.hpp"
-
-#include "../event.hpp"
-#include "../except.hpp"
-#include "../../debug.hpp"
-
-#include "./rfc7519.hpp"
-#include "./jsonish.hpp"
-
-using util::json2::personality::base;
-
-
-///////////////////////////////////////////////////////////////////////////////
-static const char*
-expect [[nodiscard]] (const char *first, const char *last, const char value)
-{
-    if (first == last || *first != value)
-        throw util::json2::parse_error {first};
-    return first + 1;
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-template <typename ParentT>
-const char*
-base<ParentT>::consume_whitespace (const char *first, const char *last) noexcept
-{
-    auto cursor = first;
-
-    while (cursor != last) {
-        switch (*cursor) {
-        case 0x20:
-        case 0x09:
-        case 0x0A:
-        case 0x0D:
-            ++cursor;
-            continue;
-        }
-
-        break;
-    }
-
-    return cursor;
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-template <typename ParentT>
-const char*
-base<ParentT>::parse_number (const std::function<util::json2::callback_t> &cb,
-                             const char *first,
-                             const char *last)
-{
-    (void)last;
-
-    // number: minus? int frac? exp?
-    auto cursor = first;
-
-    // minus: '-'
-    if (*cursor == '-')
-        ++cursor;
-
-    // int: '0' | [1-9] DIGIT*
-    switch (*cursor) {
-        case '1'...'9':
-        {
-            ++cursor;
-            while ('0' <= *cursor && *cursor <= '9')
-                ++cursor;
-            break;
-        }
-
-        case '0':
-            // leading zero means we _must_ be parsing a fractional value so we
-            // look ahead to ensure we're about to do so. note that we don't use
-            // `expect' here because it implies consumption of '.'
-            ++cursor;
-            if (*cursor != '.')
-                throw util::json2::parse_error { cursor };
-            break;
-
-        default:
-            throw util::json2::parse_error { cursor };
-    }
-
-    // frac: '.' digit+
-    if (*cursor == '.') {
-        ++cursor;
-
-        auto frac_start = cursor;
-        while ('0' <= *cursor && *cursor <= '9')
-            ++cursor;
-        if (frac_start == cursor)
-            throw util::json2::parse_error { cursor };
-    }
-
-    // exp: [eE] [-+]? digit+
-    if (*cursor == 'e' || *cursor == 'E') {
-        ++cursor;
-
-        if (*cursor == '-' || *cursor == '+')
-            ++cursor;
-
-        auto exp_digits = cursor;
-        while ('0' <= *cursor && *cursor <= '9')
-            ++cursor;
-        if (exp_digits == cursor)
-            throw util::json2::parse_error { cursor };
-    }
-
-    cb ({ first, cursor });
-    return cursor;
-}
-
-
-//-----------------------------------------------------------------------------
-template <typename ParentT>
-template <int N>
-const char*
-base<ParentT>::parse_literal (const std::function<util::json2::callback_t> &cb,
-                              const char *first,
-                              const char *last,
-                              const char (&value)[N])
-{
-    CHECK_LE (first, last);
-
-    if (last - first < N - 1)
-        throw util::json2::overrun_error { first };
-
-    if (!std::equal (first, first + N - 1, value))
-        throw util::json2::parse_error { first };
-
-    cb ({ first, first + N - 1 });
-    return first + N - 1;
-}
-
-
-//-----------------------------------------------------------------------------
-template <typename ParentT>
-const char*
-base<ParentT>::parse_string (const std::function<util::json2::callback_t> &cb,
-                             const char *first,
-                             const char *last)
-{
-    CHECK_LE (first, last);
-
-    auto cursor = first;
-
-    cursor = expect (cursor, last, '"');
-
-    for ( ; cursor != last && *cursor != '"'; ) {
-        // advance the simple case first; unescaped character
-        if (*cursor++ != '\\') {
-            continue;
-        }
-
-        if (*cursor++ == 'u') {
-            for (int i = 0; i < 4; ++i) {
-                switch (*cursor) {
-                    case 'a'...'f':
-                    case 'A'...'F':
-                        ++cursor;
-                        continue;
-                    default:
-                        throw util::json2::parse_error { cursor };
-                }
-            }
-        }
-    }
-
-    cursor = expect (cursor, last, '"');
-    cb ({ first, cursor });
-    return cursor;
-}
-
-
-//-----------------------------------------------------------------------------
-template <typename ParentT>
-const char*
-base<ParentT>::parse_array (const std::function<util::json2::callback_t> &cb,
-                            const char *first,
-                            const char *last)
-{
-    CHECK_LE (first, last);
-
-    auto cursor = first;
-
-    if (*cursor != '[')
-        throw util::json2::parse_error {cursor};
-    cb ({ cursor, cursor + 1 });
-    ++cursor;
-
-    cursor = ParentT::consume_whitespace (cursor, last);
-
-    if (*cursor == ']') {
-        cb ({cursor, cursor + 1});
-        return ++cursor;
-    }
-
-    cursor = ParentT::parse_value (cb, cursor, last);
-
-    if (*cursor == ']') {
-        cb ({cursor, cursor + 1});
-        return ++cursor;
-    }
-
-    do {
-        cursor = ParentT::consume_whitespace (cursor, last);
-        cursor = expect (cursor, last, ',');
-        cursor = ParentT::consume_whitespace (cursor, last);
-        cursor = ParentT::parse_value (cb, cursor, last);
-    } while (*cursor != ']');
-
-    cb ({cursor, cursor + 1});
-    ++cursor;
-
-    return cursor;
-}
-
-
-//-----------------------------------------------------------------------------
-template <typename ParentT>
-const char*
-base<ParentT>::parse_object (const std::function<util::json2::callback_t> &cb,
-                             const char *first,
-                             const char *last)
-{
-    CHECK_LE (first, last);
-
-    auto cursor = first;
-    cursor = expect (cursor, last, '{');
-    cb ({ cursor - 1, cursor });
-
-    cursor = ParentT::consume_whitespace (cursor, last);
-
-    if (*cursor == '}') {
-        cb ({cursor, cursor + 1});
-        return ++cursor;
-    };
-
-    auto parse_member = [] (auto _cb, auto _cursor, auto _last) {
-        _cursor = ParentT::parse_key (_cb, _cursor, _last);
-
-        _cursor = ParentT::consume_whitespace (_cursor, _last);
-        _cursor = expect (_cursor, _last, ':');
-        _cursor = ParentT::consume_whitespace (_cursor, _last);
-
-        _cursor = ParentT::parse_value (_cb, _cursor, _last);
-        _cursor = ParentT::consume_whitespace (_cursor, _last);
-
-        return _cursor;
-    };
-
-    cursor = parse_member (cb, cursor, last);
-
-    if (*cursor == '}') {
-        cb ({cursor, cursor + 1});
-        return ++cursor;
-    }
-
-    do {
-        cursor = expect (cursor, last, ',');
-        cursor = ParentT::consume_whitespace (cursor, last);
-        cursor = parse_member (cb, cursor, last);
-    } while (*cursor != '}');
-
-    cursor = expect (cursor, last, '}');
-    cb ({cursor - 1, cursor});
-    return cursor;
-}
-
-
-
-///////////////////////////////////////////////////////////////////////////////
-template <typename ParentT>
-const char*
-base<ParentT>::parse_value (const std::function<util::json2::callback_t> &cb,
-                            const char *first,
-                            const char *last)
-{
-    switch (*first) {
-    case '+':
-    case '-':
-    case '0'...'9':
-        return ParentT::parse_number (cb, first, last);
-
-    case '"':
-        return ParentT::parse_string (cb, first, last);
-
-    case 't': return ParentT::parse_literal (cb, first, last, "true");
-    case 'f': return ParentT::parse_literal (cb, first, last, "false");
-    case 'n': return ParentT::parse_literal (cb, first, last, "null");
-
-    case '[': return ParentT::parse_array (cb, first, last);
-    case '{': return ParentT::parse_object (cb, first, last);
-    }
-
-    return ParentT::parse_unknown (cb, first, last);
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-template <typename ParentT>
-const char*
-base<ParentT>::parse_unknown (const std::function<util::json2::callback_t>&,
-                              const char *first,
-                              const char *last)
-{
-    (void)last;
-    throw parse_error {first};
-};
-
-
-
-//-----------------------------------------------------------------------------
-#define INSTANTIATE(KLASS) template struct util::json2::personality::base<KLASS>;
-MAP_JSON2_PERSONALITY_TYPES (INSTANTIATE)
diff --git a/json2/personality/base.hpp b/json2/personality/base.hpp
deleted file mode 100644
index 4e20e14a..00000000
--- a/json2/personality/base.hpp
+++ /dev/null
@@ -1,90 +0,0 @@
-/*
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Copyright 2017 Danny Robson <danny@nerdcruft.net>
- */
-
-#ifndef CRUFT_UTIL_JSON2_PERSONALITY_BASE_HPP
-#define CRUFT_UTIL_JSON2_PERSONALITY_BASE_HPP
-
-#include "../fwd.hpp"
-
-#include <functional>
-
-
-namespace util::json2::personality {
-    template <typename T>
-    struct base {
-        static const char*
-        consume_whitespace [[nodiscard]] (const char *first, const char *last) noexcept;
-
-
-        static const char*
-        parse_number [[nodiscard]] (
-            const std::function<callback_t>&,
-            const char *first,
-            const char *last
-        );
-
-
-        template <int N>
-        static const char*
-        parse_literal [[nodiscard]] (
-            const std::function<callback_t>&,
-            const char *first,
-            const char *last,
-            const char (&value)[N]
-        );
-
-
-        static const char*
-        parse_string [[nodiscard]] (
-            const std::function<callback_t>&,
-            const char *first,
-            const char *last
-        );
-
-
-        static const char*
-        parse_array [[nodiscard]] (
-            const std::function<callback_t>&,
-            const char *first,
-            const char *last
-        );
-
-
-        static const char*
-        parse_object [[nodiscard]] (
-            const std::function<callback_t>&,
-            const char *first,
-            const char *last
-        );
-
-
-        static const char*
-        parse_value [[nodiscard]] (
-            const std::function<callback_t>&,
-            const char *first,
-            const char *last
-        );
-
-        static const char*
-        parse_unknown [[noreturn]] (
-            const std::function<callback_t>&,
-            const char *first,
-            const char *last
-        );
-    };
-};
-
-#endif
diff --git a/json2/personality/jsonish.cpp b/json2/personality/jsonish.cpp
deleted file mode 100644
index 45b8b973..00000000
--- a/json2/personality/jsonish.cpp
+++ /dev/null
@@ -1,201 +0,0 @@
-/*
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Copyright 2017 Danny Robson <danny@nerdcruft.net>
- */
-
-#include "./jsonish.hpp"
-
-#include "./base.hpp"
-#include "../event.hpp"
-#include "../except.hpp"
-#include "../../debug.hpp"
-
-using util::json2::personality::jsonish;
-
-
-///////////////////////////////////////////////////////////////////////////////
-const char*
-jsonish::consume_whitespace (const char *first, const char *last) noexcept
-{
-    auto cursor = base<jsonish>::consume_whitespace (first, last);
-
-    // consume a comment
-    if (cursor != last && *cursor == '#') {
-        while (cursor != last && *cursor != '\n')
-            ++cursor;
-
-        return consume_whitespace (cursor, last);
-    }
-
-    return cursor;
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-// format is:
-//   int: '0x' hex+ | '0' oct+ | '0b' bit+
-//
-//   float: significand exp?
-//   significand: digit+ ('.' digit*)?
-//   exp: [eE] sign? digit+
-//
-//   number: [+-] (int | float)
-const char*
-jsonish::parse_number (const std::function<callback_t> &cb,
-                       const char *first,
-                       const char *last)
-{
-    auto cursor = first;
-
-    if (cursor != last && (*cursor == '+' || *cursor == '-'))
-        ++cursor;
-
-    if (cursor != last && *cursor == '0') {
-        ++cursor;
-
-        if (cursor == last)
-            throw parse_error {cursor};
-
-        char max = '9';
-        switch (*cursor) {
-        case 'x': {
-            // parse the hex integer here because we can simplify the
-            // remaining cases somewhat if we don't need to care about the
-            // multiple ranges of valid digits.
-            ++cursor;
-
-            auto digit_start = cursor;
-            while (cursor != last && ((('0' <= *cursor) && (*cursor <= '9')) ||
-                                      (('a' <= *cursor) && (*cursor <= 'f')) ||
-                                      (('A' <= *cursor) && (*cursor <= 'F'))))
-                ++cursor;
-            if (digit_start == cursor)
-                throw parse_error {cursor};
-
-            cb ({first, cursor});
-            return cursor;
-        };
-
-        case 'b': max = '1'; break;
-        case '0'...'7': max = '7'; break;
-
-        case '.':
-            goto frac;
-        }
-
-        auto digit_start = ++cursor;
-        while (cursor != last && '0' <= *cursor && *cursor <= max)
-            ++cursor;
-        if (digit_start == cursor)
-            throw parse_error {cursor};
-
-        cb ({first, cursor});
-        return cursor;
-    }
-
-    while (cursor != last && '0' <= *cursor && *cursor <= '9')
-        ++cursor;
-    if (cursor == last)
-        goto done;
-
-    if (*cursor != '.')
-        goto exp;
-
-frac:
-    ++cursor;
-    while (cursor != last && *cursor >= '0' && *cursor <= '9')
-        ++cursor;
-    if (cursor == last)
-        goto done;
-
-exp:
-    if (cursor != last && (*cursor == 'e'  || *cursor == 'E')) {
-        ++cursor;
-
-        if (cursor != last && (*cursor == '+' || *cursor == '-'))
-            ++cursor;
-
-        auto digit_start = cursor;
-        while (cursor != last && '0' <= *cursor && *cursor <= '9')
-            ++cursor;
-        if (digit_start == cursor)
-            throw parse_error {cursor};
-    }
-
-    if (first == cursor)
-        throw parse_error {cursor};
-
-done:
-    cb ({first, cursor});
-    return cursor;
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-const char*
-jsonish::parse_key (const std::function<callback_t> &cb,
-                    const char *first,
-                    const char *last)
-{
-    auto cursor = first;
-    if (cursor == last)
-        throw parse_error {cursor};
-
-    // must start with alpha or underscore
-    switch (*cursor) {
-    case 'a'...'z':
-    case 'A'...'Z':
-    case '_':
-        ++cursor;
-        break;
-
-    default:
-        throw parse_error {cursor};
-    }
-
-
-    while (cursor != last) {
-        switch (*cursor) {
-        case 'a'...'z':
-        case 'A'...'Z':
-        case '_':
-        case '0'...'9':
-            ++cursor;
-            break;
-
-        default:
-            cb ({first, cursor});
-            return cursor;
-        }
-    }
-
-    cb ({first, cursor});
-    return cursor;
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-const char*
-jsonish::parse_string (const std::function<callback_t> &cb,
-                       const char *first,
-                       const char *last)
-{
-    if (first == last)
-        throw parse_error {first};
-
-    if (*first == '"')
-        return base<jsonish>::parse_string (cb, first, last);
-    else
-        return parse_key (cb, first, last);
-}
diff --git a/json2/personality/jsonish.hpp b/json2/personality/jsonish.hpp
deleted file mode 100644
index fd44f61c..00000000
--- a/json2/personality/jsonish.hpp
+++ /dev/null
@@ -1,101 +0,0 @@
-/*
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Copyright 2017 Danny Robson <danny@nerdcruft.net>
- */
-
-#ifndef CRUFT_UTIL_JSON2_PERSONALITY_JSONISH_HPP
-#define CRUFT_UTIL_JSON2_PERSONALITY_JSONISH_HPP
-
-#include "../fwd.hpp"
-
-#include "./base.hpp"
-
-#include <functional>
-
-
-namespace util::json2::personality {
-    struct jsonish {
-        static const char*
-        consume_whitespace [[nodiscard]] (
-            const char *first,
-            const char *last
-        ) noexcept;
-
-
-        static const char*
-        parse_value [[nodiscard]] (
-            const std::function<callback_t> &cb,
-            const char *first, const char *last
-        ) { return base<jsonish>::parse_value (cb, first, last); }
-
-
-        static const char*
-        parse_number [[nodiscard]] (
-            const std::function<callback_t> &cb,
-            const char *first,
-            const char *last
-        );
-
-
-        template <int N>
-        static const char*
-        parse_literal [[nodiscard]] (
-            const std::function<callback_t> &cb,
-            const char *first,
-            const char *last,
-            const char (&value)[N]
-        ) { return base<jsonish>::parse_literal (cb, first, last, value); }
-
-
-        static const char*
-        parse_string [[nodiscard]] (
-            const std::function<callback_t> &cb,
-            const char *first,
-            const char *last
-        );
-
-
-        static const char*
-        parse_array [[nodiscard]] (
-            const std::function<callback_t> &cb,
-            const char *first,
-            const char *last
-        ) { return base<jsonish>::parse_array (cb, first, last); }
-
-
-        static const char*
-        parse_key [[nodiscard]] (
-            const std::function<callback_t> &cb,
-            const char *first,
-            const char *last);
-
-
-        static const char*
-        parse_object [[nodiscard]] (
-            const std::function<callback_t> &cb,
-            const char *first,
-            const char *last
-        ) { return base<jsonish>::parse_object (cb, first, last); }
-
-
-        static const char*
-        parse_unknown [[nodiscard]] (
-            const std::function<callback_t> &cb,
-            const char *first,
-            const char *last
-        ) { return parse_string (cb, first, last); }
-    };
-};
-
-#endif
diff --git a/json2/personality/rfc7519.cpp b/json2/personality/rfc7519.cpp
deleted file mode 100644
index 041c6cdd..00000000
--- a/json2/personality/rfc7519.cpp
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Copyright 2017 Danny Robson <danny@nerdcruft.net>
- */
-
-#include "./rfc7519.hpp"
-
-#include "./base.hpp"
-
-using util::json2::personality::rfc7159;
diff --git a/json2/personality/rfc7519.hpp b/json2/personality/rfc7519.hpp
deleted file mode 100644
index cf26e0ad..00000000
--- a/json2/personality/rfc7519.hpp
+++ /dev/null
@@ -1,100 +0,0 @@
-/*
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Copyright 2017 Danny Robson <danny@nerdcruft.net>
- */
-
-#ifndef CRUFT_UTIL_JSON2_PERSONALITY_RFC7159_HPP
-#define CRUFT_UTIL_JSON2_PERSONALITY_RFC7159_HPP
-
-#include "./base.hpp"
-
-#include "../fwd.hpp"
-
-#include <functional>
-
-namespace util::json2::personality {
-    struct rfc7159 {
-        static const char*
-        consume_whitespace [[nodiscard]] (const char *first, const char *last) noexcept
-        { return base<rfc7159>::consume_whitespace (first, last); }
-
-
-        static const char*
-        parse_value [[nodiscard]] (
-            const std::function<callback_t> &cb,
-            const char *first, const char *last
-        ) { return base<rfc7159>::parse_value (cb, first, last); }
-
-
-        static const char*
-        parse_number [[nodiscard]] (
-            const std::function<callback_t> &cb,
-            const char *first,
-            const char *last
-        ) { return base<rfc7159>::parse_number (cb, first, last); }
-
-
-        template <int N>
-        static const char*
-        parse_literal [[nodiscard]] (
-            const std::function<callback_t> &cb,
-            const char *first,
-            const char *last,
-            const char (&value)[N]
-        ) { return base<rfc7159>::parse_literal (cb, first, last, value); }
-
-
-        static const char*
-        parse_string [[nodiscard]] (
-            const std::function<callback_t> &cb,
-            const char *first,
-            const char *last
-        ) { return base<rfc7159>::parse_string (cb, first, last); }
-
-
-        static const char*
-        parse_array [[nodiscard]] (
-            const std::function<callback_t> &cb,
-            const char *first,
-            const char *last
-        ) { return base<rfc7159>::parse_array (cb, first, last); }
-
-
-        static const char*
-        parse_key [[nodiscard]] (
-            const std::function<callback_t> &cb,
-            const char *first,
-            const char *last)
-        { return parse_string (cb, first, last); }
-
-
-        static const char*
-        parse_object [[nodiscard]] (
-            const std::function<callback_t> &cb,
-            const char *first,
-            const char *last
-        ) { return base<rfc7159>::parse_object (cb, first, last); }
-
-
-        static const char *
-        parse_unknown [[noreturn]] (
-            const std::function<callback_t> &cb,
-            const char *first,
-            const char *last)
-        { throw base<rfc7159>::parse_unknown (cb, first, last); }
-    };
-};
-
-
-#endif
\ No newline at end of file
diff --git a/json2/tree.cpp b/json2/tree.cpp
deleted file mode 100644
index 0ca18b6f..00000000
--- a/json2/tree.cpp
+++ /dev/null
@@ -1 +0,0 @@
-#include "./tree.hpp"
\ No newline at end of file
diff --git a/json2/tree.hpp b/json2/tree.hpp
deleted file mode 100644
index f9049603..00000000
--- a/json2/tree.hpp
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Copyright 2017 Danny Robson <danny@nerdcruft.net>
- */
-
-#ifndef CRUFT_JSON2_TREE_HPP
-#define CRUFT_JSON2_TREE_HPP
-
-
-
-#endif
\ No newline at end of file
diff --git a/range.cpp b/range.cpp
index 40b6ce95..2037721f 100644
--- a/range.cpp
+++ b/range.cpp
@@ -18,7 +18,6 @@
 #include "range.hpp"
 
 #include "debug.hpp"
-#include "json/tree.hpp"
 #include "maths.hpp"
 #include "random.hpp"
 
@@ -199,25 +198,3 @@ template struct util::range<uint8_t>;
 template struct util::range<uint16_t>;
 template struct util::range<uint32_t>;
 template struct util::range<uint64_t>;
-
-
-//-----------------------------------------------------------------------------
-namespace json::tree {
-    template <>
-    util::range<double>
-    io<util::range<double>>::deserialise (const json::tree::node &node)
-    {
-        if (node.is_string () && (node == "UNIT" ||
-                                  node == "unit")) {
-            return util::range<double>::unit ();
-        } else if (node.is_string () && (node == "UNLIMITED" ||
-                                         node == "unlimited")) {
-            return util::range<double>::unlimited ();
-        } else {
-            return {
-                node[0].as_number (),
-                node[1].as_number ()
-            };
-        }
-    }
-}
diff --git a/test/json-parse.sh.in b/test/json-parse.sh.in
deleted file mode 100755
index 1d0c6990..00000000
--- a/test/json-parse.sh.in
+++ /dev/null
@@ -1,38 +0,0 @@
-#!/bin/sh
-
-validate="@CMAKE_CURRENT_BINARY_DIR@/json-validate"
-basedir="@CMAKE_CURRENT_SOURCE_DIR@/test/json/validate"
-
-count=0
-code=0
-
-for i in $(ls "${basedir}/good/"*);
-do
-    $validate $i 2>/dev/null 1>&2
-
-    if [ $? -eq 0 ]; then
-        echo "ok     - good/$(basename $i .json)"
-    else
-        echo "not ok - good/$(basename $i .json)"
-        code=1
-    fi
-
-    count=$((count+1))
-done
-
-for i in $(ls "${basedir}/bad/"*);
-do
-    $validate $i 1>&2 2>/dev/null
-
-    if [ $? -eq 0 ]; then
-        echo "not ok - bad/$(basename $i .json)"
-        code=1
-    else
-        echo "ok     - bad/$(basename $i .json)"
-    fi
-
-    count=$((count+1))
-done
-
-echo "1..$count"
-exit $code
diff --git a/test/json-schema.py.in b/test/json-schema.py.in
deleted file mode 100644
index bdcbeb42..00000000
--- a/test/json-schema.py.in
+++ /dev/null
@@ -1,54 +0,0 @@
-#!/usr/bin/env python3
-
-import sys
-import glob
-import os.path
-import subprocess
-import re
-
-## fix paths for running under Wine
-def systemise_path(path):
-    if "@EXEEXT@" == ".exe":
-        return "Z:%s" % os.path.abspath(path)
-    return path
-
-
-SDIR = "@abs_top_srcdir@"
-BDIR = "@abs_top_builddir@"
-
-TOOL = os.path.join(BDIR, "tools", "json-schema@EXEEXT@")
-
-RUNNER = os.path.join("@abs_top_srcdir@", "build-aux", "wine-crlf.sh") if "@EXEEXT@" == ".exe" else "/usr/bin/env"
-
-TEST_EXTRACT = re.compile("(.*?)_(\d{4})_(pass|fail).json")
-
-SCHEMA_DIR = os.path.join(SDIR, "test", "json", "schema")
-SCHEMAS = glob.iglob(os.path.join(SCHEMA_DIR, "*.schema"))
-
-EXPECTED = {
-    "pass": 0,
-    "fail": 1
-}
-
-
-print("1..%s" % len(glob.glob(os.path.join(SCHEMA_DIR, "*.json"))))
-code=0
-
-for schema in SCHEMAS:
-    (name, _) = os.path.splitext(os.path.basename(schema))
-    test_glob = name + "_*.json"
-
-    for test in glob.iglob(os.path.join(SCHEMA_DIR, test_glob)):
-        command = [RUNNER, TOOL, systemise_path(schema), systemise_path(test)]
-
-        (name, seq, success) = TEST_EXTRACT.match(test).groups()
-        res = subprocess.call(command, stdout=subprocess.DEVNULL,stderr=subprocess.STDOUT)
-
-        if res != EXPECTED[success]:
-            print('got res', res)
-            print('not ok -', os.path.basename(test), '#', ' '.join(command))
-            code=1
-        else:
-            print('ok -', os.path.basename(test))
-
-sys.exit(code)
diff --git a/test/json/compare.py.in b/test/json/compare.py.in
deleted file mode 100755
index 6fbd12e2..00000000
--- a/test/json/compare.py.in
+++ /dev/null
@@ -1,30 +0,0 @@
-#!/usr/bin/env python3
-
-from glob import glob
-from subprocess import call
-from os.path import basename
-
-tool="@CMAKE_CURRENT_BINARY_DIR@/json-compare"
-src="@CMAKE_CURRENT_SOURCE_DIR@/test/json/compare"
-suffix=".a.json"
-
-failures = 0
-
-for expected in [ "good", "bad" ]:
-    for path in glob(f"{src}/{expected}/*{suffix}"):
-        base = path[:-len(suffix)]
-
-        inputs = glob(f"{base}*.json")
-        code = call([tool, *inputs])
-
-        success = (expected == "good") == (code == 0)
-
-        prefix = ""
-
-        if not success:
-            prefix = "not "
-            failures += 1
-
-        print(prefix, "ok - ", expected, basename(base), code)
-
-exit(1 if failures else 0)
diff --git a/test/json/compare/bad/0001-float.a.json b/test/json/compare/bad/0001-float.a.json
deleted file mode 100644
index 6324d401..00000000
--- a/test/json/compare/bad/0001-float.a.json
+++ /dev/null
@@ -1 +0,0 @@
-3.14
diff --git a/test/json/compare/bad/0001-float.b.json b/test/json/compare/bad/0001-float.b.json
deleted file mode 100644
index b25fc793..00000000
--- a/test/json/compare/bad/0001-float.b.json
+++ /dev/null
@@ -1 +0,0 @@
-3.142
diff --git a/test/json/compare/bad/1000-truncated_array.a.json b/test/json/compare/bad/1000-truncated_array.a.json
deleted file mode 100644
index ab08ad45..00000000
--- a/test/json/compare/bad/1000-truncated_array.a.json
+++ /dev/null
@@ -1 +0,0 @@
-[0,1,2]
diff --git a/test/json/compare/bad/1000-truncated_array.b.json b/test/json/compare/bad/1000-truncated_array.b.json
deleted file mode 100644
index 49ad6773..00000000
--- a/test/json/compare/bad/1000-truncated_array.b.json
+++ /dev/null
@@ -1 +0,0 @@
-[0,1]
diff --git a/test/json/compare/bad/2000-truncated_object.a.json b/test/json/compare/bad/2000-truncated_object.a.json
deleted file mode 100644
index 5e8f00fe..00000000
--- a/test/json/compare/bad/2000-truncated_object.a.json
+++ /dev/null
@@ -1 +0,0 @@
-{"a":0,"b":1}
diff --git a/test/json/compare/bad/2000-truncated_object.b.json b/test/json/compare/bad/2000-truncated_object.b.json
deleted file mode 100644
index 8994090c..00000000
--- a/test/json/compare/bad/2000-truncated_object.b.json
+++ /dev/null
@@ -1 +0,0 @@
-{"a":0}
diff --git a/test/json/compare/bad/2001-object_value.a.json b/test/json/compare/bad/2001-object_value.a.json
deleted file mode 100644
index 8994090c..00000000
--- a/test/json/compare/bad/2001-object_value.a.json
+++ /dev/null
@@ -1 +0,0 @@
-{"a":0}
diff --git a/test/json/compare/bad/2001-object_value.b.json b/test/json/compare/bad/2001-object_value.b.json
deleted file mode 100644
index a41bb024..00000000
--- a/test/json/compare/bad/2001-object_value.b.json
+++ /dev/null
@@ -1 +0,0 @@
-{"a":0.00001}
diff --git a/test/json/compare/good/0001-integer.a.json b/test/json/compare/good/0001-integer.a.json
deleted file mode 100644
index 231a7d57..00000000
--- a/test/json/compare/good/0001-integer.a.json
+++ /dev/null
@@ -1 +0,0 @@
-638
diff --git a/test/json/compare/good/0001-integer.b.json b/test/json/compare/good/0001-integer.b.json
deleted file mode 100644
index 231a7d57..00000000
--- a/test/json/compare/good/0001-integer.b.json
+++ /dev/null
@@ -1 +0,0 @@
-638
diff --git a/test/json/compare/good/0002-string.a.json b/test/json/compare/good/0002-string.a.json
deleted file mode 100644
index ceb0313f..00000000
--- a/test/json/compare/good/0002-string.a.json
+++ /dev/null
@@ -1 +0,0 @@
-"the quick brown fox"
diff --git a/test/json/compare/good/0002-string.b.json b/test/json/compare/good/0002-string.b.json
deleted file mode 100644
index ceb0313f..00000000
--- a/test/json/compare/good/0002-string.b.json
+++ /dev/null
@@ -1 +0,0 @@
-"the quick brown fox"
diff --git a/test/json/compare/good/0004-float.a.json b/test/json/compare/good/0004-float.a.json
deleted file mode 100644
index 6324d401..00000000
--- a/test/json/compare/good/0004-float.a.json
+++ /dev/null
@@ -1 +0,0 @@
-3.14
diff --git a/test/json/compare/good/0004-float.b.json b/test/json/compare/good/0004-float.b.json
deleted file mode 100644
index 6324d401..00000000
--- a/test/json/compare/good/0004-float.b.json
+++ /dev/null
@@ -1 +0,0 @@
-3.14
diff --git a/test/json/compare/good/0005-true.a.json b/test/json/compare/good/0005-true.a.json
deleted file mode 100644
index 27ba77dd..00000000
--- a/test/json/compare/good/0005-true.a.json
+++ /dev/null
@@ -1 +0,0 @@
-true
diff --git a/test/json/compare/good/0005-true.b.json b/test/json/compare/good/0005-true.b.json
deleted file mode 100644
index 27ba77dd..00000000
--- a/test/json/compare/good/0005-true.b.json
+++ /dev/null
@@ -1 +0,0 @@
-true
diff --git a/test/json/compare/good/0006-false.a.json b/test/json/compare/good/0006-false.a.json
deleted file mode 100644
index c508d536..00000000
--- a/test/json/compare/good/0006-false.a.json
+++ /dev/null
@@ -1 +0,0 @@
-false
diff --git a/test/json/compare/good/0006-false.b.json b/test/json/compare/good/0006-false.b.json
deleted file mode 100644
index c508d536..00000000
--- a/test/json/compare/good/0006-false.b.json
+++ /dev/null
@@ -1 +0,0 @@
-false
diff --git a/test/json/compare/good/0007-null.a.json b/test/json/compare/good/0007-null.a.json
deleted file mode 100644
index 19765bd5..00000000
--- a/test/json/compare/good/0007-null.a.json
+++ /dev/null
@@ -1 +0,0 @@
-null
diff --git a/test/json/compare/good/0007-null.b.json b/test/json/compare/good/0007-null.b.json
deleted file mode 100644
index 19765bd5..00000000
--- a/test/json/compare/good/0007-null.b.json
+++ /dev/null
@@ -1 +0,0 @@
-null
diff --git a/test/json/compare/good/0010-object.a.json b/test/json/compare/good/0010-object.a.json
deleted file mode 100644
index 2393cd01..00000000
--- a/test/json/compare/good/0010-object.a.json
+++ /dev/null
@@ -1 +0,0 @@
-{"foo":"bar"}
diff --git a/test/json/compare/good/0010-object.b.json b/test/json/compare/good/0010-object.b.json
deleted file mode 100644
index 2393cd01..00000000
--- a/test/json/compare/good/0010-object.b.json
+++ /dev/null
@@ -1 +0,0 @@
-{"foo":"bar"}
diff --git a/test/json/compare/good/0020-array.a.json b/test/json/compare/good/0020-array.a.json
deleted file mode 100644
index 29513c49..00000000
--- a/test/json/compare/good/0020-array.a.json
+++ /dev/null
@@ -1 +0,0 @@
-[true]
diff --git a/test/json/compare/good/0020-array.b.json b/test/json/compare/good/0020-array.b.json
deleted file mode 100644
index 29513c49..00000000
--- a/test/json/compare/good/0020-array.b.json
+++ /dev/null
@@ -1 +0,0 @@
-[true]
diff --git a/test/json/compare/good/5000-object.a.json b/test/json/compare/good/5000-object.a.json
deleted file mode 100644
index 5e8f00fe..00000000
--- a/test/json/compare/good/5000-object.a.json
+++ /dev/null
@@ -1 +0,0 @@
-{"a":0,"b":1}
diff --git a/test/json/compare/good/5000-object.b.json b/test/json/compare/good/5000-object.b.json
deleted file mode 100644
index 61a6cebd..00000000
--- a/test/json/compare/good/5000-object.b.json
+++ /dev/null
@@ -1 +0,0 @@
-{"b":1,"a":0}
diff --git a/test/json/pointer.py.in b/test/json/pointer.py.in
deleted file mode 100755
index d6701c09..00000000
--- a/test/json/pointer.py.in
+++ /dev/null
@@ -1,44 +0,0 @@
-#!/usr/bin/env python3
-
-import os.path
-import tempfile
-import subprocess
-from glob import glob
-
-
-if __name__ == '__main__':
-    json_tests = "@CMAKE_CURRENT_SOURCE_DIR@/test/json/pointer/validate/"
-    json_pointer = "@CMAKE_CURRENT_BINARY_DIR@/json-pointer"
-    json_compare = "@CMAKE_CURRENT_BINARY_DIR@/json-compare"
-
-    paths = glob(os.path.join(json_tests, "*.pointer"))
-    paths = (os.path.splitext(p)[0] for p in paths)
-    names = sorted(p for p in paths)
-
-    failures = 0
-
-    for n in names:
-        input = f"{n}.input.json"
-        truth = f"{n}.truth.json"
-        with open(f"{n}.pointer") as f: pointer = f.read()
-
-        success = False
-
-        try:
-            with tempfile.NamedTemporaryFile(delete=True) as result:
-                do_query = [json_pointer, pointer.rstrip(), input]
-                do_compare = [json_compare, result.name, truth]
-
-                #print(do_query)
-                #print(do_compare)
-
-                subprocess.check_call(do_query, stdout=result)
-                subprocess.check_call(do_compare)
-                success = True
-        except subprocess.CalledProcessError:
-            failures += 1
-
-        prefix = "not " if not success else ""
-        print(f"{prefix}ok - {n}")
-
-    exit(1 if failures else 0)
diff --git a/test/json/pointer/validate/0000_root_object.input.json b/test/json/pointer/validate/0000_root_object.input.json
deleted file mode 120000
index 99e75ac2..00000000
--- a/test/json/pointer/validate/0000_root_object.input.json
+++ /dev/null
@@ -1 +0,0 @@
-object.json
\ No newline at end of file
diff --git a/test/json/pointer/validate/0000_root_object.pointer b/test/json/pointer/validate/0000_root_object.pointer
deleted file mode 100644
index 792d6005..00000000
--- a/test/json/pointer/validate/0000_root_object.pointer
+++ /dev/null
@@ -1 +0,0 @@
-#
diff --git a/test/json/pointer/validate/0000_root_object.truth.json b/test/json/pointer/validate/0000_root_object.truth.json
deleted file mode 120000
index 99e75ac2..00000000
--- a/test/json/pointer/validate/0000_root_object.truth.json
+++ /dev/null
@@ -1 +0,0 @@
-object.json
\ No newline at end of file
diff --git a/test/json/pointer/validate/0001_emptykey.input.json b/test/json/pointer/validate/0001_emptykey.input.json
deleted file mode 120000
index 99e75ac2..00000000
--- a/test/json/pointer/validate/0001_emptykey.input.json
+++ /dev/null
@@ -1 +0,0 @@
-object.json
\ No newline at end of file
diff --git a/test/json/pointer/validate/0001_emptykey.pointer b/test/json/pointer/validate/0001_emptykey.pointer
deleted file mode 100644
index cd2af4ff..00000000
--- a/test/json/pointer/validate/0001_emptykey.pointer
+++ /dev/null
@@ -1 +0,0 @@
-#/
diff --git a/test/json/pointer/validate/0001_emptykey.truth.json b/test/json/pointer/validate/0001_emptykey.truth.json
deleted file mode 100644
index 10f85add..00000000
--- a/test/json/pointer/validate/0001_emptykey.truth.json
+++ /dev/null
@@ -1 +0,0 @@
-"empty"
diff --git a/test/json/pointer/validate/0002_key.input.json b/test/json/pointer/validate/0002_key.input.json
deleted file mode 120000
index 99e75ac2..00000000
--- a/test/json/pointer/validate/0002_key.input.json
+++ /dev/null
@@ -1 +0,0 @@
-object.json
\ No newline at end of file
diff --git a/test/json/pointer/validate/0002_key.pointer b/test/json/pointer/validate/0002_key.pointer
deleted file mode 100644
index eaa30520..00000000
--- a/test/json/pointer/validate/0002_key.pointer
+++ /dev/null
@@ -1 +0,0 @@
-#/string
diff --git a/test/json/pointer/validate/0002_key.truth.json b/test/json/pointer/validate/0002_key.truth.json
deleted file mode 100644
index 1ab186a7..00000000
--- a/test/json/pointer/validate/0002_key.truth.json
+++ /dev/null
@@ -1 +0,0 @@
-"value"
diff --git a/test/json/pointer/validate/0003_key_index.input.json b/test/json/pointer/validate/0003_key_index.input.json
deleted file mode 120000
index 99e75ac2..00000000
--- a/test/json/pointer/validate/0003_key_index.input.json
+++ /dev/null
@@ -1 +0,0 @@
-object.json
\ No newline at end of file
diff --git a/test/json/pointer/validate/0003_key_index.pointer b/test/json/pointer/validate/0003_key_index.pointer
deleted file mode 100644
index ff171184..00000000
--- a/test/json/pointer/validate/0003_key_index.pointer
+++ /dev/null
@@ -1 +0,0 @@
-#/array/2
diff --git a/test/json/pointer/validate/0003_key_index.truth.json b/test/json/pointer/validate/0003_key_index.truth.json
deleted file mode 100644
index 0cfbf088..00000000
--- a/test/json/pointer/validate/0003_key_index.truth.json
+++ /dev/null
@@ -1 +0,0 @@
-2
diff --git a/test/json/pointer/validate/0004_deep_traverse.input.json b/test/json/pointer/validate/0004_deep_traverse.input.json
deleted file mode 120000
index 99e75ac2..00000000
--- a/test/json/pointer/validate/0004_deep_traverse.input.json
+++ /dev/null
@@ -1 +0,0 @@
-object.json
\ No newline at end of file
diff --git a/test/json/pointer/validate/0004_deep_traverse.pointer b/test/json/pointer/validate/0004_deep_traverse.pointer
deleted file mode 100644
index 1dfe3074..00000000
--- a/test/json/pointer/validate/0004_deep_traverse.pointer
+++ /dev/null
@@ -1 +0,0 @@
-#/object/inner/value/2
diff --git a/test/json/pointer/validate/0004_deep_traverse.truth.json b/test/json/pointer/validate/0004_deep_traverse.truth.json
deleted file mode 100644
index b8626c4c..00000000
--- a/test/json/pointer/validate/0004_deep_traverse.truth.json
+++ /dev/null
@@ -1 +0,0 @@
-4
diff --git a/test/json/pointer/validate/object.json b/test/json/pointer/validate/object.json
deleted file mode 100644
index 77f585c0..00000000
--- a/test/json/pointer/validate/object.json
+++ /dev/null
@@ -1,11 +0,0 @@
-{
-    "": "empty",
-    "string": "value",
-    "array": [ 0, 1, 2, 3 ],
-    "object": {
-        "boolean": true,
-        "inner": {
-            "value": [ 3, 1, 4 ]
-        }
-    }
-}
diff --git a/test/json/schema.py.in b/test/json/schema.py.in
deleted file mode 100755
index 5ff9af9f..00000000
--- a/test/json/schema.py.in
+++ /dev/null
@@ -1,108 +0,0 @@
-#!/usr/bin/env python3
-
-from glob import glob
-import subprocess
-
-import os.path
-import os
-import tempfile
-
-validate="@CMAKE_CURRENT_BINARY_DIR@/json-schema"
-compare="@CMAKE_CURRENT_BINARY_DIR@/json-compare"
-src="@CMAKE_CURRENT_SOURCE_DIR@/test/json/schema"
-devnull=open(os.devnull, 'w')
-
-
-def test_bad(schema:str, dir:str) -> int:
-    failures = 0
-
-    for input in glob(os.path.join(dir, "*.json")):
-        code = subprocess.call([validate, schema, input], stdout=devnull, stderr=devnull)
-
-        prefix = ""
-        if code == 0:
-            prefix = "not "
-            failures += 1
-
-        prefix = "not " if code == 0 else ""
-        print(f"{prefix}ok - {input}")
-
-    return failures
-
-
-def test_good(schema:str, dir:str) -> int:
-    # extract a list of inputs and truths. the truth list may be incomplete
-    # (if we're not dealing with defaults) so we can't use it directly.
-    inputs  = glob(os.path.join(dir, "*.input.json"))
-    results = glob(os.path.join(dir, "*.result.json"))
-
-    unused = [x for x in glob(f"{dir}/*") if x not in inputs and x not in results]
-    if unused:
-        raise RuntimeError("unused inputs", unused)
-
-    inputs.sort()
-
-    failures = 0
-
-    for test in inputs:
-        # check if we have a corresponding .result.json file as the ground
-        # truth. if not then we assume that there shouldn't be any chance in
-        # the resulting json and set the truth to the test file.
-        (base,_) = os.path.splitext(test)
-        (base,_) = os.path.splitext(base)
-        truth = f"{base}.result.json"
-
-        if not os.path.isfile(truth):
-            truth = test
-
-        success = False
-
-        try:
-            # a two stage check:
-            # * apply the schema to the test file
-            # * test it matches the truth file
-            with tempfile.NamedTemporaryFile(delete=True) as out:
-                subprocess.check_call([validate, schema, test], stdout=out)
-                subprocess.check_call([compare, out.name, truth])
-                success = True
-        except subprocess.CalledProcessError:
-            failures += 1
-
-        prefix = "not " if not success else ""
-        print(f"{prefix}ok - {test}")
-
-    return failures
-
-
-def validation_group(dir:str) -> int:
-    schema = os.path.join(dir, "schema.json")
-    if not os.path.isfile(schema):
-        raise Exception(f"schema is not present, {schema}")
-
-    failures  = 0
-    failures += test_good(schema, os.path.join(dir, "good"))
-    failures += test_bad(schema, os.path.join(dir, "bad"))
-
-    return failures
-
-def test_validation(dir:str) -> int:
-    failures = 0
-
-    groups = (x for x in os.listdir(dir))
-    groups = (os.path.join(dir, x) for x in groups)
-    groups = (x for x in groups if os.path.isdir(x))
-
-    for name in sorted(groups):
-        path = os.path.join(src, name)
-        if not os.path.isdir(path):
-            continue
-        failures += validation_group(path)
-
-    return failures
-
-
-if __name__ == "__main__":
-    failures = 0
-
-    failures += test_validation(os.path.join(src, "validation"))
-    exit(1 if failures else 0)
diff --git a/test/json/schema/parsing/bad/0000_multipleOf_zero.json b/test/json/schema/parsing/bad/0000_multipleOf_zero.json
deleted file mode 100644
index 3797c646..00000000
--- a/test/json/schema/parsing/bad/0000_multipleOf_zero.json
+++ /dev/null
@@ -1,4 +0,0 @@
-{
-    "description": "multipleOf must be strictly greater than zero",
-    "multipleOf": 0
-}
diff --git a/test/json/schema/parsing/bad/0001_multipleOf_negative.json b/test/json/schema/parsing/bad/0001_multipleOf_negative.json
deleted file mode 100644
index d85643d6..00000000
--- a/test/json/schema/parsing/bad/0001_multipleOf_negative.json
+++ /dev/null
@@ -1,4 +0,0 @@
-{
-    "description": "multipleOf must be strictly greater than zero",
-    "multipleOf": -1
-}
diff --git a/test/json/schema/validation/0000_empty/good/0001.input.json b/test/json/schema/validation/0000_empty/good/0001.input.json
deleted file mode 100644
index 9d55f0cd..00000000
--- a/test/json/schema/validation/0000_empty/good/0001.input.json
+++ /dev/null
@@ -1 +0,0 @@
-[1,"a", {}]
diff --git a/test/json/schema/validation/0000_empty/good/0001.result.json b/test/json/schema/validation/0000_empty/good/0001.result.json
deleted file mode 120000
index 7593de9b..00000000
--- a/test/json/schema/validation/0000_empty/good/0001.result.json
+++ /dev/null
@@ -1 +0,0 @@
-0001.input.json
\ No newline at end of file
diff --git a/test/json/schema/validation/0000_empty/good/0002.input.json b/test/json/schema/validation/0000_empty/good/0002.input.json
deleted file mode 100644
index 810c96ee..00000000
--- a/test/json/schema/validation/0000_empty/good/0002.input.json
+++ /dev/null
@@ -1 +0,0 @@
-"foo"
diff --git a/test/json/schema/validation/0000_empty/good/0002.result.json b/test/json/schema/validation/0000_empty/good/0002.result.json
deleted file mode 120000
index 50ef5fbb..00000000
--- a/test/json/schema/validation/0000_empty/good/0002.result.json
+++ /dev/null
@@ -1 +0,0 @@
-0002.input.json
\ No newline at end of file
diff --git a/test/json/schema/validation/0000_empty/schema.json b/test/json/schema/validation/0000_empty/schema.json
deleted file mode 100644
index 0967ef42..00000000
--- a/test/json/schema/validation/0000_empty/schema.json
+++ /dev/null
@@ -1 +0,0 @@
-{}
diff --git a/test/json/schema/validation/0001_type_any/good/0001.input.json b/test/json/schema/validation/0001_type_any/good/0001.input.json
deleted file mode 100644
index 0967ef42..00000000
--- a/test/json/schema/validation/0001_type_any/good/0001.input.json
+++ /dev/null
@@ -1 +0,0 @@
-{}
diff --git a/test/json/schema/validation/0001_type_any/good/0001.result.json b/test/json/schema/validation/0001_type_any/good/0001.result.json
deleted file mode 120000
index 7593de9b..00000000
--- a/test/json/schema/validation/0001_type_any/good/0001.result.json
+++ /dev/null
@@ -1 +0,0 @@
-0001.input.json
\ No newline at end of file
diff --git a/test/json/schema/validation/0001_type_any/good/0002.input.json b/test/json/schema/validation/0001_type_any/good/0002.input.json
deleted file mode 100644
index fe51488c..00000000
--- a/test/json/schema/validation/0001_type_any/good/0002.input.json
+++ /dev/null
@@ -1 +0,0 @@
-[]
diff --git a/test/json/schema/validation/0001_type_any/good/0002.result.json b/test/json/schema/validation/0001_type_any/good/0002.result.json
deleted file mode 120000
index 50ef5fbb..00000000
--- a/test/json/schema/validation/0001_type_any/good/0002.result.json
+++ /dev/null
@@ -1 +0,0 @@
-0002.input.json
\ No newline at end of file
diff --git a/test/json/schema/validation/0001_type_any/good/0003.input.json b/test/json/schema/validation/0001_type_any/good/0003.input.json
deleted file mode 100644
index 810c96ee..00000000
--- a/test/json/schema/validation/0001_type_any/good/0003.input.json
+++ /dev/null
@@ -1 +0,0 @@
-"foo"
diff --git a/test/json/schema/validation/0001_type_any/good/0003.result.json b/test/json/schema/validation/0001_type_any/good/0003.result.json
deleted file mode 120000
index 1e873d0d..00000000
--- a/test/json/schema/validation/0001_type_any/good/0003.result.json
+++ /dev/null
@@ -1 +0,0 @@
-0003.input.json
\ No newline at end of file
diff --git a/test/json/schema/validation/0001_type_any/good/0004.input.json b/test/json/schema/validation/0001_type_any/good/0004.input.json
deleted file mode 100644
index 6324d401..00000000
--- a/test/json/schema/validation/0001_type_any/good/0004.input.json
+++ /dev/null
@@ -1 +0,0 @@
-3.14
diff --git a/test/json/schema/validation/0001_type_any/good/0004.result.json b/test/json/schema/validation/0001_type_any/good/0004.result.json
deleted file mode 120000
index 676a073b..00000000
--- a/test/json/schema/validation/0001_type_any/good/0004.result.json
+++ /dev/null
@@ -1 +0,0 @@
-0004.input.json
\ No newline at end of file
diff --git a/test/json/schema/validation/0001_type_any/good/0005.input.json b/test/json/schema/validation/0001_type_any/good/0005.input.json
deleted file mode 100644
index 27ba77dd..00000000
--- a/test/json/schema/validation/0001_type_any/good/0005.input.json
+++ /dev/null
@@ -1 +0,0 @@
-true
diff --git a/test/json/schema/validation/0001_type_any/good/0005.result.json b/test/json/schema/validation/0001_type_any/good/0005.result.json
deleted file mode 120000
index 3ae127b7..00000000
--- a/test/json/schema/validation/0001_type_any/good/0005.result.json
+++ /dev/null
@@ -1 +0,0 @@
-0005.input.json
\ No newline at end of file
diff --git a/test/json/schema/validation/0001_type_any/good/0006.input.json b/test/json/schema/validation/0001_type_any/good/0006.input.json
deleted file mode 100644
index 19765bd5..00000000
--- a/test/json/schema/validation/0001_type_any/good/0006.input.json
+++ /dev/null
@@ -1 +0,0 @@
-null
diff --git a/test/json/schema/validation/0001_type_any/good/0006.result.json b/test/json/schema/validation/0001_type_any/good/0006.result.json
deleted file mode 120000
index 8a10eaa5..00000000
--- a/test/json/schema/validation/0001_type_any/good/0006.result.json
+++ /dev/null
@@ -1 +0,0 @@
-0006.input.json
\ No newline at end of file
diff --git a/test/json/schema/validation/0001_type_any/schema.json b/test/json/schema/validation/0001_type_any/schema.json
deleted file mode 100644
index 2a2c1435..00000000
--- a/test/json/schema/validation/0001_type_any/schema.json
+++ /dev/null
@@ -1 +0,0 @@
-{"type": ["object", "array", "string", "number", "boolean", "null"]}
diff --git a/test/json/schema/validation/0002_type_number/bad/0001.json b/test/json/schema/validation/0002_type_number/bad/0001.json
deleted file mode 100644
index 810c96ee..00000000
--- a/test/json/schema/validation/0002_type_number/bad/0001.json
+++ /dev/null
@@ -1 +0,0 @@
-"foo"
diff --git a/test/json/schema/validation/0002_type_number/good/0001.input.json b/test/json/schema/validation/0002_type_number/good/0001.input.json
deleted file mode 100644
index 6324d401..00000000
--- a/test/json/schema/validation/0002_type_number/good/0001.input.json
+++ /dev/null
@@ -1 +0,0 @@
-3.14
diff --git a/test/json/schema/validation/0002_type_number/good/0001.result.json b/test/json/schema/validation/0002_type_number/good/0001.result.json
deleted file mode 120000
index 7593de9b..00000000
--- a/test/json/schema/validation/0002_type_number/good/0001.result.json
+++ /dev/null
@@ -1 +0,0 @@
-0001.input.json
\ No newline at end of file
diff --git a/test/json/schema/validation/0002_type_number/good/0002.input.json b/test/json/schema/validation/0002_type_number/good/0002.input.json
deleted file mode 100644
index 00750edc..00000000
--- a/test/json/schema/validation/0002_type_number/good/0002.input.json
+++ /dev/null
@@ -1 +0,0 @@
-3
diff --git a/test/json/schema/validation/0002_type_number/good/0002.result.json b/test/json/schema/validation/0002_type_number/good/0002.result.json
deleted file mode 120000
index 50ef5fbb..00000000
--- a/test/json/schema/validation/0002_type_number/good/0002.result.json
+++ /dev/null
@@ -1 +0,0 @@
-0002.input.json
\ No newline at end of file
diff --git a/test/json/schema/validation/0002_type_number/schema.json b/test/json/schema/validation/0002_type_number/schema.json
deleted file mode 100644
index 33909a9d..00000000
--- a/test/json/schema/validation/0002_type_number/schema.json
+++ /dev/null
@@ -1 +0,0 @@
-{"type":"number"}
diff --git a/test/json/schema/validation/0003_type_integer/bad/0001-integer_float.json b/test/json/schema/validation/0003_type_integer/bad/0001-integer_float.json
deleted file mode 100644
index d3827e75..00000000
--- a/test/json/schema/validation/0003_type_integer/bad/0001-integer_float.json
+++ /dev/null
@@ -1 +0,0 @@
-1.0
diff --git a/test/json/schema/validation/0003_type_integer/bad/0002-float.json b/test/json/schema/validation/0003_type_integer/bad/0002-float.json
deleted file mode 100644
index 9459d4ba..00000000
--- a/test/json/schema/validation/0003_type_integer/bad/0002-float.json
+++ /dev/null
@@ -1 +0,0 @@
-1.1
diff --git a/test/json/schema/validation/0003_type_integer/bad/0003-string.json b/test/json/schema/validation/0003_type_integer/bad/0003-string.json
deleted file mode 100644
index 810c96ee..00000000
--- a/test/json/schema/validation/0003_type_integer/bad/0003-string.json
+++ /dev/null
@@ -1 +0,0 @@
-"foo"
diff --git a/test/json/schema/validation/0003_type_integer/good/0001.input.json b/test/json/schema/validation/0003_type_integer/good/0001.input.json
deleted file mode 100644
index d00491fd..00000000
--- a/test/json/schema/validation/0003_type_integer/good/0001.input.json
+++ /dev/null
@@ -1 +0,0 @@
-1
diff --git a/test/json/schema/validation/0003_type_integer/schema.json b/test/json/schema/validation/0003_type_integer/schema.json
deleted file mode 100644
index e0b87281..00000000
--- a/test/json/schema/validation/0003_type_integer/schema.json
+++ /dev/null
@@ -1 +0,0 @@
-{"type": "integer"}
diff --git a/test/json/schema/validation/0004_type_object/bad/0001.json b/test/json/schema/validation/0004_type_object/bad/0001.json
deleted file mode 100644
index fe51488c..00000000
--- a/test/json/schema/validation/0004_type_object/bad/0001.json
+++ /dev/null
@@ -1 +0,0 @@
-[]
diff --git a/test/json/schema/validation/0004_type_object/good/0001.input.json b/test/json/schema/validation/0004_type_object/good/0001.input.json
deleted file mode 100644
index 0967ef42..00000000
--- a/test/json/schema/validation/0004_type_object/good/0001.input.json
+++ /dev/null
@@ -1 +0,0 @@
-{}
diff --git a/test/json/schema/validation/0004_type_object/good/0001.result.json b/test/json/schema/validation/0004_type_object/good/0001.result.json
deleted file mode 120000
index 7593de9b..00000000
--- a/test/json/schema/validation/0004_type_object/good/0001.result.json
+++ /dev/null
@@ -1 +0,0 @@
-0001.input.json
\ No newline at end of file
diff --git a/test/json/schema/validation/0004_type_object/schema.json b/test/json/schema/validation/0004_type_object/schema.json
deleted file mode 100644
index 8d33e0b5..00000000
--- a/test/json/schema/validation/0004_type_object/schema.json
+++ /dev/null
@@ -1 +0,0 @@
-{"type":"object"}
diff --git a/test/json/schema/validation/1000_string_length/bad/0001.json b/test/json/schema/validation/1000_string_length/bad/0001.json
deleted file mode 100644
index 231f150c..00000000
--- a/test/json/schema/validation/1000_string_length/bad/0001.json
+++ /dev/null
@@ -1 +0,0 @@
-"a"
diff --git a/test/json/schema/validation/1000_string_length/bad/0002.json b/test/json/schema/validation/1000_string_length/bad/0002.json
deleted file mode 100644
index 363e68c4..00000000
--- a/test/json/schema/validation/1000_string_length/bad/0002.json
+++ /dev/null
@@ -1 +0,0 @@
-"abcdefg"
diff --git a/test/json/schema/validation/1000_string_length/good/0001.input.json b/test/json/schema/validation/1000_string_length/good/0001.input.json
deleted file mode 100644
index cb5537d5..00000000
--- a/test/json/schema/validation/1000_string_length/good/0001.input.json
+++ /dev/null
@@ -1 +0,0 @@
-"ab"
diff --git a/test/json/schema/validation/1000_string_length/good/0001.result.json b/test/json/schema/validation/1000_string_length/good/0001.result.json
deleted file mode 120000
index 7593de9b..00000000
--- a/test/json/schema/validation/1000_string_length/good/0001.result.json
+++ /dev/null
@@ -1 +0,0 @@
-0001.input.json
\ No newline at end of file
diff --git a/test/json/schema/validation/1000_string_length/good/0002.input.json b/test/json/schema/validation/1000_string_length/good/0002.input.json
deleted file mode 100644
index 5655d601..00000000
--- a/test/json/schema/validation/1000_string_length/good/0002.input.json
+++ /dev/null
@@ -1 +0,0 @@
-"abcdef"
diff --git a/test/json/schema/validation/1000_string_length/good/0002.result.json b/test/json/schema/validation/1000_string_length/good/0002.result.json
deleted file mode 120000
index 50ef5fbb..00000000
--- a/test/json/schema/validation/1000_string_length/good/0002.result.json
+++ /dev/null
@@ -1 +0,0 @@
-0002.input.json
\ No newline at end of file
diff --git a/test/json/schema/validation/1000_string_length/schema.json b/test/json/schema/validation/1000_string_length/schema.json
deleted file mode 100644
index c5465346..00000000
--- a/test/json/schema/validation/1000_string_length/schema.json
+++ /dev/null
@@ -1,7 +0,0 @@
-{
-    "$schema": "http://json-schema.org/draft-04/schema#",
-
-    "type": "string",
-    "minLength": 2,
-    "maxLength": 6
-}
diff --git a/test/json/schema/validation/2000_signed_min/bad/0001.json b/test/json/schema/validation/2000_signed_min/bad/0001.json
deleted file mode 100644
index ae538dab..00000000
--- a/test/json/schema/validation/2000_signed_min/bad/0001.json
+++ /dev/null
@@ -1 +0,0 @@
--1.1
diff --git a/test/json/schema/validation/2000_signed_min/good/0001.input.json b/test/json/schema/validation/2000_signed_min/good/0001.input.json
deleted file mode 100644
index 573541ac..00000000
--- a/test/json/schema/validation/2000_signed_min/good/0001.input.json
+++ /dev/null
@@ -1 +0,0 @@
-0
diff --git a/test/json/schema/validation/2000_signed_min/good/0001.result.json b/test/json/schema/validation/2000_signed_min/good/0001.result.json
deleted file mode 120000
index 7593de9b..00000000
--- a/test/json/schema/validation/2000_signed_min/good/0001.result.json
+++ /dev/null
@@ -1 +0,0 @@
-0001.input.json
\ No newline at end of file
diff --git a/test/json/schema/validation/2000_signed_min/schema.json b/test/json/schema/validation/2000_signed_min/schema.json
deleted file mode 100644
index 33e581a6..00000000
--- a/test/json/schema/validation/2000_signed_min/schema.json
+++ /dev/null
@@ -1 +0,0 @@
-{ "type": "number", "minimum": -1 }
diff --git a/test/json/schema/validation/2001_unsigned_max/bad/0001.json b/test/json/schema/validation/2001_unsigned_max/bad/0001.json
deleted file mode 100644
index 9459d4ba..00000000
--- a/test/json/schema/validation/2001_unsigned_max/bad/0001.json
+++ /dev/null
@@ -1 +0,0 @@
-1.1
diff --git a/test/json/schema/validation/2001_unsigned_max/good/0001.input.json b/test/json/schema/validation/2001_unsigned_max/good/0001.input.json
deleted file mode 100644
index 3a2e3f49..00000000
--- a/test/json/schema/validation/2001_unsigned_max/good/0001.input.json
+++ /dev/null
@@ -1 +0,0 @@
--1
diff --git a/test/json/schema/validation/2001_unsigned_max/good/0001.result.json b/test/json/schema/validation/2001_unsigned_max/good/0001.result.json
deleted file mode 120000
index 7593de9b..00000000
--- a/test/json/schema/validation/2001_unsigned_max/good/0001.result.json
+++ /dev/null
@@ -1 +0,0 @@
-0001.input.json
\ No newline at end of file
diff --git a/test/json/schema/validation/2001_unsigned_max/schema.json b/test/json/schema/validation/2001_unsigned_max/schema.json
deleted file mode 100644
index bdae19e7..00000000
--- a/test/json/schema/validation/2001_unsigned_max/schema.json
+++ /dev/null
@@ -1 +0,0 @@
-{ "type": "number", "maximum": 1 }
diff --git a/test/json/schema/validation/2002_exclusive_min/bad/0000_below.json b/test/json/schema/validation/2002_exclusive_min/bad/0000_below.json
deleted file mode 100644
index 0cfbf088..00000000
--- a/test/json/schema/validation/2002_exclusive_min/bad/0000_below.json
+++ /dev/null
@@ -1 +0,0 @@
-2
diff --git a/test/json/schema/validation/2002_exclusive_min/bad/1000_equal.json b/test/json/schema/validation/2002_exclusive_min/bad/1000_equal.json
deleted file mode 100644
index 00750edc..00000000
--- a/test/json/schema/validation/2002_exclusive_min/bad/1000_equal.json
+++ /dev/null
@@ -1 +0,0 @@
-3
diff --git a/test/json/schema/validation/2002_exclusive_min/good/0000_above.input.json b/test/json/schema/validation/2002_exclusive_min/good/0000_above.input.json
deleted file mode 100644
index b8626c4c..00000000
--- a/test/json/schema/validation/2002_exclusive_min/good/0000_above.input.json
+++ /dev/null
@@ -1 +0,0 @@
-4
diff --git a/test/json/schema/validation/2002_exclusive_min/schema.json b/test/json/schema/validation/2002_exclusive_min/schema.json
deleted file mode 100644
index 48b04e9c..00000000
--- a/test/json/schema/validation/2002_exclusive_min/schema.json
+++ /dev/null
@@ -1 +0,0 @@
-{ "type": "integer", "exclusiveMinimum": 3 }
diff --git a/test/json/schema/validation/2003_exclusive_max/bad/0000_above.json b/test/json/schema/validation/2003_exclusive_max/bad/0000_above.json
deleted file mode 100644
index b8626c4c..00000000
--- a/test/json/schema/validation/2003_exclusive_max/bad/0000_above.json
+++ /dev/null
@@ -1 +0,0 @@
-4
diff --git a/test/json/schema/validation/2003_exclusive_max/bad/1000_equal.json b/test/json/schema/validation/2003_exclusive_max/bad/1000_equal.json
deleted file mode 100644
index 00750edc..00000000
--- a/test/json/schema/validation/2003_exclusive_max/bad/1000_equal.json
+++ /dev/null
@@ -1 +0,0 @@
-3
diff --git a/test/json/schema/validation/2003_exclusive_max/good/0000_below.input.json b/test/json/schema/validation/2003_exclusive_max/good/0000_below.input.json
deleted file mode 100644
index 0cfbf088..00000000
--- a/test/json/schema/validation/2003_exclusive_max/good/0000_below.input.json
+++ /dev/null
@@ -1 +0,0 @@
-2
diff --git a/test/json/schema/validation/2003_exclusive_max/schema.json b/test/json/schema/validation/2003_exclusive_max/schema.json
deleted file mode 100644
index 7ac97362..00000000
--- a/test/json/schema/validation/2003_exclusive_max/schema.json
+++ /dev/null
@@ -1 +0,0 @@
-{ "type": "integer", "exclusiveMaximum": 3 }
diff --git a/test/json/schema/validation/2004_multiple_of/bad/0000_integer.json b/test/json/schema/validation/2004_multiple_of/bad/0000_integer.json
deleted file mode 100644
index d00491fd..00000000
--- a/test/json/schema/validation/2004_multiple_of/bad/0000_integer.json
+++ /dev/null
@@ -1 +0,0 @@
-1
diff --git a/test/json/schema/validation/2004_multiple_of/good/0000_zero.input.json b/test/json/schema/validation/2004_multiple_of/good/0000_zero.input.json
deleted file mode 100644
index 573541ac..00000000
--- a/test/json/schema/validation/2004_multiple_of/good/0000_zero.input.json
+++ /dev/null
@@ -1 +0,0 @@
-0
diff --git a/test/json/schema/validation/2004_multiple_of/good/1000_identity.input.json b/test/json/schema/validation/2004_multiple_of/good/1000_identity.input.json
deleted file mode 100644
index c239c60c..00000000
--- a/test/json/schema/validation/2004_multiple_of/good/1000_identity.input.json
+++ /dev/null
@@ -1 +0,0 @@
-1.5
diff --git a/test/json/schema/validation/2004_multiple_of/good/2000_ten_times.input.json b/test/json/schema/validation/2004_multiple_of/good/2000_ten_times.input.json
deleted file mode 100644
index 60d3b2f4..00000000
--- a/test/json/schema/validation/2004_multiple_of/good/2000_ten_times.input.json
+++ /dev/null
@@ -1 +0,0 @@
-15
diff --git a/test/json/schema/validation/2004_multiple_of/schema.json b/test/json/schema/validation/2004_multiple_of/schema.json
deleted file mode 100644
index 4ca1328d..00000000
--- a/test/json/schema/validation/2004_multiple_of/schema.json
+++ /dev/null
@@ -1 +0,0 @@
-{ "type": "number", "multipleOf": 1.5 }
diff --git a/test/json/schema/validation/3000_bool_null/bad/0000_int.json b/test/json/schema/validation/3000_bool_null/bad/0000_int.json
deleted file mode 100644
index d00491fd..00000000
--- a/test/json/schema/validation/3000_bool_null/bad/0000_int.json
+++ /dev/null
@@ -1 +0,0 @@
-1
diff --git a/test/json/schema/validation/3000_bool_null/bad/0001_string.json b/test/json/schema/validation/3000_bool_null/bad/0001_string.json
deleted file mode 100644
index 810c96ee..00000000
--- a/test/json/schema/validation/3000_bool_null/bad/0001_string.json
+++ /dev/null
@@ -1 +0,0 @@
-"foo"
diff --git a/test/json/schema/validation/3000_bool_null/bad/0002_null.json b/test/json/schema/validation/3000_bool_null/bad/0002_null.json
deleted file mode 100644
index 19765bd5..00000000
--- a/test/json/schema/validation/3000_bool_null/bad/0002_null.json
+++ /dev/null
@@ -1 +0,0 @@
-null
diff --git a/test/json/schema/validation/3000_bool_null/bad/1000_array.json b/test/json/schema/validation/3000_bool_null/bad/1000_array.json
deleted file mode 100644
index 29513c49..00000000
--- a/test/json/schema/validation/3000_bool_null/bad/1000_array.json
+++ /dev/null
@@ -1 +0,0 @@
-[true]
diff --git a/test/json/schema/validation/3000_bool_null/bad/1001_object.json b/test/json/schema/validation/3000_bool_null/bad/1001_object.json
deleted file mode 100644
index f3a450ff..00000000
--- a/test/json/schema/validation/3000_bool_null/bad/1001_object.json
+++ /dev/null
@@ -1 +0,0 @@
-{"val": true}
diff --git a/test/json/schema/validation/3000_bool_null/good/0000_true.input.json b/test/json/schema/validation/3000_bool_null/good/0000_true.input.json
deleted file mode 100644
index 27ba77dd..00000000
--- a/test/json/schema/validation/3000_bool_null/good/0000_true.input.json
+++ /dev/null
@@ -1 +0,0 @@
-true
diff --git a/test/json/schema/validation/3000_bool_null/good/0000_true.result.json b/test/json/schema/validation/3000_bool_null/good/0000_true.result.json
deleted file mode 120000
index 5d173c77..00000000
--- a/test/json/schema/validation/3000_bool_null/good/0000_true.result.json
+++ /dev/null
@@ -1 +0,0 @@
-0000_true.input.json
\ No newline at end of file
diff --git a/test/json/schema/validation/3000_bool_null/good/0001_false.input.json b/test/json/schema/validation/3000_bool_null/good/0001_false.input.json
deleted file mode 100644
index c508d536..00000000
--- a/test/json/schema/validation/3000_bool_null/good/0001_false.input.json
+++ /dev/null
@@ -1 +0,0 @@
-false
diff --git a/test/json/schema/validation/3000_bool_null/good/0001_false.result.json b/test/json/schema/validation/3000_bool_null/good/0001_false.result.json
deleted file mode 120000
index 66f667a1..00000000
--- a/test/json/schema/validation/3000_bool_null/good/0001_false.result.json
+++ /dev/null
@@ -1 +0,0 @@
-0001_false.input.json
\ No newline at end of file
diff --git a/test/json/schema/validation/3000_bool_null/schema.json b/test/json/schema/validation/3000_bool_null/schema.json
deleted file mode 100644
index 3c2b31d0..00000000
--- a/test/json/schema/validation/3000_bool_null/schema.json
+++ /dev/null
@@ -1 +0,0 @@
-{ "type": "boolean" }
diff --git a/test/json/schema/validation/5000_array/good/0000_array.input.json b/test/json/schema/validation/5000_array/good/0000_array.input.json
deleted file mode 100644
index fe51488c..00000000
--- a/test/json/schema/validation/5000_array/good/0000_array.input.json
+++ /dev/null
@@ -1 +0,0 @@
-[]
diff --git a/test/json/schema/validation/5000_array/good/0000_array.result.json b/test/json/schema/validation/5000_array/good/0000_array.result.json
deleted file mode 120000
index fcfba099..00000000
--- a/test/json/schema/validation/5000_array/good/0000_array.result.json
+++ /dev/null
@@ -1 +0,0 @@
-0000_array.input.json
\ No newline at end of file
diff --git a/test/json/schema/validation/5000_array/schema.json b/test/json/schema/validation/5000_array/schema.json
deleted file mode 100644
index b79cfbba..00000000
--- a/test/json/schema/validation/5000_array/schema.json
+++ /dev/null
@@ -1 +0,0 @@
-{ "type": "array" }
diff --git a/test/json/schema/validation/6000_object/good/0001-empty.input.json b/test/json/schema/validation/6000_object/good/0001-empty.input.json
deleted file mode 100644
index 0967ef42..00000000
--- a/test/json/schema/validation/6000_object/good/0001-empty.input.json
+++ /dev/null
@@ -1 +0,0 @@
-{}
diff --git a/test/json/schema/validation/6000_object/good/0001-empty.result.json b/test/json/schema/validation/6000_object/good/0001-empty.result.json
deleted file mode 120000
index e1bc1698..00000000
--- a/test/json/schema/validation/6000_object/good/0001-empty.result.json
+++ /dev/null
@@ -1 +0,0 @@
-0001-empty.input.json
\ No newline at end of file
diff --git a/test/json/schema/validation/6000_object/good/0002-keyval.input.json b/test/json/schema/validation/6000_object/good/0002-keyval.input.json
deleted file mode 100644
index 2393cd01..00000000
--- a/test/json/schema/validation/6000_object/good/0002-keyval.input.json
+++ /dev/null
@@ -1 +0,0 @@
-{"foo":"bar"}
diff --git a/test/json/schema/validation/6000_object/good/0002-keyval.result.json b/test/json/schema/validation/6000_object/good/0002-keyval.result.json
deleted file mode 120000
index e0dd148f..00000000
--- a/test/json/schema/validation/6000_object/good/0002-keyval.result.json
+++ /dev/null
@@ -1 +0,0 @@
-0002-keyval.input.json
\ No newline at end of file
diff --git a/test/json/schema/validation/6000_object/good/0003-array.input.json b/test/json/schema/validation/6000_object/good/0003-array.input.json
deleted file mode 100644
index 74d7470a..00000000
--- a/test/json/schema/validation/6000_object/good/0003-array.input.json
+++ /dev/null
@@ -1 +0,0 @@
-{"array":[]}
diff --git a/test/json/schema/validation/6000_object/good/0003-array.result.json b/test/json/schema/validation/6000_object/good/0003-array.result.json
deleted file mode 120000
index 13897d9a..00000000
--- a/test/json/schema/validation/6000_object/good/0003-array.result.json
+++ /dev/null
@@ -1 +0,0 @@
-0003-array.input.json
\ No newline at end of file
diff --git a/test/json/schema/validation/6000_object/good/0004-object.input.json b/test/json/schema/validation/6000_object/good/0004-object.input.json
deleted file mode 100644
index 167a8aa9..00000000
--- a/test/json/schema/validation/6000_object/good/0004-object.input.json
+++ /dev/null
@@ -1 +0,0 @@
-{"object":{}}
diff --git a/test/json/schema/validation/6000_object/good/0004-object.result.json b/test/json/schema/validation/6000_object/good/0004-object.result.json
deleted file mode 120000
index 166e75bc..00000000
--- a/test/json/schema/validation/6000_object/good/0004-object.result.json
+++ /dev/null
@@ -1 +0,0 @@
-0004-object.input.json
\ No newline at end of file
diff --git a/test/json/schema/validation/6000_object/schema.json b/test/json/schema/validation/6000_object/schema.json
deleted file mode 100644
index 7edc429b..00000000
--- a/test/json/schema/validation/6000_object/schema.json
+++ /dev/null
@@ -1 +0,0 @@
-{"type": "object"}
diff --git a/test/json/schema/validation/6100_object_properties/bad/1000_string_number.json b/test/json/schema/validation/6100_object_properties/bad/1000_string_number.json
deleted file mode 100644
index a6bc640a..00000000
--- a/test/json/schema/validation/6100_object_properties/bad/1000_string_number.json
+++ /dev/null
@@ -1 +0,0 @@
-{ "string": 1 }
diff --git a/test/json/schema/validation/6100_object_properties/bad/2000_number_object.json b/test/json/schema/validation/6100_object_properties/bad/2000_number_object.json
deleted file mode 100644
index a6df22f9..00000000
--- a/test/json/schema/validation/6100_object_properties/bad/2000_number_object.json
+++ /dev/null
@@ -1 +0,0 @@
-{ "number": {}}
diff --git a/test/json/schema/validation/6100_object_properties/bad/3000_object_array.json b/test/json/schema/validation/6100_object_properties/bad/3000_object_array.json
deleted file mode 100644
index a98e1052..00000000
--- a/test/json/schema/validation/6100_object_properties/bad/3000_object_array.json
+++ /dev/null
@@ -1 +0,0 @@
-{ "object": []}
diff --git a/test/json/schema/validation/6100_object_properties/bad/4000_array_object.json b/test/json/schema/validation/6100_object_properties/bad/4000_array_object.json
deleted file mode 100644
index 70230c05..00000000
--- a/test/json/schema/validation/6100_object_properties/bad/4000_array_object.json
+++ /dev/null
@@ -1 +0,0 @@
-{ "array": {} }
diff --git a/test/json/schema/validation/6100_object_properties/bad/5000_bool_number.json b/test/json/schema/validation/6100_object_properties/bad/5000_bool_number.json
deleted file mode 100644
index d493963d..00000000
--- a/test/json/schema/validation/6100_object_properties/bad/5000_bool_number.json
+++ /dev/null
@@ -1 +0,0 @@
-{ "boolean": 0 }
diff --git a/test/json/schema/validation/6100_object_properties/bad/6000_null_bool.json b/test/json/schema/validation/6100_object_properties/bad/6000_null_bool.json
deleted file mode 100644
index 34cd667b..00000000
--- a/test/json/schema/validation/6100_object_properties/bad/6000_null_bool.json
+++ /dev/null
@@ -1 +0,0 @@
-{ "null": 0 }
diff --git a/test/json/schema/validation/6100_object_properties/good/1000_string.input.json b/test/json/schema/validation/6100_object_properties/good/1000_string.input.json
deleted file mode 100644
index 633ebac6..00000000
--- a/test/json/schema/validation/6100_object_properties/good/1000_string.input.json
+++ /dev/null
@@ -1 +0,0 @@
-{ "string": "value" }
diff --git a/test/json/schema/validation/6100_object_properties/good/2000_number.input.json b/test/json/schema/validation/6100_object_properties/good/2000_number.input.json
deleted file mode 100644
index 6ba55e09..00000000
--- a/test/json/schema/validation/6100_object_properties/good/2000_number.input.json
+++ /dev/null
@@ -1 +0,0 @@
-{ "number": 42 }
diff --git a/test/json/schema/validation/6100_object_properties/good/3000_object.input.json b/test/json/schema/validation/6100_object_properties/good/3000_object.input.json
deleted file mode 100644
index 6e50545d..00000000
--- a/test/json/schema/validation/6100_object_properties/good/3000_object.input.json
+++ /dev/null
@@ -1 +0,0 @@
-{ "object": {} }
diff --git a/test/json/schema/validation/6100_object_properties/good/4000_array.input.json b/test/json/schema/validation/6100_object_properties/good/4000_array.input.json
deleted file mode 100644
index 367dc4a0..00000000
--- a/test/json/schema/validation/6100_object_properties/good/4000_array.input.json
+++ /dev/null
@@ -1 +0,0 @@
-{ "array": [] }
diff --git a/test/json/schema/validation/6100_object_properties/good/5000_false.input.json b/test/json/schema/validation/6100_object_properties/good/5000_false.input.json
deleted file mode 100644
index 9298f8fc..00000000
--- a/test/json/schema/validation/6100_object_properties/good/5000_false.input.json
+++ /dev/null
@@ -1 +0,0 @@
-{ "boolean": false }
diff --git a/test/json/schema/validation/6100_object_properties/good/5001_true.input.json b/test/json/schema/validation/6100_object_properties/good/5001_true.input.json
deleted file mode 100644
index 42406343..00000000
--- a/test/json/schema/validation/6100_object_properties/good/5001_true.input.json
+++ /dev/null
@@ -1 +0,0 @@
-{ "boolean": true }
diff --git a/test/json/schema/validation/6100_object_properties/good/6000_null.input.json b/test/json/schema/validation/6100_object_properties/good/6000_null.input.json
deleted file mode 100644
index d7a20efc..00000000
--- a/test/json/schema/validation/6100_object_properties/good/6000_null.input.json
+++ /dev/null
@@ -1 +0,0 @@
-{ "null": null }
diff --git a/test/json/schema/validation/6100_object_properties/schema.json b/test/json/schema/validation/6100_object_properties/schema.json
deleted file mode 100644
index 64e6f9a2..00000000
--- a/test/json/schema/validation/6100_object_properties/schema.json
+++ /dev/null
@@ -1,8 +0,0 @@
-{ "properties": {
-    "string": { "type": "string" },
-    "number": { "type": "number" },
-    "object": { "type": "object" },
-    "array": { "type": "array" },
-    "boolean": { "type": "boolean" },
-    "null": { "type": "null" }
-} }
diff --git a/test/json/schema/validation/6200_pattern_properties/bad/0000_string.json b/test/json/schema/validation/6200_pattern_properties/bad/0000_string.json
deleted file mode 100644
index 60aba440..00000000
--- a/test/json/schema/validation/6200_pattern_properties/bad/0000_string.json
+++ /dev/null
@@ -1 +0,0 @@
-{ "sinteger": 0 }
diff --git a/test/json/schema/validation/6200_pattern_properties/bad/1000_integer.json b/test/json/schema/validation/6200_pattern_properties/bad/1000_integer.json
deleted file mode 100644
index 226ec4de..00000000
--- a/test/json/schema/validation/6200_pattern_properties/bad/1000_integer.json
+++ /dev/null
@@ -1 +0,0 @@
-{ "istring": "value" }
diff --git a/test/json/schema/validation/6200_pattern_properties/bad/2000_foo.json b/test/json/schema/validation/6200_pattern_properties/bad/2000_foo.json
deleted file mode 100644
index 87b9e225..00000000
--- a/test/json/schema/validation/6200_pattern_properties/bad/2000_foo.json
+++ /dev/null
@@ -1 +0,0 @@
-{ "Foo": 1 }
diff --git a/test/json/schema/validation/6200_pattern_properties/bad/3000_foo_integer.json b/test/json/schema/validation/6200_pattern_properties/bad/3000_foo_integer.json
deleted file mode 100644
index 54bd9597..00000000
--- a/test/json/schema/validation/6200_pattern_properties/bad/3000_foo_integer.json
+++ /dev/null
@@ -1 +0,0 @@
-{ "iFoo": 0 }
diff --git a/test/json/schema/validation/6200_pattern_properties/bad/3000_foo_string.json b/test/json/schema/validation/6200_pattern_properties/bad/3000_foo_string.json
deleted file mode 100644
index 1078eeff..00000000
--- a/test/json/schema/validation/6200_pattern_properties/bad/3000_foo_string.json
+++ /dev/null
@@ -1 +0,0 @@
-{ "sFoo": "var" }
diff --git a/test/json/schema/validation/6200_pattern_properties/bad/3100_foo_enum.json b/test/json/schema/validation/6200_pattern_properties/bad/3100_foo_enum.json
deleted file mode 100644
index 9d968878..00000000
--- a/test/json/schema/validation/6200_pattern_properties/bad/3100_foo_enum.json
+++ /dev/null
@@ -1,3 +0,0 @@
-{
-    "sFoo": null
-}
diff --git a/test/json/schema/validation/6200_pattern_properties/good/0000_string.input.json b/test/json/schema/validation/6200_pattern_properties/good/0000_string.input.json
deleted file mode 100644
index 14a4c5aa..00000000
--- a/test/json/schema/validation/6200_pattern_properties/good/0000_string.input.json
+++ /dev/null
@@ -1 +0,0 @@
-{ "s": "value" }
diff --git a/test/json/schema/validation/6200_pattern_properties/good/0001_string.input.json b/test/json/schema/validation/6200_pattern_properties/good/0001_string.input.json
deleted file mode 100644
index a0c82020..00000000
--- a/test/json/schema/validation/6200_pattern_properties/good/0001_string.input.json
+++ /dev/null
@@ -1 +0,0 @@
-{ "skey": "value" }
diff --git a/test/json/schema/validation/6200_pattern_properties/good/1000_integer.input.json b/test/json/schema/validation/6200_pattern_properties/good/1000_integer.input.json
deleted file mode 100644
index c46c54e5..00000000
--- a/test/json/schema/validation/6200_pattern_properties/good/1000_integer.input.json
+++ /dev/null
@@ -1 +0,0 @@
-{ "i": 0 }
diff --git a/test/json/schema/validation/6200_pattern_properties/good/1001_integer.input.json b/test/json/schema/validation/6200_pattern_properties/good/1001_integer.input.json
deleted file mode 100644
index 91afca55..00000000
--- a/test/json/schema/validation/6200_pattern_properties/good/1001_integer.input.json
+++ /dev/null
@@ -1 +0,0 @@
-{ "ikey": 0 }
diff --git a/test/json/schema/validation/6200_pattern_properties/good/2000_foo_string.input.json b/test/json/schema/validation/6200_pattern_properties/good/2000_foo_string.input.json
deleted file mode 100644
index 3b9dc3ed..00000000
--- a/test/json/schema/validation/6200_pattern_properties/good/2000_foo_string.input.json
+++ /dev/null
@@ -1 +0,0 @@
-{ "thisEndsWithFoo": "foo" }
diff --git a/test/json/schema/validation/6200_pattern_properties/good/2001_foo_null.input.json b/test/json/schema/validation/6200_pattern_properties/good/2001_foo_null.input.json
deleted file mode 100644
index f776c674..00000000
--- a/test/json/schema/validation/6200_pattern_properties/good/2001_foo_null.input.json
+++ /dev/null
@@ -1 +0,0 @@
-{ "thisEndsWithFoo": null }
diff --git a/test/json/schema/validation/6200_pattern_properties/good/2100_foo_string.input.json b/test/json/schema/validation/6200_pattern_properties/good/2100_foo_string.input.json
deleted file mode 100644
index e7a8ed9c..00000000
--- a/test/json/schema/validation/6200_pattern_properties/good/2100_foo_string.input.json
+++ /dev/null
@@ -1 +0,0 @@
-{ "sFoo": "foo" }
diff --git a/test/json/schema/validation/6200_pattern_properties/schema.json b/test/json/schema/validation/6200_pattern_properties/schema.json
deleted file mode 100644
index 1cf59300..00000000
--- a/test/json/schema/validation/6200_pattern_properties/schema.json
+++ /dev/null
@@ -1,7 +0,0 @@
-{
-    "patternProperties": {
-        "^s": { "type": "string" },
-        "^i": { "type": "integer" },
-        "Foo$": { "enum": [ "foo", null ] }
-    }
-}
diff --git a/test/json/schema/validation/6300_additional_properties/bad/0000_null.json b/test/json/schema/validation/6300_additional_properties/bad/0000_null.json
deleted file mode 100644
index 19765bd5..00000000
--- a/test/json/schema/validation/6300_additional_properties/bad/0000_null.json
+++ /dev/null
@@ -1 +0,0 @@
-null
diff --git a/test/json/schema/validation/6300_additional_properties/bad/1000_object_null.json b/test/json/schema/validation/6300_additional_properties/bad/1000_object_null.json
deleted file mode 100644
index 95ced786..00000000
--- a/test/json/schema/validation/6300_additional_properties/bad/1000_object_null.json
+++ /dev/null
@@ -1 +0,0 @@
-{ "key": null }
diff --git a/test/json/schema/validation/6300_additional_properties/bad/2000_object_object.json b/test/json/schema/validation/6300_additional_properties/bad/2000_object_object.json
deleted file mode 100644
index 2818351c..00000000
--- a/test/json/schema/validation/6300_additional_properties/bad/2000_object_object.json
+++ /dev/null
@@ -1,3 +0,0 @@
-{
-    "key": {}
-}
diff --git a/test/json/schema/validation/6300_additional_properties/good/0000_empty.input.json b/test/json/schema/validation/6300_additional_properties/good/0000_empty.input.json
deleted file mode 100644
index 0967ef42..00000000
--- a/test/json/schema/validation/6300_additional_properties/good/0000_empty.input.json
+++ /dev/null
@@ -1 +0,0 @@
-{}
diff --git a/test/json/schema/validation/6300_additional_properties/good/1000_object_value.input.json b/test/json/schema/validation/6300_additional_properties/good/1000_object_value.input.json
deleted file mode 100644
index 7ba1b793..00000000
--- a/test/json/schema/validation/6300_additional_properties/good/1000_object_value.input.json
+++ /dev/null
@@ -1 +0,0 @@
-{ "key": "value" }
diff --git a/test/json/schema/validation/6300_additional_properties/schema.json b/test/json/schema/validation/6300_additional_properties/schema.json
deleted file mode 100644
index cf614d0e..00000000
--- a/test/json/schema/validation/6300_additional_properties/schema.json
+++ /dev/null
@@ -1,3 +0,0 @@
-{
-    "additionalProperties": { "type": "string" }
-}
diff --git a/test/json/schema/validation/6301_additional_properties/bad/0000_int.json b/test/json/schema/validation/6301_additional_properties/bad/0000_int.json
deleted file mode 100644
index 419d2081..00000000
--- a/test/json/schema/validation/6301_additional_properties/bad/0000_int.json
+++ /dev/null
@@ -1 +0,0 @@
-{ "int": "string" }
diff --git a/test/json/schema/validation/6301_additional_properties/bad/1000_bool.json b/test/json/schema/validation/6301_additional_properties/bad/1000_bool.json
deleted file mode 100644
index e248c7fe..00000000
--- a/test/json/schema/validation/6301_additional_properties/bad/1000_bool.json
+++ /dev/null
@@ -1 +0,0 @@
-{ "bool": "string" }
diff --git a/test/json/schema/validation/6301_additional_properties/good/0000_int.input.json b/test/json/schema/validation/6301_additional_properties/good/0000_int.input.json
deleted file mode 100644
index 54a34add..00000000
--- a/test/json/schema/validation/6301_additional_properties/good/0000_int.input.json
+++ /dev/null
@@ -1 +0,0 @@
-{ "int": 0 }
diff --git a/test/json/schema/validation/6301_additional_properties/good/1000_bool.input.json b/test/json/schema/validation/6301_additional_properties/good/1000_bool.input.json
deleted file mode 100644
index d32dc830..00000000
--- a/test/json/schema/validation/6301_additional_properties/good/1000_bool.input.json
+++ /dev/null
@@ -1 +0,0 @@
-{ "bool": true }
diff --git a/test/json/schema/validation/6301_additional_properties/good/2000_string.input.json b/test/json/schema/validation/6301_additional_properties/good/2000_string.input.json
deleted file mode 100644
index 6710bddc..00000000
--- a/test/json/schema/validation/6301_additional_properties/good/2000_string.input.json
+++ /dev/null
@@ -1 +0,0 @@
-{ "key": "string" }
diff --git a/test/json/schema/validation/6301_additional_properties/good/3000_all.input.json b/test/json/schema/validation/6301_additional_properties/good/3000_all.input.json
deleted file mode 100644
index a59ae248..00000000
--- a/test/json/schema/validation/6301_additional_properties/good/3000_all.input.json
+++ /dev/null
@@ -1,5 +0,0 @@
-{
-    "int": 0,
-    "bool": true,
-    "key": "string"
-}
diff --git a/test/json/schema/validation/6301_additional_properties/schema.json b/test/json/schema/validation/6301_additional_properties/schema.json
deleted file mode 100644
index 6562c6fa..00000000
--- a/test/json/schema/validation/6301_additional_properties/schema.json
+++ /dev/null
@@ -1,9 +0,0 @@
-{
-    "properties": {
-        "int": { "type": "integer" }
-    },
-    "patternProperties": {
-        "^bool": { "type": "boolean" }
-    },
-    "additionalProperties": { "type": "string" }
-}
diff --git a/test/json/schema/validation/6400_object_default/good/0000_complete.input.json b/test/json/schema/validation/6400_object_default/good/0000_complete.input.json
deleted file mode 100644
index a5482800..00000000
--- a/test/json/schema/validation/6400_object_default/good/0000_complete.input.json
+++ /dev/null
@@ -1 +0,0 @@
-{ "string": "foo" }
diff --git a/test/json/schema/validation/6400_object_default/good/1000_defaulted.input.json b/test/json/schema/validation/6400_object_default/good/1000_defaulted.input.json
deleted file mode 100644
index ffcd4415..00000000
--- a/test/json/schema/validation/6400_object_default/good/1000_defaulted.input.json
+++ /dev/null
@@ -1 +0,0 @@
-{ }
diff --git a/test/json/schema/validation/6400_object_default/good/1000_defaulted.result.json b/test/json/schema/validation/6400_object_default/good/1000_defaulted.result.json
deleted file mode 100644
index 633ebac6..00000000
--- a/test/json/schema/validation/6400_object_default/good/1000_defaulted.result.json
+++ /dev/null
@@ -1 +0,0 @@
-{ "string": "value" }
diff --git a/test/json/schema/validation/6400_object_default/schema.json b/test/json/schema/validation/6400_object_default/schema.json
deleted file mode 100644
index 55783478..00000000
--- a/test/json/schema/validation/6400_object_default/schema.json
+++ /dev/null
@@ -1,9 +0,0 @@
-{
-    "type": "object",
-    "properties": {
-        "string": {
-            "type": "string",
-            "default": "value"
-        }
-    }
-}
diff --git a/test/json/schema/validation/7000_enum/bad/0000_integer.json b/test/json/schema/validation/7000_enum/bad/0000_integer.json
deleted file mode 100644
index d00491fd..00000000
--- a/test/json/schema/validation/7000_enum/bad/0000_integer.json
+++ /dev/null
@@ -1 +0,0 @@
-1
diff --git a/test/json/schema/validation/7000_enum/bad/1000_true.json b/test/json/schema/validation/7000_enum/bad/1000_true.json
deleted file mode 100644
index 27ba77dd..00000000
--- a/test/json/schema/validation/7000_enum/bad/1000_true.json
+++ /dev/null
@@ -1 +0,0 @@
-true
diff --git a/test/json/schema/validation/7000_enum/bad/2000_string.json b/test/json/schema/validation/7000_enum/bad/2000_string.json
deleted file mode 100644
index 196e5879..00000000
--- a/test/json/schema/validation/7000_enum/bad/2000_string.json
+++ /dev/null
@@ -1 +0,0 @@
-"bar"
diff --git a/test/json/schema/validation/7000_enum/bad/3000_empty_object.json b/test/json/schema/validation/7000_enum/bad/3000_empty_object.json
deleted file mode 100644
index ffcd4415..00000000
--- a/test/json/schema/validation/7000_enum/bad/3000_empty_object.json
+++ /dev/null
@@ -1 +0,0 @@
-{ }
diff --git a/test/json/schema/validation/7000_enum/bad/3100_single_entry_object.json b/test/json/schema/validation/7000_enum/bad/3100_single_entry_object.json
deleted file mode 100644
index 810c6f71..00000000
--- a/test/json/schema/validation/7000_enum/bad/3100_single_entry_object.json
+++ /dev/null
@@ -1 +0,0 @@
-{ "val": "key" }
diff --git a/test/json/schema/validation/7000_enum/bad/3101_multi_entry_object.json b/test/json/schema/validation/7000_enum/bad/3101_multi_entry_object.json
deleted file mode 100644
index 71e61e3e..00000000
--- a/test/json/schema/validation/7000_enum/bad/3101_multi_entry_object.json
+++ /dev/null
@@ -1 +0,0 @@
-{ "key": "val", "additional": "error" }
diff --git a/test/json/schema/validation/7000_enum/bad/4000_array.json b/test/json/schema/validation/7000_enum/bad/4000_array.json
deleted file mode 100644
index 58c70395..00000000
--- a/test/json/schema/validation/7000_enum/bad/4000_array.json
+++ /dev/null
@@ -1 +0,0 @@
-[ 1.1 ]
diff --git a/test/json/schema/validation/7000_enum/bad/5000_none.json b/test/json/schema/validation/7000_enum/bad/5000_none.json
deleted file mode 100644
index 68787000..00000000
--- a/test/json/schema/validation/7000_enum/bad/5000_none.json
+++ /dev/null
@@ -1 +0,0 @@
-null 
diff --git a/test/json/schema/validation/7000_enum/good/0000_number.input.json b/test/json/schema/validation/7000_enum/good/0000_number.input.json
deleted file mode 100644
index 9459d4ba..00000000
--- a/test/json/schema/validation/7000_enum/good/0000_number.input.json
+++ /dev/null
@@ -1 +0,0 @@
-1.1
diff --git a/test/json/schema/validation/7000_enum/good/1000_boolean.input.json b/test/json/schema/validation/7000_enum/good/1000_boolean.input.json
deleted file mode 100644
index c508d536..00000000
--- a/test/json/schema/validation/7000_enum/good/1000_boolean.input.json
+++ /dev/null
@@ -1 +0,0 @@
-false
diff --git a/test/json/schema/validation/7000_enum/good/2000_string.input.json b/test/json/schema/validation/7000_enum/good/2000_string.input.json
deleted file mode 100644
index 810c96ee..00000000
--- a/test/json/schema/validation/7000_enum/good/2000_string.input.json
+++ /dev/null
@@ -1 +0,0 @@
-"foo"
diff --git a/test/json/schema/validation/7000_enum/good/3000_object.input.json b/test/json/schema/validation/7000_enum/good/3000_object.input.json
deleted file mode 100644
index d3a16359..00000000
--- a/test/json/schema/validation/7000_enum/good/3000_object.input.json
+++ /dev/null
@@ -1 +0,0 @@
-{ "key": "val" }
diff --git a/test/json/schema/validation/7000_enum/good/4000_array.input.json b/test/json/schema/validation/7000_enum/good/4000_array.input.json
deleted file mode 100644
index fe51488c..00000000
--- a/test/json/schema/validation/7000_enum/good/4000_array.input.json
+++ /dev/null
@@ -1 +0,0 @@
-[]
diff --git a/test/json/schema/validation/7000_enum/schema.json b/test/json/schema/validation/7000_enum/schema.json
deleted file mode 100644
index 8b06c85d..00000000
--- a/test/json/schema/validation/7000_enum/schema.json
+++ /dev/null
@@ -1 +0,0 @@
-{ "enum": [ 1.1, false, "foo", { "key": "val" }, [] ] }
diff --git a/test/json/validate/bad/0000_empty.json b/test/json/validate/bad/0000_empty.json
deleted file mode 100644
index e69de29b..00000000
diff --git a/test/json/validate/bad/1000_capital_false.json b/test/json/validate/bad/1000_capital_false.json
deleted file mode 100644
index 671c0a97..00000000
--- a/test/json/validate/bad/1000_capital_false.json
+++ /dev/null
@@ -1 +0,0 @@
-[False]
diff --git a/test/json/validate/bad/1000_capital_null.json b/test/json/validate/bad/1000_capital_null.json
deleted file mode 100644
index eeaf3182..00000000
--- a/test/json/validate/bad/1000_capital_null.json
+++ /dev/null
@@ -1 +0,0 @@
-[Null]
diff --git a/test/json/validate/bad/1000_capital_true.json b/test/json/validate/bad/1000_capital_true.json
deleted file mode 100644
index 22d4980c..00000000
--- a/test/json/validate/bad/1000_capital_true.json
+++ /dev/null
@@ -1 +0,0 @@
-[True]
diff --git a/test/json/validate/bad/1000_leading_zero.json b/test/json/validate/bad/1000_leading_zero.json
deleted file mode 100644
index 8d13d4c8..00000000
--- a/test/json/validate/bad/1000_leading_zero.json
+++ /dev/null
@@ -1 +0,0 @@
-[ 00 ]
diff --git a/test/json/validate/bad/2000_trailing_comma.json b/test/json/validate/bad/2000_trailing_comma.json
deleted file mode 100644
index e8b1a170..00000000
--- a/test/json/validate/bad/2000_trailing_comma.json
+++ /dev/null
@@ -1 +0,0 @@
-[1,]
diff --git a/test/json/validate/bad/2000_unfinished_array.json b/test/json/validate/bad/2000_unfinished_array.json
deleted file mode 100644
index 558ed37d..00000000
--- a/test/json/validate/bad/2000_unfinished_array.json
+++ /dev/null
@@ -1 +0,0 @@
-[
diff --git a/test/json/validate/bad/2000_unfinished_object.json b/test/json/validate/bad/2000_unfinished_object.json
deleted file mode 100644
index 98232c64..00000000
--- a/test/json/validate/bad/2000_unfinished_object.json
+++ /dev/null
@@ -1 +0,0 @@
-{
diff --git a/test/json/validate/bad/2001_unfinished_array.json b/test/json/validate/bad/2001_unfinished_array.json
deleted file mode 100644
index 079b5796..00000000
--- a/test/json/validate/bad/2001_unfinished_array.json
+++ /dev/null
@@ -1 +0,0 @@
-]
diff --git a/test/json/validate/bad/2001_unfinished_object.json b/test/json/validate/bad/2001_unfinished_object.json
deleted file mode 100644
index 5c34318c..00000000
--- a/test/json/validate/bad/2001_unfinished_object.json
+++ /dev/null
@@ -1 +0,0 @@
-}
diff --git a/test/json/validate/bad/3000_missing_array_seperator.json b/test/json/validate/bad/3000_missing_array_seperator.json
deleted file mode 100644
index 5a3f03a1..00000000
--- a/test/json/validate/bad/3000_missing_array_seperator.json
+++ /dev/null
@@ -1 +0,0 @@
-[1 2]
diff --git a/test/json/validate/bad/3000_missing_object_key.json b/test/json/validate/bad/3000_missing_object_key.json
deleted file mode 100644
index 992f0c28..00000000
--- a/test/json/validate/bad/3000_missing_object_key.json
+++ /dev/null
@@ -1 +0,0 @@
-{:"bar"}
diff --git a/test/json/validate/bad/3000_missing_object_seperator.json b/test/json/validate/bad/3000_missing_object_seperator.json
deleted file mode 100644
index 2ab1ca5d..00000000
--- a/test/json/validate/bad/3000_missing_object_seperator.json
+++ /dev/null
@@ -1 +0,0 @@
-{"foo"}
diff --git a/test/json/validate/bad/3000_missing_object_value.json b/test/json/validate/bad/3000_missing_object_value.json
deleted file mode 100644
index 7d6e2426..00000000
--- a/test/json/validate/bad/3000_missing_object_value.json
+++ /dev/null
@@ -1 +0,0 @@
-{"foo":}
diff --git a/test/json/validate/good/0000_false.json b/test/json/validate/good/0000_false.json
deleted file mode 100644
index c508d536..00000000
--- a/test/json/validate/good/0000_false.json
+++ /dev/null
@@ -1 +0,0 @@
-false
diff --git a/test/json/validate/good/0000_integer.json b/test/json/validate/good/0000_integer.json
deleted file mode 100644
index ca856b12..00000000
--- a/test/json/validate/good/0000_integer.json
+++ /dev/null
@@ -1 +0,0 @@
-[0,1,-1,98465]
diff --git a/test/json/validate/good/0000_null.json b/test/json/validate/good/0000_null.json
deleted file mode 100644
index 19765bd5..00000000
--- a/test/json/validate/good/0000_null.json
+++ /dev/null
@@ -1 +0,0 @@
-null
diff --git a/test/json/validate/good/0000_pair_str.json b/test/json/validate/good/0000_pair_str.json
deleted file mode 100644
index 10583251..00000000
--- a/test/json/validate/good/0000_pair_str.json
+++ /dev/null
@@ -1,3 +0,0 @@
-{
-	"foo" : "bar"
-}
diff --git a/test/json/validate/good/0000_real.json b/test/json/validate/good/0000_real.json
deleted file mode 100644
index 382b490c..00000000
--- a/test/json/validate/good/0000_real.json
+++ /dev/null
@@ -1,8 +0,0 @@
-[
-1.0e5,
-1.0E5,
--1.0e5,
--1.0e-5,
-9.123e2,
-15.0e5
-]
diff --git a/test/json/validate/good/0000_true.json b/test/json/validate/good/0000_true.json
deleted file mode 100644
index 27ba77dd..00000000
--- a/test/json/validate/good/0000_true.json
+++ /dev/null
@@ -1 +0,0 @@
-true
diff --git a/test/json/validate/good/1000_empty_array.json b/test/json/validate/good/1000_empty_array.json
deleted file mode 100644
index 0d4f101c..00000000
--- a/test/json/validate/good/1000_empty_array.json
+++ /dev/null
@@ -1,2 +0,0 @@
-[
-]
diff --git a/test/json/validate/good/1000_empty_object.json b/test/json/validate/good/1000_empty_object.json
deleted file mode 100644
index 2c63c085..00000000
--- a/test/json/validate/good/1000_empty_object.json
+++ /dev/null
@@ -1,2 +0,0 @@
-{
-}
diff --git a/test/json/validate/good/2000_recursive_array.json b/test/json/validate/good/2000_recursive_array.json
deleted file mode 100644
index 4460d1b1..00000000
--- a/test/json/validate/good/2000_recursive_array.json
+++ /dev/null
@@ -1 +0,0 @@
-[[null]]
diff --git a/test/json/validate/good/2000_recursive_object.json b/test/json/validate/good/2000_recursive_object.json
deleted file mode 100644
index ee5089ce..00000000
--- a/test/json/validate/good/2000_recursive_object.json
+++ /dev/null
@@ -1 +0,0 @@
-{"foo":{}}
diff --git a/test/json/validate/good/2001_recursive_array.json b/test/json/validate/good/2001_recursive_array.json
deleted file mode 100644
index 93d51406..00000000
--- a/test/json/validate/good/2001_recursive_array.json
+++ /dev/null
@@ -1 +0,0 @@
-[{}]
diff --git a/test/json/validate/good/2001_recursive_object.json b/test/json/validate/good/2001_recursive_object.json
deleted file mode 100644
index 6dab5c82..00000000
--- a/test/json/validate/good/2001_recursive_object.json
+++ /dev/null
@@ -1 +0,0 @@
-{"foo":[]}
diff --git a/test/json/validate/good/3000_string_escape.json b/test/json/validate/good/3000_string_escape.json
deleted file mode 100644
index d864ebfc..00000000
--- a/test/json/validate/good/3000_string_escape.json
+++ /dev/null
@@ -1,12 +0,0 @@
-[
-"foo\tbar",
-"\"",
-"\\",
-"\/",
-"\b",
-"\f",
-"\n",
-"\r",
-"\t",
-"\u0062"
-]
diff --git a/test/json2/event.cpp b/test/json2/event.cpp
deleted file mode 100644
index f0159519..00000000
--- a/test/json2/event.cpp
+++ /dev/null
@@ -1,463 +0,0 @@
-#include "json2/event.hpp"
-#include "json2/except.hpp"
-#include "tap.hpp"
-
-#include <vector>
-#include <cstring>
-#include <functional>
-
-
-///////////////////////////////////////////////////////////////////////////////
-void
-test_numbers (util::TAP::logger &tap)
-{
-    static const struct {
-        const char *data;
-        bool good;
-        const char *message;
-    } TESTS[] = {
-        { "1", true, "single digit" },
-        { "01", false, "leading zero" },
-        { "-1", true, "leading minus" },
-        { "+1", false, "leading plus" },
-        { "1.", false, "truncated fraction" },
-        { "1.0", true, "fraction" },
-        { "1.0e", false, "truncated exponential" },
-        { "1.0e1", true, "lower exponential" },
-        { "1.0E1", true, "upper exponential" },
-        { "1.0e+1", true, "positive exponential" },
-        { "1.0e+", false, "truncated positive exponential" },
-        { "1.0e-1", true, "negative exponential" },
-        { "1.0e-", false, "truncated negative exponential" },
-    };
-
-    for (const auto &t: TESTS) {
-        auto first = t.data;
-        auto last  = first + strlen (first);
-
-        if (!t.good) {
-            tap.expect_throw<util::json2::error> (
-                [&] () {
-                    util::json2::event::parse ([] (auto) {}, first, last);
-                },
-                "number, %s",
-                t.message
-            );
-        } else {
-            util::json2::event::type_t type;
-            auto end = util::json2::event::parse (
-                [&type] (auto p) { type = p.type (); }, first, last
-            );
-
-            tap.expect (
-                last == end && type == util::json2::event::type_t::NUMBER,
-                "number, %s",
-                t.message
-            );
-        }
-    }
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-void
-test_literals (util::TAP::logger &tap)
-{
-    static const struct {
-        const char *data;
-        bool good;
-        util::json2::event::type_t type;
-        const char *message;
-    } TESTS[] = {
-        { "true", true,  util::json2::event::type_t::BOOLEAN, "lower true" },
-        { "TRUE", false, util::json2::event::type_t::BOOLEAN, "upper true" },
-        { "truE", false, util::json2::event::type_t::BOOLEAN, "mixed true" },
-        { "tru",  false, util::json2::event::type_t::BOOLEAN, "truncated true" },
-
-        { "false", true, util::json2::event::type_t::BOOLEAN, "lower false" },
-        { "FALSE", false, util::json2::event::type_t::BOOLEAN, "upper false" },
-        { "falSe", false, util::json2::event::type_t::BOOLEAN, "mixed false" },
-        { "fals",  false, util::json2::event::type_t::BOOLEAN, "truncated false" },
-
-        { "null", true, util::json2::event::type_t::NONE, "lower null" },
-        { "NULL", false, util::json2::event::type_t::NONE, "upper null" },
-        { "nUll", false, util::json2::event::type_t::NONE, "mixed null" },
-        { "nul",  false, util::json2::event::type_t::NONE, "truncated null" },
-    };
-
-    for (const auto &t: TESTS) {
-        auto first = t.data;
-        auto last  = first + strlen (first);
-
-        if (t.good) {
-            util::json2::event::type_t type;
-            util::json2::event::parse ([&type] (auto p) { type = p.type (); }, first, last);
-            tap.expect_eq (type, t.type, "literal, %s", t.message);
-        } else {
-            tap.expect_throw<util::json2::parse_error> (
-                [first,last] () {
-                    util::json2::event::parse ([] (auto) {}, first, last);
-                },
-                "literal, %s",
-                t.message
-            );
-        }
-    }
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-void
-test_strings (util::TAP::logger &tap)
-{
-    static const struct {
-        const char *data;
-        bool good;
-        const char *message;
-    } TESTS[] = {
-        { "\"abc\"", true, "abc" },
-        { "\"\"", true, "empty" },
-        { "\"", false, "unbalanced quote" },
-        { "\"\\n\"", true, "newline escape" },
-        { "\"\\a\"", true, "valid unnecessary escape" },
-        { "\"\\uABCD\"", true, "upper unicode hex escape" },
-        { "\"\\uabcd\"", true, "lower unicode hex escape" },
-        { "\"\\uab\"", false, "truncated unicode hex escape" },
-        { "\"\\uabxy\"", false, "invalid unicode hex escape" },
-    };
-
-    for (const auto &t: TESTS) {
-        auto first = t.data;
-        auto last  = first + strlen (first);
-
-        if (t.good) {
-            util::json2::event::type_t type;
-            util::json2::event::parse ([&type] (auto p) { type = p.type (); }, first, last);
-            tap.expect_eq (type, util::json2::event::type_t::STRING, "string, %s", t.message);
-        } else {
-            tap.expect_throw<util::json2::parse_error> (
-                [first,last] () {
-                    util::json2::event::parse ([] (auto) {}, first, last);
-                },
-                "string, %s",
-                t.message
-            );
-        }
-    }
-};
-
-
-///////////////////////////////////////////////////////////////////////////////
-void
-test_arrays (util::TAP::logger &tap)
-{
-    using util::json2::event::type_t;
-
-    static const struct {
-        const char *data;
-        bool good;
-        std::vector<util::json2::event::type_t> types;
-        const char *message;
-    } TESTS[] = {
-        {
-            "[]",
-            true,
-            {
-                type_t::ARRAY_BEGIN,
-                type_t::ARRAY_END
-            },
-            "empty"
-        },
-        {
-            "[1]",
-            true,
-            {
-                type_t::ARRAY_BEGIN,
-                type_t::NUMBER,
-                type_t::ARRAY_END
-            },
-            "single number"
-        },
-        {
-            "[1true]",
-            false,
-            {
-                type_t::ARRAY_BEGIN,
-                type_t::NUMBER
-            },
-            "contatenated number/bool"
-        },
-        {
-            "[1,2]",
-            true,
-            {
-                type_t::ARRAY_BEGIN,
-                type_t::NUMBER,
-                type_t::NUMBER,
-                type_t::ARRAY_END
-            },
-            "two numbers"
-        },
-        {
-            "[1,]",
-            false,
-            {
-                type_t::ARRAY_BEGIN,
-                type_t::NUMBER
-            },
-            "single trailing comma"
-        },
-        {
-            "[1,2,]",
-            false,
-            {
-                type_t::ARRAY_BEGIN,
-                type_t::NUMBER,
-                type_t::NUMBER
-            },
-            "double trailing comma"
-        },
-        {
-            "[,]",
-            false,
-            {
-                type_t::ARRAY_BEGIN
-            },
-            "only comma"
-        },
-        {
-            "[",
-            false,
-            {
-                type_t::ARRAY_BEGIN
-            },
-            "missing terminator"
-        },
-        {
-            "[[]]",
-            true,
-            {
-                type_t::ARRAY_BEGIN,
-                type_t::ARRAY_BEGIN,
-                type_t::ARRAY_END,
-                type_t::ARRAY_END
-            },
-            "nested array"
-        },
-        {
-            "[[]",
-            false,
-            {
-                type_t::ARRAY_BEGIN,
-                type_t::ARRAY_END
-            },
-            "unbalanced nested array"
-        },
-    };
-
-    for (const auto &t: TESTS) {
-        auto first = t.data;
-        auto last  = first + strlen (first);
-
-        if (t.good) {
-            std::vector<type_t> types;
-            util::json2::event::parse ([&types] (auto p) { types.push_back (p.type ()); }, first, last);
-            tap.expect_eq (types, t.types, "array, %s", t.message);
-        } else {
-            tap.expect_throw<util::json2::parse_error> (
-                [&] () {
-                    util::json2::event::parse ([] (auto) { }, first, last);
-                }, "array, %s", t.message
-            );
-        }
-    }
-};
-
-
-///////////////////////////////////////////////////////////////////////////////
-void
-test_objects (util::TAP::logger &tap)
-{
-    using util::json2::event::type_t;
-
-    static const struct {
-        const char *data;
-        bool good;
-        std::vector<type_t> types;
-        std::vector<std::string> strings;
-        const char *message;
-    } TESTS[] = {
-        {
-            "{}",
-            true,
-            {
-                type_t::OBJECT_BEGIN,
-                type_t::OBJECT_END
-            },
-            {},
-            "empty"
-        },
-        {
-            "{",
-            false,
-            { type_t::OBJECT_BEGIN },
-            {},
-            "missing terminator"
-        },
-        {
-            R"json({"a":1})json",
-            true,
-            {
-                type_t::OBJECT_BEGIN,
-                type_t::STRING,
-                type_t::NUMBER,
-                type_t::OBJECT_END
-            },
-            {
-                "\"a\""
-            },
-            "empty"
-        },
-        {
-            "{1:1}",
-            false,
-            {
-                type_t::OBJECT_BEGIN
-            },
-            {},
-            "integer key"
-        },
-        {
-            "{:1}",
-            false,
-            {
-                type_t::OBJECT_BEGIN
-            },
-            {},
-            "no key"
-        },
-        {
-            R"json({"a":})json",
-            false,
-            {
-                type_t::OBJECT_BEGIN,
-                type_t::STRING
-            },
-            {},
-            "no value"
-        },
-        {
-            R"json({"a":[]})json",
-            true,
-            {
-                type_t::OBJECT_BEGIN,
-                type_t::STRING,
-                type_t::ARRAY_BEGIN,
-                type_t::ARRAY_END,
-                type_t::OBJECT_END
-            },
-            { "\"a\"" },
-            "array value" },
-        {
-            R"json({ "a": { "b": null } })json",
-            true,
-            {
-                type_t::OBJECT_BEGIN,
-                type_t::STRING,
-                type_t::OBJECT_BEGIN,
-                type_t::STRING,
-                type_t::NONE,
-                type_t::OBJECT_END,
-                type_t::OBJECT_END
-            },
-            {
-                "\"a\"",
-                "\"b\""
-            },
-            "recursive object"
-        }
-    };
-
-    for (const auto &t: TESTS) {
-        auto first = t.data;
-        auto last  = first + strlen (first);
-
-        if (t.good) {
-            std::vector<type_t> types;
-            std::vector<std::string> strings;
-
-            util::json2::event::parse ([&] (auto p) {
-                types.push_back (p.type ());
-                if (p.type () == type_t::STRING)
-                    strings.push_back (std::string {p.first, p.last});
-            }, first, last);
-
-            tap.expect (types == t.types && strings == t.strings, "object, %s", t.message);
-        } else {
-            tap.expect_throw<util::json2::parse_error> (
-                [&] () {
-                    util::json2::event::parse ([] (auto) {}, first, last);
-                }, "object, %s", t.message
-            );
-        }
-    }
-};
-
-
-///////////////////////////////////////////////////////////////////////////////
-void
-test_jsonish (util::TAP::logger &tap)
-{
-    static const struct {
-        const char *data;
-        const char *message;
-    } TESTS[] = {
-        //{ "{}", "empty object" },
-        //{ "0xdeadbeef", "hex literal" },
-        //{ "0b11011100", "binary literal" },
-        //{ "0666", "octal literal" },
-        //{ "0.", "float without frac" },
-        //{ "+0.", "float with leading +" },
-        //{ "-0.", "float with leading -" },
-        //{ "string", "bare literal string" },
-        //{ "{foo: 1}", "bare string key" },
-        //{ "{foo: bar}", "bare string key and value" },
-        //{ "{foo: bar,}", "trailing object comma" },
-        //{ "[1,]", "trailing array comma" },
-        //{ "1 #comment", "trailing comment" },
-        { "#comment\n1", "leading comment" },
-    };
-
-    for (const auto &t: TESTS) {
-        bool success = true;
-        try {
-            util::json2::event::parse<util::json2::personality::jsonish> (
-                [] (auto) {},
-                t.data,
-                t.data + strlen (t.data)
-            );
-        } catch (const util::json2::error&) {
-            success = false;
-        }
-
-        tap.expect (success, "jsonish, %s", t.message);
-    }
-};
-
-
-///////////////////////////////////////////////////////////////////////////////
-int
-main (void)
-{
-    util::TAP::logger tap;
-
-    test_numbers (tap);
-    test_literals (tap);
-    test_strings (tap);
-    test_arrays (tap);
-    test_objects (tap);
-
-    test_jsonish (tap);
-
-    return tap.status ();
-}
\ No newline at end of file
diff --git a/test/json_types.cpp b/test/json_types.cpp
deleted file mode 100644
index 2edeeea5..00000000
--- a/test/json_types.cpp
+++ /dev/null
@@ -1,131 +0,0 @@
-#include "json/tree.hpp"
-
-#include "debug.hpp"
-#include "maths.hpp"
-#include "tap.hpp"
-
-#include <memory>
-#include <cstdlib>
-
-int
-main (void)
-{
-    util::TAP::logger tap;
-
-    static const std::string TEST_STRING = R"_(
-        {
-           "string":"brad",
-           "integer":1,
-           "null":null,
-           "false":false,
-           "true":true,
-           "double":3.14,
-           "object":{
-               "test": "test"
-           },
-           "array":[
-               1, 2, 3, 4
-           ]
-        })_";
-
-    std::unique_ptr<json::tree::node> ptr = json::tree::parse (util::make_view (TEST_STRING));
-    tap.expect (ptr->is_object (), "is_object");
-    CHECK (ptr->is_object ());
-
-    const json::tree::node &ref = *ptr;
-
-    {
-        tap.expect ( ref["string"].is_string (),    "string is_string");
-        tap.expect (!ref["string"].is_array (),     "string not is_array");
-        tap.expect (!ref["string"].is_boolean (),   "string not is_boolean");
-        tap.expect (!ref["string"].is_null (),      "string not is_null");
-        tap.expect (!ref["string"].is_number (),    "string not is_number");
-        tap.expect (!ref["string"].is_object (),    "string not is_object");
-
-        tap.expect_eq (ref["string"].as_string (), "brad", "string value equality");
-    }
-
-    {
-        tap.expect ( ref["integer"].is_number (),   "integer is_number");
-        tap.expect (!ref["integer"].is_array (),    "integer not is_array");
-        tap.expect (!ref["integer"].is_boolean (),  "integer not is_boolean");
-        tap.expect (!ref["integer"].is_null (),     "integer not is_null");
-        tap.expect (!ref["integer"].is_object (),   "integer not is_object");
-        tap.expect (!ref["integer"].is_string (),   "integer not is_string");
-        tap.expect (
-            util::equal (
-                ref["integer"].as_number ().as_uint (),
-                1u
-            ),
-            "integer value equality"
-        );
-    }
-
-    {
-        tap.expect ( ref["null"].is_null (),    "null is_null");
-        tap.expect (!ref["null"].is_array (),   "null not is_array");
-        tap.expect (!ref["null"].is_boolean (), "null not is_boolean");
-        tap.expect (!ref["null"].is_number (),  "null not is_number");
-        tap.expect (!ref["null"].is_object (),  "null not is_object");
-        tap.expect (!ref["null"].is_string (),  "null not is_string");
-    }
-
-    {
-        tap.expect ( ref["false"].is_boolean (),    "false is_boolean");
-        tap.expect (!ref["false"].is_array (),      "false not is_array");
-        tap.expect (!ref["false"].is_null (),       "false not is_null");
-        tap.expect (!ref["false"].is_number (),     "false not is_number");
-        tap.expect (!ref["false"].is_object (),     "false not is_object");
-        tap.expect (!ref["false"].is_string (),     "false not is_string");
-
-        tap.expect_eq (ref["false"].as_boolean (), false, "false value equality");
-    }
-
-    {
-        tap.expect ( ref["true"].is_boolean (), "true, is_boolean");
-        tap.expect (!ref["true"].is_array (),   "true not is_array");
-        tap.expect (!ref["true"].is_null (),    "true not is_null");
-        tap.expect (!ref["true"].is_number (),  "true not is_number");
-        tap.expect (!ref["true"].is_object (),  "true not is_object");
-        tap.expect (!ref["true"].is_string (),  "true not is_string");
-
-        tap.expect_eq ( ref["true"].as_boolean (), true, "true value equality");
-    }
-
-    {
-        tap.expect ( ref["double"].is_number (), "double is_number");
-
-        tap.expect (!ref["double"].is_array (),   "double not is_array");
-        tap.expect (!ref["double"].is_boolean (), "double not is_boolean");
-        tap.expect (!ref["double"].is_null (),    "double not is_null");
-        tap.expect (!ref["double"].is_object (),  "double not is_object");
-        tap.expect (!ref["double"].is_string (),  "double not is_string");
-        tap.expect (
-            util::equal (
-                ref["double"].as_number ().as<double> (),
-                3.14
-            ),
-            "double value equality"
-        );
-    }
-
-    {
-        tap.expect ( ref["object"].is_object (),    "object is_object");
-        tap.expect (!ref["object"].is_array (),     "object not is_array");
-        tap.expect (!ref["object"].is_boolean (),   "object not is_boolean");
-        tap.expect (!ref["object"].is_null (),      "object not is_null");
-        tap.expect (!ref["object"].is_number (),    "object not is_number");
-        tap.expect (!ref["object"].is_string (),    "object not is_string");
-    }
-
-    {
-        tap.expect ( ref["array"].is_array (),      "array is_array");
-        tap.expect (!ref["array"].is_boolean (),    "array not is_boolean");
-        tap.expect (!ref["array"].is_null (),       "array not is_null");
-        tap.expect (!ref["array"].is_number (),     "array not is_number");
-        tap.expect (!ref["array"].is_object (),     "array not is_object");
-        tap.expect (!ref["array"].is_string (),     "array not is_string");
-    }
-
-    return tap.status ();
-}
diff --git a/vector.cpp b/vector.cpp
index 21d0f326..a37c7e8e 100644
--- a/vector.cpp
+++ b/vector.cpp
@@ -18,8 +18,6 @@
 
 #include "debug.hpp"
 
-#include "json/tree.hpp"
-
 #include <cmath>
 
 using util::vector;
@@ -100,29 +98,9 @@ struct util::debug::validator<vector<S,T>> {
 
 
 ///////////////////////////////////////////////////////////////////////////////
-template <size_t S, typename T>
-const json::tree::node&
-util::operator>> (const json::tree::node &node, util::vector<S,T> &v)
-{
-    const json::tree::array &array = node.as_array ();
-    if (array.size () != S)
-        throw std::runtime_error ("Invalid dimensionality for json-to-vector");
-
-    // XXX: This used to be a std::transform but gcc 4.9.0 hit an internal
-    // compiler error at this point in release mode, so we dumb it down a
-    // little.
-    for (size_t i = 0; i < array.size (); ++i)
-        v.data[i] = array[i].as<T> ();
-
-    return node;
-}
-
-
-//-----------------------------------------------------------------------------
-#define INSTANTIATE_S_T(S,T)                                                    \
-template struct util::vector<S,T>;                                              \
-template struct util::debug::validator<vector<S,T>>; \
-template const json::tree::node& util::operator>> (const json::tree::node&, util::vector<S,T>&);
+#define INSTANTIATE_S_T(S,T)       \
+template struct util::vector<S,T>; \
+template struct util::debug::validator<vector<S,T>>;
 
 
 #define INSTANTIATE(T)  \
diff --git a/vector.hpp b/vector.hpp
index 8ea6d205..d867a166 100644
--- a/vector.hpp
+++ b/vector.hpp
@@ -22,7 +22,6 @@
 #include "coord.hpp"
 
 #include "debug.hpp"
-#include "json/fwd.hpp"
 #include "maths.hpp"
 
 #include <cstddef>
@@ -194,11 +193,6 @@ namespace util {
     template <typename T> vector<2,T> to_euler   (vector<3,T>);
     template <typename T> vector<3,T> from_euler (vector<2,T>);
 
-    // output and serialisation operators
-    template <size_t S, typename T>
-    const json::tree::node&
-    operator>> (const json::tree::node&, vector<S,T>&);
-
     template <typename T> using vector1 = vector<1,T>;
     template <typename T> using vector2 = vector<2,T>;
     template <typename T> using vector3 = vector<3,T>;