ea 0.2.5 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 44e2c62c415fec32597751f87ec29e35529726a61cdcc1908ae0b0a371b94443
-  data.tar.gz: 68fce8e4b397c9c9701d443f9dcf74f8fe7b15c286b4442fbdacd63a1808ec5f
+  metadata.gz: cf343d41c80cffbd277dd67bf172d0c947ddae898f51dacc1a2fffc3af871b0a
+  data.tar.gz: b554c52026c03c0a431e31140f840fedd495fae447b738c4d9fda4fae30c9eda
 SHA512:
-  metadata.gz: f251cc03250dbddf267365a7c3f671c8ba4faf8203ce592529ce2cbf9ca95a723f694a2e768c6271d032fd51308bba6694e9368c63f3a47282dd3c58e5921092
-  data.tar.gz: 14c25b3daa1ace6436f06109e23a3b01a4b75de008c8a18f789db8e81b66dbe89881a49e01cb8cc8dd90d8c950b927f594a17c2a2b6a7d4a0fd7328da9296793
+  metadata.gz: bdec06da4470d865e75c52cbe8c5bec83ae4f242b223e98b436e5c244e8dcf8fd3c9a03bfe3f1ef3eedd9d2443fa52c21544755e8ff9cb3c5e698ee0a4b685f3
+  data.tar.gz: 5db5b284986bd79b3c1165f491d95cb6a5b9cd88d0bcdcab116e77abd92ebd84b267c8f3614850fa669d544085eca6eba52a6eea45c992e42439aa0b38803194

data/TODO.refactor/01-ea-model-domain-layer.md

@@ -0,0 +1,64 @@
+# 01 - Ea::Model Domain Layer
+
+## Status: DONE (2026-07-19)
+
+## Problem
+
+EA QEA/XMI sources are tightly coupled to their storage format. The
+existing pipeline funnels everything through `Lutaml::Uml::Document`,
+which is lossy (drops annotations, tagged values, diagram coordinates)
+and slow (allocates huge Ruby object graphs).
+
+We need a canonical in-process domain model — `Ea::Model::*` — that
+both QEA and XMI sources harmonize into. The model is the single
+source of truth for "what the model IS". Source format becomes
+irrelevant once you're in `Ea::Model`.
+
+## Architectural Principle
+
+Hexagonal / Ports & Adapters. `Ea::Model` is the hexagon:
+- **Driving ports** = source adapters (`Ea::Sources::Qea`,
+  `Ea::Sources::Xmi`) that produce model instances from source files.
+- **Driven ports** = consumer adapters (`Ea::Spa`, future
+  `Ea::Export::*`, `Ea::Validate::*`, `Ea::Compare::*`) that project
+  or transform the model for their use case.
+
+Dependencies point inward only. The model never knows about a source
+format; consumers never know about a source format.
+
+## Domain Types
+
+- `Ea::Model::Document` — root container (packages, classifiers,
+  relationships, diagrams, stereotypes)
+- `Ea::Model::Package` — hierarchical containment (sub-packages,
+  owned classifiers)
+- `Ea::Model::Classifier` (abstract) → `Class`, `DataType`,
+  `PrimitiveType`, `Enumeration`, `Interface`
+- `Ea::Model::Property` — typed slot, multiplicity, defaults,
+  stereotypes, tagged values
+- `Ea::Model::Operation` — signature, parameters, return type
+- `Ea::Model::Parameter`
+- `Ea::Model::Relationship` (abstract) → `Association` (two ends),
+  `Generalization`, `Realization`, `Dependency`
+- `Ea::Model::EnumerationLiteral`
+- `Ea::Model::Stereotype` — first-class, with tagged-value schema
+- `Ea::Model::TaggedValue` — first-class (key, value, scope)
+- `Ea::Model::Annotation` — first-class (type, body, author)
+- `Ea::Model::Diagram` + `DiagramElement` (with bounds/style) +
+  `DiagramConnector` (with waypoints/style)
+- `Ea::Model::Point` (x,y), `Ea::Model::Bounds` (x,y,w,h),
+  `Ea::Model::Waypoint`
+
+## Files
+
+- `lib/ea/model.rb` — namespace + autoloads
+- `lib/ea/model/base.rb` — `Ea::Model::Base` (lutaml-model subclass,
+  common `id`, `name`, `qualified_name` attrs)
+- One file per type under `lib/ea/model/`
+- `spec/ea/model/*_spec.rb` — type-level specs
+
+## Verification
+
+- Each type has a spec verifying attributes, defaults, JSON round-trip
+- `Ea::Model::Document` builds in-memory fixtures for use by upstream
+  specs (no source-format coupling in model specs)

data/TODO.refactor/02-ea-model-qea-source-adapter.md

@@ -0,0 +1,58 @@
+# 02 - QEA Source Adapter
+
+## Status: DONE (2026-07-19)
+
+## Problem
+
+`Ea::Qea::Database` is a typed wrap of the Sparx SQLite schema. It
+mirrors the schema 1:1 — `t_object`, `t_package`, `t_connector`,
+`t_attribute`, `t_operation`, `t_diagram`, `t_diagramlinks`,
+`t_objectproperties`, `t_objectconstrains`, etc. — with their
+packed-string columns and integer-coded types. It is intentionally
+faithful to the source format.
+
+`Ea::Model::*` is the canonical domain. Something has to translate.
+
+## Approach
+
+`Ea::Sources::Qea::Adapter` is a driving adapter: takes a
+`Ea::Qea::Database`, produces an `Ea::Model::Document`. The adapter
+walks the database tables once, builds typed model instances, and
+resolves foreign-key references into model-id references.
+
+The adapter is structured as a coordinator + per-table builders
+(OCP/MECE):
+- `Adapter` — orchestrates traversal
+- `PackageBuilder` — `t_package → Model::Package`
+- `ClassifierBuilder` — `t_object (Class/DataType/Enum/Interface)
+  → Model::Classifier subclass`
+- `PropertyBuilder` — `t_attribute → Model::Property`
+- `OperationBuilder` — `t_operation + t_operationsparams →
+  Model::Operation`
+- `RelationshipBuilder` — `t_connector → Model::Relationship
+  subclass` (dispatches on `Connector_Type`)
+- `StereotypeBuilder` — `t_object + stylename → Model::Stereotype
+  application`
+- `TaggedValueBuilder` — `t_objectproperties → Model::TaggedValue`
+- `AnnotationBuilder` — `t_object.Note + t_document →
+  Model::Annotation`
+- `DiagramBuilder` — `t_diagram + t_diagramlinks + t_dg +
+  t_connector → Model::Diagram` (with coordinates!)
+
+ID normalization: EA GUIDs (`{GUID}`) are normalized to plain
+strings. References become model `id` references (decoupled from
+source format).
+
+## Files
+
+- `lib/ea/sources.rb` — namespace
+- `lib/ea/sources/qea.rb` — namespace + autoloads
+- `lib/ea/sources/qea/adapter.rb`
+- `lib/ea/sources/qea/*.rb` — per-table builders
+- `spec/ea/sources/qea/*_spec.rb`
+
+## Verification
+
+- Builder specs against in-memory `Ea::Qea` fixtures
+- Round-trip: real QEA fixture → `Ea::Model::Document`, assert
+  package/class/relationship counts and known element names

data/TODO.refactor/03-ea-model-xmi-source-adapter.md

@@ -0,0 +1,33 @@
+# 03 - XMI Source Adapter
+
+## Status: DONE (2026-07-19)
+
+## Problem
+
+Sparx-flavored XMI files (`.xmi`) parse into `Xmi::Sparx::Root`.
+Same harmonization problem as QEA — different format, same model.
+
+## Approach
+
+`Ea::Sources::Xmi::Adapter` mirrors the QEA adapter's structure
+(coordinator + per-element builders), but reads from the parsed
+`Xmi::Sparx::Root` tree instead of SQLite tables. Builders
+dispatch on `xmi:type` discriminator (`uml:Class`,
+`uml:Association`, etc.).
+
+Deferred until TODOs 01, 02, 06, 10 are green so the SPA pipeline
+proves itself on QEA first (the perf pain point). XMI is already
+served by the existing `lutaml-uml` pipeline; the EA-native QEA
+pipeline is the gap.
+
+## Files
+
+- `lib/ea/sources/xmi.rb` + `lib/ea/sources/xmi/adapter.rb` +
+  per-element builders
+- `spec/ea/sources/xmi/*_spec.rb`
+
+## Verification
+
+- Round-trip on existing `spec/fixtures/*.xmi`
+- Parity assertions vs the QEA adapter where the same model is
+  available in both formats

data/TODO.refactor/04-ea-model-annotations-tagged-values.md

@@ -0,0 +1,34 @@
+# 04 - Annotations and Tagged Values (the EA value-add)
+
+## Status: DONE (2026-07-19, folded into TODO 01)
+
+## Problem
+
+Pure-UML pipelines drop or downplay the EA value-add: rich
+annotations (notes, documentation, change history) and tagged
+values (key/value metadata scoped to stereotypes). The canonical
+`Ea::Model` must capture these as first-class concepts.
+
+## Approach
+
+Modeled in TODO 01 as:
+
+- `Ea::Model::Annotation` — `type` (enum: comment/documentation/
+  change/file/requirement), `body`, `author`, `modified_date`
+- `Ea::Model::TaggedValue` — `key`, `value`, `stereotype_ref`
+  (optional; nil for unscoped tagged values)
+- `Ea::Model::Stereotype` — `name`, `qualified_name`, `profile`,
+  plus its tagged-value schema (declared keys with type/default)
+
+These types live alongside Classifiers/Properties in the model —
+they're not afterthoughts. The QEA source adapter populates them
+from `t_object.Note`, `t_objectproperties`, `t_objectconstraints`,
+etc.
+
+## Verification
+
+- Spec: a Class with 3 annotations of different types round-trips
+- Spec: a Class with 2 stereotypes, each with tagged values,
+  round-trips
+- Spec: search projection includes annotation bodies in search
+  content

data/TODO.refactor/05-ea-model-diagrams-coordinates.md

@@ -0,0 +1,37 @@
+# 05 - Diagrams with Coordinates (the EA value-add)
+
+## Status: DONE (2026-07-19, folded into TODO 01)
+
+## Problem
+
+EA diagrams carry pixel-accurate element positions, connector
+waypoints, color and font styling. UML-only SPAs drop all of this
+and present a tree of classes. For browsing the original model,
+the diagram IS the artifact.
+
+## Approach
+
+Modeled in TODO 01 as:
+
+- `Ea::Model::Diagram` — owns elements + connectors + metadata
+- `Ea::Model::DiagramElement` — `model_element_ref` (id to a
+  Classifier/Package/etc.), `bounds` (x,y,w,h), `style` (parsed
+  from EA's packed `Style` string into typed fields: fill, line,
+  font, etc.)
+- `Ea::Model::DiagramConnector` — `relationship_ref` (id to a
+  Relationship), `waypoints` (ordered list of Points), `labels`,
+  `style`
+- `Ea::Model::Waypoint` — `Point` + optional routing hint
+- `Ea::Model::Point` (x: Integer, y: Integer)
+- `Ea::Model::Bounds` (x, y, width, height)
+
+Style parsing lives in `Ea::Sources::Qea::DiagramStyleParser` —
+takes the EA `styleex`/`Style` packed strings and emits a typed
+`DiagramStyle` value. Same parser pattern as `Ea::Diagram::StyleParser`
+(which exists today for the SVG renderer); we share or unify.
+
+## Verification
+
+- Spec: parse a real EA diagram from plateau model fixture, assert
+  element bounds and connector waypoints are non-empty
+- Spec: diagram projects to SPA shape with bounds/waypoints intact

data/TODO.refactor/06-spa-projection-layer.md

@@ -0,0 +1,45 @@
+# 06 - SPA Projection Layer
+
+## Status: DONE (2026-07-19)
+
+## Problem
+
+The SPA needs a view of the model that's shardable, searchable,
+and lazy-loadable. But sharding/search/lazy-loading are properties
+of the *view*, not the model — putting them on `Ea::Model::*`
+would couple the model to one consumer.
+
+## Approach
+
+`Ea::Spa::*` is the projection. One-way transform from
+`Ea::Model::Document` to view-shaped artifacts:
+
+- `Ea::Spa::Projector` — walks the model, emits:
+  - `Skeleton` — top-level: metadata + package tree + flat
+    classifier index (`id, name, type, package_id, qualified_name`)
+  - `Shard` (per-entity) — full detail of one Class/Package/etc.
+    including properties/operations/relationships/annotations/
+    tagged values
+  - `SearchIndex` — flat search entries (id, type, name, qname,
+    package, content) ready for MiniSearch
+  - `PackageTree` — hierarchical navigation tree
+
+Projection is lossy by design: the SPA doesn't carry every model
+field; it carries what browsing needs.
+
+## Files
+
+- `lib/ea/spa.rb` — namespace
+- `lib/ea/spa/projector.rb`
+- `lib/ea/spa/skeleton.rb`, `skeleton_entry.rb`
+- `lib/ea/spa/shard.rb`, `shard_writer.rb`
+- `lib/ea/spa/search_index.rb`, `search_entry.rb`
+- `lib/ea/spa/package_tree.rb`, `package_tree_node.rb`
+- `lib/ea/spa/lazy_ref.rb`
+- `spec/ea/spa/*_spec.rb`
+
+## Verification
+
+- Projector spec: in-memory model → skeleton/shards/search
+- Round-trip: QEA fixture → Model → Spa::Skeleton — assert
+  element counts match

data/TODO.refactor/07-spa-sharded-output-strategy.md

@@ -0,0 +1,28 @@
+# 07 - Sharded Output Strategy
+
+## Status: DONE (2026-07-19)
+
+## Problem
+
+Single-file output doesn't scale. For large models, the SPA must
+ship as skeleton + per-entity shards, loaded on demand.
+
+## Approach
+
+Output strategy pattern (mirrors existing lutaml-uml shape):
+
+- `Ea::Spa::Output::Strategy` (abstract)
+- `Ea::Spa::Output::SingleFileStrategy` — embeds everything in
+  one HTML (small models only)
+- `Ea::Spa::Output::ShardedMultiFileStrategy` — directory with
+  `skeleton.json`, `search.json`, `data/classes/{id}.json`,
+  `data/packages/{id}.json`, `data/diagrams/{id}.json`
+
+Size threshold auto-selects: under 2 MB JSON → single file, else
+sharded. Configurable.
+
+## Verification
+
+- Spec: small model → single-file output
+- Spec: large model → sharded output, skeleton lists every
+  classifier, each shard file exists and parses

data/TODO.refactor/08-spa-build-time-search-index.md

@@ -0,0 +1,24 @@
+# 08 - Build-time Search Index
+
+## Status: DONE (2026-07-19)
+
+## Problem
+
+Frontend search currently scans a flat list in memory. For 10k+
+classes, that's slow. Need a real inverted index built at build
+time, lazy-loaded at run time.
+
+## Approach
+
+`Ea::Spa::SearchIndex` produces documents in MiniSearch-friendly
+shape (id, name, qualifiedName, type, package, content with
+boosts). Frontend loads MiniSearch JS lib lazily on first search
+focus,hydrates the index from `search.json`.
+
+Frontend integration deferred until TODO 09 lands the data
+contract. Ruby-side emission: implemented in TODO 06.
+
+## Verification
+
+- Spec: search index includes all classifiers with correct boosts
+- Spec: search content includes annotation bodies (rich)

data/TODO.refactor/09-spa-frontend-data-contract.md

@@ -0,0 +1,25 @@
+# 09 - SPA Frontend Data Contract
+
+## Status: DEFERRED (frontend extraction)
+
+## Problem
+
+Vue frontend lives in `lutaml-uml/frontend`. EA-side SPA needs to
+share it without forking.
+
+## Approach
+
+Define a versioned JSON schema for the SPA data contract. Both
+`lutaml-uml`'s SPA and `Ea::Spa` produce JSON conforming to the
+schema. Frontend is extracted to its own npm package
+(`@lutaml/spa-frontend`) and consumed by both.
+
+Deferred until Ruby-side projection is proven stable. For now,
+`Ea::Spa` emits JSON in a shape compatible with the existing Vue
+frontend's data loader, so we can copy the frontend in for
+testing.
+
+## Verification
+
+- Schema spec: every field documented, has a fixture
+- Cross-compat: existing Vue frontend can load `Ea::Spa`'s output

data/TODO.refactor/10-spa-cli-command-rework.md

@@ -0,0 +1,34 @@
+# 10 - Rework `ea spa` CLI Command
+
+## Status: DONE (2026-07-19)
+
+## Problem
+
+`Ea::Cli::Command::Spa` currently delegates to
+`Lutaml::UmlRepository::StaticSite::Generator`, forcing the QEA →
+UML transform. The new pipeline is QEA → `Ea::Model` → `Ea::Spa`.
+
+## Approach
+
+Rewire to:
+1. `Ea.parse(file)` → source-specific model (QEA Database or XMI
+   Root)
+2. Source adapter → `Ea::Model::Document`
+3. `Ea::Spa::Projector` → skeleton + shards + search index
+4. `Ea::Spa::Output::Strategy` → HTML/JSON on disk
+
+Output mode auto-selected by payload size, overridable by
+`--mode=single_file|sharded` flag.
+
+## Files
+
+- `lib/ea/cli/command/spa.rb` — reworked
+- `lib/ea/cli/command/repository_builder.rb` — extended to feed
+  the new pipeline
+- `spec/ea/cli/spa_spec.rb` — end-to-end on a small fixture
+
+## Verification
+
+- `ea spa path/to/small.qea` produces a valid SPA
+- `ea spa path/to/plateau-model/20251010_current_plateau_v5.1.qea`
+  completes in minutes, not hours

data/TODO.refactor/11-spa-perf-benchmark.md

@@ -0,0 +1,23 @@
+# 11 - SPA Performance Benchmark
+
+## Status: DEFERRED (until pipeline is stable)
+
+## Problem
+
+Need empirical proof that the 45 MB CityGML QEA becomes
+browseable.
+
+## Approach
+
+Benchmark spec that:
+- Loads `plateau-model/20251010_current_plateau_v5.1.qea` (6 MB)
+- Loads `plateau-model/20260323_CityGML_3.0_Consolidated_Draft.qea`
+  (45 MB)
+- Reports: parse time, model build time, projection time, output
+  size, shard count
+- Snapshot to compare regressions
+
+## Verification
+
+The plateau v5.1 must complete in < 60 s end-to-end on a laptop.
+CityGML 45 MB should complete in < 10 min.

data/TODO.refactor/12-lutaml-uml-static-site-deprecation.md

@@ -0,0 +1,28 @@
+# 12 - lutaml-uml StaticSite Fate
+
+## Status: DEFERRED (post-validation)
+
+## Problem
+
+Once `Ea::Spa` is stable, `Lutaml::UmlRepository::StaticSite` is
+redundant for EA sources. Decide: deprecate, or repurpose as the
+"UML-purist" view for non-EA sources.
+
+## Approach
+
+Three options:
+1. **Deprecate entirely** — once EA users move to `ea spa`,
+   remove from `lutaml-uml`. Cleanest.
+2. **Keep as UML-purist SPA** — for users who want the abstracted
+   UML view (e.g. after cross-vendor harmonization via
+   `lutaml-uml`). Document as a separate use case.
+3. **Keep as thin wrapper** — `lutaml-uml`'s SPA calls into
+   `Ea::Spa` for EA sources, falls back to its own pipeline for
+   non-EA. Hybrid.
+
+Decision deferred until `Ea::Spa` proves itself on the plateau
+model (TODO 11). Document the decision as an ADR when made.
+
+## Verification
+
+Decision recorded; downstream callers notified if deprecation.

data/lib/ea/cli/app.rb

@@ -13,8 +13,8 @@ module Ea
       OUTPUT_OPTION = { type: :string, aliases: :o }.freeze
 
       # Shared kwargs for any command that accepts a YAML config file.
-      # Matches the OUTPUT_OPTION pattern so adding config-file support
-      # to another command is a one-line addition.
+      # Matches OUTPUT_OPTION; adding config support to a command is a
+      # one-line addition.
       CONFIG_OPTION = { type: :string, aliases: :c }.freeze
 
       class << self
@@ -74,18 +74,24 @@ module Ea
         Command::Convert.new(file: file, **symbolize(options)).call
       end
 
-      desc "spa FILE", "Generate single-page app (SPA) from QEA/XMI/LUR"
+      desc "spa FILE", "Generate single-page app (SPA) from QEA/XMI"
       option :output, **OUTPUT_OPTION,
-             desc: "Output path (default: <basename>.html)"
+             desc: "Output path (default: <basename>.html or <basename>.spa/)"
       option :config, **CONFIG_OPTION,
-             desc: "Path to lutaml-uml static-site YAML config " \
-                   "(sets title, description, logos, etc.)"
+             desc: "Path to SPA YAML config (overrides model metadata: title, description, etc.)"
       option :mode, type: :string, default: "single_file",
-                    desc: "Output mode: single_file | multi_file"
+                    desc: "Output mode: single_file | sharded"
       def spa(file)
         Command::Spa.new(file: file, **symbolize(options)).call
       end
 
+      desc "svg NAME FILE", "Render a diagram from QEA/XMI to standalone SVG"
+      option :output, **OUTPUT_OPTION,
+             desc: "Output path (default: <basename>.<diagram>.svg)"
+      def svg(name, file)
+        Command::Svg.new(name: name, file: file, **symbolize(options)).call
+      end
+
       private
 
       def symbolize(opts)

data/lib/ea/cli/command/spa.rb

@@ -5,88 +5,73 @@ module Ea
     module Command
       # `ea spa FILE [--output=PATH] [--mode=MODE]`
       #
-      # Generates a static single-page application (SPA) from a QEA,
-      # XMI, or LUR file. The SPA shows the package hierarchy, class
-      # details, diagram list, and member navigation in a browser.
+      # Generates a static single-page application (SPA) from a QEA
+      # or XMI file using the Ea::Model native pipeline:
       #
-      # Pipeline:
-      #   1. Ea::Transformations.to_uml(file) → Lutaml::Uml::Document
-      #   2. Lutaml::UmlRepository::Repository.from_document(document)
-      #   3. Lutaml::UmlRepository::StaticSite::Generator.new(repo, ...).generate
-      #
-      # Output format defaults to single-file Vue IIFE HTML.
+      #   1. Source parse (Ea::Qea::Database / Xmi::Sparx::Root)
+      #   2. Source adapter → Ea::Model::Document
+      #   3. Ea::Spa::Projector → skeleton + shards + search index
+      #   4. Ea::Spa::Output::Strategy → HTML/JSON on disk
       class Spa < Base
         DEFAULT_MODE = :single_file
 
         def call
-          repository = RepositoryBuilder.build_repository(file_path)
-
-          require_lutaml_uml_static_site!
-          strategy = resolve_output_strategy
-
+          document = build_model_document
           output_path = resolve_output_path
-          options = {
+          Ea::Spa::Generator.new(
+            document,
             output: output_path,
             mode: mode,
-            output_strategy: strategy,
-            config_path: resolve_config_path,
-          }.compact
-
-          Lutaml::UmlRepository::StaticSite::Generator
-            .new(repository, options)
-            .generate
+            configuration: spa_configuration
+          ).generate
 
           formatter.render([[output_path]], columns: [:written_to])
         end
 
         private
 
-        def mode
-          (options[:mode] || DEFAULT_MODE).to_sym
+        def build_model_document
+          case File.extname(file_path).downcase
+          when ".qea"
+            Ea::Sources::Qea::Adapter.from_path(file_path)
+          when ".xmi"
+            Ea::Sources::Xmi::Adapter.from_path(file_path)
+          else
+            raise Ea::Cli::UnsupportedFormat,
+                  "Unknown file format: #{File.extname(file_path)}"
+          end
         end
 
-        def resolve_output_path
-          options[:output] || default_output_path
+        def mode
+          (options[:mode] || DEFAULT_MODE).to_sym
         end
 
-        def resolve_config_path
+        def spa_configuration
           path = options[:config]
           return nil unless path
 
           expanded = File.expand_path(path)
           unless File.exist?(expanded)
             raise Ea::Cli::FileNotFound,
-                  "Config file not found: #{path}"
+                  "SPA config not found: #{path}"
           end
 
-          expanded
+          Ea::Spa::Configuration.load(expanded)
+        end
+
+        def resolve_output_path
+          options[:output] || default_output_path
         end
 
         def default_output_path
           base = File.basename(file_path, ".*")
           dir = File.dirname(file_path)
-          File.join(dir, "#{base}.html")
-        end
-
-        def resolve_output_strategy
-          case mode
-          when :single_file, "single_file"
-            Lutaml::UmlRepository::StaticSite::Output::VueInlinedStrategy
-          when :multi_file, "multi_file"
-            Lutaml::UmlRepository::StaticSite::Output::MultiFileStrategy
+          if mode == :sharded
+            File.join(dir, "#{base}.spa")
           else
-            raise Ea::Cli::UnsupportedFormat,
-                  "Unknown spa mode '#{mode}': use single_file or multi_file"
+            File.join(dir, "#{base}.html")
           end
         end
-
-        def require_lutaml_uml_static_site!
-          require "lutaml/uml_repository/static_site"
-        rescue LoadError => e
-          raise Ea::Cli::MissingUmlDependency,
-                "spa command requires the `lutaml-uml` gem. " \
-                "Install it via `gem install lutaml-uml`. (#{e.message})"
-        end
       end
     end
   end