open-loam 0.1.0 → 0.2.0

data/lib/generators/{loam/install/templates/migrations/create_loam_pending_actions.rb → open_loam/install/templates/migrations/create_open_loam_pending_actions.rb}

@@ -1,16 +1,16 @@
-class CreateLoamPendingActions < ActiveRecord::Migration[<%= ActiveRecord::VERSION::STRING.to_f %>]
+class CreateOpenLoamPendingActions < ActiveRecord::Migration[<%= ActiveRecord::VERSION::STRING.to_f %>]
   def change
-    create_table :loam_pending_actions<%= loam_id_option %> do |t|
-      t.references :tenant, null: false, foreign_key: { to_table: :loam_tenants }<%= loam_type_option %>
-      t.<%= loam_key_column_type %> :actor_id<%= loam_key_limit_option %>                       # who staged it (the proposer)
+    create_table :open_loam_pending_actions<%= open_loam_id_option %> do |t|
+      t.references :tenant, null: false, foreign_key: { to_table: :open_loam_tenants }<%= open_loam_type_option %>
+      t.<%= open_loam_key_column_type %> :actor_id<%= open_loam_key_limit_option %>                       # who staged it (the proposer)
       t.string :status, null: false, default: "pending"
       t.string :action_type, null: false       # create / update / destroy
       t.string :target_type                     # the model being mutated
-      t.<%= loam_key_column_type %> :target_id<%= loam_key_limit_option %>                       # null for a staged create
+      t.<%= open_loam_key_column_type %> :target_id<%= open_loam_key_limit_option %>                       # null for a staged create
       t.text :changeset                         # encrypted JSON of the proposed changes
       t.text :summary, null: false              # human-readable description
       t.string :idempotency_key, null: false    # keyed HMAC; same proposal collapses to one row
-      t.<%= loam_key_column_type %> :reviewed_by_id<%= loam_key_limit_option %>                  # the approving/rejecting manager
+      t.<%= open_loam_key_column_type %> :reviewed_by_id<%= open_loam_key_limit_option %>                  # the approving/rejecting manager
       t.datetime :reviewed_at
       t.text :result                            # execution outcome, or "rejected: <reason>"
       t.text :error                             # execution failure message
@@ -19,8 +19,8 @@ class CreateLoamPendingActions < ActiveRecord::Migration[<%= ActiveRecord::VERSI
     # One row per distinct proposal per tenant.
     # Only ONE PENDING row per proposal per tenant — a rejected/executed row with
     # the same key may coexist, so a rejected proposal can be re-staged later.
-    add_index :loam_pending_actions, %i[tenant_id idempotency_key], unique: true,
-              where: "status = 'pending'", name: "index_loam_pending_actions_pending_key"
-    add_index :loam_pending_actions, %i[tenant_id status]
+    add_index :open_loam_pending_actions, %i[tenant_id idempotency_key], unique: true,
+              where: "status = 'pending'", name: "index_open_loam_pending_actions_pending_key"
+    add_index :open_loam_pending_actions, %i[tenant_id status]
   end
 end

data/lib/generators/{loam/install/templates/migrations/create_loam_perspectives.rb → open_loam/install/templates/migrations/create_open_loam_perspectives.rb}

@@ -1,10 +1,10 @@
-class CreateLoamPerspectives < ActiveRecord::Migration[<%= ActiveRecord::VERSION::STRING.to_f %>]
+class CreateOpenLoamPerspectives < ActiveRecord::Migration[<%= ActiveRecord::VERSION::STRING.to_f %>]
   def change
-    create_table :loam_perspectives<%= loam_id_option %> do |t|
-      t.references :tenant, null: false, foreign_key: { to_table: :loam_tenants }<%= loam_type_option %>
+    create_table :open_loam_perspectives<%= open_loam_id_option %> do |t|
+      t.references :tenant, null: false, foreign_key: { to_table: :open_loam_tenants }<%= open_loam_type_option %>
       t.string :entity_type, null: false        # which entity this view is for
       t.string :name, null: false               # human label
-      t.<%= loam_key_column_type %> :owner_id<%= loam_key_limit_option %>                         # the user who owns a private view
+      t.<%= open_loam_key_column_type %> :owner_id<%= open_loam_key_limit_option %>                         # the user who owns a private view
       t.string :visibility, null: false, default: "private"  # private / role / tenant
       t.string :role                             # set when visibility is "role"
       t.boolean :is_default, null: false, default: false
@@ -12,6 +12,6 @@ class CreateLoamPerspectives < ActiveRecord::Migration[<%= ActiveRecord::VERSION
       t.integer :lock_version, null: false, default: 0  # optimistic locking
       t.timestamps
     end
-    add_index :loam_perspectives, %i[tenant_id entity_type]
+    add_index :open_loam_perspectives, %i[tenant_id entity_type]
   end
 end

data/lib/generators/{loam/install/templates/migrations/create_loam_progress_jobs.rb → open_loam/install/templates/migrations/create_open_loam_progress_jobs.rb}

@@ -1,7 +1,7 @@
-class CreateLoamProgressJobs < ActiveRecord::Migration[<%= ActiveRecord::VERSION::STRING.to_f %>]
+class CreateOpenLoamProgressJobs < ActiveRecord::Migration[<%= ActiveRecord::VERSION::STRING.to_f %>]
   def change
-    create_table :loam_progress_jobs<%= loam_id_option %> do |t|
-      t.references :tenant, null: false, foreign_key: { to_table: :loam_tenants }<%= loam_type_option %>
+    create_table :open_loam_progress_jobs<%= open_loam_id_option %> do |t|
+      t.references :tenant, null: false, foreign_key: { to_table: :open_loam_tenants }<%= open_loam_type_option %>
       t.string :key                                   # optional caller-chosen id (e.g. "reindex:Gadget")
       t.string :name, null: false                     # human label
       t.string :status, null: false, default: "running"  # running / completed / failed / cancelled
@@ -9,12 +9,12 @@ class CreateLoamProgressJobs < ActiveRecord::Migration[<%= ActiveRecord::VERSION
       t.integer :completed, null: false, default: 0
       t.text :message                                 # latest status line
       t.text :error                                   # set when failed
-      t.<%= loam_key_column_type %> :actor_id<%= loam_key_limit_option %>                              # who started it
+      t.<%= open_loam_key_column_type %> :actor_id<%= open_loam_key_limit_option %>                              # who started it
       t.datetime :started_at
       t.datetime :finished_at
       t.json :result                                  # structured result for a finished job (e.g. an import summary)
       t.timestamps                                    # updated_at is the heartbeat
     end
-    add_index :loam_progress_jobs, %i[tenant_id status]
+    add_index :open_loam_progress_jobs, %i[tenant_id status]
   end
 end

data/lib/generators/open_loam/install/templates/migrations/create_open_loam_record_locks.rb

@@ -0,0 +1,16 @@
+class CreateOpenLoamRecordLocks < ActiveRecord::Migration[<%= ActiveRecord::VERSION::STRING.to_f %>]
+  def change
+    create_table :open_loam_record_locks<%= open_loam_id_option %> do |t|
+      t.references :tenant, null: false, foreign_key: { to_table: :open_loam_tenants }<%= open_loam_type_option %>
+      t.string :lockable_type, null: false
+      t.<%= open_loam_key_column_type %> :lockable_id<%= open_loam_key_limit_option %>, null: false
+      t.references :locked_by, null: false, foreign_key: { to_table: :users }<%= open_loam_type_option %>
+      t.string :token, null: false
+      t.datetime :expires_at, null: false   # TTL; an expired lock is treated as free
+      t.timestamps                          # updated_at is the heartbeat
+    end
+    # One advisory lock per record.
+    add_index :open_loam_record_locks, %i[tenant_id lockable_type lockable_id], unique: true,
+              name: "index_open_loam_record_locks_on_lockable"
+  end
+end

data/lib/generators/{loam/install/templates/migrations/create_loam_scheduled_jobs.rb → open_loam/install/templates/migrations/create_open_loam_scheduled_jobs.rb}

@@ -1,7 +1,7 @@
-class CreateLoamScheduledJobs < ActiveRecord::Migration[<%= ActiveRecord::VERSION::STRING.to_f %>]
+class CreateOpenLoamScheduledJobs < ActiveRecord::Migration[<%= ActiveRecord::VERSION::STRING.to_f %>]
   def change
-    create_table :loam_scheduled_jobs<%= loam_id_option %> do |t|
-      t.references :tenant, null: false, foreign_key: { to_table: :loam_tenants }<%= loam_type_option %>
+    create_table :open_loam_scheduled_jobs<%= open_loam_id_option %> do |t|
+      t.references :tenant, null: false, foreign_key: { to_table: :open_loam_tenants }<%= open_loam_type_option %>
       t.string :key, null: false                        # unique per tenant
       t.string :name, null: false
       t.string :job_class, null: false                  # a whitelisted ActiveJob class name
@@ -14,7 +14,7 @@ class CreateLoamScheduledJobs < ActiveRecord::Migration[<%= ActiveRecord::VERSIO
       t.boolean :active, null: false, default: true
       t.timestamps
     end
-    add_index :loam_scheduled_jobs, %i[tenant_id key], unique: true
-    add_index :loam_scheduled_jobs, %i[active next_run_at locked_until]
+    add_index :open_loam_scheduled_jobs, %i[tenant_id key], unique: true
+    add_index :open_loam_scheduled_jobs, %i[active next_run_at locked_until]
   end
 end

data/lib/generators/open_loam/install/templates/migrations/create_open_loam_search_tokens.rb

@@ -0,0 +1,18 @@
+class CreateOpenLoamSearchTokens < ActiveRecord::Migration[<%= ActiveRecord::VERSION::STRING.to_f %>]
+  def change
+    create_table :open_loam_search_tokens<%= open_loam_id_option %> do |t|
+      t.references :tenant, null: false, foreign_key: { to_table: :open_loam_tenants }<%= open_loam_type_option %>
+      t.string :searchable_type, null: false  # the entity class name (e.g. "Gadget")
+      t.<%= open_loam_key_column_type %> :searchable_id<%= open_loam_key_limit_option %>, null: false     # the record it indexes
+      t.string :token, null: false             # one normalized word
+    end
+    # The match subquery filters by (tenant, type, token); index maintenance
+    # deletes by (tenant, type, record). One index each — no timestamps: these
+    # are plumbing rows written with insert_all/delete_all.
+    #
+    # Shipped even though the default LikeDriver never uses it, so switching to
+    # OpenLoam::Search::TokenDriver is a one-line initializer change, not a migration.
+    add_index :open_loam_search_tokens, %i[tenant_id searchable_type token]
+    add_index :open_loam_search_tokens, %i[tenant_id searchable_type searchable_id]
+  end
+end

data/lib/generators/{loam/install/templates/migrations/create_loam_sso_providers.rb → open_loam/install/templates/migrations/create_open_loam_sso_providers.rb}

@@ -1,7 +1,7 @@
-class CreateLoamSsoProviders < ActiveRecord::Migration[<%= ActiveRecord::VERSION::STRING.to_f %>]
+class CreateOpenLoamSsoProviders < ActiveRecord::Migration[<%= ActiveRecord::VERSION::STRING.to_f %>]
   def change
-    create_table :loam_sso_providers<%= loam_id_option %> do |t|
-      t.references :tenant, null: false, foreign_key: { to_table: :loam_tenants }<%= loam_type_option %>
+    create_table :open_loam_sso_providers<%= open_loam_id_option %> do |t|
+      t.references :tenant, null: false, foreign_key: { to_table: :open_loam_tenants }<%= open_loam_type_option %>
       t.string :name, null: false
       t.string :protocol, null: false, default: "oidc"  # "oidc" shipped; "saml" is a seam
       t.string :issuer                                    # OIDC discovery base (.well-known)
@@ -9,26 +9,26 @@ class CreateLoamSsoProviders < ActiveRecord::Migration[<%= ActiveRecord::VERSION
       t.text :client_secret                               # ENCRYPTED at rest (tenant-scoped key)
       t.string :domain, null: false                       # email domain for home-realm discovery
       t.string :jit_role, null: false, default: "employee"  # role for JIT-provisioned users
-      t.json :group_role_map, null: false, default: {}    # IdP group -> Loam role (first match wins)
+      t.json :group_role_map, null: false, default: {}    # IdP group -> OpenLoam role (first match wins)
       t.boolean :active, null: false, default: true
       t.timestamps
     end
     # HRD resolves a provider by email domain, cross-tenant, before login — so the
     # domain is globally unique (one owning IdP per domain).
-    add_index :loam_sso_providers, :domain, unique: true
-    add_index :loam_sso_providers, %i[tenant_id active]
+    add_index :open_loam_sso_providers, :domain, unique: true
+    add_index :open_loam_sso_providers, %i[tenant_id active]
 
     # The durable link between an external identity (provider + subject) and a
     # local User — the primary lookup on callback (email can change at the IdP,
     # `sub` does not).
-    create_table :loam_sso_identities<%= loam_id_option %> do |t|
-      t.references :tenant, null: false, foreign_key: { to_table: :loam_tenants }<%= loam_type_option %>
-      t.references :sso_provider, null: false, foreign_key: { to_table: :loam_sso_providers }<%= loam_type_option %>
-      t.<%= loam_key_column_type %> :user_id<%= loam_key_limit_option %>, null: false  # the local User this identity belongs to
+    create_table :open_loam_sso_identities<%= open_loam_id_option %> do |t|
+      t.references :tenant, null: false, foreign_key: { to_table: :open_loam_tenants }<%= open_loam_type_option %>
+      t.references :sso_provider, null: false, foreign_key: { to_table: :open_loam_sso_providers }<%= open_loam_type_option %>
+      t.<%= open_loam_key_column_type %> :user_id<%= open_loam_key_limit_option %>, null: false  # the local User this identity belongs to
       t.string :sub, null: false      # the IdP's stable subject identifier
       t.timestamps
     end
-    add_index :loam_sso_identities, %i[sso_provider_id sub], unique: true
-    add_index :loam_sso_identities, :user_id
+    add_index :open_loam_sso_identities, %i[sso_provider_id sub], unique: true
+    add_index :open_loam_sso_identities, :user_id
   end
 end

data/lib/generators/open_loam/install/templates/migrations/create_open_loam_tenants.rb

@@ -0,0 +1,9 @@
+class CreateOpenLoamTenants < ActiveRecord::Migration[<%= ActiveRecord::VERSION::STRING.to_f %>]
+  def change
+    create_table :open_loam_tenants<%= open_loam_id_option %> do |t|
+      t.string :name, null: false
+      t.string :slug, null: false, index: { unique: true }
+      t.timestamps
+    end
+  end
+end

data/lib/generators/open_loam/install/templates/migrations/create_open_loam_translations.rb

@@ -0,0 +1,15 @@
+class CreateOpenLoamTranslations < ActiveRecord::Migration[<%= ActiveRecord::VERSION::STRING.to_f %>]
+  def change
+    create_table :open_loam_translations<%= open_loam_id_option %> do |t|
+      t.references :tenant, null: false, foreign_key: { to_table: :open_loam_tenants }<%= open_loam_type_option %>
+      t.string :translatable_type, null: false
+      t.<%= open_loam_key_column_type %> :translatable_id<%= open_loam_key_limit_option %>, null: false
+      t.string :locale, null: false            # "en", "de", "pl"
+      t.string :field, null: false             # the translated attribute
+      t.text :value                            # the per-locale content
+      t.timestamps
+    end
+    add_index :open_loam_translations, %i[translatable_type translatable_id locale field],
+              unique: true, name: "index_open_loam_translations_unique"
+  end
+end

data/lib/generators/open_loam/install/templates/migrations/create_open_loam_webhook_endpoints.rb

@@ -0,0 +1,13 @@
+class CreateOpenLoamWebhookEndpoints < ActiveRecord::Migration[<%= ActiveRecord::VERSION::STRING.to_f %>]
+  def change
+    create_table :open_loam_webhook_endpoints<%= open_loam_id_option %> do |t|
+      t.references :tenant, null: false, foreign_key: { to_table: :open_loam_tenants }<%= open_loam_type_option %>
+      t.string :url, null: false
+      t.string :event_pattern, null: false
+      t.string :secret, null: false
+      t.boolean :active, null: false, default: true
+      t.timestamps
+    end
+    add_index :open_loam_webhook_endpoints, %i[tenant_id active]
+  end
+end

data/lib/generators/{loam → open_loam}/install/templates/migrations/create_users.rb

@@ -1,6 +1,6 @@
 class CreateUsers < ActiveRecord::Migration[<%= ActiveRecord::VERSION::STRING.to_f %>]
   def change
-    create_table :users<%= loam_id_option %> do |t|
+    create_table :users<%= open_loam_id_option %> do |t|
       t.string :name, null: false
       t.string :email, null: false
       t.string :password_digest, null: false

data/lib/generators/{loam → open_loam}/install/templates/user.rb

@@ -1,15 +1,15 @@
 # Minimal actor model. Deliberately NOT tenant-scoped: a user can belong to
-# many tenants via Loam::Membership (role is per tenant). Swap in your real
-# auth (Devise, OmniAuth, SSO) later — Loam only needs an `id` and, for the
+# many tenants via OpenLoam::Membership (role is per tenant). Swap in your real
+# auth (Devise, OmniAuth, SSO) later — OpenLoam only needs an `id` and, for the
 # bundled admin login, something that answers `authenticate_by`.
 class User < ApplicationRecord
-  # Loam's foreign keys point at this table, so its key has to be generated
+  # OpenLoam's foreign keys point at this table, so its key has to be generated
   # the same way theirs are when the app does not use integer keys.
-  include Loam::GeneratedKey
+  include OpenLoam::GeneratedKey
 
   has_secure_password
 
-  has_many :loam_memberships, class_name: "Loam::Membership"
+  has_many :open_loam_memberships, class_name: "OpenLoam::Membership"
 
   validates :name, presence: true
   validates :email, presence: true, uniqueness: true

data/lib/generators/{loam → open_loam}/primary_key_options.rb

@@ -1,8 +1,8 @@
-module Loam
+module OpenLoam
   module Generators
-    # Shared primary-key shaping for `loam:install` and `loam:entity`.
+    # Shared primary-key shaping for `open_loam:install` and `open_loam:entity`.
     #
-    # Loam's migrations used to spell every key `bigint` — implicitly in
+    # OpenLoam's migrations used to spell every key `bigint` — implicitly in
     # `create_table`, and explicitly in `t.references` and the polymorphic
     # `*_id` columns. In an app whose own tables use string or uuid keys the
     # foreign keys then do not line up with the tables they point at, and every
@@ -10,7 +10,7 @@ module Loam
     #
     # The key type is taken from, in order: an explicit --primary-key-type, the
     # host app's own `config.generators` setting (so an app that already told
-    # Rails what its keys look like does not have to tell Loam separately), and
+    # Rails what its keys look like does not have to tell OpenLoam separately), and
     # bigint as the Rails default.
     #
     # The templates ask for the *rendered fragment* rather than the type, so
@@ -34,15 +34,15 @@ module Loam
 
       private
 
-      def loam_key_type
-        @loam_key_type ||= begin
+      def open_loam_key_type
+        @open_loam_key_type ||= begin
           requested = (options[:primary_key_type] || host_app_primary_key_type).to_s
           requested = "bigint" if requested.empty?
 
           unless SUPPORTED.include?(requested)
             raise Thor::Error,
-                  "Unsupported --primary-key-type #{requested.inspect}. Loam generates #{SUPPORTED.join(', ')}. " \
-                  "A key type Loam does not know how to size would produce migrations that look right and " \
+                  "Unsupported --primary-key-type #{requested.inspect}. OpenLoam generates #{SUPPORTED.join(', ')}. " \
+                  "A key type OpenLoam does not know how to size would produce migrations that look right and " \
                   "do not line up with your tables."
           end
 
@@ -60,40 +60,40 @@ module Loam
         nil
       end
 
-      def loam_key_limit
+      def open_loam_key_limit
         return options[:key_limit].to_i if options[:key_limit]
 
-        loam_key_type == :string ? DEFAULT_STRING_LIMIT : nil
+        open_loam_key_type == :string ? DEFAULT_STRING_LIMIT : nil
       end
 
       # Appended to `create_table :x` — "" for bigint, so the default path is
       # byte-for-byte what it was.
-      def loam_id_option
-        return "" if loam_key_type == :bigint
+      def open_loam_id_option
+        return "" if open_loam_key_type == :bigint
 
-        "#{loam_key_fragment.sub('type:', 'id:')}"
+        "#{open_loam_key_fragment.sub('type:', 'id:')}"
       end
 
       # Appended inside `t.references :x, ...`.
-      def loam_type_option
-        return "" if loam_key_type == :bigint
+      def open_loam_type_option
+        return "" if open_loam_key_type == :bigint
 
-        loam_key_fragment
+        open_loam_key_fragment
       end
 
       # The bare column type for a polymorphic or un-constrained `*_id`, which
       # cannot use t.references.
-      def loam_key_column_type
-        loam_key_type
+      def open_loam_key_column_type
+        open_loam_key_type
       end
 
-      def loam_key_limit_option
-        loam_key_limit ? ", limit: #{loam_key_limit}" : ""
+      def open_loam_key_limit_option
+        open_loam_key_limit ? ", limit: #{open_loam_key_limit}" : ""
       end
 
-      def loam_key_fragment
-        fragment = ", type: :#{loam_key_type}"
-        fragment += ", limit: #{loam_key_limit}" if loam_key_limit
+      def open_loam_key_fragment
+        fragment = ", type: :#{open_loam_key_type}"
+        fragment += ", limit: #{open_loam_key_limit}" if open_loam_key_limit
         fragment
       end
     end

data/lib/open-loam.rb

@@ -1,5 +1,5 @@
 # Bundler auto-requires the gem's name ("open-loam") on load. The library's
-# entry point and whole namespace are `loam` / `Loam::` — the gem is only
+# entry point and whole namespace are `open_loam` / `OpenLoam::` — the gem is only
 # *distributed* as open-loam (the plain `loam` name is taken on RubyGems). This
 # shim bridges the two so `gem "open-loam"` works with the default require.
-require_relative "loam"
+require_relative "open_loam"

data/lib/{loam → open_loam}/attachable.rb

@@ -1,10 +1,10 @@
-module Loam
+module OpenLoam
   # Files on a record, via ActiveStorage:
   #
   #   equipment.files.attach(io: File.open(path), filename: "manual.pdf")
   #   equipment.files.each { |file| url_for(file) }
   #
-  # KNOWN BOUNDARY: ActiveStorage blobs live in global tables that Loam does
+  # KNOWN BOUNDARY: ActiveStorage blobs live in global tables that OpenLoam does
   # NOT tenant-scope. The association is scoped (a record only ever lists its
   # own files, and the record is tenant-scoped), but a signed blob URL is a
   # bearer capability: whoever holds the link can fetch the file, with no
@@ -15,8 +15,8 @@ module Loam
 
     included do
       unless respond_to?(:has_many_attached)
-        raise Loam::Error,
-              "#{name} includes Loam::Attachable but ActiveStorage is not available. " \
+        raise OpenLoam::Error,
+              "#{name} includes OpenLoam::Attachable but ActiveStorage is not available. " \
               "Run `bin/rails active_storage:install && bin/rails db:migrate`, or remove the include " \
               "(this app was probably generated with --skip-active-storage)."
       end

data/lib/{loam → open_loam}/auditable.rb

@@ -1,6 +1,6 @@
-module Loam
+module OpenLoam
   # Audit-by-default. Included in every generated entity: create/update/destroy
-  # writes a Loam::AuditRecord tagged with tenant + actor + changeset. "Who
+  # writes a OpenLoam::AuditRecord tagged with tenant + actor + changeset. "Who
   # changed the excavator's price, and when" is answered structurally, not by
   # remembering to log.
   module Auditable
@@ -9,54 +9,54 @@ module Loam
     IGNORED_ATTRIBUTES = %w[updated_at created_at].freeze
 
     included do
-      after_create  { loam_audit("create") }
-      after_update  { loam_audit(loam_audit_action) if loam_audit_changes.any? }
-      after_destroy { loam_audit("destroy") }
+      after_create  { open_loam_audit("create") }
+      after_update  { open_loam_audit(open_loam_audit_action) if open_loam_audit_changes.any? }
+      after_destroy { open_loam_audit("destroy") }
     end
 
     private
 
-    # Relabel the audit that the save inside the block writes. Loam::SoftDeletable
+    # Relabel the audit that the save inside the block writes. OpenLoam::SoftDeletable
     # uses this to record a soft-delete (an UPDATE) as "soft_delete"/"restore"
     # rather than the "update" it would otherwise be — one audit path, reused,
     # not a second one to keep in sync.
-    def loam_audit_as(action)
-      previous = @loam_audit_action
-      @loam_audit_action = action
+    def open_loam_audit_as(action)
+      previous = @open_loam_audit_action
+      @open_loam_audit_action = action
       yield
     ensure
-      @loam_audit_action = previous
+      @open_loam_audit_action = previous
     end
 
-    def loam_audit_action
-      @loam_audit_action || "update"
+    def open_loam_audit_action
+      @open_loam_audit_action || "update"
     end
 
-    def loam_audit(action)
-      Loam::AuditRecord.create!(
+    def open_loam_audit(action)
+      OpenLoam::AuditRecord.create!(
         auditable_type: self.class.name,
         auditable_id: id,
         action: action,
-        actor_id: Loam::Current.actor&.id,
-        changeset: action == "destroy" ? {} : loam_audit_changes
+        actor_id: OpenLoam::Current.actor&.id,
+        changeset: action == "destroy" ? {} : open_loam_audit_changes
       )
     end
 
-    def loam_audit_changes
+    def open_loam_audit_changes
       changes = saved_changes.except(*IGNORED_ATTRIBUTES)
-      loam_redact_encrypted(changes)
+      open_loam_redact_encrypted(changes)
     end
 
     # The audit trail must record the FACT that an encrypted field changed, never
     # its value — neither the plaintext nor the ciphertext (a ciphertext still
     # leaks length and, over time, correlations). So an encrypted column's change
     # becomes "[encrypted]", and its blind-index sibling is dropped entirely.
-    # A no-op for models without Loam::Encryptable.
-    def loam_redact_encrypted(changes)
-      return changes unless self.class.respond_to?(:loam_encrypted_attributes)
+    # A no-op for models without OpenLoam::Encryptable.
+    def open_loam_redact_encrypted(changes)
+      return changes unless self.class.respond_to?(:open_loam_encrypted_attributes)
 
-      encrypted = self.class.loam_encrypted_attributes.map(&:to_s)
-      hash_columns = self.class.loam_searchable_encrypted_attributes.map { |name| "#{name}_hash" }
+      encrypted = self.class.open_loam_encrypted_attributes.map(&:to_s)
+      hash_columns = self.class.open_loam_searchable_encrypted_attributes.map { |name| "#{name}_hash" }
 
       changes.each_with_object({}) do |(column, values), redacted|
         next if hash_columns.include?(column)

data/lib/{loam → open_loam}/auth_throttle.rb

@@ -1,12 +1,12 @@
-module Loam
+module OpenLoam
   # Rate-limiting + lockout for authentication, to blunt online brute-force of
   # passwords and (especially) 6-digit TOTP codes. A DB-backed counter keyed by
   # the submitted identifier: after N failures within a window, the identifier is
   # locked; a success clears the counter.
   #
-  #   Loam::AuthThrottle.locked?(email)                      # refuse if true
-  #   Loam::AuthThrottle.record_failure(email, kind: "password", ip: request.ip)
-  #   Loam::AuthThrottle.clear(email)                        # on success
+  #   OpenLoam::AuthThrottle.locked?(email)                      # refuse if true
+  #   OpenLoam::AuthThrottle.record_failure(email, kind: "password", ip: request.ip)
+  #   OpenLoam::AuthThrottle.clear(email)                        # on success
   #
   # PER-IDENTIFIER is the primary defense (an attacker targets one account /
   # code). A per-ip throttle to blunt spraying across accounts is a clean
@@ -15,7 +15,7 @@ module Loam
   # (needs a cache store + a gem); this DB counter is the portable,
   # single-process-correct prototype.
   #
-  # Thresholds come from Loam::Configs (per-tenant-overridable, but read globally
+  # Thresholds come from OpenLoam::Configs (per-tenant-overridable, but read globally
   # here at the auth layer with sane defaults):
   #   security.max_auth_attempts   (default 10)
   #   security.auth_window_minutes (default 15) — failures counted in this window
@@ -24,15 +24,15 @@ module Loam
     module_function
 
     def max_attempts
-      Loam::Configs.get("security.max_auth_attempts", default: 10).to_i
+      OpenLoam::Configs.get("security.max_auth_attempts", default: 10).to_i
     end
 
     def window
-      Loam::Configs.get("security.auth_window_minutes", default: 15).to_i.minutes
+      OpenLoam::Configs.get("security.auth_window_minutes", default: 15).to_i.minutes
     end
 
     def lockout
-      Loam::Configs.get("security.auth_lockout_minutes", default: 15).to_i.minutes
+      OpenLoam::Configs.get("security.auth_lockout_minutes", default: 15).to_i.minutes
     end
 
     # Log a failed attempt. Recorded for ANY submitted identifier — existing or
@@ -41,7 +41,7 @@ module Loam
       identifier = normalize(identifier)
       return if identifier.blank?
 
-      Loam::AuthAttempt.create!(identifier: identifier, kind: kind.to_s, ip: ip)
+      OpenLoam::AuthAttempt.create!(identifier: identifier, kind: kind.to_s, ip: ip)
     end
 
     # Locked if there are >= max failures within the window. Old attempts age out
@@ -73,7 +73,7 @@ module Loam
     end
 
     def attempts(identifier)
-      Loam::AuthAttempt.where(identifier: normalize(identifier))
+      OpenLoam::AuthAttempt.where(identifier: normalize(identifier))
     end
 
     def normalize(identifier)

data/lib/{loam → open_loam}/base32.rb

@@ -1,4 +1,4 @@
-module Loam
+module OpenLoam
   # RFC 4648 Base32 — the encoding authenticator apps expect for a TOTP secret.
   # Ruby ships Base64 but not Base32, and this is ~15 lines, so no dependency.
   # No padding on encode (authenticators don't want it); decode ignores case,

data/lib/{loam → open_loam}/bulk.rb

@@ -1,11 +1,11 @@
-module Loam
+module OpenLoam
   # Datatable bulk actions over selected records — policy-checked PER record and
   # tenant-scoped. The ids are resolved THROUGH the tenant scope
   # (`model.where(id: ids)`), so a forged cross-tenant id is simply not found —
   # a bulk op can never reach another tenant's rows.
   #
-  #   Loam::Bulk.soft_delete(Equipment, params[:ids])
-  #   Loam::Bulk.set_field(Equipment, params[:ids], field: "status", value: "retired")
+  #   OpenLoam::Bulk.soft_delete(Equipment, params[:ids])
+  #   OpenLoam::Bulk.set_field(Equipment, params[:ids], field: "status", value: "retired")
   #
   # Returns the number of records actually affected (a record the actor may not
   # touch, or an id from another tenant, is silently skipped).
@@ -32,7 +32,7 @@ module Loam
     end
 
     # A relation for "export selected" — tenant-scoped, so it composes with
-    # Loam::Export.csv and can't leak another tenant's rows.
+    # OpenLoam::Export.csv and can't leak another tenant's rows.
     def selected(model, ids)
       model.where(id: Array(ids))
     end
@@ -40,20 +40,20 @@ module Loam
     def each_permitted(model, ids)
       count = 0
       selected(model, ids).find_each do |record|
-        count += 1 if yield(record, Loam::Policy.for(record))
+        count += 1 if yield(record, OpenLoam::Policy.for(record))
       end
       count
     end
 
     def writable_column?(model, field)
-      model.column_names.include?(field) && Loam::Import::PLUMBING.exclude?(field) && !workflow_column?(model, field)
+      model.column_names.include?(field) && OpenLoam::Import::PLUMBING.exclude?(field) && !workflow_column?(model, field)
     end
 
     # A workflow status column may ONLY change through a transition (role-gated).
     # Skip it here so a bulk set-field can't self-"approve" (the model guard is
     # the backstop; this keeps the bulk op a clean no-op rather than an error).
     def workflow_column?(model, field)
-      model.respond_to?(:loam_workflow) && model.loam_workflow&.column == field
+      model.respond_to?(:open_loam_workflow) && model.open_loam_workflow&.column == field
     end
   end
 end