lex-agentic-attention 0.1.0

data/spec/legion/extensions/agentic/attention/prism/helpers/beam_spec.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Attention::Prism::Helpers::Beam do
+  let(:beam_id) { 'test-beam-001' }
+  let(:domain)  { :cognition }
+  let(:content) { 'The idea of emergence in complex systems where local interactions produce global patterns' }
+  subject(:beam) { described_class.new(beam_id: beam_id, domain: domain, content: content) }
+
+  describe '#initialize' do
+    it 'sets beam_id' do
+      expect(beam.beam_id).to eq(beam_id)
+    end
+
+    it 'sets domain' do
+      expect(beam.domain).to eq(domain)
+    end
+
+    it 'sets content' do
+      expect(beam.content).to eq(content)
+    end
+
+    it 'starts with no components' do
+      expect(beam.components).to be_empty
+    end
+
+    it 'starts with purity 0.0' do
+      expect(beam.purity).to eq(0.0)
+    end
+  end
+
+  describe '#decompose!' do
+    before { beam.decompose! }
+
+    it 'returns self for chaining' do
+      fresh = described_class.new(beam_id: 'x', domain: :test, content: 'test')
+      expect(fresh.decompose!).to be(fresh)
+    end
+
+    it 'creates one component per spectral band' do
+      expect(beam.components.size).to eq(Legion::Extensions::Agentic::Attention::Prism::Helpers::Constants::SPECTRAL_BANDS.size)
+    end
+
+    it 'creates components as SpectralComponent instances' do
+      beam.components.each do |c|
+        expect(c).to be_a(Legion::Extensions::Agentic::Attention::Prism::Helpers::SpectralComponent)
+      end
+    end
+
+    it 'covers all spectral bands' do
+      bands = beam.components.map(&:band)
+      expect(bands).to contain_exactly(*Legion::Extensions::Agentic::Attention::Prism::Helpers::Constants::SPECTRAL_BANDS)
+    end
+
+    it 'sets purity after decomposition' do
+      expect(beam.purity).to be >= 0.0
+      expect(beam.purity).to be <= 1.0
+    end
+
+    it 'all component intensities are in 0..1' do
+      beam.components.each do |c|
+        expect(c.intensity).to be_between(0.0, 1.0)
+      end
+    end
+
+    it 'works with empty content' do
+      empty_beam = described_class.new(beam_id: 'empty', domain: :test, content: '')
+      empty_beam.decompose!
+      expect(empty_beam.components.size).to eq(8)
+    end
+  end
+
+  describe '#recompose' do
+    it 'returns empty string when no components' do
+      expect(beam.recompose).to eq('')
+    end
+
+    it 'returns a synthesis string after decomposition' do
+      beam.decompose!
+      result = beam.recompose
+      expect(result).to be_a(String)
+      expect(result).not_to be_empty
+    end
+
+    it 'excludes faded components' do
+      beam.decompose!
+      beam.components.each { |c| c.attenuate!(rate: 0.99) }
+      result = beam.recompose
+      # all faded -> empty
+      expect(result).to eq('')
+    end
+
+    it 'sorts by descending intensity in synthesis' do
+      beam.decompose!
+      active = beam.components.reject(&:faded?)
+      next if active.empty?
+
+      active.sort_by { |c| -c.intensity }.map(&:intensity)
+      result = beam.recompose
+      # verify result is non-empty and structured
+      expect(result).to include('|') if active.size > 1
+    end
+  end
+
+  describe '#dominant_band' do
+    it 'returns nil when no components' do
+      expect(beam.dominant_band).to be_nil
+    end
+
+    it 'returns a band symbol after decomposition' do
+      beam.decompose!
+      band = beam.dominant_band
+      expect(band).to be_a(Symbol)
+      expect(Legion::Extensions::Agentic::Attention::Prism::Helpers::Constants::SPECTRAL_BANDS).to include(band)
+    end
+
+    it 'returns the band with highest intensity' do
+      beam.decompose!
+      beam.components.max_by(&:intensity).band
+      # dominant_band prefers dominant? ones but falls back to max intensity
+      expect(beam.dominant_band).to be_a(Symbol)
+      expect(beam.dominant_band).not_to be_nil
+    end
+  end
+
+  describe '#spectral_balance' do
+    it 'returns empty hash when no components' do
+      expect(beam.spectral_balance).to eq({})
+    end
+
+    it 'returns a hash with band keys after decomposition' do
+      beam.decompose!
+      balance = beam.spectral_balance
+      expect(balance).to be_a(Hash)
+      balance.each_key do |k|
+        expect(Legion::Extensions::Agentic::Attention::Prism::Helpers::Constants::SPECTRAL_BANDS).to include(k)
+      end
+    end
+
+    it 'balance values sum to approximately 1.0' do
+      beam.decompose!
+      balance = beam.spectral_balance
+      next if balance.empty?
+
+      expect(balance.values.sum).to be_within(0.001).of(1.0)
+    end
+
+    it 'all balance values are between 0 and 1' do
+      beam.decompose!
+      beam.spectral_balance.each_value do |v|
+        expect(v).to be_between(0.0, 1.0)
+      end
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns a hash with expected keys when not decomposed' do
+      h = beam.to_h
+      expect(h).to have_key(:beam_id)
+      expect(h).to have_key(:domain)
+      expect(h).to have_key(:content)
+      expect(h).to have_key(:purity)
+      expect(h).to have_key(:components)
+    end
+
+    it 'includes purity_label' do
+      expect(beam.to_h).to have_key(:purity_label)
+    end
+
+    it 'includes spectral_balance' do
+      expect(beam.to_h).to have_key(:spectral_balance)
+    end
+
+    it 'includes dominant_band' do
+      expect(beam.to_h).to have_key(:dominant_band)
+    end
+
+    it 'includes component_count' do
+      beam.decompose!
+      expect(beam.to_h[:component_count]).to eq(8)
+    end
+  end
+end

data/spec/legion/extensions/agentic/attention/prism/helpers/constants_spec.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Attention::Prism::Helpers::Constants do
+  describe 'SPECTRAL_BANDS' do
+    it 'contains exactly 8 bands' do
+      expect(described_class::SPECTRAL_BANDS.size).to eq(8)
+    end
+
+    it 'includes all expected bands in order' do
+      expect(described_class::SPECTRAL_BANDS).to eq(
+        %i[infrared red orange yellow green blue violet ultraviolet]
+      )
+    end
+
+    it 'is frozen' do
+      expect(described_class::SPECTRAL_BANDS).to be_frozen
+    end
+  end
+
+  describe 'WAVELENGTH_RANGES' do
+    it 'has a range for every spectral band' do
+      described_class::SPECTRAL_BANDS.each do |band|
+        expect(described_class::WAVELENGTH_RANGES).to have_key(band)
+      end
+    end
+
+    it 'infrared covers 700..1000' do
+      expect(described_class::WAVELENGTH_RANGES[:infrared]).to eq(700..1000)
+    end
+
+    it 'red covers 620..699' do
+      expect(described_class::WAVELENGTH_RANGES[:red]).to eq(620..699)
+    end
+
+    it 'ultraviolet covers 10..379' do
+      expect(described_class::WAVELENGTH_RANGES[:ultraviolet]).to eq(10..379)
+    end
+
+    it 'all ranges are Range objects' do
+      described_class::WAVELENGTH_RANGES.each_value do |range|
+        expect(range).to be_a(Range)
+      end
+    end
+  end
+
+  describe 'MAX_BEAMS' do
+    it 'is 200' do
+      expect(described_class::MAX_BEAMS).to eq(200)
+    end
+  end
+
+  describe 'INTENSITY_LABELS' do
+    it 'has 5 entries' do
+      expect(described_class::INTENSITY_LABELS.size).to eq(5)
+    end
+
+    it 'labels trace for intensity 0.0..0.19' do
+      entry = described_class::INTENSITY_LABELS.find { |e| e[:range].cover?(0.0) }
+      expect(entry[:label]).to eq(:trace)
+    end
+
+    it 'labels brilliant for intensity 0.8..1.0' do
+      entry = described_class::INTENSITY_LABELS.find { |e| e[:range].cover?(1.0) }
+      expect(entry[:label]).to eq(:brilliant)
+    end
+
+    it 'labels moderate for intensity 0.5' do
+      entry = described_class::INTENSITY_LABELS.find { |e| e[:range].cover?(0.5) }
+      expect(entry[:label]).to eq(:moderate)
+    end
+  end
+
+  describe 'PURITY_LABELS' do
+    it 'has 5 entries' do
+      expect(described_class::PURITY_LABELS.size).to eq(5)
+    end
+
+    it 'labels turbid for purity 0.0' do
+      entry = described_class::PURITY_LABELS.find { |e| e[:range].cover?(0.0) }
+      expect(entry[:label]).to eq(:turbid)
+    end
+
+    it 'labels prismatic for purity 1.0' do
+      entry = described_class::PURITY_LABELS.find { |e| e[:range].cover?(1.0) }
+      expect(entry[:label]).to eq(:prismatic)
+    end
+
+    it 'labels pure for purity 0.8' do
+      entry = described_class::PURITY_LABELS.find { |e| e[:range].cover?(0.8) }
+      expect(entry[:label]).to eq(:pure)
+    end
+  end
+end

data/spec/legion/extensions/agentic/attention/prism/helpers/prism_engine_spec.rb

@@ -0,0 +1,253 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Attention::Prism::Helpers::PrismEngine do
+  subject(:engine) { described_class.new }
+
+  describe '#create_beam' do
+    it 'creates a beam and returns success' do
+      result = engine.create_beam(domain: :cognition, content: 'test idea')
+      expect(result[:success]).to be true
+      expect(result[:beam_id]).to be_a(String)
+      expect(result[:domain]).to eq(:cognition)
+    end
+
+    it 'uses provided beam_id when given' do
+      result = engine.create_beam(domain: :logic, content: 'custom id', beam_id: 'my-beam')
+      expect(result[:beam_id]).to eq('my-beam')
+    end
+
+    it 'generates a uuid beam_id when not provided' do
+      result = engine.create_beam(domain: :logic, content: 'auto id')
+      expect(result[:beam_id]).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'stores the created beam' do
+      result = engine.create_beam(domain: :test, content: 'stored')
+      expect(engine.beam_count).to eq(1)
+      expect(engine.get_beam(result[:beam_id])).not_to be_nil
+    end
+
+    it 'raises ArgumentError when MAX_BEAMS is reached' do
+      stub_const('Legion::Extensions::Agentic::Attention::Prism::Helpers::Constants::MAX_BEAMS', 2)
+      engine.create_beam(domain: :d, content: 'a')
+      engine.create_beam(domain: :d, content: 'b')
+      expect { engine.create_beam(domain: :d, content: 'c') }.to raise_error(ArgumentError, /MAX_BEAMS/)
+    end
+
+    it 'increments beam_count each time' do
+      3.times { |i| engine.create_beam(domain: :test, content: "idea #{i}") }
+      expect(engine.beam_count).to eq(3)
+    end
+  end
+
+  describe '#decompose' do
+    let(:beam_id) { engine.create_beam(domain: :science, content: 'quantum entanglement across spacetime')[:beam_id] }
+
+    it 'returns success with component count' do
+      result = engine.decompose(beam_id)
+      expect(result[:success]).to be true
+      expect(result[:component_count]).to eq(8)
+    end
+
+    it 'returns dominant_band' do
+      result = engine.decompose(beam_id)
+      expect(result[:dominant_band]).to be_a(Symbol)
+    end
+
+    it 'returns purity value' do
+      result = engine.decompose(beam_id)
+      expect(result[:purity]).to be_between(0.0, 1.0)
+    end
+
+    it 'returns error when beam not found' do
+      result = engine.decompose('nonexistent-id')
+      expect(result[:success]).to be false
+      expect(result[:error]).to include('not found')
+    end
+  end
+
+  describe '#recompose' do
+    before do
+      @id = engine.create_beam(domain: :philosophy, content: 'consciousness and qualia')[:beam_id]
+      engine.decompose(@id)
+    end
+
+    it 'returns success with synthesis string' do
+      beam = engine.get_beam(@id)
+      non_faded = beam.components.reject(&:faded?)
+      ids = non_faded.map { |c| "#{@id}:#{c.band}" }
+      result = engine.recompose(ids)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns empty synthesis for empty component_ids' do
+      result = engine.recompose([])
+      expect(result[:success]).to be true
+      expect(result[:synthesis]).to eq('')
+    end
+
+    it 'returns empty synthesis for unknown component ids' do
+      result = engine.recompose(['fake:red', 'fake:blue'])
+      expect(result[:success]).to be true
+      expect(result[:active_count]).to eq(0)
+    end
+  end
+
+  describe '#attenuate_all!' do
+    before do
+      id1 = engine.create_beam(domain: :d, content: 'idea one')[:beam_id]
+      id2 = engine.create_beam(domain: :d, content: 'idea two')[:beam_id]
+      engine.decompose(id1)
+      engine.decompose(id2)
+    end
+
+    it 'returns success with count of attenuated components' do
+      result = engine.attenuate_all!
+      expect(result[:success]).to be true
+      expect(result[:attenuated]).to eq(16)
+    end
+
+    it 'returns the rate used' do
+      result = engine.attenuate_all!(rate: 0.05)
+      expect(result[:rate]).to eq(0.05)
+    end
+
+    it 'reduces intensities of all components' do
+      id = engine.create_beam(domain: :test, content: 'bright idea')[:beam_id]
+      engine.decompose(id)
+      beam = engine.get_beam(id)
+      before_intensities = beam.components.map(&:intensity).dup
+      engine.attenuate_all!(rate: 0.2)
+      after_intensities = beam.components.map(&:intensity)
+      before_intensities.zip(after_intensities).each do |before, after|
+        expect(after).to be <= before
+      end
+    end
+
+    it 'works when no beams have been decomposed' do
+      fresh = described_class.new
+      fresh.create_beam(domain: :d, content: 'x')
+      result = fresh.attenuate_all!
+      expect(result[:success]).to be true
+      expect(result[:attenuated]).to eq(0)
+    end
+  end
+
+  describe '#dominant_bands' do
+    it 'returns empty hash when no beams' do
+      expect(engine.dominant_bands).to eq({})
+    end
+
+    it 'returns a hash with band counts after decomposition' do
+      id = engine.create_beam(domain: :test, content: 'a complex idea about systems')[:beam_id]
+      engine.decompose(id)
+      bands = engine.dominant_bands
+      expect(bands).to be_a(Hash)
+    end
+
+    it 'counts multiple beams correctly' do
+      2.times do |i|
+        id = engine.create_beam(domain: :test, content: "idea #{i}" * 20)[:beam_id]
+        engine.decompose(id)
+      end
+      bands = engine.dominant_bands
+      expect(bands.values.sum).to eq(2)
+    end
+  end
+
+  describe '#most_intense' do
+    before do
+      3.times do |i|
+        id = engine.create_beam(domain: :test, content: "concept #{i} with depth")[:beam_id]
+        engine.decompose(id)
+      end
+    end
+
+    it 'returns up to limit components' do
+      result = engine.most_intense(limit: 5)
+      expect(result.size).to be <= 5
+    end
+
+    it 'returns component hashes' do
+      result = engine.most_intense(limit: 3)
+      result.each do |item|
+        expect(item).to have_key(:band)
+        expect(item).to have_key(:intensity)
+      end
+    end
+
+    it 'returns fewer items than limit when not enough components' do
+      fresh = described_class.new
+      id = fresh.create_beam(domain: :d, content: 'x')[:beam_id]
+      fresh.decompose(id)
+      result = fresh.most_intense(limit: 100)
+      expect(result.size).to eq(8)
+    end
+
+    it 'returns components sorted by descending intensity' do
+      result = engine.most_intense(limit: 10)
+      intensities = result.map { |c| c[:intensity] }
+      expect(intensities).to eq(intensities.sort.reverse)
+    end
+  end
+
+  describe '#spectral_report' do
+    it 'returns expected keys' do
+      report = engine.spectral_report
+      expect(report).to have_key(:total_beams)
+      expect(report).to have_key(:decomposed_beams)
+      expect(report).to have_key(:total_components)
+      expect(report).to have_key(:dominant_bands)
+      expect(report).to have_key(:avg_purity)
+      expect(report).to have_key(:most_intense)
+    end
+
+    it 'reports 0 beams on fresh engine' do
+      expect(engine.spectral_report[:total_beams]).to eq(0)
+    end
+
+    it 'reports correct beam counts after creation and decomposition' do
+      2.times { |i| engine.create_beam(domain: :d, content: "idea #{i}") }
+      id = engine.create_beam(domain: :d, content: 'decomposed')[:beam_id]
+      engine.decompose(id)
+      report = engine.spectral_report
+      expect(report[:total_beams]).to eq(3)
+      expect(report[:decomposed_beams]).to eq(1)
+    end
+
+    it 'avg_purity is 0.0 when no decomposed beams' do
+      engine.create_beam(domain: :d, content: 'not decomposed')
+      expect(engine.spectral_report[:avg_purity]).to eq(0.0)
+    end
+
+    it 'avg_purity is between 0 and 1 after decomposition' do
+      id = engine.create_beam(domain: :d, content: 'will decompose')[:beam_id]
+      engine.decompose(id)
+      expect(engine.spectral_report[:avg_purity]).to be_between(0.0, 1.0)
+    end
+  end
+
+  describe '#clear!' do
+    it 'removes all beams' do
+      engine.create_beam(domain: :d, content: 'a')
+      engine.create_beam(domain: :d, content: 'b')
+      engine.clear!
+      expect(engine.beam_count).to eq(0)
+    end
+
+    it 'returns self' do
+      expect(engine.clear!).to be(engine)
+    end
+  end
+
+  describe '#get_beam' do
+    it 'returns nil for unknown id' do
+      expect(engine.get_beam('nope')).to be_nil
+    end
+
+    it 'returns the beam for a known id' do
+      id = engine.create_beam(domain: :d, content: 'x')[:beam_id]
+      expect(engine.get_beam(id)).to be_a(Legion::Extensions::Agentic::Attention::Prism::Helpers::Beam)
+    end
+  end
+end

data/spec/legion/extensions/agentic/attention/prism/helpers/spectral_component_spec.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Attention::Prism::Helpers::SpectralComponent do
+  let(:valid_args) { { band: :green, wavelength: 520, intensity: 0.75, content: 'relational structure' } }
+  subject(:component) { described_class.new(**valid_args) }
+
+  describe '#initialize' do
+    it 'creates a component with valid attributes' do
+      expect(component.band).to eq(:green)
+      expect(component.wavelength).to eq(520)
+      expect(component.intensity).to eq(0.75)
+      expect(component.content).to eq('relational structure')
+    end
+
+    it 'raises ArgumentError for unknown band' do
+      expect { described_class.new(band: :gamma, wavelength: 520, intensity: 0.5, content: 'x') }
+        .to raise_error(ArgumentError, /Unknown band/)
+    end
+
+    it 'raises ArgumentError when wavelength out of range for band' do
+      expect { described_class.new(band: :red, wavelength: 200, intensity: 0.5, content: 'x') }
+        .to raise_error(ArgumentError, /out of range/)
+    end
+
+    it 'clamps intensity above 1.0 to 1.0' do
+      c = described_class.new(band: :blue, wavelength: 470, intensity: 1.5, content: 'test')
+      expect(c.intensity).to eq(1.0)
+    end
+
+    it 'clamps intensity below 0.0 to 0.0' do
+      c = described_class.new(band: :blue, wavelength: 470, intensity: -0.3, content: 'test')
+      expect(c.intensity).to eq(0.0)
+    end
+
+    it 'accepts intensity of exactly 0.0' do
+      c = described_class.new(band: :violet, wavelength: 420, intensity: 0.0, content: 'x')
+      expect(c.intensity).to eq(0.0)
+    end
+
+    it 'accepts intensity of exactly 1.0' do
+      c = described_class.new(band: :red, wavelength: 650, intensity: 1.0, content: 'x')
+      expect(c.intensity).to eq(1.0)
+    end
+  end
+
+  describe '#attenuate!' do
+    it 'reduces intensity by the default rate' do
+      original = component.intensity
+      component.attenuate!
+      expect(component.intensity).to be < original
+    end
+
+    it 'reduces intensity by the specified rate' do
+      component.attenuate!(rate: 0.3)
+      expect(component.intensity).to be_within(0.001).of(0.45)
+    end
+
+    it 'clamps intensity at 0.0' do
+      component.attenuate!(rate: 2.0)
+      expect(component.intensity).to eq(0.0)
+    end
+
+    it 'returns self for chaining' do
+      expect(component.attenuate!).to be(component)
+    end
+
+    it 'takes absolute value of rate (negative rate still attenuates)' do
+      original = component.intensity
+      component.attenuate!(rate: -0.1)
+      expect(component.intensity).to be < original
+    end
+  end
+
+  describe '#amplify!' do
+    let(:low_component) { described_class.new(band: :green, wavelength: 520, intensity: 0.3, content: 'low') }
+
+    it 'increases intensity by the default boost' do
+      original = low_component.intensity
+      low_component.amplify!
+      expect(low_component.intensity).to be > original
+    end
+
+    it 'increases intensity by specified boost' do
+      low_component.amplify!(boost: 0.4)
+      expect(low_component.intensity).to be_within(0.001).of(0.7)
+    end
+
+    it 'clamps intensity at 1.0' do
+      low_component.amplify!(boost: 5.0)
+      expect(low_component.intensity).to eq(1.0)
+    end
+
+    it 'returns self for chaining' do
+      expect(low_component.amplify!).to be(low_component)
+    end
+  end
+
+  describe '#dominant?' do
+    it 'returns true when intensity >= 0.7' do
+      c = described_class.new(band: :blue, wavelength: 470, intensity: 0.8, content: 'x')
+      expect(c.dominant?).to be true
+    end
+
+    it 'returns true at exactly 0.7' do
+      c = described_class.new(band: :blue, wavelength: 470, intensity: 0.7, content: 'x')
+      expect(c.dominant?).to be true
+    end
+
+    it 'returns false when intensity < 0.7' do
+      c = described_class.new(band: :blue, wavelength: 470, intensity: 0.69, content: 'x')
+      expect(c.dominant?).to be false
+    end
+  end
+
+  describe '#faded?' do
+    it 'returns true when intensity <= 0.1' do
+      c = described_class.new(band: :orange, wavelength: 600, intensity: 0.05, content: 'x')
+      expect(c.faded?).to be true
+    end
+
+    it 'returns true at exactly 0.1' do
+      c = described_class.new(band: :orange, wavelength: 600, intensity: 0.1, content: 'x')
+      expect(c.faded?).to be true
+    end
+
+    it 'returns false when intensity > 0.1' do
+      c = described_class.new(band: :orange, wavelength: 600, intensity: 0.11, content: 'x')
+      expect(c.faded?).to be false
+    end
+  end
+
+  describe '#intensity_label' do
+    it 'returns :trace for intensity 0.05' do
+      c = described_class.new(band: :green, wavelength: 520, intensity: 0.05, content: 'x')
+      expect(c.intensity_label).to eq(:trace)
+    end
+
+    it 'returns :brilliant for intensity 0.9' do
+      c = described_class.new(band: :green, wavelength: 520, intensity: 0.9, content: 'x')
+      expect(c.intensity_label).to eq(:brilliant)
+    end
+
+    it 'returns :strong for intensity 0.65' do
+      c = described_class.new(band: :green, wavelength: 520, intensity: 0.65, content: 'x')
+      expect(c.intensity_label).to eq(:strong)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns a hash with all expected keys' do
+      h = component.to_h
+      expect(h.keys).to contain_exactly(:band, :wavelength, :intensity, :intensity_label, :content, :dominant, :faded)
+    end
+
+    it 'includes correct band' do
+      expect(component.to_h[:band]).to eq(:green)
+    end
+
+    it 'includes dominant flag' do
+      expect(component.to_h[:dominant]).to be(component.dominant?)
+    end
+
+    it 'includes faded flag' do
+      expect(component.to_h[:faded]).to be(component.faded?)
+    end
+
+    it 'includes intensity rounded to 10 decimal places' do
+      expect(component.to_h[:intensity]).to eq(0.75)
+    end
+  end
+end