seams 0.1.0

data/lib/generators/seams/notifications/templates/app/models/notification.rb.tt

@@ -0,0 +1,218 @@
+# frozen_string_literal: true
+
+module Notifications
+  # Represents a scheduled notification belonging to an +owner+.
+  #
+  # Concrete delivery types are STI subclasses under
+  # +Notifications::Strategies+ — +InApp+, +Email+, +Sms+ — each
+  # implementing its own +#dispatch!+. They share this base's schema,
+  # scheduling, and audit logic.
+  #
+  # Scheduling is delegated to ice_cube. The schedule is persisted as
+  # a json hash via +schedule_data+ and exposed through
+  # +schedule+/+schedule=+. +next_delivery_at+ is an indexed cache so
+  # the recurring sweeper hits one query.
+  class Notification < ApplicationRecord
+    self.table_name = "notifications"
+
+    belongs_to :owner, polymorphic: true
+    has_many   :deliveries, class_name: "Notifications::Delivery",
+                            dependent: :destroy, inverse_of: :notification
+
+    # Concrete STI subclasses permitted for creation. Anything else
+    # fails validation rather than booting an unknown subclass.
+    PERMITTED_TYPES = [
+      "Notifications::Strategies::InApp",
+      "Notifications::Strategies::Email",
+      "Notifications::Strategies::Sms"
+    ].freeze
+
+    FREQUENCIES = %w[once daily weekly monthly].freeze
+
+    # Templates resolve to file reads via ERB. Lock the value down so a
+    # row can't reach outside the templates dir or evaluate arbitrary
+    # files. Allowed: lowercase letters, digits, underscores, dashes,
+    # forward slashes (so subdirs like "billing/invoice_paid" work).
+    # No leading slash, no `..`, no consecutive slashes.
+    TEMPLATE_NAME_PATTERN = %r{\A[a-z0-9_\-]+(?:/[a-z0-9_\-]+)*\z}
+
+    validates :type,     inclusion: { in: PERMITTED_TYPES }
+    validates :template, presence: true,
+                         format: { with: TEMPLATE_NAME_PATTERN, message: "must be a slash-separated lowercase identifier" }
+
+    scope :due,        -> { where(next_delivery_at: ..Time.current) }
+    scope :pending,    -> { where.not(next_delivery_at: nil) }
+    scope :completed,  -> { where(next_delivery_at: nil) }
+    scope :unread,     -> { where(read_at: nil) }
+    scope :recent,     -> { order(created_at: :desc) }
+
+    # Accept short type names ("Email", "Sms", "InApp") in API params
+    # and normalise to fully-qualified class names. Falls back to the
+    # base class so the inclusion validation returns 422 instead of
+    # raising a 500.
+    def self.find_sti_class(type_name)
+      super(expand_type(type_name))
+    rescue ::ActiveRecord::SubclassNotFound
+      self
+    end
+
+    def self.expand_type(type_name)
+      PERMITTED_TYPES.find { |t| t.demodulize == type_name } || type_name
+    end
+
+    def type=(value)
+      super(self.class.expand_type(value.to_s))
+    end
+
+    # Deserialises +schedule_data+ into an IceCube::Schedule instance.
+    def schedule
+      return nil if schedule_data.blank?
+
+      IceCube::Schedule.from_hash(schedule_data)
+    end
+
+    # Assigns an IceCube::Schedule, persisting it as json and setting
+    # +next_delivery_at+ to the schedule's first occurrence.
+    def schedule=(sched)
+      self.schedule_data    = sched&.to_hash
+      self.next_delivery_at = sched&.first
+    end
+
+    # Form-friendly schedule constructor. Accepts:
+    #   { starts_at:, frequency: once|daily|weekly|monthly,
+    #     interval: 1, count: 5, until: "2026-12-31" }
+    # so host code never has to import ice_cube.
+    def schedule_config=(config)
+      return if config.blank?
+
+      sched = IceCube::Schedule.new(Time.zone.parse(config[:starts_at].to_s))
+      rule  = build_recurrence_rule(config)
+      sched.add_recurrence_rule(rule) if rule
+      self.schedule = sched
+    end
+
+    # Renders the ERB template named by +template+ in the requested
+    # +format+ (`:text` (default) or `:html`). Looks first in the host's
+    # app/views/notifications/templates/<name>.<format>.erb, then falls
+    # back to the engine's bundled templates. Hosts override by
+    # dropping a file. Raises Notifications::Error if no template
+    # exists at the requested format — callers that want to probe
+    # without raising should use #template_exists?(format:).
+    def rendered_content(format: :text)
+      path = find_template_path(format: format) ||
+             raise(Notifications::Error,
+                   "Template #{template.inspect} (#{format}) not found under any allowed root")
+
+      ERB.new(File.read(path)).result_with_hash(notification: self)
+    end
+
+    def template_exists?(format: :text)
+      !find_template_path(format: format).nil?
+    end
+
+    def due?
+      next_delivery_at.present? && next_delivery_at <= Time.current
+    end
+
+    def read?
+      read_at.present?
+    end
+
+    def mark_as_read!
+      update!(read_at: Time.current) unless read?
+    end
+
+    def send_async
+      Notifications::SendNotificationJob.perform_later(id)
+    end
+
+    # Synchronous delivery. Publishes lifecycle events OUTSIDE the
+    # transaction so subscribers don't run inside the AR transaction
+    # (a slow subscriber would hold table locks; a raise would roll
+    # back the delivery write).
+    # No-ops if not yet due (defensive against duplicate enqueue).
+    def send!
+      return unless due?
+
+      Seams::Events::Publisher.publish(
+        "notification.queued.notifications",
+        id: id, type: type, owner_type: owner_type, owner_id: owner_id
+      )
+
+      dispatch!
+      self.class.transaction do
+        deliveries.create!(sent_at: Time.current)
+        advance!
+      end
+
+      Seams::Events::Publisher.publish(
+        "notification.delivered.notifications",
+        id: id, type: type, owner_type: owner_type, owner_id: owner_id
+      )
+    rescue StandardError => e
+      Seams::Events::Publisher.publish(
+        "notification.failed.notifications", id: id, type: type, error: "#{e.class}: #{e.message}"
+      )
+      raise
+    end
+
+    # Advances +next_delivery_at+ to the next ice_cube occurrence
+    # after now. nil when no further occurrences exist (one-shots
+    # become "completed").
+    def advance!
+      update!(next_delivery_at: schedule&.next_occurrence)
+    end
+
+    FREQUENCY_BUILDERS = {
+      "daily"   => ->(interval) { IceCube::Rule.daily(interval) },
+      "weekly"  => ->(interval) { IceCube::Rule.weekly(interval) },
+      "monthly" => ->(interval) { IceCube::Rule.monthly(interval) }
+    }.freeze
+    private_constant :FREQUENCY_BUILDERS
+
+    private
+
+    def build_recurrence_rule(config)
+      builder = FREQUENCY_BUILDERS[config[:frequency].to_s]
+      return unless builder
+
+      interval = [config[:interval].to_i, 1].max
+      apply_rule_constraints(builder.call(interval), config)
+    end
+
+    def apply_rule_constraints(rule, config)
+      rule = rule.count(config[:count].to_i)                  if config[:count].present?
+      rule = rule.until(Time.zone.parse(config[:until].to_s)) if config[:until].present?
+      rule
+    end
+
+    # Each strategy implements its own dispatch.
+    def dispatch!
+      raise NotImplementedError, "#{self.class} must implement #dispatch!"
+    end
+
+    PERMITTED_FORMATS = %i[text html].freeze
+
+    def find_template_path(format: :text)
+      raise ArgumentError, "format must be :text or :html" unless PERMITTED_FORMATS.include?(format)
+
+      # Realpath check — even though TEMPLATE_NAME_PATTERN already
+      # rejects "..", a defence-in-depth `realpath` confirms the
+      # resolved file lives under one of the two whitelisted roots.
+      host_root   = Rails.root.join("app/views/notifications/templates")
+      engine_root = Notifications::Engine.root.join("app/views/notifications/templates")
+
+      [host_root, engine_root].each do |root|
+        candidate = root.join("#{template}.#{format}.erb")
+        next unless candidate.exist?
+
+        resolved = candidate.realpath
+        return resolved if resolved.to_s.start_with?(root.realpath.to_s)
+      end
+
+      # No template at this format. Caller decides whether to fall back
+      # (e.g. mailer trying :html then :text) or raise.
+      nil
+    end
+  end
+end

data/lib/generators/seams/notifications/templates/app/models/notification_preference.rb.tt

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Notifications
+  # Per-Identity channel + notification-type toggle. Absence of a row
+  # means "use defaults" (everything enabled). Presence with
+  # enabled: false means the Identity opted out.
+  #
+  # Keyed by `identity_id` (not the polymorphic Notification owner):
+  # channel preferences belong with the human, not with whatever
+  # other model a Notification happens to be addressed at (an
+  # Account, a Membership, a host-defined model).
+  class NotificationPreference < ApplicationRecord
+    self.table_name = "notification_preferences"
+
+    # Mirrors the keys of Notifications::Notifiable::STRATEGY_CLASSES
+    # but kept as plain strings here because the column stores strings.
+    CHANNELS = %w[in_app email sms].freeze
+
+    validates :identity_id, :channel, presence: true
+    validates :channel, inclusion: { in: CHANNELS }
+    validates :identity_id, uniqueness: { scope: %i[channel notification_type] }
+
+    def self.enabled?(identity_id:, channel:, notification_type: nil)
+      pref = find_by(identity_id: identity_id, channel: channel, notification_type: notification_type) ||
+             find_by(identity_id: identity_id, channel: channel, notification_type: nil)
+      pref ? pref.enabled : true
+    end
+  end
+end

data/lib/generators/seams/notifications/templates/app/models/strategies/email.rb.tt

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Notifications
+  module Strategies
+    # Email notification. +#dispatch!+ delegates to the configured
+    # email adapter, which ultimately renders the +template+ ERB
+    # against the owner and posts to the gateway (ActionMailer by
+    # default; swap with +Notifications.configuration.email_adapter+).
+    #
+    # The polymorphic +owner+ supplies the recipient address. We try
+    # +#email_address+ first (Rails 8's `has_secure_password` convention,
+    # used by some host User models), then +#email+ (Auth::Identity and
+    # most host User models). If the owner includes
+    # +Notifications::Notifiable+, +#email_notification_recipient+ wins.
+    # Hosts whose owner exposes a different attribute should override
+    # +#recipient+ on the strategy or set +recipient+ explicitly when
+    # creating the Notification.
+    class Email < Notification
+      def recipient
+        super.presence || resolve_email_from_owner
+      end
+
+      private
+
+      def dispatch!
+        Notifications.email_adapter.deliver(notification: self)
+      end
+
+      def resolve_email_from_owner
+        return nil unless owner
+
+        owner.try(:email_notification_recipient) ||
+          owner.try(:email_address) ||
+          owner.try(:email)
+      end
+    end
+  end
+end

data/lib/generators/seams/notifications/templates/app/models/strategies/in_app.rb.tt

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Notifications
+  module Strategies
+    # In-app notification. The +Notification+ row IS the delivery —
+    # the bell view renders pending rows for the recipient and
+    # +#mark_as_read!+ flips +read_at+. +#dispatch!+ broadcasts on
+    # the per-recipient ActionCable channel so connected clients
+    # update without polling. No-op when ActionCable isn't booted.
+    class InApp < Notification
+      def recipient
+        super.presence || owner&.id&.to_s
+      end
+
+      private
+
+      def dispatch!
+        return unless defined?(Notifications::NotificationChannel) && defined?(::ActionCable)
+
+        Notifications::NotificationChannel.broadcast_to(
+          owner, id: id, template: template, body: rendered_content
+        )
+      end
+    end
+  end
+end

data/lib/generators/seams/notifications/templates/app/models/strategies/sms.rb.tt

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Notifications
+  module Strategies
+    # SMS notification. +#dispatch!+ delegates to the configured SMS
+    # adapter (NullSms by default — logs and drops; swap with
+    # +Notifications.configuration.sms_adapter+).
+    #
+    # The polymorphic +owner+ supplies the recipient phone number.
+    # If the owner includes +Notifications::Notifiable+,
+    # +#sms_notification_recipient+ wins; otherwise we fall back to
+    # +#phone+. Hosts whose owner exposes a different attribute
+    # should override +#recipient+ on the strategy or set +recipient+
+    # explicitly when creating the Notification.
+    class Sms < Notification
+      def recipient
+        super.presence || resolve_phone_from_owner
+      end
+
+      private
+
+      def dispatch!
+        Notifications.sms_adapter.deliver(notification: self)
+      end
+
+      def resolve_phone_from_owner
+        return nil unless owner
+
+        owner.try(:sms_notification_recipient) || owner.try(:phone)
+      end
+    end
+  end
+end

data/lib/generators/seams/notifications/templates/app/subscribers/auth_subscriber.rb.tt

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Notifications
+  # Consumes Auth events. On +identity.signed_up.auth+:
+  #   1. Resolves the recipient by `payload[:identity_id]`. The owner
+  #      of the welcome notification is the Auth::Identity itself
+  #      (the human who just signed up).
+  #   2. Enqueues Notifications::CreateNotificationJob — which creates
+  #      InApp + (preferences-permitting) Email rows out-of-band.
+  #
+  # Notifications are NEVER created inline inside the publisher's
+  # thread (see Seams::Events::Publisher docstring); the job is the
+  # boundary.
+  #
+  # Hosts that want a different owner (an Account, a Membership, or
+  # a host-defined User) should override this subscriber — copy this
+  # file into their host engine, change `OWNER_CLASS_NAME` and the
+  # resolution rule, and re-attach. The Notification table accepts
+  # any polymorphic owner; the choice is purely about which model
+  # the welcome notification "belongs to" in the bell partial / index.
+  #
+  # +.attach!+ is idempotent across Rails autoreload via
+  # +Seams::Events::Publisher.attach_class+ — registering the class by
+  # NAME (a String) rather than capturing a closure means each dispatch
+  # re-resolves the constant, so edits to +handle_signed_up+ are picked
+  # up without a server restart.
+  class AuthSubscriber
+    SUBSCRIBER_KEY = :notifications_auth_subscriber
+    OWNER_CLASS_NAME = "Auth::Identity"
+
+    class << self
+      def attach!
+        Seams::Events::Publisher.attach_class(
+          SUBSCRIBER_KEY,
+          "identity.signed_up.auth",
+          class_name:  "Notifications::AuthSubscriber",
+          method_name: :handle_signed_up
+        )
+      end
+
+      private
+
+      def handle_signed_up(payload)
+        identity_id = payload[:identity_id]
+        return unless identity_id
+
+        Notifications::CreateNotificationJob.perform_later(
+          owner_class: OWNER_CLASS_NAME,
+          owner_id:    identity_id,
+          template:    "welcome",
+          strategy:    "in_app"
+        )
+
+        return unless email_enabled?(identity_id)
+
+        Notifications::CreateNotificationJob.perform_later(
+          owner_class: OWNER_CLASS_NAME,
+          owner_id:    identity_id,
+          template:    "welcome",
+          strategy:    "email"
+        )
+      end
+
+      def email_enabled?(identity_id)
+        Notifications::NotificationPreference.enabled?(
+          identity_id: identity_id, channel: "email", notification_type: "welcome"
+        )
+      end
+    end
+  end
+end

data/lib/generators/seams/notifications/templates/app/subscribers/billing_subscriber.rb.tt

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module Notifications
+  # Consumes Billing events and enqueues a Notifications::CreateNotificationJob
+  # (which creates the InApp Notification out-of-band — never inline,
+  # see Seams::Events::Publisher docstring).
+  #
+  # Every subscribed event publishes the same canonical Wave-9 payload
+  # shape:
+  #   { gateway:, livemode:, account_id:, customer_ref:, ref:, object_id:, object: }
+  #
+  # `account_id` is the UUID of the Accounts::Account (the billing
+  # tenant) the event belongs to. Notifications attaches the resulting
+  # Notification row to that Account directly — the recipient model is
+  # whatever class the host configured as the billing tenant
+  # (`Billing.configuration.billable_class`, default
+  # "Accounts::Account"). One human Identity may belong to many
+  # Accounts; per-Account billing notifications belong with the tenant,
+  # not with the human.
+  #
+  # +.attach!+ is idempotent across Rails autoreload via
+  # +Seams::Events::Publisher.attach_class+ — each event registers its
+  # subscriber by class NAME (a String), so dispatch re-resolves the
+  # constant on every call. Edits to a +handle_*+ method take effect
+  # without a server restart.
+  class BillingSubscriber
+    SUBSCRIBER_KEY = :notifications_billing_subscriber
+    SUBSCRIBER_CLASS_NAME = "Notifications::BillingSubscriber"
+
+    # (event_name => [handler_method, template]). Handler methods are
+    # one-line wrappers around #enqueue — kept separate (rather than a
+    # single block-capturing handler) so each registration goes through
+    # +attach_class+ and survives Rails autoreload.
+    EVENT_HANDLERS = {
+      "subscription.created.billing"  => [:handle_subscription_created,  "billing/subscription_started"],
+      "subscription.updated.billing"  => [:handle_subscription_updated,  "billing/subscription_updated"],
+      "subscription.canceled.billing" => [:handle_subscription_canceled, "billing/subscription_canceled"],
+      "invoice.paid.billing"          => [:handle_invoice_paid,          "billing/invoice_paid"],
+      "invoice.failed.billing"        => [:handle_invoice_failed,        "billing/invoice_failed"],
+      # Lifetime Deal events (issue #2 section 3A.LTD)
+      "lifetime.granted.billing"      => [:handle_lifetime_granted,      "billing/lifetime_granted"],
+      "lifetime.purchased.billing"    => [:handle_lifetime_purchased,    "billing/lifetime_purchased"]
+    }.freeze
+
+    class << self
+      def attach!
+        EVENT_HANDLERS.each do |event, (method_name, _template)|
+          Seams::Events::Publisher.attach_class(
+            SUBSCRIBER_KEY,
+            event,
+            class_name:  SUBSCRIBER_CLASS_NAME,
+            method_name: method_name
+          )
+        end
+      end
+
+      # Owner class the billing subscriber attaches the Notification row
+      # to. Reads from `Billing.configuration.billable_class` so hosts
+      # with a custom tenant model (a host-defined `Workspace`, etc.) get
+      # the right `owner_type` without overriding this subscriber. Falls
+      # back to the canonical `"Accounts::Account"` if billing isn't
+      # configured.
+      def owner_class_name
+        return "Accounts::Account" unless defined?(Billing) && Billing.respond_to?(:configuration)
+
+        Billing.configuration.billable_class.to_s.presence || "Accounts::Account"
+      end
+
+      private
+
+      def handle_subscription_created(payload)
+        enqueue(payload, EVENT_HANDLERS.fetch("subscription.created.billing").last)
+      end
+
+      def handle_subscription_updated(payload)
+        enqueue(payload, EVENT_HANDLERS.fetch("subscription.updated.billing").last)
+      end
+
+      def handle_subscription_canceled(payload)
+        enqueue(payload, EVENT_HANDLERS.fetch("subscription.canceled.billing").last)
+      end
+
+      def handle_invoice_paid(payload)
+        enqueue(payload, EVENT_HANDLERS.fetch("invoice.paid.billing").last)
+      end
+
+      def handle_invoice_failed(payload)
+        enqueue(payload, EVENT_HANDLERS.fetch("invoice.failed.billing").last)
+      end
+
+      def handle_lifetime_granted(payload)
+        enqueue(payload, EVENT_HANDLERS.fetch("lifetime.granted.billing").last)
+      end
+
+      def handle_lifetime_purchased(payload)
+        enqueue(payload, EVENT_HANDLERS.fetch("lifetime.purchased.billing").last)
+      end
+
+      # Wave 9: every canonical billing payload carries `account_id:`
+      # (the UUID of the Accounts::Account that owns the billing row)
+      # right next to `customer_ref:`. We address the notification at
+      # the tenant directly — no host-User lookup needed.
+      def enqueue(payload, template)
+        account_id = payload[:account_id]
+        if account_id.nil? || account_id.to_s.empty?
+          # Visible signal — a silent miss here looks identical to "no
+          # recipient matched", which makes "billing notifications never
+          # fire" hard to debug. Log loudly once per call.
+          Seams::Observability.adapter.warn(
+            "notifications.billing_subscriber.skip",
+            engine: "notifications",
+            reason: "billing event missing account_id",
+            customer_ref: payload[:customer_ref]
+          )
+          return
+        end
+
+        Notifications::CreateNotificationJob.perform_later(
+          owner_class: owner_class_name,
+          owner_id:    account_id,
+          template:    template,
+          strategy:    "in_app"
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <meta http-equiv="X-UA-Compatible" content="IE=edge">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <title><%%= @notification&.template.to_s.titleize %></title>
+    <style>
+      body  { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; color: #222; line-height: 1.5; max-width: 560px; margin: 24px auto; padding: 0 16px; }
+      p     { margin: 0 0 12px; }
+      .meta { color: #888; font-size: 12px; border-top: 1px solid #eee; padding-top: 12px; margin-top: 24px; }
+      a     { color: #1a73e8; }
+    </style>
+  </head>
+  <body>
+    <%%= yield %>
+
+    <p class="meta">
+      Sent via Seams Notifications.
+    </p>
+  </body>
+</html>

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

@@ -0,0 +1,4 @@
+<%%= yield %>
+
+---
+Sent via Seams Notifications.

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

@@ -0,0 +1,15 @@
+<%%# Notification bell partial. Render in the host layout: %>
+<%%#   <%%= render "notifications/bell", recipient: current_user %> %>
+<%%
+  count = recipient&.notifications&.where(type: "Notifications::Strategies::InApp")&.unread&.count || 0
+%>
+
+<a href="<%%= notifications.notifications_path %>"
+   class="notifications-bell"
+   data-controller="notification-bell"
+   data-notification-bell-count-value="<%%= count %>">
+  <span class="notifications-bell-icon">🔔</span>
+  <%% if count.positive? %>
+    <span class="notifications-bell-count" data-notification-bell-target="count"><%%= count %></span>
+  <%% end %>
+</a>

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

@@ -0,0 +1,15 @@
+<h1>Notifications</h1>
+
+<%% if @notifications.unread.exists? %>
+  <%%= button_to "Mark all as read", mark_all_as_read_notifications_path, method: :patch %>
+<%% end %>
+
+<ul>
+  <%% @notifications.each do |n| %>
+    <li class="<%%= 'unread' unless n.read? %>">
+      <strong><%%= n.template.to_s.titleize %></strong>
+      <p><%%= n.rendered_content %></p>
+      <%%= time_tag n.created_at %>
+    </li>
+  <%% end %>
+</ul>

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

@@ -0,0 +1,4 @@
+<%%# Default billing/invoice_failed HTML. Override at %>
+<%%# app/views/notifications/templates/billing/invoice_failed.html.erb. %>
+<p>We couldn't process your latest invoice. Please update your payment method
+to avoid an interruption in service.</p>

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

@@ -0,0 +1,4 @@
+<%%# Default billing/invoice_failed template. Override at %>
+<%%# app/views/notifications/templates/billing/invoice_failed.erb. %>
+We couldn't process your latest invoice. Please update your payment method
+to avoid an interruption in service.

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

@@ -0,0 +1,3 @@
+<%%# Default billing/invoice_paid HTML. Override at %>
+<%%# app/views/notifications/templates/billing/invoice_paid.html.erb. %>
+<p>Your invoice has been paid. Thank you.</p>

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

@@ -0,0 +1,3 @@
+<%%# Default billing/invoice_paid template. Override at %>
+<%%# app/views/notifications/templates/billing/invoice_paid.erb. %>
+Your invoice has been paid. Thank you.

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

@@ -0,0 +1,5 @@
+<%%# Default billing/lifetime_granted HTML — fires when an admin %>
+<%%# privately grants a Lifetime Deal (no Stripe charge). Override at %>
+<%%# app/views/notifications/templates/billing/lifetime_granted.html.erb. %>
+<p>A lifetime pass has been granted to your account. You have permanent
+access to this product — no further payment required.</p>

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

@@ -0,0 +1,5 @@
+<%%# Default billing/lifetime_granted template — fires when an admin %>
+<%%# privately grants a Lifetime Deal (no Stripe charge). Override at %>
+<%%# app/views/notifications/templates/billing/lifetime_granted.erb. %>
+A lifetime pass has been granted to your account. You have permanent
+access to this product — no further payment required.

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

@@ -0,0 +1,5 @@
+<%%# Default billing/lifetime_purchased HTML — fires when a customer %>
+<%%# pays for a Lifetime Deal via Stripe Checkout. Override at %>
+<%%# app/views/notifications/templates/billing/lifetime_purchased.html.erb. %>
+<p>Thank you for your lifetime purchase. You have permanent access to this
+product — no recurring billing, ever.</p>

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

@@ -0,0 +1,5 @@
+<%%# Default billing/lifetime_purchased template — fires when a customer %>
+<%%# pays for a Lifetime Deal via Stripe Checkout. Override at %>
+<%%# app/views/notifications/templates/billing/lifetime_purchased.erb. %>
+Thank you for your lifetime purchase. You have permanent access to this
+product — no recurring billing, ever.

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

@@ -0,0 +1,4 @@
+<%%# Default billing/subscription_canceled HTML. Override at %>
+<%%# app/views/notifications/templates/billing/subscription_canceled.html.erb. %>
+<p>Your subscription has been canceled. You'll continue to have access through
+the end of your current billing period.</p>

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

@@ -0,0 +1,4 @@
+<%%# Default billing/subscription_canceled template. Override at %>
+<%%# app/views/notifications/templates/billing/subscription_canceled.erb. %>
+Your subscription has been canceled. You'll continue to have access through
+the end of your current billing period.