@lucent-lang/lucent 0.0.4 → 0.1.1

package/runtime/cpp/lucent/buffer.h

@@ -0,0 +1,328 @@
+// Lucent runtime — native buffers.
+//
+// A NativeBuffer is bytes that native code owns: allocated by the runtime,
+// or adopted from native code with the release it requires and the
+// executor that release must run on. Its handle is reference counted, but a
+// reference keeps only the handle alive: access to the bytes is a borrow,
+// granted for the length of one synchronous call. Read borrows share;
+// a write borrow excludes every other. A borrow that conflicts is refused at
+// once with an InvalidStateError, never waited for, whatever thread asks.
+//
+// The storage is released once: at close(), which a borrow refuses, or when
+// the last reference goes, on the executor it requires. After that every
+// alias refuses access. Copies are explicit (toBytes, fromBytes) and
+// counted (stats), so a path that should not copy can prove it does not.
+//
+// A transfer moves the storage, uncopied, to a new handle and leaves every
+// alias of the old one refusing reads, writes and transfers: the new handle
+// is its only owner. This is how a buffer crosses to a compute task
+// (transport.h): the move commits only once the task's whole input has been
+// copied, and rolls back otherwise. Once committed, the storage follows the
+// task's handle: a refused submission or a cancelled task releases it.
+#pragma once
+
+#include <algorithm>
+#include <atomic>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <functional>
+#include <memory>
+#include <span>
+#include <type_traits>
+
+#include "bytes.h"
+#include "core.h"
+#include "execution.h"
+#include "jserror.h"
+#include "jsstring.h"
+#include "transport.h"
+
+namespace lucent {
+
+class NativeBufferObject;
+using NativeBuffer = Ref<NativeBufferObject>;
+
+/// What every native buffer has done since the process started.
+struct NativeBufferStats {
+  uint64_t allocated = 0;
+  uint64_t adopted = 0;
+  /// Storage released (closed, or its last reference gone).
+  uint64_t released = 0;
+  /// Storage moved to a new handle.
+  uint64_t transfers = 0;
+  /// Payload copies made (toBytes, fromBytes), and their bytes.
+  uint64_t copies = 0;
+  uint64_t bytesCopied = 0;
+};
+
+class NativeBufferObject final : public Object {
+ public:
+  enum class State : uint8_t { Open, Transferring, Transferred, Closed };
+
+  /// Releases adopted storage.
+  using Destroy = std::function<void(uint8_t* data, size_t size)>;
+
+  /// `size` zeroed bytes, which any thread may free. `origin` names the
+  /// buffer in errors and reports.
+  static NativeBuffer allocate(double size, String origin = {});
+
+  /// Takes `size` bytes at `data`: `destroy` releases them, on `destroyOn`'s
+  /// thread if given (posted there from any other), else wherever the buffer
+  /// is released. `destroyOn` must outlive the buffer.
+  static NativeBuffer adopt(uint8_t* data, size_t size, Destroy destroy, ExecutionContext* destroyOn = nullptr,
+                            String origin = {});
+
+  /// A new buffer holding a copy of `bytes`.
+  static NativeBuffer fromBytes(const Bytes& bytes, String origin = {});
+
+  /// Releases the storage if it still holds it; an error from the release
+  /// is reported.
+  ~NativeBufferObject() override;
+
+  NativeBufferObject(const NativeBufferObject&) = delete;
+  NativeBufferObject& operator=(const NativeBufferObject&) = delete;
+
+  State state() const { return stateOf(word_.load(std::memory_order_acquire)); }
+
+  bool isOpen() const { return state() == State::Open; }
+
+  /// The bytes it holds: 0 once closed or transferred.
+  size_t size() const { return size_.load(std::memory_order_acquire); }
+
+  /// How many times its storage was transferred before reaching it.
+  uint32_t generation() const { return generation_; }
+
+  const String& origin() const { return origin_; }
+
+  /// Borrows now in progress.
+  size_t readers() const { return word_.load(std::memory_order_acquire) >> kReaderShift; }
+  bool writing() const { return (word_.load(std::memory_order_acquire) & kWriter) != 0; }
+
+  /// Calls `f(std::span<const uint8_t>)` while no one writes, and returns
+  /// what it returns. Throws InvalidStateError if the buffer is not open or
+  /// is being written.
+  template <class F>
+  decltype(auto) withRead(F&& f) {
+    Borrow borrow(*this, false);
+    return f(std::span<const uint8_t>(data_, size_.load(std::memory_order_relaxed)));
+  }
+
+  /// Calls `f(std::span<uint8_t>)` with the buffer to itself. Throws
+  /// InvalidStateError if it is not open or is borrowed.
+  template <class F>
+  decltype(auto) withWrite(F&& f) {
+    Borrow borrow(*this, true);
+    return f(std::span<uint8_t>(data_, size_.load(std::memory_order_relaxed)));
+  }
+
+  /// A copy of the bytes (a Uint8Array snapshot), under a read borrow.
+  Bytes toBytes();
+
+  /// Releases the storage and returns true if it was open; false, at once,
+  /// if it was already closed or transferred. Throws InvalidStateError
+  /// while borrowed. Run here, the release's error reaches the caller;
+  /// posted to its executor, it is reported.
+  bool close();
+
+  /// Moves the storage to a new handle, one generation on, and returns it:
+  /// this one, and every alias of it, refuses access from now on. Throws
+  /// InvalidStateError if it is not open or is borrowed.
+  NativeBuffer transfer();
+
+  static NativeBufferStats stats();
+
+  /// Counted copies between borrowed bytes and a Uint8Array, for callers
+  /// that cannot be lent the storage itself (JavaScript): out of a read
+  /// borrow's bytes, and back into a write borrow's (what fits).
+  static Bytes copyOut(std::span<const uint8_t> bytes);
+  static void copyIn(std::span<uint8_t> to, const Bytes& from);
+
+ private:
+  friend struct Transport<NativeBuffer>;
+
+  // The word: state in the low two bits, then the write flag, then the
+  // number of readers. 0 is open with no borrow.
+  static constexpr uint32_t kStateMask = 3;
+  static constexpr uint32_t kWriter = 4;
+  static constexpr int kReaderShift = 3;
+  static constexpr uint32_t kReader = 1u << kReaderShift;
+
+  static State stateOf(uint32_t word) { return static_cast<State>(word & kStateMask); }
+
+  /// A borrow for one call; keeps the buffer alive while it lasts.
+  class Borrow {
+   public:
+    Borrow(NativeBufferObject& buffer, bool write);
+    ~Borrow();
+
+    Borrow(const Borrow&) = delete;
+    Borrow& operator=(const Borrow&) = delete;
+
+   private:
+    std::shared_ptr<Object> keep_;
+    NativeBufferObject& buffer_;
+    const bool write_;
+  };
+
+  NativeBufferObject(uint8_t* data, size_t size, Destroy destroy, ExecutionContext* destroyOn, String origin,
+                     uint32_t generation);
+
+  /// Throws the InvalidStateError for a use the word refuses.
+  [[noreturn]] void refuse(uint32_t word) const;
+
+  /// Moves from open with no borrow to `to`; throws if it cannot.
+  void seize(State to);
+
+  /// A transfer in two steps, so a failed copy can undo it: the storage
+  /// moves to the returned handle at once, while this one refuses access;
+  /// commit leaves it transferred, abort takes the storage back.
+  NativeBuffer beginTransfer();
+  void commitTransfer();
+  void abortTransfer(const NativeBuffer& successor);
+
+  /// Releases storage taken from a buffer, on its executor.
+  static void release(uint8_t* data, size_t size, Destroy destroy, ExecutionContext* on);
+
+  std::atomic<uint32_t> word_{0};
+
+  // Changed only by whoever seized the word: read under a borrow.
+  uint8_t* data_;
+  std::atomic<size_t> size_;
+  Destroy destroy_;
+  ExecutionContext* destroyOn_;
+
+  const String origin_;
+  const uint32_t generation_;
+};
+
+/// The bytes a borrow lends compiled code, with a Uint8Array's element
+/// semantics: reads out of range are undefined, writes out of range are
+/// ignored, values wrap to 0–255. The compiler keeps a span inside the
+/// callback it was lent to (it cannot be stored, returned or awaited
+/// across), so it never outlives its borrow.
+template <bool Writable>
+class BasicByteSpan {
+ public:
+  using Byte = std::conditional_t<Writable, uint8_t, const uint8_t>;
+
+  /// No bytes: what a variable holds before a span is assigned to it.
+  BasicByteSpan() = default;
+  explicit BasicByteSpan(std::span<Byte> bytes) : bytes_(bytes) {}
+
+  size_t size() const { return bytes_.size(); }
+  double length() const { return static_cast<double>(bytes_.size()); }
+  const uint8_t* data() const { return bytes_.data(); }
+
+  Opt<double> get(double index) const {
+    if (!contains(index)) return undefined;
+
+    return static_cast<double>(bytes_[static_cast<size_t>(index)]);
+  }
+
+  double at(size_t i) const { return static_cast<double>(bytes_[i]); }
+
+  void set(double index, double value) const
+    requires Writable
+  {
+    if (contains(index)) bytes_[static_cast<size_t>(index)] = Bytes::toUint8(value);
+  }
+
+  /// TypedArray.prototype.fill: `start` and `end` count from the end when negative.
+  void fill(double value, double start = 0) const
+    requires Writable
+  {
+    fill(value, start, length());
+  }
+
+  void fill(double value, double start, double end) const
+    requires Writable
+  {
+    size_t from = detail::relativeIndex(start, bytes_.size());
+    size_t to = detail::relativeIndex(end, bytes_.size());
+
+    if (from < to) std::fill(bytes_.begin() + from, bytes_.begin() + to, Bytes::toUint8(value));
+  }
+
+  /// TypedArray.prototype.set with a Uint8Array.
+  void setFrom(const Bytes& source, double offset = 0) const
+    requires Writable
+  {
+    if (!(offset >= 0) || static_cast<double>(source.size()) + std::trunc(offset) > length())
+      throwRangeError("offset is out of bounds");
+
+    std::copy(source.data(), source.data() + source.size(), bytes_.begin() + static_cast<size_t>(offset));
+  }
+
+ private:
+  bool contains(double index) const {
+    return index >= 0 && index < length() && std::trunc(index) == index;
+  }
+
+  std::span<Byte> bytes_;
+};
+
+/// The same bytes: two borrows of one buffer lend equal spans.
+template <bool Writable>
+bool strictEquals(const BasicByteSpan<Writable>& a, const BasicByteSpan<Writable>& b) {
+  return a.data() == b.data() && a.size() == b.size();
+}
+
+/// Like a Uint8Array's: the bytes joined with commas.
+template <bool Writable>
+String toJsString(const BasicByteSpan<Writable>& b) {
+  String out;
+  for (size_t i = 0; i < b.size(); i++) {
+    if (i > 0) out += String::fromLatin1(",");
+    out += numberToString(b.at(i));
+  }
+  return out;
+}
+
+using ByteSpan = BasicByteSpan<false>;
+using MutableByteSpan = BasicByteSpan<true>;
+
+/// `buffer.withRead(f)` as compiled: f is lent a ByteSpan.
+template <class F>
+decltype(auto) withRead(const NativeBuffer& buffer, F&& f) {
+  return buffer->withRead([&](std::span<const uint8_t> bytes) -> decltype(auto) { return f(ByteSpan(bytes)); });
+}
+
+/// `buffer.withWrite(f)` as compiled: f is lent a MutableByteSpan.
+template <class F>
+decltype(auto) withWrite(const NativeBuffer& buffer, F&& f) {
+  return buffer->withWrite([&](std::span<uint8_t> bytes) -> decltype(auto) { return f(MutableByteSpan(bytes)); });
+}
+
+/// `span[i]` read for a compound assignment: a RangeError out of range, as for a Uint8Array.
+template <bool Writable>
+double elementAt(const BasicByteSpan<Writable>& bytes, double i) {
+  Opt<double> v = bytes.get(i);
+  if (!v.has()) throwRangeError("Uint8Array index out of bounds");
+
+  return v.get();
+}
+
+inline double setElement(const MutableByteSpan& bytes, double i, double v) {
+  bytes.set(i, v);
+  return v;
+}
+
+/// A buffer crosses to a task by moving: once per input however often it
+/// appears, committed with the rest of the input.
+template <>
+struct Transport<NativeBuffer> {
+  static NativeBuffer copy(const NativeBuffer& source, CopyGraph& graph) {
+    if (!source) return source;
+
+    if (auto* moved = graph.find<NativeBuffer>(source.get())) return *moved;
+
+    NativeBuffer moved = source->beginTransfer();
+    graph.remember(source.get(), moved);
+
+    graph.onCommit([source] { source->commitTransfer(); }, [source, moved] { source->abortTransfer(moved); });
+    return moved;
+  }
+};
+
+}  // namespace lucent

package/runtime/cpp/lucent/builtins.cpp

@@ -63,7 +63,10 @@ String utf8Decode(const Bytes& b) {
 
 Promise<void> delay(double ms) {
   Promise<void> p;
-  Scheduler::instance().postDelayed(ms, [p] { p.resolve(undefined); });
+
+  // On the context the promise belongs to: the calling one.
+  ExecutionContext::of(ExecutionContext::currentRef()).postDelayed(ms, [p] { p.resolve(undefined); });
+
   return p;
 }
 

package/runtime/cpp/lucent/bytes.h

@@ -31,6 +31,16 @@ class Bytes {
   }
   static Bytes copy(const uint8_t* data, size_t n) { return Bytes(std::vector<uint8_t>(data, data + n)); }
 
+  /// A view of `length` bytes at `offset` in `buffer`, which must hold them.
+  static Bytes view(std::shared_ptr<std::vector<uint8_t>> buffer, size_t offset, size_t length) {
+    return Bytes(std::move(buffer), offset, length);
+  }
+
+  /// The buffer this view is over, and where in it the view starts: what a
+  /// copy needs to keep views of one buffer sharing theirs (transport.h).
+  const std::shared_ptr<std::vector<uint8_t>>& buffer() const { return buf_; }
+  size_t offset() const { return off_; }
+
   static uint8_t toUint8(double v) { return static_cast<uint8_t>(toUint32(v) & 0xFF); }
 
   size_t size() const { return len_; }
@@ -113,15 +123,24 @@ class Bytes {
   }
 
   const void* identity() const { return this->buf_.get(); }
-  friend bool strictEquals(const Bytes& a, const Bytes& b) { return a.buf_ == b.buf_ && a.off_ == b.off_ && a.len_ == b.len_; }
-  friend String toJsString(const Bytes& b) { return b.join(); }
 
  private:
+  Bytes(std::shared_ptr<std::vector<uint8_t>> buffer, size_t offset, size_t length)
+      : buf_(std::move(buffer)), off_(offset), len_(length) {}
+
   std::shared_ptr<std::vector<uint8_t>> buf_;
   size_t off_ = 0;
   size_t len_ = 0;
 };
 
+/// A view is named by its buffer and range, not by the object: two
+/// subarray() views of one range are the same view (docs/semantics.md).
+inline bool strictEquals(const Bytes& a, const Bytes& b) {
+  return a.buffer() == b.buffer() && a.offset() == b.offset() && a.size() == b.size();
+}
+
+inline String toJsString(const Bytes& b) { return b.join(); }
+
 /// TextEncoder().encode / TextDecoder().decode for UTF-8.
 Bytes utf8Encode(const String& s);
 String utf8Decode(const Bytes& b);

package/runtime/cpp/lucent/callback.cpp

@@ -0,0 +1,29 @@
+#include "callback.h"
+
+namespace lucent {
+
+std::function<void()> detail::followSignal(const AbortSignal& signal, std::function<void(Error)> cancel) {
+  std::weak_ptr<AbortSignalObject> weak = signal;
+
+  uint64_t id = signal->add([weak, cancel] {
+    if (auto s = weak.lock()) cancel(s->reason);
+  });
+
+  // Refused on the signal's context: it has aborted since it was checked.
+  if (id == 0) {
+    cancel(signal->reason);
+    return [] {};
+  }
+
+  return [weak, id] {
+    if (auto s = weak.lock()) s->remove(id);
+  };
+}
+
+Opt<Error> detail::abortedBy(const Opt<AbortSignal>& signal) {
+  if (!signal.has() || !signal.get() || !signal.get()->aborted.load()) return undefined;
+
+  return signal.get()->reason;
+}
+
+}  // namespace lucent

package/runtime/cpp/lucent/callback.h

@@ -0,0 +1,230 @@
+// Lucent runtime — composing callbacks into promises and subscriptions.
+//
+// fromCallback turns an API that reports once through callbacks into a
+// promise; subscribe delivers what a listener reports until it ends. Neither
+// knows what it listens to: Lucent code starts listening (the registration)
+// and returns what stops it (the cleanup).
+//
+// Each is one Operation (scope.h) under the calling context's root scope.
+// It settles exactly once, at the first of its callbacks, its signal
+// aborting and the scope's disposal; whatever comes later is dropped. Its
+// cleanup runs exactly once, as soon as it settles, or as soon as the
+// registration returns it if it settled during registration.
+//
+// Everything it runs belongs to its owner, the context it was called on:
+// the registration, the value handler, the cleanup and the promise. The
+// functions it hands to Lucent code may be called from any thread: from
+// another, a call is posted to the owner, after those posted before it,
+// and takes effect when it runs there.
+#pragma once
+
+#include <exception>
+#include <functional>
+#include <memory>
+#include <tuple>
+#include <utility>
+
+#include "abort.h"
+#include "async.h"
+#include "core.h"
+#include "execution.h"
+#include "function.h"
+#include "jserror.h"
+#include "scope.h"
+
+namespace lucent {
+
+namespace detail {
+
+/// Cancels with the signal's reason when it aborts, until the returned
+/// function stops following it. `cancel` runs on the signal's context.
+std::function<void()> followSignal(const AbortSignal& signal, std::function<void(Error)> cancel);
+
+/// The reason an already aborted signal gives; none otherwise.
+Opt<Error> abortedBy(const Opt<AbortSignal>& signal);
+
+/// Makes the function of type `F` handed to Lucent code, passing what it
+/// is called with to `sink`.
+template <class F>
+struct Handout;
+
+template <class... A>
+struct Handout<Fn<void(A...)>> {
+  template <class Sink>
+  static Fn<void(A...)> make(Sink sink) {
+    return Fn<void(A...)>([sink = std::move(sink)](A... args) mutable { sink(std::move(args)...); });
+  }
+};
+
+/// One composition's operation and owner, shared by what it hands out.
+template <class T>
+class Composition : public std::enable_shared_from_this<Composition<T>> {
+ public:
+  using Op = Operation<T>;
+  using Value = typename Op::Value;
+
+  Composition(ContextRef owner, std::shared_ptr<Op> op) : owner_(std::move(owner)), op_(std::move(op)) {}
+
+  /// Settles on the owner; the first settlement wins.
+  void succeed(Value value) {
+    if constexpr (std::is_void_v<T>) {
+      onOwner([](Op& op) { op.succeed(); });
+    } else {
+      onOwner([value = std::move(value)](Op& op) mutable { op.succeed(std::move(value)); });
+    }
+  }
+
+  void fail(Error error) {
+    onOwner([error = std::move(error)](Op& op) mutable { op.fail(std::move(error)); });
+  }
+
+  /// Runs `deliver` on the owner while the operation is pending. What it
+  /// throws settles the operation as failed.
+  template <class Deliver>
+  void deliver(Deliver deliver) {
+    onOwner([deliver = std::move(deliver)](Op& op) mutable {
+      if (op.state() != OperationState::Pending) return;
+
+      try {
+        deliver();
+      } catch (...) {
+        op.fail(currentError(std::current_exception()));
+      }
+    });
+  }
+
+  /// Cancels with `signal`'s reason when it aborts, until settlement.
+  void follow(const Opt<AbortSignal>& signal) {
+    if (!signal.has() || !signal.get()) return;
+
+    auto self = this->shared_from_this();
+    auto unfollow = followSignal(signal.get(), [self](Error reason) {
+      self->onOwner([reason = std::move(reason)](Op& op) mutable { op.cancel(std::move(reason)); });
+    });
+
+    op_->onSettled([unfollow = std::move(unfollow)](const typename Op::Outcome&) { unfollow(); });
+  }
+
+ private:
+  /// Runs `f` with the operation on the owner: now, on the owner's thread,
+  /// else posted there (and dropped if the owner takes no more work).
+  template <class F>
+  void onOwner(F f) {
+    ExecutionContext& owner = ExecutionContext::of(owner_);
+
+    if (owner.isCurrent()) {
+      f(*op_);
+      return;
+    }
+
+    owner.post([self = this->shared_from_this(), f = std::move(f)]() mutable { f(*self->op_); });
+  }
+
+  const ContextRef owner_;
+  const std::shared_ptr<Op> op_;
+};
+
+/// The cleanup a registration returned (a function, maybe absent), as the
+/// operation runs it; what the cleanup returns is ignored.
+template <class Returned>
+std::function<void()> cleanupOf(const Returned& returned) {
+  if constexpr (IsOpt<Returned>::value) {
+    if (!returned.has()) return {};
+
+    return cleanupOf(returned.get());
+  } else {
+    if (!returned) return {};
+
+    return [f = returned] { f(); };
+  }
+}
+
+/// Calls the registration and takes its cleanup, if it returns one.
+template <class Returned, class... Handed>
+std::function<void()> registerWith(const Fn<Returned(Handed...)>& registration, Handed... handed) {
+  if constexpr (std::is_void_v<Returned>) {
+    registration(std::move(handed)...);
+    return {};
+  } else {
+    return cleanupOf(registration(std::move(handed)...));
+  }
+}
+
+/// Starts an operation of the calling context that `start` registers (with
+/// the composition), following `signal`, and the promise it settles.
+template <class T, class Start>
+Promise<T> compose(const Opt<AbortSignal>& signal, Start start) {
+  using Op = Operation<T>;
+
+  ContextRef owner = ExecutionContext::currentRef();
+  Promise<T> promise;
+
+  auto op = Op::start(
+      ExecutionContext::of(owner).root(),
+      [&](const std::shared_ptr<Op>& op) {
+        auto composition = std::make_shared<Composition<T>>(owner, op);
+
+        composition->follow(signal);
+
+        return start(composition);
+      },
+      abortedBy(signal));
+
+  op->onSettled([promise](const typename Op::Outcome& outcome) {
+    if (outcome.state == OperationState::Succeeded) {
+      promise.resolve(*outcome.value);
+    } else {
+      promise.reject(outcome.error);
+    }
+  });
+
+  return promise;
+}
+
+}  // namespace detail
+
+/// `fromCallback(register, signal)` (lucent:core): calls `registration`
+/// with `resolve` and `reject`, and returns the promise the first of them,
+/// or the signal, settles. A registration that throws rejects it; it
+/// returns its cleanup (a Fn taking nothing, maybe in an Opt) or nothing.
+/// `Resolve` is `Fn<void(T)>`, or `Fn<void()>` when T is void.
+template <class T, class Resolve, class Returned>
+Promise<T> fromCallback(const Fn<Returned(Resolve, Fn<void(Error)>)>& registration, Opt<AbortSignal> signal = {}) {
+  using Composition = detail::Composition<T>;
+
+  return detail::compose<T>(signal, [&](const std::shared_ptr<Composition>& c) {
+    auto resolve = detail::Handout<Resolve>::make([c](auto... value) {
+      static_assert(sizeof...(value) <= 1, "resolve takes one value");
+
+      c->succeed(typename Composition::Value(std::move(value)...));
+    });
+    Fn<void(Error)> reject = [c](Error error) { c->fail(std::move(error)); };
+
+    return detail::registerWith(registration, std::move(resolve), std::move(reject));
+  });
+}
+
+/// `subscribe(register, onValue, signal)` (lucent:core): calls
+/// `registration` with `next`, `end` and `fail`; `next` calls `onValue`
+/// until the subscription ends, at the first of `end`, `fail`, `onValue`
+/// throwing and the signal. Returns the promise of that end. What
+/// `onValue` returns is ignored.
+template <class Next, class Returned, class OnValue>
+Promise<void> subscribe(const Fn<Returned(Next, Fn<void()>, Fn<void(Error)>)>& registration, OnValue onValue,
+                        Opt<AbortSignal> signal = {}) {
+  using Composition = detail::Composition<void>;
+
+  return detail::compose<void>(signal, [&](const std::shared_ptr<Composition>& c) {
+    auto next = detail::Handout<Next>::make([c, onValue](auto... value) {
+      c->deliver([onValue, value = std::make_tuple(std::move(value)...)]() mutable {
+        std::apply([&](auto&&... v) { onValue(std::forward<decltype(v)>(v)...); }, std::move(value));
+      });
+    });
+    Fn<void()> end = [c] { c->succeed(undefined); };
+    Fn<void(Error)> fail = [c](Error error) { c->fail(std::move(error)); };
+
+    return detail::registerWith(registration, std::move(next), std::move(end), std::move(fail));
+  });
+}
+
+}  // namespace lucent