open-loam 0.1.0 → 0.2.0

data/app/models/{loam → open_loam}/sso_provider.rb

@@ -1,20 +1,20 @@
-module Loam
+module OpenLoam
   # A tenant's connection to an external identity provider (OIDC). Per-tenant
   # config: each tenant/org wires its OWN IdP, so the client_secret is encrypted
   # under the tenant key (the default Encryptable scope) — unlike MFA, which is
   # user-keyed. Home-realm discovery matches an email `domain` to the owning
-  # provider at the sign-in page (see Loam::Sso.provider_for).
-  class SsoProvider < Loam::TenantRecord
-    self.table_name = "loam_sso_providers"
+  # provider at the sign-in page (see OpenLoam::Sso.provider_for).
+  class SsoProvider < OpenLoam::TenantRecord
+    self.table_name = "open_loam_sso_providers"
 
-    include Loam::Auditable      # config changes are audited; the secret is redacted
-    include Loam::Encryptable
+    include OpenLoam::Auditable      # config changes are audited; the secret is redacted
+    include OpenLoam::Encryptable
 
     # Tenant-scoped key (default): SSO config belongs to the tenant, and the
     # secret is only ever read inside that tenant's context on callback.
     encrypts :client_secret
 
-    has_many :identities, class_name: "Loam::SsoIdentity",
+    has_many :identities, class_name: "OpenLoam::SsoIdentity",
              foreign_key: :sso_provider_id, dependent: :delete_all
 
     validates :name, :protocol, :domain, :jit_role, presence: true
@@ -27,7 +27,7 @@ module Loam
 
     scope :active, -> { where(active: true) }
 
-    # IdP group -> Loam role, first match wins; falls back to jit_role.
+    # IdP group -> OpenLoam role, first match wins; falls back to jit_role.
     def group_roles
       group_role_map.is_a?(Hash) ? group_role_map : {}
     end

data/app/models/open_loam/tenant.rb

@@ -0,0 +1,20 @@
+module OpenLoam
+  # The tenant itself is deliberately NOT tenant-scoped — it is the axis the
+  # rest of the system is scoped by.
+  class Tenant < ActiveRecord::Base
+    include OpenLoam::GeneratedKey
+    self.table_name = "open_loam_tenants"
+
+    validates :name, presence: true
+    validates :slug, presence: true, uniqueness: true
+
+    has_many :memberships, class_name: "OpenLoam::Membership", dependent: :delete_all
+
+    # A new tenant is never empty: whatever the app registered via
+    # OpenLoam.on_tenant_created runs here, inside this tenant's context. After
+    # commit, so callbacks see a persisted tenant and may enqueue jobs.
+    # `bin/rails open_loam:sync` re-runs the same callbacks for existing tenants —
+    # which is why they must be idempotent (see OpenLoam::Lifecycle).
+    after_create_commit { OpenLoam::Lifecycle.run_tenant_created(self) }
+  end
+end

data/app/models/{loam → open_loam}/translation.rb

@@ -1,13 +1,13 @@
-module Loam
+module OpenLoam
   # A per-locale override for ONE field of ONE record — the storage behind
-  # Loam::Translatable. The record's own column holds the base (default-locale)
+  # OpenLoam::Translatable. The record's own column holds the base (default-locale)
   # value; a translation row overrides it for a specific locale. Additive:
   # writing a translation never touches the base column, so the base value is
   # never lost. Tenant-scoped and audited.
-  class Translation < Loam::TenantRecord
-    self.table_name = "loam_translations"
+  class Translation < OpenLoam::TenantRecord
+    self.table_name = "open_loam_translations"
 
-    include Loam::Auditable
+    include OpenLoam::Auditable
 
     belongs_to :translatable, polymorphic: true
 

data/app/models/{loam → open_loam}/webhook_endpoint.rb

@@ -1,12 +1,12 @@
-module Loam
+module OpenLoam
   # Where one tenant wants its domain events delivered. `event_pattern` uses
-  # the same rule as Loam::Events.subscribe — a trailing dot is a domain prefix
+  # the same rule as OpenLoam::Events.subscribe — a trailing dot is a domain prefix
   # ("rental."), anything else is an exact event name.
   #
-  # The secret signs every delivery (X-Loam-Signature), so a receiver can tell
+  # The secret signs every delivery (X-OpenLoam-Signature), so a receiver can tell
   # a real call from a forged one.
-  class WebhookEndpoint < Loam::TenantRecord
-    self.table_name = "loam_webhook_endpoints"
+  class WebhookEndpoint < OpenLoam::TenantRecord
+    self.table_name = "open_loam_webhook_endpoints"
 
     validates :url, presence: true, format: { with: %r{\Ahttps?://}, message: "must start with http:// or https://" }
     validates :event_pattern, presence: true
@@ -20,7 +20,7 @@ module Loam
     # One matcher, shared with the event bus, so "rental." means the same thing
     # to a subscriber and to a webhook.
     def matches?(event_name)
-      Loam::Events.pattern_matches?(event_pattern, event_name)
+      OpenLoam::Events.pattern_matches?(event_pattern, event_name)
     end
   end
 end

data/app/views/{loam → open_loam}/attachments/_attachments.html.erb

@@ -2,7 +2,7 @@
     Uploading happens through the entity's own form (it is an update, and the
     entity's policy decides who may do it); this partial only lists what is
     already attached. Note that these links are signed URLs, not tenant-checked
-    addresses — see Loam::Attachable. %>
+    addresses — see OpenLoam::Attachable. %>
 <h2>Files</h2>
 
 <% if record.files.attached? %>

data/app/views/{loam → open_loam}/comments/_comments.html.erb

@@ -8,7 +8,7 @@
   <p style="color:#b00"><%= flash[:alert] %></p>
 <% end %>
 
-<% record.loam_comments.oldest_first.each do |comment| %>
+<% record.open_loam_comments.oldest_first.each do |comment| %>
   <p>
     <strong><%= User.find_by(id: comment.author_id)&.name || "—" %></strong>
     <em><%= comment.created_at.to_fs(:short) %></em><br>

data/app/views/{loam → open_loam}/custom_fields/_fields.html.erb

@@ -20,14 +20,14 @@
       <% when "integer", "decimal" %>
         <%= number_field_tag param_name, value %>
       <% when "dictionary" %>
-        <% options = Loam::Dictionaries.entries(definition.dictionary_key).map { |e| [e.label, e.value] } %>
+        <% options = OpenLoam::Dictionaries.entries(definition.dictionary_key).map { |e| [e.label, e.value] } %>
         <%= select_tag param_name, options_for_select(options, value), include_blank: true, id: param_name %>
       <% else %>
         <%= text_field_tag param_name, value %>
       <% end %>
     <% else %>
       <%# A dictionary field shows its entry label, not the raw stored code. %>
-      <% display = definition.field_type == "dictionary" ? Loam::Dictionaries.label_for(definition.dictionary_key, value) : value %>
+      <% display = definition.field_type == "dictionary" ? OpenLoam::Dictionaries.label_for(definition.dictionary_key, value) : value %>
       <%= definition.name.humanize %>: <%= display %>
       <% if mode == :edit %><em>(read-only for your role)</em><% end %>
     <% end %>

data/lib/generators/{loam → open_loam}/entity/entity_generator.rb

@@ -1,19 +1,19 @@
 require "rails/generators"
 require "rails/generators/active_record"
-require "generators/loam/primary_key_options"
+require "generators/open_loam/primary_key_options"
 
-module Loam
+module OpenLoam
   module Generators
-    # `rails g loam:entity Equipment name:string daily_rate:decimal --domain rental`
+    # `rails g open_loam:entity Equipment name:string daily_rate:decimal --domain rental`
     #
     # THE interface for adding a business entity — for humans and AI agents
     # alike. One command produces a tenant-scoped, audited, evented model, its
     # policy, an admin screen, and the isolation tests that prove the
-    # guardrails hold. No decisions about how tenancy/permissions work: Loam
+    # guardrails hold. No decisions about how tenancy/permissions work: OpenLoam
     # already decided.
     class EntityGenerator < Rails::Generators::NamedBase
       include ActiveRecord::Generators::Migration
-      include Loam::Generators::PrimaryKeyOptions
+      include OpenLoam::Generators::PrimaryKeyOptions
 
       source_root File.expand_path("templates", __dir__)
 
@@ -21,7 +21,7 @@ module Loam
       class_option :domain, type: :string, default: "app",
                             desc: "Event domain prefix (-> domain.entity.created)"
       class_option :encrypt, type: :array, default: [], banner: "field field",
-                             desc: "Encrypt these fields at rest, per tenant (Loam::Encryptable)"
+                             desc: "Encrypt these fields at rest, per tenant (OpenLoam::Encryptable)"
       class_option :encrypt_searchable, type: :array, default: [], banner: "field field",
                                         desc: "Encrypt + add a blind index for exact-match lookup"
 
@@ -59,7 +59,7 @@ module Loam
       end
 
       # `namespace:` makes Rails inject the route INTO the existing
-      # `namespace :admin do` block (the one loam:install wrote) instead of
+      # `namespace :admin do` block (the one open_loam:install wrote) instead of
       # stacking one admin block per entity, and falls back to creating the
       # block when there is none. Re-running the generator is a no-op: the
       # injection is `force: false`, so identical routing code is skipped.
@@ -70,7 +70,7 @@ module Loam
       # identical `resources :gadgets` lines would leave the second one out.
       #
       # The admin resource carries the soft-delete recycle bin: `deleted` lists
-      # `only_deleted`, `restore` brings one back (see Loam::SoftDeletable).
+      # `only_deleted`, `restore` brings one back (see OpenLoam::SoftDeletable).
       def add_route
         route <<~RUBY.strip, namespace: :admin
           resources :#{plural_file_name} do
@@ -101,7 +101,7 @@ module Loam
         attributes.map(&:name)
       end
 
-      # Only text-ish columns are worth a LIKE (see Loam::Searchable), so an
+      # Only text-ish columns are worth a LIKE (see OpenLoam::Searchable), so an
       # entity with none gets no `searchable_by` declaration and stays out of
       # the global search. Encrypted columns are excluded: ciphertext is
       # meaningless to LIKE, and declaring both would raise at class load.

data/lib/generators/{loam → open_loam}/entity/templates/api_controller.rb

@@ -9,7 +9,7 @@ module Api
 
     def index
       records = <%= class_name %>.order(created_at: :desc).to_a
-      enriched = Loam::Enrichers.enrich_many(records)   # one batched pass, no N+1
+      enriched = OpenLoam::Enrichers.enrich_many(records)   # one batched pass, no N+1
       render json: records.map { |record| entity_json(record, enrichments: enriched[record.id]) }
     end
 

data/lib/generators/{loam → open_loam}/entity/templates/controller.rb

@@ -15,34 +15,34 @@ module Admin
     end
 
     def index
-      @perspective = Loam::Perspectives.resolve("<%= class_name %>", user: current_actor, id: params[:perspective_id])
-      @perspectives = Loam::Perspectives.visible_to("<%= class_name %>", user: current_actor)
+      @perspective = OpenLoam::Perspectives.resolve("<%= class_name %>", user: current_actor, id: params[:perspective_id])
+      @perspectives = OpenLoam::Perspectives.visible_to("<%= class_name %>", user: current_actor)
       @records, @page, @has_next = paginate(index_scope)
-      @index_partial = params[:cf_field].present? && Loam::CustomFieldIndex.partial?  # incomplete-index warning (L-919)
+      @index_partial = params[:cf_field].present? && OpenLoam::CustomFieldIndex.partial?  # incomplete-index warning (L-919)
     end
 
     # CSV of the CURRENT filtered/perspective view — manager-only, policy- and
-    # encryption-aware (Loam::Export).
+    # encryption-aware (OpenLoam::Export).
     def export
       require_role!(:manager)
-      send_data Loam::Export.csv(index_scope, actor: current_actor),
+      send_data OpenLoam::Export.csv(index_scope, actor: current_actor),
                 filename: "<%= plural_name %>-#{Date.current}.csv", type: "text/csv"
     end
 
     # Datatable bulk actions on the selected ids — each is policy-checked per
-    # record and tenant-scoped (Loam::Bulk). Zero selection is a no-op.
+    # record and tenant-scoped (OpenLoam::Bulk). Zero selection is a no-op.
     def bulk
       ids = Array(params[:ids])
       case params[:bulk_action]
       when "soft_delete"
-        count = Loam::Bulk.soft_delete(<%= class_name %>, ids)
+        count = OpenLoam::Bulk.soft_delete(<%= class_name %>, ids)
         redirect_to polymorphic_path([:admin, <%= class_name %>]), notice: "Deleted #{count} record(s)."
       when "set_field"
-        count = Loam::Bulk.set_field(<%= class_name %>, ids, field: params[:field], value: params[:value])
+        count = OpenLoam::Bulk.set_field(<%= class_name %>, ids, field: params[:field], value: params[:value])
         redirect_to polymorphic_path([:admin, <%= class_name %>]), notice: "Updated #{count} record(s)."
       when "export"
         require_role!(:manager)  # same gate as the dedicated export action
-        send_data Loam::Export.csv(Loam::Bulk.selected(<%= class_name %>, ids), actor: current_actor),
+        send_data OpenLoam::Export.csv(OpenLoam::Bulk.selected(<%= class_name %>, ids), actor: current_actor),
                   filename: "<%= plural_name %>-selected.csv", type: "text/csv"
       else
         redirect_to polymorphic_path([:admin, <%= class_name %>]), alert: "Unknown bulk action."
@@ -75,7 +75,7 @@ module Admin
       attach_files!(@record, policy)
 
       if @record.save
-        redirect_to [:admin, @record], notice: t("loam.flash.created", name: <%= class_name %>.model_name.human)
+        redirect_to [:admin, @record], notice: t("open_loam.flash.created", name: <%= class_name %>.model_name.human)
       else
         render :new, status: :unprocessable_entity
       end
@@ -84,7 +84,7 @@ module Admin
     def edit
       authorize!(policy_for(@record), :update?)
       # Take the advisory lock (courtesy) or learn who holds it, for the banner.
-      @lock = Loam::RecordLocks.acquire(@record, by: current_actor) || Loam::RecordLocks.active_lock(@record)
+      @lock = OpenLoam::RecordLocks.acquire(@record, by: current_actor) || OpenLoam::RecordLocks.active_lock(@record)
     end
 
     def update
@@ -94,15 +94,15 @@ module Admin
       attach_files!(@record, policy)
 
       if @record.update(permitted_params(policy))
-        Loam::RecordLocks.release(@record, by: current_actor)
-        redirect_to [:admin, @record], notice: t("loam.flash.updated", name: <%= class_name %>.model_name.human)
+        OpenLoam::RecordLocks.release(@record, by: current_actor)
+        redirect_to [:admin, @record], notice: t("open_loam.flash.updated", name: <%= class_name %>.model_name.human)
       else
         render :edit, status: :unprocessable_entity
       end
     rescue ActiveRecord::StaleObjectError
       # Someone saved between open and submit — show the diff, reload fresh, retry.
       stale_conflict!(@record, FIELDS)
-      @lock = Loam::RecordLocks.acquire(@record, by: current_actor) || Loam::RecordLocks.active_lock(@record)
+      @lock = OpenLoam::RecordLocks.acquire(@record, by: current_actor) || OpenLoam::RecordLocks.active_lock(@record)
       render :edit, status: :conflict
     end
 
@@ -111,8 +111,8 @@ module Admin
     def destroy
       authorize!(policy_for(@record), :destroy?)
       @record.soft_delete!
-      Loam::RecordLocks.release(@record, by: current_actor)
-      redirect_to [:admin, <%= class_name %>], notice: t("loam.flash.destroyed", name: <%= class_name %>.model_name.human)
+      OpenLoam::RecordLocks.release(@record, by: current_actor)
+      redirect_to [:admin, <%= class_name %>], notice: t("open_loam.flash.destroyed", name: <%= class_name %>.model_name.human)
     end
 
     # Restore looks through the deleted rows — the default scope hides them, so a
@@ -121,7 +121,7 @@ module Admin
       @record = <%= class_name %>.with_deleted.find(params[:id])
       authorize!(policy_for(@record), :update?)
       @record.restore!
-      redirect_to [:deleted, :admin, <%= class_name %>], notice: t("loam.flash.restored", name: <%= class_name %>.model_name.human)
+      redirect_to [:deleted, :admin, <%= class_name %>], notice: t("open_loam.flash.restored", name: <%= class_name %>.model_name.human)
     end
 
     private
@@ -134,7 +134,7 @@ module Admin
     # export so the CSV matches what the manager is looking at.
     def index_scope
       scope = <%= class_name %>.all
-      perspective = Loam::Perspectives.resolve("<%= class_name %>", user: current_actor, id: params[:perspective_id])
+      perspective = OpenLoam::Perspectives.resolve("<%= class_name %>", user: current_actor, id: params[:perspective_id])
       scope = perspective.apply(scope) if perspective
 <% if searchable_attributes.any? -%>
       scope = scope.search(params[:q])
@@ -160,13 +160,13 @@ module Admin
     end
 
     # A custom-field filter routed through the read-model index
-    # (Loam::CustomFieldIndex) — index-backed, not a JSON scan. An unknown field
+    # (OpenLoam::CustomFieldIndex) — index-backed, not a JSON scan. An unknown field
     # is ignored rather than raising.
     def apply_custom_field_filter(scope)
       return scope if params[:cf_field].blank?
 
-      scope.merge(Loam::CustomFieldIndex.filter(<%= class_name %>, params[:cf_field], params[:cf_op].presence || "eq", params[:cf_value]))
-    rescue Loam::Error
+      scope.merge(OpenLoam::CustomFieldIndex.filter(<%= class_name %>, params[:cf_field], params[:cf_op].presence || "eq", params[:cf_value]))
+    rescue OpenLoam::Error
       scope
     end
 

data/lib/generators/{loam → open_loam}/entity/templates/entity_test.rb

@@ -1,19 +1,19 @@
 require "test_helper"
 
-# Generated guardrail tests for <%= class_name %>. They prove the Loam
+# Generated guardrail tests for <%= class_name %>. They prove the OpenLoam
 # invariants hold for THIS entity: tenant isolation, loud failure without
 # context, audit-by-default, lifecycle events, membership-gated policies.
 # Extend freely; never delete.
-class <%= class_name %>LoamTest < ActiveSupport::TestCase
+class <%= class_name %>OpenLoamTest < ActiveSupport::TestCase
   setup do
-    @tenant_a = Loam::Tenant.create!(name: "Tenant A", slug: "a-<%= file_name %>")
-    @tenant_b = Loam::Tenant.create!(name: "Tenant B", slug: "b-<%= file_name %>")
+    @tenant_a = OpenLoam::Tenant.create!(name: "Tenant A", slug: "a-<%= file_name %>")
+    @tenant_b = OpenLoam::Tenant.create!(name: "Tenant B", slug: "b-<%= file_name %>")
     @manager = User.create!(name: "Manager", email: "manager@example.test", password: "password")
     @employee = User.create!(name: "Employee", email: "employee@example.test", password: "password")
 
     with_tenant(@tenant_a) do
-      Loam::Membership.create!(user: @manager, role: "manager")
-      Loam::Membership.create!(user: @employee, role: "employee")
+      OpenLoam::Membership.create!(user: @manager, role: "manager")
+      OpenLoam::Membership.create!(user: @employee, role: "employee")
     end
   end
 
@@ -29,15 +29,15 @@ class <%= class_name %>LoamTest < ActiveSupport::TestCase
   end
 
   test "guardrail: touching the model with no tenant context raises" do
-    assert_raises(Loam::MissingTenantError) { <%= class_name %>.count }
-    assert_raises(Loam::MissingTenantError) { <%= class_name %>.new }
+    assert_raises(OpenLoam::MissingTenantError) { <%= class_name %>.count }
+    assert_raises(OpenLoam::MissingTenantError) { <%= class_name %>.new }
   end
 
   test "guardrail: a record cannot be written into a foreign tenant" do
     record = with_tenant(@tenant_a) { <%= class_name %>.create!(<%= sample_attributes %>) }
 
     with_tenant(@tenant_b) do
-      assert_raises(Loam::MissingTenantError) { record.update!(<%= sample_attributes(1) %>) }
+      assert_raises(OpenLoam::MissingTenantError) { record.update!(<%= sample_attributes(1) %>) }
     end
   end
 
@@ -45,7 +45,7 @@ class <%= class_name %>LoamTest < ActiveSupport::TestCase
     with_tenant(@tenant_a, actor: @manager) do
       record = <%= class_name %>.create!(<%= sample_attributes %>)
 
-      audit = Loam::AuditRecord.find_by(
+      audit = OpenLoam::AuditRecord.find_by(
         auditable_type: "<%= class_name %>", auditable_id: record.id, action: "create"
       )
       assert audit, "expected an audit record for the create"
@@ -56,7 +56,7 @@ class <%= class_name %>LoamTest < ActiveSupport::TestCase
 
   test "lifecycle events are published with the tenant stamped" do
     received = []
-    subscription = Loam::Events.subscribe("<%= domain %>.<%= singular_name %>.created") do |_name, payload|
+    subscription = OpenLoam::Events.subscribe("<%= domain %>.<%= singular_name %>.created") do |_name, payload|
       received << payload
     end
 
@@ -78,7 +78,7 @@ class <%= class_name %>LoamTest < ActiveSupport::TestCase
     with_tenant(@tenant_a) do
       assert_equal 0, <%= class_name %>.count, "a soft-deleted record is gone from ordinary queries"
       assert_equal 1, <%= class_name %>.with_deleted.count, "but the row still exists"
-      assert Loam::AuditRecord.exists?(auditable_type: "<%= class_name %>", auditable_id: record_id, action: "soft_delete")
+      assert OpenLoam::AuditRecord.exists?(auditable_type: "<%= class_name %>", auditable_id: record_id, action: "soft_delete")
     end
 
     # with_deleted lifts the deleted_at filter but NOT the tenant filter.

data/lib/generators/{loam → open_loam}/entity/templates/migration.rb

@@ -1,10 +1,10 @@
 class Create<%= table_name.camelize %> < ActiveRecord::Migration[<%= ActiveRecord::VERSION::STRING.to_f %>]
   def change
-    create_table :<%= table_name %><%= loam_id_option %> do |t|
-      t.references :tenant, null: false, foreign_key: { to_table: :loam_tenants }<%= loam_type_option %>
+    create_table :<%= table_name %><%= open_loam_id_option %> do |t|
+      t.references :tenant, null: false, foreign_key: { to_table: :open_loam_tenants }<%= open_loam_type_option %>
 <% attributes.each do |attribute| -%>
 <% if encrypted?(attribute) -%>
-      t.text :<%= attribute.name %>   # encrypted at rest (Loam::Encryptable) — text, since ciphertext outgrows varchar
+      t.text :<%= attribute.name %>   # encrypted at rest (OpenLoam::Encryptable) — text, since ciphertext outgrows varchar
 <% else -%>
       t.<%= attribute.type %> :<%= attribute.name %>
 <% end -%>
@@ -14,10 +14,10 @@ class Create<%= table_name.camelize %> < ActiveRecord::Migration[<%= ActiveRecor
 <% end -%>
       t.json :custom_fields, null: false, default: {}
       t.datetime :deleted_at
-      t.integer :lock_version, null: false, default: 0   # optimistic locking (Loam::RecordLock)
+      t.integer :lock_version, null: false, default: 0   # optimistic locking (OpenLoam::RecordLock)
       t.timestamps
     end
-    # Loam::SoftDeletable filters `deleted_at IS NULL` on every query.
+    # OpenLoam::SoftDeletable filters `deleted_at IS NULL` on every query.
     add_index :<%= table_name %>, :deleted_at
 <% encrypt_searchable_names.each do |field| -%>
     add_index :<%= table_name %>, :<%= field %>_hash

data/lib/generators/{loam → open_loam}/entity/templates/model.rb

@@ -1,14 +1,14 @@
 # Tenant-scoped, audited, evented — by inheritance, not by remembering.
-class <%= class_name %> < Loam::TenantRecord
-  include Loam::Auditable
-  include Loam::Eventful
-  include Loam::CustomFields
-  include Loam::Commentable
-  include Loam::Attachable
-  include Loam::Searchable
-  include Loam::SoftDeletable
+class <%= class_name %> < OpenLoam::TenantRecord
+  include OpenLoam::Auditable
+  include OpenLoam::Eventful
+  include OpenLoam::CustomFields
+  include OpenLoam::Commentable
+  include OpenLoam::Attachable
+  include OpenLoam::Searchable
+  include OpenLoam::SoftDeletable
 <% if encrypted_field_names.any? -%>
-  include Loam::Encryptable
+  include OpenLoam::Encryptable
 <% end -%>
 
   event_domain :<%= domain %>
@@ -23,5 +23,5 @@ class <%= class_name %> < Loam::TenantRecord
 <% end -%>
 
   # Business logic goes here. Publish business events explicitly:
-  #   Loam::Events.publish("<%= domain %>.something.happened", id: id)
+  #   OpenLoam::Events.publish("<%= domain %>.something.happened", id: id)
 end

data/lib/generators/{loam → open_loam}/entity/templates/policy.rb

@@ -1,4 +1,4 @@
-class <%= class_name %>Policy < Loam::Policy
+class <%= class_name %>Policy < OpenLoam::Policy
   # Action defaults: any member of the current tenant may read/create/update/
   # destroy. Tighten by overriding, e.g.:
   #

data/lib/generators/{loam → open_loam}/entity/templates/views/_form.html.erb

@@ -1,4 +1,4 @@
-<%% policy = Loam::Policy.for(@record) %>
+<%% policy = OpenLoam::Policy.for(@record) %>
 
 <%%# Optimistic-locking conflict: what the user typed vs what is now saved. %>
 <%% if @conflict.present? %>
@@ -45,16 +45,16 @@
   <%% else %>
     <p>
       <%%= f.label :<%= attribute.name %> %>: <%%= @record.<%= attribute.name %> %>
-      <em><%%= t("loam.form.read_only") %></em>
+      <em><%%= t("open_loam.form.read_only") %></em>
     </p>
   <%% end %>
 <% end -%>
 
-  <%%= render "loam/custom_fields/fields", record: @record, policy: policy, mode: :edit %>
+  <%%= render "open_loam/custom_fields/fields", record: @record, policy: policy, mode: :edit %>
 
   <%% if policy.update? %>
     <p>
-      <%%= f.label :files, t("loam.form.attach_files") %><br>
+      <%%= f.label :files, t("open_loam.form.attach_files") %><br>
       <%%= f.file_field :files, multiple: true %>
     </p>
   <%% end %>

data/lib/generators/{loam → open_loam}/entity/templates/views/deleted.html.erb

@@ -1,13 +1,13 @@
-<h1><%%= t("loam.actions.deleted_title", name: <%= class_name %>.model_name.human(count: 2)) %></h1>
+<h1><%%= t("open_loam.actions.deleted_title", name: <%= class_name %>.model_name.human(count: 2)) %></h1>
 
-<p><%%= link_to t("loam.actions.back"), [:admin, <%= class_name %>] %></p>
+<p><%%= link_to t("open_loam.actions.back"), [:admin, <%= class_name %>] %></p>
 
 <%%# No Show/Edit here: these rows are hidden by the default scope, so a plain
     find would 404. The one action a deleted record offers is Restore. %>
 <table>
   <thead>
     <tr>
-      <th><%%= t("loam.labels.id") %></th>
+      <th><%%= t("open_loam.labels.id") %></th>
 <% attributes.each do |attribute| -%>
       <th><%%= <%= class_name %>.human_attribute_name("<%= attribute.name %>") %></th>
 <% end -%>
@@ -23,7 +23,7 @@
         <td><%%= record.<%= attribute.name %> %></td>
 <% end -%>
         <td><%%= record.deleted_at %></td>
-        <td><%%= button_to t("loam.actions.restore"), [:restore, :admin, record], method: :patch %></td>
+        <td><%%= button_to t("open_loam.actions.restore"), [:restore, :admin, record], method: :patch %></td>
       </tr>
     <%% end %>
   </tbody>
@@ -32,10 +32,10 @@
 <%%# Page links carry nothing but the page: the recycle bin has no filter box. %>
 <p>
   <%% if @page > 1 %>
-    <%%= link_to t("loam.pagination.previous"), polymorphic_path([:deleted, :admin, <%= class_name %>], page: @page - 1) %>
+    <%%= link_to t("open_loam.pagination.previous"), polymorphic_path([:deleted, :admin, <%= class_name %>], page: @page - 1) %>
   <%% end %>
-  <%%= t("loam.pagination.page", page: @page) %>
+  <%%= t("open_loam.pagination.page", page: @page) %>
   <%% if @has_next %>
-    <%%= link_to t("loam.pagination.next"), polymorphic_path([:deleted, :admin, <%= class_name %>], page: @page + 1) %>
+    <%%= link_to t("open_loam.pagination.next"), polymorphic_path([:deleted, :admin, <%= class_name %>], page: @page + 1) %>
   <%% end %>
 </p>

data/lib/generators/open_loam/entity/templates/views/edit.html.erb

@@ -0,0 +1,3 @@
+<h1><%%= t("open_loam.actions.edit_title", name: <%= class_name %>.model_name.human, id: @record.id) %></h1>
+
+<%%= render "form" %>

data/lib/generators/open_loam/entity/templates/views/index.html.erb

@@ -0,0 +1,90 @@
+<h1><%%= <%= class_name %>.model_name.human(count: 2) %></h1>
+
+<%% if @index_partial %>
+  <p style="color:#b00"><%%= t("open_loam.index.incomplete") %></p>
+<%% end %>
+
+<p>
+  <%%= link_to t("open_loam.actions.new", name: <%= class_name %>.model_name.human), new_polymorphic_path([:admin, <%= class_name %>]) %>
+  <%%= link_to t("open_loam.actions.deleted", name: <%= class_name %>.model_name.human(count: 2)), polymorphic_path([:deleted, :admin, <%= class_name %>]) %>
+  <%% if current_role == :manager %>
+    <%%= link_to t("open_loam.actions.export_csv"), url_for(action: :export, **current_index_params) %>
+    <%%= link_to t("open_loam.actions.import_csv"), new_admin_import_path(entity_type: "<%= class_name %>") %>
+  <%% end %>
+</p>
+
+<%%# Saved views (OpenLoam::Perspectives): pick one to apply, or save the current one. %>
+<%% if @perspectives.any? %>
+  <%%= form_with url: [:admin, <%= class_name %>], method: :get do %>
+    <%%= select_tag :perspective_id,
+          options_for_select([[t("open_loam.views.all", name: <%= class_name %>.model_name.human(count: 2)), "none"]] + @perspectives.map { |p| [p.name, p.id] }, @perspective&.id),
+          onchange: "this.form.submit()" %>
+    <%%= link_to t("open_loam.views.manage"), admin_perspectives_path(entity_type: "<%= class_name %>") %>
+  <%% end %>
+<%% else %>
+  <p><%%= link_to t("open_loam.views.manage_saved"), admin_perspectives_path(entity_type: "<%= class_name %>") %></p>
+<%% end %>
+
+<%%= form_with url: admin_perspectives_path, method: :post do %>
+  <%%= hidden_field_tag :entity_type, "<%= class_name %>" %>
+  <%%= hidden_field_tag :q, params[:q] %>
+  <%%= text_field_tag :name, nil, placeholder: t("open_loam.views.name_placeholder") %>
+  <%%= submit_tag t("open_loam.views.save_current") %>
+<%% end %>
+<% if searchable_attributes.any? -%>
+
+<%%= form_with url: [:admin, <%= class_name %>], method: :get do |f| %>
+  <%%= text_field_tag :q, params[:q], placeholder: t("open_loam.views.filter_placeholder", name: <%= class_name %>.model_name.human(count: 2)) %>
+  <%%= f.submit t("open_loam.actions.filter") %>
+<%% end %>
+<% end -%>
+
+<%%# Bulk actions on selected rows (OpenLoam::Bulk). Zero selection = no-op; each
+    action is policy-checked per record server-side. %>
+<%%= form_with url: url_for(action: :bulk), method: :post do %>
+  <p>
+    <%%= select_tag :bulk_action, options_for_select([[t("open_loam.bulk.delete_selected"), "soft_delete"], [t("open_loam.bulk.set_field"), "set_field"], [t("open_loam.bulk.export_selected"), "export"]]) %>
+    <%%= select_tag :field, options_for_select(%i[<%= field_names.join(" ") %>]) %>
+    <%%= text_field_tag :value, nil, placeholder: t("open_loam.bulk.new_value") %>
+    <%%= submit_tag t("open_loam.bulk.apply"), data: { turbo_confirm: t("open_loam.bulk.confirm") } %>
+  </p>
+
+  <table>
+    <thead>
+      <tr>
+        <th><input type="checkbox" onclick="document.querySelectorAll('.bulk-select').forEach(function(c){c.checked=this.checked}.bind(this))"></th>
+        <th><%%= t("open_loam.labels.id") %></th>
+<% attributes.each do |attribute| -%>
+        <th><%%= sort_link("<%= attribute.name %>", <%= class_name %>.human_attribute_name("<%= attribute.name %>")) %></th>
+<% end -%>
+        <th></th>
+      </tr>
+    </thead>
+    <tbody>
+      <%% @records.each do |record| %>
+        <tr>
+          <td><%%= check_box_tag "ids[]", record.id, false, class: "bulk-select" %></td>
+          <td><%%= record.id %></td>
+<% attributes.each do |attribute| -%>
+          <td><%%= record.<%= attribute.name %> %></td>
+<% end -%>
+          <td>
+            <%%= link_to t("open_loam.actions.show"), [:admin, record] %>
+            <%%= link_to t("open_loam.actions.edit"), edit_polymorphic_path([:admin, record]) %>
+          </td>
+        </tr>
+      <%% end %>
+    </tbody>
+  </table>
+<%% end %>
+
+<%%# Page links carry the full filter state, or page 2 would quietly drop it. %>
+<p>
+  <%% if @page > 1 %>
+    <%%= link_to t("open_loam.pagination.previous"), polymorphic_path([:admin, <%= class_name %>], **current_index_params, page: @page - 1) %>
+  <%% end %>
+  <%%= t("open_loam.pagination.page", page: @page) %>
+  <%% if @has_next %>
+    <%%= link_to t("open_loam.pagination.next"), polymorphic_path([:admin, <%= class_name %>], **current_index_params, page: @page + 1) %>
+  <%% end %>
+</p>