cyclotone 0.1.0 → 1.0.0

data/lib/cyclotone/transforms/accumulation.rb

@@ -8,11 +8,16 @@ module Cyclotone
       end
 
       def superimpose(&block)
+        raise ArgumentError, "superimpose requires a block" unless block
+
         overlay(block.call(self))
       end
 
       def layer(functions)
-        Pattern.stack(functions.map { |function| function.call(self) })
+        normalized_functions = Array(functions)
+        raise ArgumentError, "layer requires functions" if normalized_functions.empty?
+
+        Pattern.stack(normalized_functions.map { |function| function.call(self) })
       end
 
       def jux(&block)
@@ -20,8 +25,11 @@ module Cyclotone
       end
 
       def jux_by(amount, &block)
-        left = merge(Controls.pan(0.5 - (amount.to_f / 2.0)))
-        right = block.call(self).merge(Controls.pan(0.5 + (amount.to_f / 2.0)))
+        raise ArgumentError, "jux_by requires a block" unless block
+
+        offset = amount.to_f / 2.0
+        left = merge(Controls.pan((0.5 - offset).clamp(0.0, 1.0)))
+        right = block.call(self).merge(Controls.pan((0.5 + offset).clamp(0.0, 1.0)))
         Pattern.stack([left, right])
       end
 
@@ -34,12 +42,27 @@ module Cyclotone
       end
 
       def weave_with(count, pattern, functions)
+        normalized_count = normalize_weave_count(count)
+        normalized_functions = Array(functions)
+        raise ArgumentError, "weave functions must not be empty" if normalized_functions.empty?
+
         Pattern.fastcat(
-          Array.new(count) do |index|
-            functions[index % functions.length].call(pattern)
+          Array.new(normalized_count) do |index|
+            normalized_functions[index % normalized_functions.length].call(pattern)
           end
         )
       end
+
+      private
+
+      def normalize_weave_count(count)
+        normalized_count = Integer(count)
+        raise ArgumentError, "weave count must be positive" unless normalized_count.positive?
+
+        normalized_count
+      rescue ArgumentError, TypeError => error
+        raise ArgumentError, "invalid weave count: #{error.message}"
+      end
     end
   end
 end

data/lib/cyclotone/transforms/alteration.rb

@@ -3,13 +3,19 @@
 module Cyclotone
   module Transforms
     module Alteration
+      MAX_SEGMENTS = 4096
+
       def every(period, &block)
         every_with_offset(period, 0, &block)
       end
 
       def every_with_offset(period, offset, &block)
+        normalized_period = validate_positive_rational(period, "every period")
+        normalized_offset = Pattern.to_rational(offset)
+        raise ArgumentError, "every requires a block" unless block
+
         Pattern.new do |span|
-          if ((span.cycle_number - offset) % period).zero?
+          if ((span.cycle_number - normalized_offset) % normalized_period).zero?
             block.call(self).query_span(span)
           else
             query_span(span)
@@ -27,9 +33,12 @@ module Cyclotone
         sometimes_by(0.5, &block)
       end
 
-      def sometimes_by(probability, &block)
+      def sometimes_by(probability, namespace: :sometimes, &block)
+        normalized_probability = validate_probability(probability, "sometimes probability")
+        raise ArgumentError, "sometimes_by requires a block" unless block
+
         Pattern.new do |span|
-          if Support::Deterministic.float(:sometimes, probability, span.cycle_number) < probability.to_f
+          if Support::Deterministic.float(namespace, normalized_probability, span.cycle_number) < normalized_probability
             block.call(self).query_span(span)
           else
             query_span(span)
@@ -50,10 +59,13 @@ module Cyclotone
       end
 
       def chunk(count, &block)
+        normalized_count = validate_segment_count(count, "chunk count")
+        raise ArgumentError, "chunk requires a block" unless block
+
         Pattern.new do |span|
-          selected = span.cycle_number % count
-          pieces = Array.new(count) do |index|
-            segment = zoom(Rational(index, count), Rational(index + 1, count))
+          selected = span.cycle_number % normalized_count
+          pieces = Array.new(normalized_count) do |index|
+            segment = zoom(Rational(index, normalized_count), Rational(index + 1, normalized_count))
             index == selected ? block.call(segment) : segment
           end
 
@@ -62,8 +74,10 @@ module Cyclotone
       end
 
       def scramble(count)
-        reorder_segments(count) do |cycle|
-          Array.new(count) { |index| index }.shuffle(random: Support::Deterministic.random(:scramble, cycle))
+        normalized_count = validate_segment_count(count, "scramble count")
+
+        reorder_segments(normalized_count) do |cycle|
+          Array.new(normalized_count) { |index| index }.shuffle(random: Support::Deterministic.random(:scramble, cycle))
         end
       end
 
@@ -72,22 +86,28 @@ module Cyclotone
       end
 
       def iter(count)
-        reorder_segments(count) do |cycle|
-          Array.new(count) { |index| (index + cycle) % count }
+        normalized_count = validate_segment_count(count, "iter count")
+
+        reorder_segments(normalized_count) do |cycle|
+          Array.new(normalized_count) { |index| (index + cycle) % normalized_count }
         end
       end
 
       def iter_back(count)
-        reorder_segments(count) do |cycle|
-          Array.new(count) { |index| (index - cycle) % count }
+        normalized_count = validate_segment_count(count, "iter_back count")
+
+        reorder_segments(normalized_count) do |cycle|
+          Array.new(normalized_count) { |index| (index - cycle) % normalized_count }
         end
       end
 
       def degrade_by(probability)
+        normalized_probability = validate_probability(probability, "degrade probability")
+
         select_events do |event|
           cycle = (event.onset || event.part.start).floor
-          seed = [:degrade, probability, cycle, event.value, event.part.start]
-          Support::Deterministic.float(seed) >= probability.to_f
+          seed = [:degrade, normalized_probability, cycle, event.value, event.part.start]
+          Support::Deterministic.float(seed) >= normalized_probability
         end
       end
 
@@ -97,6 +117,7 @@ module Cyclotone
 
       def trunc(amount)
         limit = Pattern.to_rational(amount)
+        raise ArgumentError, "trunc amount must be between 0 and 1" if limit.negative? || limit > 1
 
         Pattern.new do |span|
           cycle_start = Rational(span.cycle_number)
@@ -123,6 +144,7 @@ module Cyclotone
         window_start = Pattern.to_rational(start_point)
         window_end = Pattern.to_rational(end_point)
         window_length = window_end - window_start
+        raise ArgumentError, "zoom end must be greater than start" unless window_length.positive?
 
         Pattern.new do |span|
           cycle_start = Rational(span.cycle_number)
@@ -148,26 +170,68 @@ module Cyclotone
       end
 
       def spread(function, values)
-        sequence = Pattern.cat(Array(values).map { |value| function.call(self, value) })
+        normalized_values = validate_values(values, "spread values")
+        raise ArgumentError, "spread requires a callable function" unless function.respond_to?(:call)
+
+        sequence = Pattern.cat(normalized_values.map { |value| function.call(self, value) })
         Pattern.new { |span| sequence.query_span(span) }
       end
 
       def fastspread(function, values)
-        Pattern.fastcat(Array(values).map { |value| function.call(self, value) })
+        normalized_values = validate_values(values, "fastspread values")
+        raise ArgumentError, "fastspread requires a callable function" unless function.respond_to?(:call)
+
+        Pattern.fastcat(normalized_values.map { |value| function.call(self, value) })
       end
 
       private
 
       def reorder_segments(count)
+        normalized_count = validate_segment_count(count, "segment count")
+
         Pattern.new do |span|
           order = yield(span.cycle_number)
-          segment_patterns = Array.new(count) do |index|
-            zoom(Rational(order[index], count), Rational(order[index] + 1, count))
+          segment_patterns = Array.new(normalized_count) do |index|
+            zoom(Rational(order[index], normalized_count), Rational(order[index] + 1, normalized_count))
           end
 
           Pattern.fastcat(segment_patterns).query_span(span)
         end
       end
+
+      def validate_positive_rational(value, label)
+        normalized = Pattern.to_rational(value)
+        raise ArgumentError, "#{label} must be positive" unless normalized.positive?
+
+        normalized
+      end
+
+      def validate_probability(value, label)
+        normalized = Float(value)
+        raise ArgumentError, "#{label} must be finite" unless normalized.finite?
+        raise ArgumentError, "#{label} must be between 0 and 1" unless normalized.between?(0.0, 1.0)
+
+        normalized
+      rescue ArgumentError, TypeError => error
+        raise ArgumentError, "invalid #{label}: #{error.message}"
+      end
+
+      def validate_segment_count(value, label)
+        normalized = Integer(value)
+        raise ArgumentError, "#{label} must be positive" unless normalized.positive?
+        raise ArgumentError, "#{label} must be <= #{MAX_SEGMENTS}" if normalized > MAX_SEGMENTS
+
+        normalized
+      rescue ArgumentError, TypeError => error
+        raise ArgumentError, "invalid #{label}: #{error.message}"
+      end
+
+      def validate_values(values, label)
+        normalized = Array(values)
+        raise ArgumentError, "#{label} must not be empty" if normalized.empty?
+
+        normalized
+      end
     end
   end
 end

data/lib/cyclotone/transforms/condition.rb

@@ -4,12 +4,18 @@ module Cyclotone
   module Transforms
     module Condition
       def when_mod(period, minimum, &block)
+        normalized_period = Pattern.to_rational(period)
+        raise ArgumentError, "when_mod period must be positive" unless normalized_period.positive?
+        raise ArgumentError, "when_mod requires a block" unless block
+
         Pattern.new do |span|
-          (span.cycle_number % period) >= minimum ? block.call(self).query_span(span) : query_span(span)
+          (span.cycle_number % normalized_period) >= Pattern.to_rational(minimum) ? block.call(self).query_span(span) : query_span(span)
         end
       end
 
       def fix(control_pattern, &block)
+        raise ArgumentError, "fix requires a block" unless block
+
         transformed = block.call(self)
 
         Pattern.new do |span|
@@ -25,10 +31,15 @@ module Cyclotone
       end
 
       def unfix(control_pattern, &block)
+        raise ArgumentError, "unfix requires a block" unless block
+
         contrast(block, proc { |pattern| pattern }, control_pattern)
       end
 
       def contrast(true_function, false_function, control_pattern)
+        raise ArgumentError, "contrast requires a true function" unless true_function.respond_to?(:call)
+        raise ArgumentError, "contrast requires a false function" unless false_function.respond_to?(:call)
+
         true_pattern = true_function.call(self)
         false_pattern = false_function.call(self)
 
@@ -49,14 +60,15 @@ module Cyclotone
 
       def struct(bool_pattern)
         Pattern.ensure_pattern(bool_pattern).combine_left(self) do |gate, value|
-          gate ? value : nil
+          truthy?(gate) ? value : nil
         end.select_events { |event| !event.value.nil? }
       end
 
       private
 
       def truthy?(value)
-        !(value.nil? || value == false || value == 0 || value == 0.0 || value == {})
+        falsey_number = value.is_a?(Numeric) && value.zero?
+        !(value.nil? || value == false || falsey_number || value == {})
       end
     end
   end

data/lib/cyclotone/transforms/sample.rb

@@ -4,9 +4,13 @@ module Cyclotone
   module Transforms
     module Sample
       def chop(count)
+        normalized_count = validate_positive_integer(count, "chop count")
+
         Pattern.fastcat(
-          Array.new(count) do |index|
-            merge(Controls.begin(index.to_f / count)).merge(Controls.end((index + 1).to_f / count))
+          Array.new(normalized_count) do |index|
+            merge(Controls.begin(Rational(index, normalized_count))).merge(
+              Controls.end(Rational(index + 1, normalized_count))
+            )
           end
         )
       end
@@ -16,11 +20,15 @@ module Cyclotone
       end
 
       def slice(count, pattern)
+        normalized_count = validate_positive_integer(count, "slice count")
         selection = Pattern.ensure_pattern(pattern)
 
         map_events do |event|
-          index = selection.query_point(event.onset || event.part.start).to_i % count
-          merge_controls(event, begin: index.to_f / count, end: (index + 1).to_f / count)
+          selected_value = selection.query_point(event.onset || event.part.start)
+          next nil if selected_value.nil?
+
+          index = selected_value.to_i % normalized_count
+          merge_controls(event, begin: Rational(index, normalized_count), end: Rational(index + 1, normalized_count))
         end
       end
 
@@ -37,22 +45,29 @@ module Cyclotone
       end
 
       def randslice(count)
+        normalized_count = validate_positive_integer(count, "randslice count")
+
         map_events do |event|
-          index = Support::Deterministic.int(count, :randslice, event.value, event.part.start)
-          merge_controls(event, begin: index.to_f / count, end: (index + 1).to_f / count)
+          index = Support::Deterministic.int(normalized_count, :randslice, event.value, event.part.start)
+          merge_controls(event, begin: Rational(index, normalized_count), end: Rational(index + 1, normalized_count))
         end
       end
 
       def loop_at(cycles)
-        merge(Controls.speed(1.0 / cycles.to_f))
+        normalized_cycles = Pattern.to_rational(cycles)
+        raise ArgumentError, "loop_at cycles must be positive" unless normalized_cycles.positive?
+
+        merge(Controls.speed(1.0 / normalized_cycles.to_f))
       end
 
       def segment(count)
+        normalized_count = validate_positive_integer(count, "segment count")
+
         Pattern.new do |span|
           cycle_start = Rational(span.cycle_number)
-          segment_length = Rational(1, count)
+          segment_length = Rational(1, normalized_count)
 
-          Array.new(count) { |index| index }.filter_map do |index|
+          Array.new(normalized_count) { |index| index }.filter_map do |index|
             segment_span = TimeSpan.new(
               cycle_start + (segment_length * index),
               cycle_start + (segment_length * (index + 1))
@@ -77,6 +92,15 @@ module Cyclotone
 
         event.with_value(merged_value)
       end
+
+      def validate_positive_integer(value, label)
+        normalized = Integer(value)
+        raise ArgumentError, "#{label} must be positive" unless normalized.positive?
+
+        normalized
+      rescue ArgumentError, TypeError => error
+        raise ArgumentError, "invalid #{label}: #{error.message}"
+      end
     end
   end
 end

data/lib/cyclotone/transforms/time.rb

@@ -5,6 +5,7 @@ module Cyclotone
     module Time
       def fast(amount)
         factor = Pattern.to_rational(amount)
+        raise ArgumentError, "fast amount must be positive" unless factor.positive?
 
         Pattern.new do |span|
           source_span = TimeSpan.new(span.start * factor, span.stop * factor)
@@ -16,7 +17,10 @@ module Cyclotone
       end
 
       def slow(amount)
-        fast(Rational(1, 1) / Pattern.to_rational(amount))
+        factor = Pattern.to_rational(amount)
+        raise ArgumentError, "slow amount must be positive" unless factor.positive?
+
+        fast(Rational(1, 1) / factor)
       end
 
       def early(amount)
@@ -57,35 +61,50 @@ module Cyclotone
         fast(amount).fmap do |value|
           next value unless value.is_a?(Hash)
 
-          current_speed = value[:speed] || 1.0
+          current_speed = value.fetch(:speed, 1.0) || 1.0
           value.merge(speed: current_speed * amount.to_f)
         end
       end
 
       def off(amount, &block)
+        raise ArgumentError, "off requires a block" unless block
+
         transformed = block.call(self).early(amount)
         Pattern.stack([self, transformed])
       end
 
       def swing(amount, div = 4)
-        step_shift = Pattern.to_rational(amount) / Pattern.to_rational(div)
+        normalized_div = Pattern.to_rational(div)
+        raise ArgumentError, "swing division must be positive" unless normalized_div.positive?
+
+        step_shift = Pattern.to_rational(amount) / normalized_div
 
         map_events do |event|
           next event unless event.onset
 
           cycle_start = Rational(event.onset.floor)
-          step_index = (((event.onset - cycle_start) * div).floor).to_i
+          step_index = ((event.onset - cycle_start) * div).floor.to_i
           next event if step_index.even?
 
-          Pattern.shift_event(event, step_shift)
+          shifted = Pattern.shift_event(event, step_shift)
+          cycle_span = TimeSpan.new(cycle_start, cycle_start + 1)
+          clipped_part = shifted.part.intersection(cycle_span)
+          next nil unless clipped_part
+
+          clipped_whole = shifted.whole&.intersection(cycle_span) || shifted.whole
+          shifted.with_span(part: clipped_part, whole: clipped_whole)
         end
       end
 
       def inside(amount, &block)
+        raise ArgumentError, "inside requires a block" unless block
+
         slow(amount).then(&block).fast(amount)
       end
 
       def outside(amount, &block)
+        raise ArgumentError, "outside requires a block" unless block
+
         fast(amount).then(&block).slow(amount)
       end
     end

data/lib/cyclotone/transition.rb

@@ -10,19 +10,21 @@ module Cyclotone
 
     def xfade_in(id, cycles, pattern)
       slot_id = normalize_slot_reference(id)
-      current = @slots[slot_id] || Pattern.silence
+      current = pattern_for_transition(slot_id)
       replacement = Pattern.ensure_pattern(pattern)
       duration = Pattern.to_rational(cycles)
       return assign(slot_id, replacement) if duration <= 0
 
       start_cycle = transition_start_cycle
 
-      mixed = Pattern.stack([
-        apply_gain_envelope(current, start_cycle: start_cycle, duration: duration, direction: :out),
-        apply_gain_envelope(replacement, start_cycle: start_cycle, duration: duration, direction: :in)
-      ])
+      mixed = Pattern.stack(
+        [
+          apply_gain_envelope(current, start_cycle: start_cycle, duration: duration, direction: :out),
+          apply_gain_envelope(replacement, start_cycle: start_cycle, duration: duration, direction: :in)
+        ]
+      )
 
-      assign(slot_id, mixed)
+      assign_transition(slot_id, mixed, replacement: replacement, finish_cycle: start_cycle + duration)
     end
 
     def clutch(id, pattern)
@@ -31,7 +33,7 @@ module Cyclotone
 
     def clutch_in(id, cycles, pattern)
       slot_id = normalize_slot_reference(id)
-      current = @slots[slot_id] || Pattern.silence
+      current = pattern_for_transition(slot_id)
       replacement = Pattern.ensure_pattern(pattern)
       duration = Pattern.to_rational(cycles)
       return assign(slot_id, replacement) if duration <= 0
@@ -48,7 +50,7 @@ module Cyclotone
         end.then { |events| Pattern.sort_events(events) }
       end
 
-      assign(slot_id, swapped)
+      assign_transition(slot_id, swapped, replacement: replacement, finish_cycle: start_cycle + duration)
     end
 
     def interpolate(id, pattern)
@@ -57,20 +59,19 @@ module Cyclotone
 
     def interpolate_in(id, cycles, pattern)
       slot_id = normalize_slot_reference(id)
-      current = @slots[slot_id] || Pattern.silence
+      current = pattern_for_transition(slot_id)
       replacement = Pattern.ensure_pattern(pattern)
       duration = Pattern.to_rational(cycles)
       return assign(slot_id, replacement) if duration <= 0
 
       start_cycle = transition_start_cycle
       morphed = Pattern.new do |span|
-        anchor_times = Pattern.stack([current, replacement]).query_span(span).map do |event|
-          event.onset || event.part.start
-        end.uniq.sort
+        source_events = current.query_span(span)
+        target_events = replacement.query_span(span)
 
-        anchor_times.filter_map do |time|
-          source_event = current.query_event_at(time)
-          target_event = replacement.query_event_at(time)
+        transition_anchor_times(source_events, target_events).filter_map do |time|
+          source_event = event_at_time(source_events, time)
+          target_event = event_at_time(target_events, time)
           base_event = target_event || source_event
           next unless base_event
 
@@ -79,7 +80,7 @@ module Cyclotone
         end.then { |events| Pattern.sort_events(events) }
       end
 
-      assign(slot_id, morphed)
+      assign_transition(slot_id, morphed, replacement: replacement, finish_cycle: start_cycle + duration)
     end
 
     def jump(id, pattern)
@@ -88,14 +89,14 @@ module Cyclotone
 
     def jump_in(id, cycles, pattern)
       slot_id = normalize_slot_reference(id)
-      current = @slots[slot_id] || Pattern.silence
+      current = pattern_for_transition(slot_id)
       replacement = Pattern.ensure_pattern(pattern)
       switch_cycle = transition_start_cycle + Pattern.to_rational(cycles)
       return assign(slot_id, replacement) if switch_cycle <= transition_start_cycle
 
       delayed = Pattern.new { |span| split_query(span, switch_cycle, current, replacement) }
 
-      assign(slot_id, delayed)
+      assign_transition(slot_id, delayed, replacement: replacement, finish_cycle: switch_cycle)
     end
 
     def anticipate(id, pattern)
@@ -107,8 +108,14 @@ module Cyclotone
       duration = Pattern.to_rational(cycles)
       return self if duration <= 0
 
-      @slots.keys.each do |slot_id|
-        assign(slot_id, apply_gain_envelope(@slots.fetch(slot_id), start_cycle: start_cycle, duration: duration, direction: :in))
+      @slots.each_key do |slot_id|
+        replacement = @slots.fetch(slot_id)
+        assign_transition(
+          slot_id,
+          apply_gain_envelope(replacement, start_cycle: start_cycle, duration: duration, direction: :in),
+          replacement: replacement,
+          finish_cycle: start_cycle + duration
+        )
       end
 
       self
@@ -119,8 +126,13 @@ module Cyclotone
       duration = Pattern.to_rational(cycles)
       return self if duration <= 0
 
-      @slots.keys.each do |slot_id|
-        assign(slot_id, apply_gain_envelope(@slots.fetch(slot_id), start_cycle: start_cycle, duration: duration, direction: :out))
+      @slots.each_key do |slot_id|
+        assign_transition(
+          slot_id,
+          apply_gain_envelope(@slots.fetch(slot_id), start_cycle: start_cycle, duration: duration, direction: :out),
+          replacement: Pattern.silence,
+          finish_cycle: start_cycle + duration
+        )
       end
 
       self
@@ -129,23 +141,13 @@ module Cyclotone
     private
 
     def apply_gain_envelope(pattern, start_cycle:, duration:, direction:)
-      Pattern.ensure_pattern(pattern).fmap do |value|
-        next value unless value.is_a?(Hash)
-
-        factor = lambda do |time|
-          progress = ((time - start_cycle.to_f) / duration.to_f).clamp(0.0, 1.0)
-          direction == :in ? progress : 1.0 - progress
-        end
-
-        value.merge(gain_envelope: factor)
-      end.map_events do |event|
-        next event unless event.value.is_a?(Hash)
-
+      Pattern.ensure_pattern(pattern).map_events do |event|
         time = event.onset || event.part.start
-        value = event.value.dup
-        envelope = value.delete(:gain_envelope)
-        current_gain = value[:gain] || 1.0
-        value[:gain] = current_gain * envelope.call(time)
+        progress = transition_progress(time, start_cycle, duration)
+        factor = direction == :in ? progress : 1.0 - progress
+        value = event.value.is_a?(Hash) ? event.value.dup : { value: event.value }
+        current_gain = value.fetch(:gain, 1.0) || 1.0
+        value[:gain] = current_gain * factor
         event.with_value(value)
       end
     end
@@ -170,9 +172,17 @@ module Cyclotone
       ((time.to_f - start_cycle.to_f) / duration.to_f).clamp(0.0, 1.0)
     end
 
-    def clutch_source(slot_id, time, value, start_cycle, duration)
+    def transition_anchor_times(source_events, target_events)
+      (source_events + target_events).map { |event| event.onset || event.part.start }.uniq.sort
+    end
+
+    def event_at_time(events, time)
+      events.find { |event| event.covers_time?(time) }
+    end
+
+    def clutch_source(slot_id, time, _value, start_cycle, duration)
       progress = transition_progress(time, start_cycle, duration)
-      chosen = Support::Deterministic.float(:clutch, slot_id, time, value) < progress
+      chosen = Support::Deterministic.float(:clutch, slot_id, time) < progress
 
       chosen ? :replacement : :current
     end
@@ -191,13 +201,15 @@ module Cyclotone
     end
 
     def interpolate_hash(source, target, progress)
-      (source.keys | target.keys).each_with_object({}) do |key, result|
-        result[key] =
+      (source.keys | target.keys).to_h do |key|
+        value =
           if source.key?(key) && target.key?(key)
             interpolate_value(source[key], target[key], progress)
           else
             progress < 0.5 ? source.fetch(key, target[key]) : target.fetch(key, source[key])
           end
+
+        [key, value]
       end
     end
   end

data/lib/cyclotone/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Cyclotone
-  VERSION = "0.1.0"
+  VERSION = "1.0.0"
 end

data/lib/cyclotone.rb

@@ -20,6 +20,7 @@ require_relative "cyclotone/controls"
 require_relative "cyclotone/oscillators"
 require_relative "cyclotone/harmony"
 require_relative "cyclotone/state"
+require_relative "cyclotone/backends/null_backend"
 require_relative "cyclotone/backends/osc_backend"
 require_relative "cyclotone/backends/midi_backend"
 require_relative "cyclotone/backends/midi_file_backend"