mxrb 0.1.0

data/docs/en-US/architecture.md

@@ -0,0 +1,170 @@
+# Mendix project architecture in MXRB
+
+[Português](../pt-BR/architecture.md) · **English** · [Deutsch](../de-DE/architecture.md)
+
+MXRB represents a Mendix project as editable Ruby while preserving the native
+model required for a safe round trip. Ruby is the source-facing language; no
+parallel MDL-like syntax is introduced.
+
+## Mendix compatibility principles
+
+- Mendix qualified names remain canonical inside the model.
+- Existing native units are preserved when no typed Ruby abstraction exists.
+- A typed edit replaces only the structure that Ruby explicitly owns.
+- MPR v1 contents stay in SQLite; MPR v2 contents stay in `mprcontents/`.
+- UUIDs, BSON GUIDs, containment and content hashes are handled by MXRB.
+- Official `mx`, MxBuild and Runtime are compatibility gates, not core APIs.
+
+## Canonical structure
+
+```text
+project.rb
+app/
+  security/
+  navigation/
+modules/
+  Sales/
+    module.rb
+    domain/
+      model.rb
+      entities/
+    application/
+      use_cases/
+      queries/
+    presentation/
+      pages/
+      client_actions/
+    infrastructure/
+      integrations/
+      services/
+    security/
+```
+
+The structure is deliberately regular. Exported files can be reviewed in Git,
+edited in Ruby and regenerated without flattening Mendix folders or dropping
+unknown documents.
+
+## Clean Architecture mapping
+
+### `domain/`
+
+Contains entities, attributes, associations, value rules and domain events.
+It must not depend on presentation or infrastructure details.
+
+```ruby
+entity :Order do
+  string :Number, documentation: "Stable order number"
+  decimal :Total, default: 0
+  association "Sales.Customer", name: "Order_Customer"
+end
+```
+
+Association cardinality follows the Mendix type/owner model:
+
+```ruby
+# 1:N (default): Reference + Default
+association "Sales.Customer", name: "Order_Customer"
+
+# 1:1: Reference + Both
+association "Sales.Profile", name: "Customer_Profile", owner: :Both
+
+# N:N: ReferenceSet + Default
+association "Sales.Tag", name: "Order_Tags", type: :ReferenceSet
+```
+
+### `application/`
+
+Contains use cases, queries, validations and jobs. A microflow is not
+automatically a service: its role is determined by its responsibility.
+
+```ruby
+microflow :CreateOrder do
+  return_type :Order
+  create_object "Sales.Order", as: :order
+  return_value :order
+end
+```
+
+### `presentation/`
+
+Contains pages, UI entry points and client-side nanoflows. Feature-oriented
+folders are preferred when a module has several independent user journeys.
+
+### `infrastructure/`
+
+Contains integrations, published/consumed services, adapters and technical
+implementation details. Repository abstractions are used only at real
+boundaries; ordinary Mendix CRUD does not require ceremonial wrappers.
+
+## Dependency rule
+
+Dependencies point inward:
+
+```text
+presentation ─┐
+              ├─> application ─> domain
+infrastructure┘
+```
+
+The semantic graph validates missing targets, cycles, cross-module relations
+and forbidden architectural dependencies.
+
+## Root file
+
+`project.rb` loads the application-level configuration, native baseline and
+module aggregators. It should contain orchestration, not business behavior.
+
+```ruby
+Mxrb.define("Shop.mpr") do
+  mendix_version "11.12.1"
+  native_units File.join(__dir__, ".mxrb", "native_units.json")
+  load File.join(__dir__, "modules", "Sales", "module.rb")
+end
+```
+
+## Ruby-to-Mendix flow
+
+1. Ruby definitions are evaluated.
+2. The writer creates or opens the target MPR.
+3. Native units are restored first.
+4. Typed overlays are matched by stable Mendix names.
+5. Changed flow/page structures are regenerated.
+6. Hashes and v1/v2 storage are updated.
+7. `mxrb validate`, `mx check` and MxBuild can act as successive gates.
+
+## Mendix-to-Ruby flow
+
+1. MXRB indexes all project units.
+2. Typed modules, entities, pages, menus and flows are exported.
+3. Deep page/flow structures remain editable Ruby.
+4. Unknown units are written to `.mxrb/native_units.json`.
+5. Canonical fingerprints permit exact reuse of unchanged native graphs.
+
+## Safe round-trip strategy
+
+### Preserving update
+
+Use the exported native baseline when editing an existing project. This mode
+keeps structures outside the currently typed surface without treating them as
+discardable opaque data.
+
+### Reconstruction
+
+For a new project, MXRB creates the SQLite schema, root unit, module tree and
+v2 `.mxunit` files when required. Exact official validation still depends on
+the matching Mendix toolchain.
+
+## Naming conventions
+
+- Mendix names are preserved exactly.
+- Ruby filenames use `snake_case`.
+- Ruby symbols may adapt names for readability.
+- Comparisons use Mendix-qualified identity, never filenames.
+- Renames are previewed across the semantic graph before being applied.
+
+## Source of truth
+
+Ruby is authoritative for explicitly declared typed structures. The native
+manifest is authoritative for preserved structures outside that declaration.
+When a deep Ruby structure is edited, its fingerprint changes and the writer
+regenerates that structure rather than silently restoring the old native one.

data/docs/en-US/compiler.md

@@ -0,0 +1,157 @@
+# Native compiler, Runtime, and MDA format
+
+MXRB's functional pipeline does not execute `mx`, `mxbuild`, `mxcli`, Studio
+Pro, or the Model SDK. Those tools may remain external compatibility gates, but
+they are not build, database, or functional-test dependencies.
+
+## Clean build
+
+`DeploymentMaterializer` creates a missing `deployment/` from the installed
+version templates and runs 12 stages: security, constants, domain model,
+artifacts, translations, system texts, system queues, client model, actions,
+settings, microflows, and the project/module index. It also creates metadata,
+dependency files, and a Runtime-ordered BSON `model.mdp`.
+
+Bootstrap has audited seeds and catalogs for 6.10.8, 7.5.0, 7.17.0,
+9.6.1.29396, 10.24.0.73019, and 11.12.1. The 6.x, 7.x, 9.x, 10.x, and 11.x families select a
+compatible compiler seed; 5.x and 8.x fail closed without an audited
+seed. Family selection applies to compiler schema only. Runtime must always
+match the MPR's exact patch.
+
+`ProjectJarBuilder` discovers the JDK through `MXRB_JAVA_HOME`, `JAVA_HOME`,
+asdf, or mise, compiles `javasource/**/*.java` against Runtime and project
+libraries, and writes a deterministic OSGi `project.jar`. VetClinic compiled
+183 sources into 249 classes.
+
+`WebBundleBuilder` selects Dojo for 6/7, Dojo plus the React wrapper for 9,
+the project-declared classic or optimized client for 10, and React for 11.
+The React path generates entrypoint/page modules, expands `.mpk`, and invokes
+the version-owned Node/Rollup (10) or Node/Rspack (11) directly. Data Grid 2 compiles for the XPath datasource and attribute-column
+subset, including `operations.json`, datasource, and attribute types.
+Untranslated types or property combinations receive a DOM fallback and are
+recorded in `web/mxrb-pages.json`; VetClinic's manifest is empty.
+
+The React compiler also materializes containers, text and headings, responsive
+grids/columns, and open/create buttons. Bootstrap injects
+`theme.compiled.css`, the manifest, and `themesource/*/public` assets, so a
+homepage containing a `LayoutGrid` no longer renders blank. To add Ruby content:
+
+Parameter-backed `DataView` forms now render editable `TextBox` fields plus
+Save/Cancel actions. Create passes the new object's GUID through `openForm2`;
+commit/rollback operations are registered with the project user roles derived
+from each page's allowed module roles. Runtime authorization is preserved
+instead of bypassed.
+
+Layouts, placeholders, scroll regions, sidebars, headers, navigation menus,
+snippets, DataViews, ListViews, form controls, images, combo boxes, Gallery,
+Data Grid 2 and schema-backed pluggable widgets are compiled through their
+native React-client contracts. Page, menu and widget actions cover navigation,
+microflows, nanoflows, object lifecycle, links and sign-out. Nanoflow programs
+also cover decisions, error handlers, JavaScript actions and server-side
+microflow/commit operations when their model contracts can be mapped safely.
+
+The React path also compiles the official Gallery with XPath and microflow
+list sources, templated item content, selection, and formatted dynamic
+attributes. Client-side nanoflow sources and actions use the Mendix
+`NanoflowObjectListProperty`, `NanoflowObjectProperty`, and `ActionProperty`
+contracts. MXRB emits real `{ name, instructions }` client programs for audited
+graph control flow, returns, variables, objects, nested nanoflow/microflow calls,
+JavaScript actions, page/message/validation actions and commits. Missing flows,
+unsafe parameter mappings and untranslated client instructions fail closed and
+remain support-manifest findings.
+
+For local developer Runtime sessions, mxrb also versions dynamic page imports,
+content-hashes the patched React Client chunk, and gives Rspack's self-import
+the same cache token as the entrypoint. This prevents Mendix's long-lived
+static-resource responses from restoring an obsolete blank page after a native
+rebuild. The generated shell also provides a bounded `openForm` adapter over
+`openForm2`; cached legacy handlers therefore navigate instead of silently
+issuing no request.
+
+```ruby
+Mxrb.define("App.mpr") do
+  mendix_version "11.12.1"
+  self.module(:App) do
+    layout :Shell
+    page(:Home) do
+      layout "App.Shell"
+      title "My application"
+      container(:main, class_name: "container") do
+        text :welcome, caption: "Content created with mxrb"
+      end
+    end
+  end
+end
+```
+
+Existing projects can be exported, changed in the DSL, and regenerated.
+Unsupported widgets remain visible in the support manifest.
+
+Before a native build, audit the complete MPR through the renderer selected for
+its Mendix version:
+
+```bash
+mxrb preflight App.mpr
+mxrb preflight App.mpr --json
+```
+
+The command is read-only and exits non-zero for unsupported versions or client
+features. Mendix 11 is audited through the React compiler, while 6/7/9 use the
+same legacy Dojo audit as `WebBundleBuilder`; this prevents a report from
+claiming compatibility through a renderer the build will not use.
+
+The Dojo path compiles Data Grid 1 database, XPath, and microflow sources plus
+audited search, sorting, paging, selection, and buttons. Every other visible
+widget is recorded per page in `web/mxrb-legacy-pages.json` and is not claimed
+as rendered.
+
+## MDA and portable package
+
+```bash
+mxrb pack App.mpr --output build/App.mda
+mxrb mda inspect build/App.mda
+mxrb portable App.mpr --output build/runtime.zip
+```
+
+MDA and portable ZIP output is deterministic. The portable package combines
+the native deployment with the installed matching Runtime, generated settings,
+constants, and scripts. MDA output includes only official roots; working
+directories such as `data`, `log`, `run`, `build`, and `.gradle` are excluded.
+
+## Regression evidence
+
+```bash
+script/runtime_boot_regression App.mpr /missing/deployment \
+  ~/.local/share/mendix/11.12.1
+```
+
+The regression creates a temporary deployment, compiles Java and web output,
+packages it, starts Runtime, and requires HTTP 200 for `/`, `dist/index.js`, and
+every generated page bundle. It also requires a clean shutdown. The transcript
+and SHA-256 are written to `tmp/runtime-boot-evidence.log`. When Chromium is
+installed, it imports every module and instantiates factories that do not need
+a session. The Data Grid bundle is imported and evaluated; its factory reads
+the client session and therefore requires an authenticated test to instantiate.
+
+On August 1, 2026, VetClinic 11.12.1 started from no deployment, executed 675
+database synchronization commands, initialized the `System` queues, scheduled
+`VetClinic.Cleanup`, returned 200 for all four page bundles, and shut down
+cleanly. The `ACT Create Animal` functional test then passed.
+
+## Explicit boundaries
+
+- all 12 stages and clean web generation are validated on 6.10.8, 7.5.0,
+  7.17.0, 9.6.1.29396, 10.24.0.73019, and 11.12.1;
+- exact native boot is proven on 10.24.0.73019 and 11.12.1. The installed 6/7/9
+  distributions contain the exact Runtime bundles but no compatible launcher; `db up` fails closed
+  instead of substituting the Java-21 launcher from 11;
+- Data Grid 1 is covered while other Dojo widgets remain explicit manifest
+  findings;
+- the optimized Mendix 10 React/Rollup path is covered by a from-scratch app;
+  the Mendix 11 React path is covered by clean preflights and complete Rspack
+  builds of LearnNow, MyFirstModule, SLATaskApp, Sudoku and VetClinic. This
+  fixture matrix is evidence for the audited contracts, not a universal claim;
+- native web bundles are generated; React Native still relies on existing
+  version-template and project assets;
+- `mx` and `mxbuild` are never fallbacks. Unsupported input produces a clear
+  compiler error or a support-manifest entry.

data/docs/en-US/conventions.md

@@ -0,0 +1,82 @@
+# Conventions
+
+[Português](../pt-BR/conventions.md) · **English** · [Deutsch](../de-DE/conventions.md)
+
+Conventions that hold across the MXRB codebase, its tests and its
+documentation. Some are enforced mechanically; the rest are enforced in
+review. Writing-style guidance for exported projects lives in
+[writing projects](writing.md).
+
+## Naming
+
+- Mendix-qualified names (`Sales.Order`) are canonical everywhere: in the
+  model, in comparisons, in errors. Ruby never renames the underlying
+  artifact.
+- Ruby files use `snake_case`; classes use `CamelCase`; symbols may adapt a
+  Mendix name for readability without changing its identity.
+- Public API methods read as verbs or queries (`plan_rename`, `apply!`,
+  `references_to`, `impact_of`); bang methods write, non-bang methods plan or
+  read.
+- Plan objects expose `changes` and `apply!`; report objects expose typed
+  collections (`diagnostics`, `call_cycles`, `module_dependencies`).
+
+## Error handling
+
+- Raise typed errors from `Mxrb::Error` downward; rescue `StandardError` only
+  at execution boundaries (CLI, runtime executor, installer cleanup).
+- Unknown encodings and corrupt structures are rejected explicitly. A
+  non-BSON `.mxunit` raises instead of being overwritten by trial; an
+  unexpected change to a file after a migration preview raises
+  `SerializationError` instead of writing stale content.
+- Preservation and rejection are different answers to different questions: an
+  unknown *structure* is preserved losslessly; an unknown *encoding* is a
+  hard stop.
+- Read-only opens never write: cache persistence, plan application and
+  version migration all require `readonly: false`.
+
+## Testing
+
+- `bundle exec rspec` is the default suite; everything must pass.
+- CI sets `MXRB_LINE_COVERAGE_MIN=100` and `MXRB_BRANCH_COVERAGE_MIN=100`; the
+  local helper defaults to 100/100 when those variables are omitted.
+  `bundle exec ruby script/branch_report.rb` lists uncovered branches by file
+  and line.
+- Coverage uses Ruby's native `Coverage` API, not an external gem. Defensive
+  branches that only fire on corrupt or malformed input — states the writer
+  can never produce — are excluded with `# :nocov:` markers, inline or as
+  region toggles. Each exclusion is a reviewed claim about reachability, not
+  a way to skip hard tests.
+- Deterministic fuzzing covers BSON documents and `.mxunit` atomic writes.
+- Evidence scripts (`script/validate_matrix`, `script/benchmark`) exist so
+  compatibility claims can be re-run instead of trusted.
+- Example files under `examples/` are executable documentation and are
+  validated against the public fixtures.
+
+## Documentation and localization
+
+- Public documentation ships in three locales with identical file sets:
+  `docs/pt-BR`, `docs/en-US`, `docs/de-DE`, plus root READMEs per language.
+  `docs/README.md` is only the language selector.
+- `spec/documentation_spec.rb` enforces, for every Markdown file in the
+  repository:
+  - locale file-set parity across all three languages;
+  - no broken relative links;
+  - no internal workflow traces (tool-continuation notes, model or tooling
+    references) — public docs describe the project, not the process that
+    wrote them;
+  - no Portuguese prose in the English writing guide.
+- Documentation states limits as plainly as capabilities. Unsupported cases
+  (for example non-BSON `.mxunit` payloads, or exact Mendix 5 execution
+  requiring Windows/Studio Pro) are documented as limitations, not omitted.
+- Relative links are preferred between pages so locale trees stay
+  self-contained.
+
+## Code style
+
+- `# frozen_string_literal: true` everywhere.
+- Immutable value objects (`Data.define`, frozen collections) cross public
+  boundaries; mutation stays inside writers and transactions.
+- `bundle exec rubocop` is the gradual static-quality gate.
+- Make the smallest change that satisfies the requirement; the plan objects
+  and the lockfile exist so that review can always see exactly what a write
+  will do before it happens.

data/docs/en-US/design-system.md

@@ -0,0 +1,163 @@
+# Navigation and design system
+
+[Português](../pt-BR/design-system.md) · **English** · [Deutsch](../de-DE/design-system.md)
+
+Navigation and design-system round trips are part of the current typed
+surface. Native profiles, filesystem assets and design-token quality tooling
+are covered by the public test and fixture matrix.
+
+## Native navigation
+
+A Mendix navigation document is read as typed Ruby through
+`project.navigation`:
+
+```ruby
+Mxrb.open("app.mpr") do |project|
+  project.navigation.profiles.each do |profile|
+    puts "#{profile.name} (#{profile.kind})"
+    puts "  home page:      #{profile.home_page}"
+    puts "  home microflow: #{profile.home_microflow}"
+    puts "  sign-in page:   #{profile.sign_in_page}"
+    puts "  app title:      #{profile.app_title}" # { "en_US" => "...", "nl_NL" => "..." }
+
+    profile.role_homes.each do |home|
+      puts "  #{home[:role]} -> #{home[:page] || home[:microflow]}"
+    end
+
+    profile.menu_items.each do |item|
+      puts "  #{item[:caption]} -> #{item[:page] || item[:microflow]}"
+    end
+  end
+end
+```
+
+Coverage and behavior:
+
+- Modern `Profiles` and the legacy Mendix 5/6 profile documents
+  (`DesktopProfile`, `PhoneProfile`, `TabletProfile`, hybrid and offline
+  variants) are normalized into the same `NavigationProfile` objects.
+- Home pages per role, nested menu trees, icons and caption translations are
+  exposed as plain Ruby data.
+- `offline?` flags offline-capable profiles.
+- Navigation references participate in the semantic index, so
+  `references_from`, rename and remove plans already account for navigation
+  targets.
+
+The same structures can be declared in the Ruby DSL and written back to the
+native navigation document. Rename, remove, diff and lint operate on those
+references, including user-role access to role-specific homes.
+
+## Design tokens from real stylesheets
+
+`project.design_system` scans the project directory (`theme/`,
+`themesource/`, `resources/`, `widgets/`, `javasource/`,
+`javascriptsource/`) for CSS custom properties and SCSS variables:
+
+```ruby
+design = project.design_system
+
+design.tokens.each do |token|
+  puts "#{token.name}: #{token.value} (#{token.kind}, #{token.path}:#{token.line})"
+end
+
+design.themes        # theme names derived from _theme-<name>.scss files
+design.catalogs      # themesource/**/design-properties.json contents
+```
+
+Each `DesignToken` is an immutable value with `name`, `value`, `kind`
+(`:css_custom_property` or `:scss_variable`), `theme`, `path` and `line`.
+
+## Materializing the Ruby contract
+
+Tokens declared through the Ruby `design_system` DSL are written to real theme
+assets during generation. MXRB owns
+`theme/web/_mxrb-design-system.scss`, adds one idempotent import to
+`theme/web/main.scss`, and publishes color tokens as Studio `ColorPicker`
+entries in `themesource/mxrb/web/design-properties.json`.
+
+Global tokens become CSS custom properties. Named themes become
+`data-mxrb-theme`/`.mxrb-theme-*` selectors; inheritance is resolved before
+writing and child values override parent values. Existing `main.scss` content
+is preserved. Invalid names, inheritance cycles, and values that could escape
+the generated CSS declaration are rejected before writing.
+
+## Guidelines the tooling enforces
+
+### Prefer tokens over literals
+
+Hard-coded colors scattered through stylesheets drift out of sync with the
+theme. `literal_colors` lists tokens whose values are raw hex colors, and
+`unresolved_references` lists `var(--x)` references that point to a token
+that does not exist:
+
+```ruby
+design.literal_colors
+design.unresolved_references.each do |issue|
+  puts "#{issue[:reference]} used by #{issue[:token].name} is undefined"
+end
+```
+
+### Check accessibility contrast
+
+`contrast_ratio` computes the WCAG luminance ratio between two hex colors:
+
+```ruby
+design.contrast_ratio("#777777", "#ffffff") # => 4.48
+```
+
+Ratios of at least 4.5 are the common baseline for normal text (7 for the
+enhanced level); the method returns the number so projects can assert their
+own thresholds in evaluations or lint rules.
+
+### Migrate literals with preview and safe apply
+
+Literal replacement follows the same plan / preview / `apply!` discipline as
+semantic refactoring:
+
+```ruby
+plan = project.plan_design_token_migration("#777777" => "var(--color-foreground)")
+
+plan.changes.each do |change|
+  puts "#{change.path}: #{change.occurrences} occurrence(s)"
+end
+
+plan.apply!
+```
+
+Guarantees:
+
+- every change lists its file, before/after contents and occurrence count;
+- `apply!` re-checks each file's SHA-256 against the preview and raises
+  `SerializationError` if a file changed meanwhile — a stale preview is never
+  written;
+- each file is written through a temporary file plus atomic rename;
+- a plan applies once; re-applying raises.
+
+The same workflows are exposed by the CLI:
+
+```sh
+bundle exec mxrb design scan App.mpr
+bundle exec mxrb design scan App.mpr --json
+bundle exec mxrb design migrate App.mpr '#3366ff' 'var(--brand-primary)'
+bundle exec mxrb design migrate App.mpr '#3366ff' 'var(--brand-primary)' --apply
+```
+
+`scan` prints each token's name, value, kind, theme, and source location, plus
+literal-color and unresolved-reference totals. `migrate` remains a preview
+until `--apply` is supplied. Contrast pairs declared in the Ruby contract are
+checked by `mxrb lint` against their configured WCAG level.
+
+## Themes, resources and unknown structures
+
+Themes, images, widgets, resources and Java sources are copied through
+`.mxrb/assets.json`. Every entry has a relative path, size and SHA-256 digest;
+reconstruction rejects traversal, missing files and checksum mismatches.
+Unknown model units remain in the lossless native baseline.
+
+## Validation status
+
+The typed navigation writer, design-system materializer, asset manifest,
+contrast/literal lint and atomic migration are implemented. Structural round
+trips pass the six-fixture matrix, including modern `Profiles` and preserved
+legacy navigation shapes. See the [validation matrix](validation-matrix.md)
+for the current evidence.

data/docs/en-US/entity-dsl.md

@@ -0,0 +1,53 @@
+# Entity DSL
+
+[Português](../pt-BR/entity-dsl.md) · **English** · [Deutsch](../de-DE/entity-dsl.md)
+
+Files created by `mxrb entity new Module.Entity` are evaluated inside the
+module block, so declarations use the local name:
+
+```ruby
+entity :Animal do
+  documentation "Animal cared for by the clinic"
+  string :Name, default: "", documentation: "Display name"
+  integer :Age, default: 0
+  long :ExternalId
+  float :Weight
+  decimal :Balance
+  boolean :Active, default: true
+  datetime :BirthDate
+  autonumber :Sequence
+  hashstring :PasswordHash
+  binary :Document
+  enum :Species, enumeration: "VetClinic.AnimalSpecies"
+end
+```
+
+Available types are `string`, `integer`, `long`, `float`, `decimal`, `boolean`,
+`datetime`, `autonumber`, `hashstring`, `binary`, and `enum`. Options currently
+written to the MPR are `default:`, `documentation:`, and `enumeration:` for enum
+attributes. Declare the enumeration separately with `enumeration`; use `enum`
+for an entity attribute.
+
+## Associations
+
+```ruby
+association "VetClinic.Owner", name: "Animal_Owner" # N:1 Reference
+association "VetClinic.Passport", name: "Animal_Passport", owner: :Both # 1:1
+association "VetClinic.Tag", name: "Animal_Tags", type: :ReferenceSet # N:N
+association "VetClinic.Group", name: "Animal_Groups",
+            type: :ReferenceSet, owner: :Both
+```
+
+The first argument is the qualified target. `type:` accepts `:Reference`
+(default) or `:ReferenceSet`; `owner:` accepts `:Default` or `:Both`.
+
+## Persistence, events, and access
+
+Use `non_persistent!` for a non-persistable entity. Lifecycle hooks are
+`before_commit`, `after_commit`, `before_delete`, and `after_delete`, each with
+`microflow:`. Access rules accept qualified roles plus `create:`, `delete:`,
+`read:`, `write:`, and `xpath:`; read/write accept `:all`, `:none`, or an
+attribute list.
+
+Run `mxrb entity --help`, then validate generated output with
+`mxrb generate project.rb` and `mxrb validate App.mpr`.