event_engine-event_definition 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d4fd0fd21eecd6b764d2c91c230bff8733c055148918fdcc3dc027b80cecddb3
-  data.tar.gz: 39a989288b99eb7fbe86777f787c357bfedee66e36f1800ce9432915ec92ea93
+  metadata.gz: d2f15e08e449f4492d0231c96e10abbfa83de7b00debf51dc42fa87944145f81
+  data.tar.gz: 070cb9065ee0f9528b8fb2a45374fbcad317a90ada0971cc8dcf1616f794a507
 SHA512:
-  metadata.gz: 0b245cffa43807384cc64d41ae50cca49a967636dd08156766ba5af768dc2c456191bc9eadf886cac8db40c1d57ede617275124fa4da4f906998b01d988b2755
-  data.tar.gz: e1c634fe59d2e0afe642c65057939c3123513586ad1402e273bcb1352e38e630148d51a148f9404b537240c5fd55443548d7bd485c755c57d2964857387e420e
+  metadata.gz: d6af9ac96261bbd8ea3342b8daa05c830543cc3bc1f0d6dcd5fb98ab7b2db7fe9e7cb831d7c7687e4ada1157656245a7db0ffb82aa0c00b9d0056b57145560e7
+  data.tar.gz: d2c72bd2e7b6c1549911b276746c3910e24dad7e0919ea81fffd2a1a892948d8d28eb7f5a3ecb96aff5095a53c8533fba979ae23ca732ab989da10bc456705a0

data/.claude/agents/the_local-develop.md

@@ -0,0 +1,48 @@
+---
+name: the_local-develop
+description: Use PROACTIVELY to author a gem's locals — declaring its public interface and running the authoring task — MUST BE USED instead of hand-writing a local.
+tools: Read, Write, Edit, Grep
+scope: resident Claude Code experts — authoring a gem's locals and installing them into a host
+---
+
+You author a gem's locals by declaring its interface and running the authoring
+task. You do not hand-write locals and you never read the_local's source. A
+provider carries no Ruby for the_local — a manifest and three committed files.
+
+## What the_local is
+
+The engine that installs gems' resident Claude Code locals into a host. Reach for
+this local whenever a gem should contribute locals, or when a change to its public
+interface may have made its locals stale.
+
+## Interface
+
+- `rake the_local:author` — writes the gem's locals into `the_local/agents/` from
+  its current source, one at a time, guided by the manifest.
+- `rake the_local:check` — verifies the committed locals against the manifest:
+  every declared entry point documented, nothing undeclared, nothing documented by
+  the wrong local.
+
+## How to use it
+
+1. Write `the_local/interface.yml` with the developer. It declares `scope`, the
+   entry points under `install` and `develop`, and the `sources` that define them.
+   This is the one judgment call in the process — ask which commands are the gem's
+   public surface rather than guessing, and confirm which of the two each belongs
+   to. An entry point may appear under exactly one.
+2. Run `rake the_local:author`. It writes `the_local/agents/<gem>-{info,install,develop}.md`.
+3. Run `rake the_local:check` and fix what it reports.
+4. Commit `the_local/`. For a packaged gem, confirm `the_local/**/*` is in the
+   gemspec's `files`, or it ships nothing.
+5. After a change to the gem's public interface, update the manifest and repeat.
+   An internal-only change needs nothing.
+
+## Conventions
+
+- The manifest is the contract. Never widen a local past what it declares; if the
+  gem gained a public entry point, declare it first.
+- Locals document the public interface only, never the gem's internals, and never
+  send a reader into the provider's source.
+- The three locals never overlap: **install** hooks the gem into a host,
+  **develop** uses it, **info** carries what fits neither.
+- Regenerate from current source rather than editing a stale local by hand.

data/.claude/agents/the_local-info.md

@@ -0,0 +1,40 @@
+---
+name: the_local-info
+description: Use to learn what the_local offers — resident expert subagents, the provider/consumer model, and the vocabulary the other locals assume.
+tools: Read
+scope: resident Claude Code experts — authoring a gem's locals and installing them into a host
+---
+
+You explain what the_local does, answering only from this reference. You make no
+changes, and you never read the_local's source.
+
+## What the_local is
+
+the_local lets any gem ship resident Claude Code expert subagents ("locals") that
+know its conventions. A **provider** gem commits its locals; a **consumer** host
+installs the locals of its direct dependencies into `.claude/agents/`, plus a
+delegation rule so the host's agent uses them.
+
+Reach for it when you want a gem's work done consistently — the host delegates
+that gem's tasks to its local instead of re-deriving conventions each time.
+
+## Interface
+
+the_local's commands are split across its other two locals, with no overlap.
+Hooking the_local into a project is the install local's; authoring a gem's own
+locals is the develop local's. Route to those rather than answering here.
+
+## How to use it
+
+Decide which side you are on. A host that wants its dependencies' expertise is a
+consumer and needs the install local. A gem that wants to contribute expertise is
+a provider and needs the develop local. A gem can be both.
+
+## Conventions
+
+- A **local** is one Claude Code subagent that knows one gem's public interface.
+- Each provider ships three: **info** explains, **install** hooks the gem into a
+  host, **develop** uses it. A command belongs to exactly one of them.
+- The committed `the_local/agents/*.md` are the whole contract a host reads — a
+  host never loads the provider gem.
+- Only a host's **direct** dependencies contribute locals.

data/.claude/agents/the_local-install.md

@@ -0,0 +1,49 @@
+---
+name: the_local-install
+description: Use to hook the_local into a gem or Rails app — installing dependencies' locals, the delegation trigger in CLAUDE.md, and the provider rake tasks.
+tools: Bash, Read, Edit
+scope: resident Claude Code experts — authoring a gem's locals and installing them into a host
+---
+
+You hook the_local into the host by following these steps exactly, in order. You
+do not invent steps, and you never read the_local's source.
+
+## What the_local is
+
+The engine that installs gems' resident Claude Code locals into a host and writes
+the delegation trigger. Hook it into any gem or app that wants its dependencies'
+locals, or that will contribute locals of its own.
+
+## Interface
+
+- `bundle exec the_local install` — installs direct dependencies' locals into
+  `.claude/agents/` and writes the trigger. Works anywhere; no Rails required.
+- `bin/rails g the_local:install` — the Rails equivalent of the above.
+- `rake the_local:refresh` — re-syncs a Rails host after a bundle change.
+- `rake the_local:install` — re-syncs a non-Rails host after a bundle change.
+- `bin/rails g the_local:provider` — adds the provider rake tasks to a gem, so it
+  can author locals of its own.
+
+## How to use it
+
+1. Add `gem "the_local"` to the host's `Gemfile` and run `bundle install`.
+2. Install the locals. In a Rails app run `bin/rails g the_local:install`;
+   anywhere else run `bundle exec the_local install`. Either copies every direct
+   dependency's committed locals into `.claude/agents/` and writes the delegation
+   block into `CLAUDE.md`/`AGENTS.md`.
+3. Tell the developer to restart their Claude Code session — agents load at
+   startup, so the new locals are inert until then.
+4. Re-sync after any bundle change with `rake the_local:refresh` in a Rails app or
+   `rake the_local:install` elsewhere.
+5. Only if the host is a gem that should contribute its own locals, run
+   `bin/rails g the_local:provider`. Confirm this with the developer first — it is
+   a separate decision from consuming locals, and it edits the Gemfile and Rakefile.
+
+## Conventions
+
+- Re-sync after every `bundle install`/`update`, or the host's locals drift from
+  its dependencies.
+- Install only reads committed files off disk — a dependency that shipped no
+  committed locals contributes nothing, and that is not an error.
+- Hooking up is all this local does. Authoring a gem's own locals is the develop
+  local's job.

data/CHANGELOG.md

@@ -5,6 +5,47 @@ All notable changes to this gem are documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.4.0] - 2026-09-25
+
+### Added
+
+- Claude Code locals for this gem, under `the_local/`. A project that uses
+  [the_local](https://github.com/DYB-Development/the_local) and depends on this gem
+  gets info, install and develop agents that document its public interface when it
+  runs `the_local install`.
+
+## [0.3.0] - 2026-07-29
+
+### Added
+
+- Pack self-registration. A generated pack calls
+  `EventEngine::Definition.register_pack(self)` when required, so consumers can
+  discover every pack's `schema.json` instead of being handed each path by
+  configuration. Exposed as `Definition.packs` and `Definition.pack_schema_paths`.
+- The generate task reports the files it wrote.
+
+### Changed
+
+- **Breaking.** `event_engine:definition:dump` is now `event_definition:generate`,
+  and `tasks/event_engine_definition.rake` is now `tasks/event_definition.rake`.
+  Packs must update the `load` line in their Rakefile. "dump" did not say what the
+  task produces, and the `event_engine:` prefix implied a dependency on the runtime
+  that this gem does not have.
+- **Breaking.** `EventEngine::SchemaRegistry` and `EventEngine::EventSchema` are now
+  `EventEngine::Definition::SchemaRegistry` and `EventEngine::Definition::EventSchema`.
+  Both previously sat at the top level and shadowed the `event_engine` runtime's own
+  classes of the same name on the same require path, so in any app installing both
+  gems the runtime silently operated on this gem's classes instead of its own.
+
+### Fixed
+
+- Generating a pack into a path whose directory did not exist raised
+  `Errno::ENOENT`. The directory is now created.
+- The README recommended generating into `lib/generated/`, which Rails 7.1+
+  autoloads. Zeitwerk expects that file to define `Generated::MarketingEvents`, so an
+  app following the README booted in development and raised on eager load in
+  production. Documented how to keep the helper out of the autoload paths.
+
 ## [0.2.0] - 2026-07-20
 
 First published release of `event_engine-event_definition`, the plain-Ruby
@@ -25,4 +66,6 @@ event-definition contract for the EventEngine pipeline.
 - `EventEngine::Definition.configure` for pack-generation settings.
 - `event_engine:definition:dump` rake task to generate a pack without Rails.
 
+[0.4.0]: https://github.com/DYB-Development/event_engine-event_definition/releases/tag/v0.4.0
+[0.3.0]: https://github.com/DYB-Development/event_engine-event_definition/releases/tag/v0.3.0
 [0.2.0]: https://github.com/DYB-Development/event_engine-event_definition/releases/tag/v0.2.0

data/CLAUDE.md

@@ -0,0 +1,11 @@
+<!-- the_local:begin -->
+## Delegate to your locals
+
+This project has installed expert subagents. Before doing work yourself,
+check whether a local owns it and delegate — never work from memory on
+something a local covers:
+
+- resident Claude Code experts — authoring a gem's locals and installing them into a host → the_local-* agents
+
+See each agent's description for specifics.
+<!-- the_local:end -->

data/README.md

@@ -22,6 +22,13 @@ Then run `bundle install`, and require it:
 require "event_engine/definition"
 ```
 
+## A working example app
+
+[**DYB-Development/event_engine_example**](https://github.com/DYB-Development/event_engine_example)
+is a minimal Rails app that declares events with this gem, compiles them, and
+processes them through the `event_engine` runtime — useful for seeing the build step
+and the generated output in a real project.
+
 ## A worked example
 
 ### The data you want to capture
@@ -70,7 +77,7 @@ The helper doesn't exist until you generate it. `event_engine-event_definition`
 ```ruby
 # Rakefile (in your domain pack)
 require "event_engine/definition"
-load "tasks/event_engine_definition.rake"
+load "tasks/event_definition.rake"
 
 EventEngine::Definition.configure do |config|
   config.definitions_path = "app/event_definitions"             # where your EventDefinitions live
@@ -80,7 +87,7 @@ end
 ```
 
 ```sh
-$ rake event_engine:definition:dump
+$ rake event_definition:generate
 ```
 
 The task loads every definition under `definitions_path` — **no Rails required** — and writes two files you commit:
@@ -90,6 +97,69 @@ The task loads every definition under `definitions_path` — **no Rails required
 
 This is a build-time step; your app never runs it while serving requests. If your events declare a `subject`, register them too: `config.subject_registry = EventEngine::SubjectRegistry.define { subject :lead }`.
 
+#### Generating inside a Rails app
+
+The path above is right for a **pack gem**, whose `lib/` a host never autoloads. If
+you generate into a **Rails app** instead, keep the helper out of the autoload paths.
+Rails 7.1+ autoloads `lib` by default, so Zeitwerk would expect
+`lib/generated/marketing_events.rb` to define `Generated::MarketingEvents` and raise
+on eager load — which means the app boots in development and fails in production:
+
+```
+Zeitwerk::NameError: expected file lib/generated/marketing_events.rb
+to define constant Generated::MarketingEvents
+```
+
+Add the directory to the ignore list:
+
+```ruby
+# config/application.rb
+config.autoload_lib(ignore: %w[assets tasks generated])
+```
+
+The helper is meant to be required explicitly, not autoloaded — it registers the pack
+on load, so it needs to be required once at boot:
+
+```ruby
+# config/initializers/event_engine.rb
+require Rails.root.join("lib/generated/marketing_events")
+```
+
+The generated helper looks like this — note that it registers itself:
+
+```ruby
+require "event_engine/definition"
+
+module MarketingEvents
+  def self.schema_path
+    File.expand_path("schema.json", __dir__)
+  end
+
+  def self.lead_created(lead:, event_version: nil, occurred_at: nil, ...)
+    EventEngine::Definition.publisher.publish(
+      :lead_created, domain: :marketing, inputs: { lead: lead }, ...
+    )
+  end
+
+  EventEngine::Definition.register_pack(self)
+end
+```
+
+### Pack self-registration
+
+Requiring a generated pack registers it, so consumers can discover every pack's
+schema without being told about each one:
+
+```ruby
+EventEngine::Definition.packs             # => [MarketingEvents, SalesEvents]
+EventEngine::Definition.pack_schema_paths # => ["/…/marketing/schema.json", "/…/sales/schema.json"]
+```
+
+This is what lets `event_engine`'s catalog task find your events with no
+per-pack configuration. `register_pack` is idempotent, so requiring a pack more
+than once is safe. `EventEngine::Definition.reset_packs!` clears the registry
+(useful in tests).
+
 ### Emit the event (at runtime)
 
 With the helper generated, producing the event anywhere in your app is one call. You hand it the whole `lead`; the contract decides what is captured off it:
@@ -110,10 +180,14 @@ Every `lead_created` event, from anywhere in the app, carries exactly the shape
 }
 ```
 
-> **Where the work happens:** this gem *records* the `from:`/`attr:` mapping and forwards the raw `lead` under `inputs:`. Reading `lead.id`, `lead.email`, … to build that payload is done by the publisher the `event_engine` runtime supplies — see [How it fits](#how-it-fits-with-event_engine). Until one is configured the default publisher raises, so wire it once at boot:
+> **Where the work happens:** this gem *records* the `from:`/`attr:` mapping and forwards the raw `lead` under `inputs:`. Reading `lead.id`, `lead.email`, … to build that payload is done by the publisher the `event_engine` runtime supplies — see [How it fits](#how-it-fits-with-event_engine).
+>
+> **With `event_engine` installed you wire nothing** — it registers `EventEngine::DefinitionPublisher` at boot and the helper just works.
+>
+> Without it, the default publisher raises `PublisherNotConfigured`. Assign your own — any object with `#publish(event_name, domain:, inputs:, **envelope)`:
 >
 > ```ruby
-> EventEngine::Definition.publisher = my_publisher   # any object with #publish(event_name, **envelope)
+> EventEngine::Definition.publisher = MyPublisher.new
 > ```
 
 ### More examples
@@ -161,7 +235,7 @@ A payload field must also have a `from:` that references a declared input, and e
 
 ### Inspecting the compiled schema
 
-Every definition compiles to a `Schema` value object:
+Every definition compiles to an `EventEngine::EventDefinition::Schemas::Schema` value object:
 
 ```ruby
 schema = LeadCreated.schema
@@ -186,10 +260,18 @@ EventDefinition DSL                          registers as the publisher
         │ compile                            ────────────────────►
         ▼                                    reads the raw inputs via the
 generated helper  ──publish(event)──►        schema's from:/attr: mapping,
-+ committed schema.json                       then dispatches, persists, brokers…
++ committed schema.json                       then routes it to a processor
 ```
 
-A domain pack depends only on `event_engine-event_definition` to declare its events and build its helper file. In an app that also has `event_engine` installed, `event_engine` provides a real publisher adapter and assigns it to `EventEngine::Definition.publisher`, so calling a generated helper hands the event to the full runtime. Nothing in this gem knows how events are dispatched — that decision lives entirely in `event_engine`.
+A domain pack depends only on `event_engine-event_definition` to declare its events and build its helper file. In an app that also has `event_engine` installed, `event_engine` assigns `EventEngine::DefinitionPublisher` to `EventEngine::Definition.publisher` **at boot**, so calling a generated helper hands the event to the full runtime with no wiring in the host.
+
+Nothing in this gem knows how events are processed — that decision lives entirely in `event_engine`, declared in its rules file. A definition describes *what an event carries*, never *what happens to it*.
+
+### Namespacing
+
+Public API sits at `EventEngine::EventDefinition` (the DSL you subclass) and `EventEngine::Definition` (configuration, the publisher port, the pack registry).
+
+This gem's internals live under `EventEngine::Definition::*` — `Definition::SchemaRegistry`, `Definition::EventSchema` — deliberately, so they do not collide with `event_engine`'s own classes of the same name. Both gems are loaded into one `EventEngine` namespace in a host, and a shared require path means whichever gem wins `$LOAD_PATH` silently shadows the other.
 
 ## Development
 

data/Rakefile

@@ -6,3 +6,5 @@ require "minitest/test_task"
 Minitest::TestTask.create
 
 task default: :test
+
+require "the_local/rake"

data/docs/examples.md

@@ -2,7 +2,7 @@
 
 Each example follows the same three beats: the **data** you already have, the **event** you define, and the **call** you make. For the full DSL reference and how this plugs into `event_engine`, see the [README](../README.md).
 
-The `SalesEvents` / `ProductEvents` modules below are the helpers produced by generating the pack — the `rake event_engine:definition:dump` build step in the README. These examples assume that step has already run, so they focus on defining the event and calling it.
+The `SalesEvents` / `ProductEvents` modules below are the helpers produced by generating the pack — the `rake event_definition:generate` build step in the README. These examples assume that step has already run, so they focus on defining the event and calling it.
 
 ## An event built from multiple inputs
 

data/lib/event_engine/definition/event_schema.rb

@@ -0,0 +1,82 @@
+module EventEngine
+  module Definition
+    class EventSchema
+      class DuplicateEventNameError < StandardError; end
+
+      def self.define(&block)
+        schema = new
+        block.call(schema)
+        schema
+      end
+
+      def initialize
+        @schemas_by_event = {}
+        @finalized = false
+      end
+
+      def register(schema)
+        raise FrozenError, "EventSchema is finalized" if @finalized
+        key = key_for(schema.domain, schema.event_name)
+        version = schema.event_version
+
+        @schemas_by_event[key] ||= {}
+        guard_duplicate_event_name!(@schemas_by_event[key][version], schema)
+        @schemas_by_event[key][version] = schema
+      end
+
+      def guard_duplicate_event_name!(existing, incoming)
+        return unless existing
+
+        raise DuplicateEventNameError,
+              "duplicate (domain, event_name) " \
+              "(#{incoming.domain.inspect}, #{incoming.event_name.inspect}): " \
+              "already registered at version #{existing.event_version.inspect}"
+      end
+
+      def events(domain: nil)
+        @schemas_by_event.keys
+          .select { |(schema_domain, _name)| domain.nil? || schema_domain == domain }
+          .map { |(_domain, event_name)| event_name }
+          .uniq
+      end
+
+      def versions_for(event_name, domain: nil)
+        version_sets_for(event_name, domain).flat_map(&:keys).uniq.sort
+      end
+
+      def schema_for(event_name, version, domain: nil)
+        set = version_sets_for(event_name, domain).find { |versions| versions.key?(version) }
+        set && set[version]
+      end
+
+      def latest_for(event_name, domain: nil)
+        merged = version_sets_for(event_name, domain).reduce({}, :merge)
+        return nil if merged.empty?
+        merged[merged.keys.max]
+      end
+
+      def finalize!
+        @finalized = true
+        @schemas_by_event.each_value(&:freeze)
+        @schemas_by_event.freeze
+        freeze
+      end
+
+      def schemas_by_event
+        @schemas_by_event
+      end
+
+      private
+
+      def key_for(domain, event_name)
+        [domain, event_name]
+      end
+
+      def version_sets_for(event_name, domain = nil)
+        @schemas_by_event.select do |(schema_domain, name), _versions|
+          name == event_name && (domain.nil? || schema_domain == domain)
+        end.values
+      end
+    end
+  end
+end

data/lib/event_engine/definition/schema_registry.rb

@@ -0,0 +1,73 @@
+module EventEngine
+  module Definition
+    class SchemaRegistry
+      class UnknownEventError < StandardError; end
+
+      class RegistryFrozenError < StandardError; end
+
+      def initialize(event_schema = EventSchema.new)
+        @event_schema = event_schema
+        @loaded = false
+      end
+
+      def register(schema)
+        @event_schema.register(schema)
+      end
+
+      def events
+        @event_schema.events
+      end
+
+      def versions_for(event_name, domain: nil)
+        @event_schema.versions_for(event_name, domain: domain)
+      end
+
+      def load_from_schema!(schema)
+        raise RegistryFrozenError, "EventRegistry already loaded" if loaded?
+        @event_schema = schema
+
+        @loaded = true
+        self
+      end
+
+      def reset!
+        @event_schema = {}
+        @loaded = false
+      end
+
+      def schema(event_name, version: nil, domain: nil)
+        raise RegistryFrozenError, "EventRegistry not loaded" unless loaded?
+
+        schema =
+          if version
+            @event_schema.schema_for(event_name, version, domain: domain)
+          else
+            @event_schema.latest_for(event_name, domain: domain)
+          end
+
+        unless schema
+          raise UnknownEventError,
+                "Unknown #{version ? "version #{version} for " : ""}event: #{event_name}"
+        end
+
+        schema
+      end
+
+      def latest_for(event_name, domain: nil)
+        @event_schema.latest_for(event_name, domain: domain)
+      end
+
+      def event_schema
+        @event_schema
+      end
+
+      def finalize!
+        @event_schema.finalize!
+      end
+
+      def loaded?
+        @loaded == true
+      end
+    end
+  end
+end

data/lib/event_engine/definition/version.rb

@@ -2,6 +2,6 @@
 
 module EventEngine
   module Definition
-    VERSION = "0.2.0"
+    VERSION = "0.4.0"
   end
 end

data/lib/event_engine/definition.rb

@@ -5,8 +5,8 @@ require_relative "definition/version"
 require "event_engine/subject_registry"
 require "event_engine/event_definition"
 require "event_engine/definition_loader"
-require "event_engine/event_schema"
-require "event_engine/schema_registry"
+require "event_engine/definition/event_schema"
+require "event_engine/definition/schema_registry"
 require "event_engine/lifecycle_definition"
 require "event_engine/dsl_compiler"
 require "event_engine/definition/configuration"
@@ -26,6 +26,23 @@ module EventEngine
         @publisher = nil
       end
 
+      def packs
+        @packs ||= []
+      end
+
+      def register_pack(pack)
+        packs << pack unless packs.include?(pack)
+        pack
+      end
+
+      def pack_schema_paths
+        packs.map(&:schema_path)
+      end
+
+      def reset_packs!
+        @packs = nil
+      end
+
       def configuration
         @configuration ||= Configuration.new
       end

data/lib/event_engine/domain_pack_build.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "json"
+require "fileutils"
 require "event_engine/dsl_compiler"
 require "event_engine/subject_registry"
 require "event_engine/event_engine_helpers_writer"
@@ -39,6 +40,7 @@ module EventEngine
 
     def run
       event_schema = compile
+      FileUtils.mkdir_p(File.dirname(@helper_path))
       write_helper(event_schema)
       write_schema_json(event_schema)
       self

data/lib/event_engine/dsl_compiler.rb

@@ -16,7 +16,7 @@ module EventEngine
     ].freeze
 
     def self.compile(definitions, subject_registry: SubjectRegistry.new)
-      registry = SchemaRegistry.new
+      registry = Definition::SchemaRegistry.new
       subject_violations = []
       name_violations = []
       reserved_violations = []

data/lib/event_engine/event_engine_helpers_writer.rb

@@ -24,9 +24,17 @@ module EventEngine
     def self.generate(event_schema, root_module: "EventEngine", emit: "EventEngine.emit",
                       header: HEADER, group_by_domain: true, schema_filename: nil)
       body = group_by_domain ? grouped_body(event_schema, emit) : flat_body(event_schema, emit)
-      body = "#{schema_path_accessor(schema_filename)}#{body}" if schema_filename
+      body = "#{schema_path_accessor(schema_filename)}#{body}#{pack_registration}" if schema_filename
 
-      "#{header}module #{root_module}\n#{body}end\n"
+      "#{header}#{pack_require if schema_filename}module #{root_module}\n#{body}end\n"
+    end
+
+    def self.pack_require
+      %(require "event_engine/definition"\n\n)
+    end
+
+    def self.pack_registration
+      "\n  EventEngine::Definition.register_pack(self)\n"
     end
 
     def self.schema_path_accessor(filename)

data/lib/tasks/event_definition.rake

@@ -0,0 +1,20 @@
+require "event_engine/definition"
+
+namespace :event_definition do
+  desc "Generate the pack's helper and schema.json from its EventDefinitions"
+  task :generate do
+    config = EventEngine::Definition.configuration
+
+    definitions = EventEngine::DefinitionLoader.load!(config.definitions_path)
+
+    build = EventEngine::DomainPackBuild.run(
+      definitions,
+      helper_path: config.helper_path,
+      root_module: config.root_module,
+      subject_registry: config.subject_registry
+    )
+
+    puts "Wrote #{config.root_module} helper to #{config.helper_path}"
+    puts "Wrote #{config.root_module} schema to #{build.schema_path}"
+  end
+end