seams 0.1.0

data/lib/generators/seams/notifications/templates/app/views/templates/billing/subscription_started.html.erb.tt

@@ -0,0 +1,4 @@
+<%%# Default billing/subscription_started HTML, fires from %>
+<%%# subscription.created.billing. Override at %>
+<%%# app/views/notifications/templates/billing/subscription_started.html.erb. %>
+<p>Your subscription is active. Welcome aboard.</p>

data/lib/generators/seams/notifications/templates/app/views/templates/billing/subscription_started.text.erb.tt

@@ -0,0 +1,5 @@
+<%%# Default billing/subscription_started template, used by BillingSubscriber %>
+<%%# when it consumes subscription.created.billing. Override by dropping a %>
+<%%# file at app/views/notifications/templates/billing/subscription_started.erb %>
+<%%# in your host. %>
+Your subscription is active. Welcome aboard.

data/lib/generators/seams/notifications/templates/app/views/templates/billing/subscription_updated.html.erb.tt

@@ -0,0 +1,3 @@
+<%%# Default billing/subscription_updated HTML. Override at %>
+<%%# app/views/notifications/templates/billing/subscription_updated.html.erb. %>
+<p>Your subscription has been updated.</p>

data/lib/generators/seams/notifications/templates/app/views/templates/billing/subscription_updated.text.erb.tt

@@ -0,0 +1,3 @@
+<%%# Default billing/subscription_updated template. Override at %>
+<%%# app/views/notifications/templates/billing/subscription_updated.erb. %>
+Your subscription has been updated.

data/lib/generators/seams/notifications/templates/app/views/templates/default.html.erb.tt

@@ -0,0 +1,10 @@
+<%%# Default HTML template. notification is the local. Override at %>
+<%%# app/views/notifications/templates/<name>.html.erb in the host. %>
+<p>Hello,</p>
+
+<p>You have a notification.</p>
+
+<p>—<br>
+This is the default Seams notification template. Override it by creating
+<code>app/views/notifications/templates/&lt;your-template&gt;.html.erb</code>
+in your host app.</p>

data/lib/generators/seams/notifications/templates/app/views/templates/default.text.erb.tt

@@ -0,0 +1,11 @@
+<%%# Default ERB template. The notification model exposes itself via %>
+<%%# the local variable +notification+. Override by dropping a file %>
+<%%# at app/views/notifications/templates/<name>.erb in your host. %>
+Hello,
+
+You have a notification.
+
+—
+This is the default Seams notification template. Override it by
+creating app/views/notifications/templates/<your-template>.erb in
+your host app.

data/lib/generators/seams/notifications/templates/app/views/templates/welcome.html.erb.tt

@@ -0,0 +1,6 @@
+<%%# Default welcome HTML template, used by AuthSubscriber when it %>
+<%%# consumes identity.signed_up.auth. Override by dropping a file at %>
+<%%# app/views/notifications/templates/welcome.html.erb in your host. %>
+<p>Welcome<%%= ", #{notification.owner.respond_to?(:name) ? notification.owner.name : ''}".rstrip %>!</p>
+
+<p>Thanks for signing up. Reply to this email if you need anything.</p>

data/lib/generators/seams/notifications/templates/app/views/templates/welcome.text.erb.tt

@@ -0,0 +1,6 @@
+<%%# Default welcome template, used by AuthSubscriber when it consumes %>
+<%%# identity.signed_up.auth. Override by dropping a file at %>
+<%%# app/views/notifications/templates/welcome.erb in your host. %>
+Welcome<%%= ", #{notification.owner.respond_to?(:name) ? notification.owner.name : ''}".rstrip %>!
+
+Thanks for signing up. Reply to this email if you need anything.

data/lib/generators/seams/notifications/templates/config/initializers/notifications.rb.tt

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+# Configuration for the Notifications engine.
+#
+# Adapters
+# --------
+# Email defaults to Notifications::Adapters::ActionMailer (delegates to
+# the engine's NotificationMailer). SMS defaults to a no-op NullSms
+# adapter that logs and drops. Swap either by assigning a class name
+# (a string — resolved via constantize at delivery time so the host
+# doesn't have to require the adapter at boot):
+#
+#   Notifications.configure do |config|
+#     config.email_adapter = "MyApp::MailgunAdapter"
+#     config.sms_adapter   = "MyApp::TwilioAdapter"
+#   end
+#
+# Optional: Notifiable concern
+# ----------------------------
+# Notifications work without the concern — every Notification has a
+# polymorphic `owner`, and `Notifications::Notification.create!(owner: anything, ...)`
+# is the always-supported path.
+#
+# The concern is OPTIONAL sugar: it adds a `notifications` has_many
+# association and a `#notify(strategy:, template:)` helper to whatever
+# class includes it. Pick one of the patterns below if you want that
+# convenience.
+#
+# Pattern A — wire onto Auth::Identity (canonical post-Wave-9 host):
+#
+#   Rails.application.config.to_prepare do
+#     Auth::Identity.include(Notifications::Notifiable)
+#   end
+#
+# Pattern B — wire onto a host User class (hosts that keep their own
+# domain User alongside Auth::Identity):
+#
+#   class User < ApplicationRecord
+#     include Notifications::Notifiable
+#   end
+#
+# Pattern C — don't include the concern at all. Use
+# `Notifications::Notification.create!(owner: ..., template: ...)` or
+# the per-strategy classes directly.
+#
+# Default subscriber
+# ------------------
+# Notifications::AuthSubscriber listens for `identity.signed_up.auth`
+# and creates an InApp + Email welcome notification owned by the
+# Auth::Identity. To redirect the welcome notification at a different
+# owner (an Account, a Membership, a host User), copy
+# `engines/notifications/app/subscribers/notifications/auth_subscriber.rb`
+# into your host's app/subscribers/, change `OWNER_CLASS_NAME` and the
+# resolution rule, then re-attach in this initializer:
+#
+#   Rails.application.config.to_prepare do
+#     Notifications::AuthSubscriber.attach!
+#   end

data/lib/generators/seams/notifications/templates/config/routes.rb.tt

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+Notifications::Engine.routes.draw do
+  resources :notifications, only: %i[index show] do
+    member do
+      patch :mark_as_read
+    end
+    collection do
+      patch :mark_all_as_read
+    end
+  end
+
+  resource :preferences, only: %i[show update]
+
+  # Follow-up generators that add admin-side notification routes (digest scheduling, channel-specific opt-outs) splice their resources here.
+  # seams:insertion-point notifications.routes.after_preferences
+end

data/lib/generators/seams/notifications/templates/db/migrate/create_notification_deliveries.rb.tt

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+# What: creates notification_deliveries — one row per successful send.
+# Why:  audit trail for support and ops ("when did we last send X to
+#       user Y?") without round-tripping the upstream gateway.
+# Risk: append-only writes from Notification#send!. Indexed by
+#       notification_id for join queries from the bell view.
+class CreateNotificationDeliveries < ActiveRecord::Migration[7.1]
+  def change
+    create_table :notification_deliveries do |t|
+      t.references :notification, null: false, foreign_key: true, index: true
+      t.datetime   :sent_at,      null: false
+      t.timestamps
+    end
+  end
+end

data/lib/generators/seams/notifications/templates/db/migrate/create_notification_preferences.rb.tt

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# What: creates notification_preferences for per-Identity opt-outs.
+# Why:  hosts need a place for "email me when X" toggles. Channel
+#       preferences live with the human (Auth::Identity), not with
+#       the polymorphic Notification owner — a host wiring
+#       notifications onto an Account or Membership still resolves
+#       toggles via the Identity behind the actor. Single row per
+#       (identity, channel, notification_type) — absence means
+#       use defaults.
+# Risk: tiny table, indexed for fast lookup.
+class CreateNotificationPreferences < ActiveRecord::Migration[7.1]
+  def change
+    create_table :notification_preferences do |t|
+      t.bigint  :identity_id,       null: false
+      t.string  :channel,           null: false  # "in_app" | "email" | "sms"
+      t.string  :notification_type
+      t.boolean :enabled,           null: false, default: true
+      t.timestamps
+    end
+
+    add_index :notification_preferences, %i[identity_id channel notification_type], unique: true,
+                                                                                     name: "index_notification_prefs_unique"
+  end
+end

data/lib/generators/seams/notifications/templates/db/migrate/create_notifications.rb.tt

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+# What: creates the notifications table for the STI Notification model.
+# Why:  every channel (in-app, email, SMS) shares the same scheduling +
+#       audit semantics. STI keeps that DRY: one table, one indexed
+#       next_delivery_at, three subclasses with their own dispatch!.
+# Risk: append + per-row updates (read_at flips, next_delivery_at
+#       advances). Indexed by (next_delivery_at) for the due sweeper
+#       and (owner) for the bell view.
+class CreateNotifications < ActiveRecord::Migration[7.1]
+  def change
+    create_table :notifications do |t|
+      t.string  :type,             null: false   # STI discriminator
+      # Polymorphic owner: can be Auth::Identity (bigint), an
+      # Accounts::Account (UUID post-Wave-9), or any other host model.
+      # `owner_id` is stored as a string so the column accommodates
+      # both PK types without needing two separate FKs. Rails handles
+      # the type coercion in the polymorphic association — the lookup
+      # uses `WHERE owner_type = ? AND owner_id = ?` and AR casts the
+      # parameter to text in the prepared statement.
+      t.string  :owner_type, null: false
+      t.string  :owner_id,   null: false
+      t.string  :recipient                       # destination address (override of owner default)
+      t.string  :template,         null: false
+      t.jsonb   :schedule_data                   # IceCube::Schedule#to_hash
+      t.datetime :next_delivery_at
+      t.datetime :read_at                        # InApp only
+      t.timestamps
+    end
+
+    add_index :notifications, %i[owner_type owner_id]
+    add_index :notifications, :next_delivery_at
+    add_index :notifications, %i[type next_delivery_at]
+  end
+end

data/lib/generators/seams/notifications/templates/lib/adapters/abstract.rb.tt

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Notifications
+  module Adapters
+    # Contract every notification adapter must implement. Subclass
+    # this in your host application to wire Mailgun, SendGrid, Twilio,
+    # etc., then point the relevant +Notifications.configuration+
+    # knob at the subclass name.
+    #
+    # Each adapter receives the full Notification object so it can
+    # read +recipient+, +template+, +rendered_content+, +owner+ —
+    # whatever the gateway needs. Returns a Hash that includes at
+    # least { ok: true|false, provider: <string> }.
+    class Abstract
+      def deliver(notification:)
+        raise NotImplementedError, "#{self.class} must implement #deliver"
+      end
+    end
+  end
+end

data/lib/generators/seams/notifications/templates/lib/adapters/action_mailer.rb.tt

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "notifications/adapters/abstract"
+
+module Notifications
+  module Adapters
+    # Default email adapter — delegates to the engine's
+    # NotificationMailer which renders the notification's template
+    # and dispatches via ActionMailer.
+    class ActionMailer < Abstract
+      def deliver(notification:)
+        Notifications::NotificationMailer.notify(notification).deliver_later
+        { ok: true, provider: "action_mailer" }
+      end
+    end
+  end
+end

data/lib/generators/seams/notifications/templates/lib/adapters/null_sms.rb.tt

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "notifications/adapters/abstract"
+
+module Notifications
+  module Adapters
+    # No-op SMS adapter. Logs the delivery via Seams::Observability
+    # and returns success without dispatching. Useful in development
+    # and tests so SMS calls succeed without burning vendor quota.
+    class NullSms < Abstract
+      def deliver(notification:)
+        Seams::Observability.adapter.info(
+          "notifications.null_sms.deliver",
+          engine: "notifications",
+          to: notification.recipient,
+          template: notification.template,
+          length: notification.rendered_content.to_s.length
+        )
+        { ok: true, provider: "null_sms" }
+      end
+    end
+  end
+end

data/lib/generators/seams/notifications/templates/lib/concerns/notifiable.rb.tt

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module Notifications
+  # OPTIONAL convenience concern. Adds a +notifications+ has_many
+  # association + a +#notify+ helper to whatever model includes it.
+  # Notifications themselves are polymorphic — every Notification has
+  # an +owner+, which can be ANY ActiveRecord model. You don't need
+  # this concern to attach notifications to a model:
+  #
+  #   Notifications::Notification.create!(owner: anything, template: ...)
+  #
+  # The concern is just sugar for the receiving side.
+  #
+  # Three include patterns hosts can pick from:
+  #
+  # 1. Wire into Auth::Identity (most common for canonical seams hosts
+  #    after Wave 9 — the "human" is Auth::Identity, not a host User):
+  #
+  #    # config/initializers/notifications.rb
+  #    Rails.application.config.to_prepare do
+  #      Auth::Identity.include(Notifications::Notifiable)
+  #    end
+  #
+  # 2. Wire into a host-defined User class (older hosts that still
+  #    keep their own User model alongside Auth::Identity):
+  #
+  #    class User < ApplicationRecord
+  #      include Notifications::Notifiable
+  #    end
+  #
+  # 3. Don't include the concern at all. Create notifications via
+  #    +Notifications::Notification.create!(owner: ..., template: ...)+
+  #    or the per-strategy classes directly. The polymorphic +owner+
+  #    column doesn't care.
+  #
+  # Once included:
+  #
+  #   target.notify(strategy: :email,  template: "welcome")
+  #   target.notify(strategy: :sms,    template: "alert", schedule_config: { starts_at: 1.day.from_now, frequency: "once" })
+  #   target.notify(strategy: :in_app, template: "system")
+  module Notifiable
+    extend ActiveSupport::Concern
+
+    STRATEGY_CLASSES = {
+<%- if channels.include?("email") -%>
+      email:  "Notifications::Strategies::Email",
+<%- end -%>
+<%- if channels.include?("sms") -%>
+      sms:    "Notifications::Strategies::Sms",
+<%- end -%>
+<%- if channels.include?("in_app") -%>
+      in_app: "Notifications::Strategies::InApp",
+<%- end -%>
+      # Follow-up generators that ship new delivery strategies (push, webhook, slack) splice their `key: "Notifications::Strategies::ClassName",` entry here. Trailing commas on every entry keep the hash valid both before and after a splice.
+      # seams:insertion-point notifications.notifiable.strategies
+    }.freeze
+
+    included do
+      has_many :notifications, class_name: "Notifications::Notification",
+                               as: :owner, dependent: :destroy
+    end
+
+    def notify(strategy:, template:, schedule_config: nil, recipient: nil)
+      notif = notifications.build(
+        type:      STRATEGY_CLASSES.fetch(strategy.to_sym),
+        recipient: recipient,
+        template:  template
+      )
+      assign_schedule!(notif, schedule_config)
+      notif.save!
+      notif.send_async if notif.due?
+      notif
+    end
+
+    # Looks up a registered Notifications::TypeRegistry::Type by name
+    # and creates one Notification per channel the type supports
+    # (subject to the host's NotificationPreference rows). Returns the
+    # array of created notifications.
+    #
+    # Preference lookup keys off `identity_id` — if the including
+    # model is an Auth::Identity, that's just `id`. Hosts that include
+    # the concern on a non-Identity model (a host User keyed by a
+    # different identity_id, an Account, etc.) should override
+    # `notification_preference_identity_id` to return the right id.
+    def notify_typed(type:, schedule_config: nil, recipient: nil)
+      record = Notifications::TypeRegistry.fetch(type)
+      preference_id = notification_preference_identity_id
+      record.channels.filter_map do |channel|
+        next unless STRATEGY_CLASSES.key?(channel.to_sym)
+        next unless Notifications::NotificationPreference.enabled?(
+          identity_id: preference_id, channel: channel.to_s, notification_type: record.name
+        )
+
+        notify(strategy: channel, template: record.template,
+               schedule_config: schedule_config, recipient: recipient)
+      end
+    end
+
+    # Override on a non-Identity host class to point preference lookup
+    # at the right identity_id. Default: the receiver's own id (works
+    # when Notifiable is included on Auth::Identity directly).
+    def notification_preference_identity_id
+      id
+    end
+
+    # Override per-host if the receiver exposes its email address under
+    # a different name (e.g. a host User that keeps `primary_email_id`).
+    # Default falls back to `email_address` (the Rails 8 has_secure_password
+    # convention some hosts keep) and then `email` (Auth::Identity + most
+    # host User models).
+    def email_notification_recipient
+      try(:email_address) || try(:email)
+    end
+
+    def sms_notification_recipient
+      try(:phone)
+    end
+
+    def unread_in_app_notifications
+      notifications.where(type: "Notifications::Strategies::InApp").unread
+    end
+
+    private
+
+    def assign_schedule!(notif, schedule_config)
+      if schedule_config
+        notif.schedule_config = schedule_config
+      else
+        notif.schedule = IceCube::Schedule.new(Time.current)
+      end
+    end
+  end
+end

data/lib/generators/seams/notifications/templates/lib/configuration.rb.tt

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Notifications
+  # Engine-scoped configuration. Override in
+  # config/initializers/notifications.rb of the host application:
+  #
+  #   Notifications.configure do |c|
+  #     c.email_adapter = "Notifications::Adapters::Mailgun"
+  #     c.sms_adapter   = "Notifications::Adapters::Twilio"
+  #   end
+  class Configuration
+    attr_accessor :email_adapter, :sms_adapter, :default_from
+    # Follow-up generators that add knobs (push adapter, webhook adapter, in-app retention) declare their attr_accessor here.
+    # seams:insertion-point notifications.configuration.attributes
+
+    def initialize
+      @email_adapter = "Notifications::Adapters::ActionMailer"
+      @sms_adapter   = "Notifications::Adapters::NullSms"
+      @default_from  = "no-reply@example.com"
+      # Follow-up generators that add defaults for new attributes (matching notifications.configuration.attributes) splice them here.
+      # seams:insertion-point notifications.configuration.defaults
+    end
+  end
+end

data/lib/generators/seams/notifications/templates/lib/engine.rb.tt

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Notifications
+  class Engine < ::Rails::Engine
+    isolate_namespace Notifications
+
+    config.generators do |g|
+      g.test_framework :rspec
+    end
+
+    initializer "notifications.register_events" do
+      Seams::EventRegistry.register("notification.queued.notifications",     emitted_by: "Notifications")
+      Seams::EventRegistry.register("notification.delivered.notifications",  emitted_by: "Notifications")
+      Seams::EventRegistry.register("notification.failed.notifications",     emitted_by: "Notifications")
+      # Follow-up generators that ship new delivery semantics (notification.bounced.notifications, etc.) register them here.
+      # seams:insertion-point notifications.engine.events
+    end
+
+    initializer "notifications.append_migrations" do |app|
+      unless app.root == root
+        config.paths["db/migrate"].expanded.each do |expanded_path|
+          app.config.paths["db/migrate"] << expanded_path
+        end
+      end
+    end
+
+    config.after_initialize do
+      require "notifications/concerns/notifiable"
+      Notifications::AuthSubscriber.attach!
+      # Follow-up generators that ship subscribers for new cross-engine events (Notifications::TeamsSubscriber, etc.) splice their attach! calls here.
+      # seams:insertion-point notifications.engine.subscribers
+      Notifications::BillingSubscriber.attach! if defined?(Billing::Engine)
+    end
+  end
+end

data/lib/generators/seams/notifications/templates/lib/notifications.rb.tt

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "notifications/version"
+require "notifications/configuration"
+require "notifications/type_registry"
+require "notifications/engine"
+require "notifications/concerns/notifiable"
+require "notifications/adapters/abstract"
+require "notifications/adapters/action_mailer"
+require "notifications/adapters/null_sms"
+
+module Notifications
+  class Error          < StandardError; end
+  class AdapterError   < Error; end
+
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield configuration
+    end
+
+    # Seed the TypeRegistry with the default cross-engine notification
+    # types other engines emit (auth.signed_up, billing.invoice_paid,
+    # etc). Hosts call this from their initializer; subsequent
+    # +TypeRegistry.register+ calls override the defaults or extend the
+    # set with host-specific types.
+    def seed_default_types!
+      TypeRegistry.register("welcome",
+                            template: "welcome",
+                            channels: %i[in_app email],
+                            display:  "Welcome")
+      TypeRegistry.register("billing.invoice_paid",
+                            template: "billing/invoice_paid",
+                            channels: %i[in_app email],
+                            display:  "Invoice paid")
+      TypeRegistry.register("billing.invoice_failed",
+                            template: "billing/invoice_failed",
+                            channels: %i[in_app email],
+                            display:  "Invoice payment failed")
+      TypeRegistry.register("billing.subscription_started",
+                            template: "billing/subscription_started",
+                            channels: %i[in_app email],
+                            display:  "Subscription started")
+      TypeRegistry.register("billing.subscription_canceled",
+                            template: "billing/subscription_canceled",
+                            channels: %i[in_app email],
+                            display:  "Subscription canceled")
+      TypeRegistry.register("billing.lifetime_purchased",
+                            template: "billing/lifetime_purchased",
+                            channels: %i[in_app email],
+                            display:  "Lifetime access purchased")
+      # Follow-up generators that ship new cross-engine notification types (teams.invitation_received, auth.password_reset) splice their TypeRegistry.register(...) call here.
+      # seams:insertion-point notifications.type_registry.defaults
+    end
+
+    def email_adapter
+      configuration.email_adapter.constantize.new
+    rescue NameError => e
+      raise Notifications::AdapterError,
+            "Notifications.configuration.email_adapter is set to " \
+            "#{configuration.email_adapter.inspect}, which could not be resolved: #{e.message}"
+    end
+
+    def sms_adapter
+      configuration.sms_adapter.constantize.new
+    rescue NameError => e
+      raise Notifications::AdapterError,
+            "Notifications.configuration.sms_adapter is set to " \
+            "#{configuration.sms_adapter.inspect}, which could not be resolved: #{e.message}"
+    end
+  end
+end

data/lib/generators/seams/notifications/templates/lib/type_registry.rb.tt

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Notifications
+  # Registry of typed notification semantics — distinct from the STI
+  # strategy classes (InApp / Email / Sms), which are *delivery
+  # channels*, not *what the notification is about*.
+  #
+  # A NotificationType pairs a stable name (e.g. "billing.invoice_paid")
+  # with a template path, the channels it can fan out to, and a human
+  # display name. Hosts register types up front in an initializer so
+  # the host has a closed-set list to power preference UIs and audit
+  # queries.
+  #
+  #   # config/initializers/notifications.rb
+  #   Notifications::TypeRegistry.register("billing.invoice_paid",
+  #                                        template: "billing/invoice_paid",
+  #                                        channels: %i[in_app email],
+  #                                        display: "Invoice paid")
+  #
+  #   user.notify_typed(type: "billing.invoice_paid")
+  #
+  # The engine seeds a small default set on boot (see
+  # +Notifications.seed_default_types!+); hosts override or extend
+  # in their initializer.
+  module TypeRegistry
+    Type = Struct.new(:name, :template, :channels, :display, keyword_init: true) do
+      def supports_channel?(channel)
+        channels.map(&:to_sym).include?(channel.to_sym)
+      end
+
+      def to_s
+        name
+      end
+    end
+
+    UnknownType = Class.new(StandardError)
+
+    @types = {}
+    @mutex = Mutex.new
+
+    module_function
+
+    def register(name, template:, channels:, display: nil)
+      @mutex.synchronize do
+        @types[name.to_s] = Type.new(
+          name:     name.to_s,
+          template: template.to_s,
+          channels: Array(channels).map(&:to_sym),
+          display:  display || name.to_s.tr("._", " ").capitalize
+        )
+      end
+    end
+
+    def find(name)
+      @types[name.to_s]
+    end
+
+    def fetch(name)
+      find(name) || raise(UnknownType, "no notification type registered as #{name.inspect}")
+    end
+
+    def all
+      @types.values
+    end
+
+    def names
+      @types.keys
+    end
+
+    def reset!
+      @mutex.synchronize { @types = {} }
+    end
+  end
+end