taski 0.8.3 → 0.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cddae184fb1f55c69b42995e51c3bf5711d31f978ec383a00a73d2ce3531ca15
-  data.tar.gz: 3e79ca2bf3a6cd163272bbff98ff3b980f3a3b69293607dd45879501d50904c4
+  metadata.gz: 7c7ea0740de2f0d1fcf24a72fe5b32e75128fa4d793718b3ac12a2c041c37628
+  data.tar.gz: 8fb45c4d390a98709d934f4b59f14a613d689ed7538df630cb4328bc405b2803
 SHA512:
-  metadata.gz: 9310e8b52be98d9087de88b4b7f5d105896edd85137c2f43e6c968c8daaf00dc6b4843ff9d1f228a089dcd7ceb379715c2b640d3c547ce173659dc7130cd1768
-  data.tar.gz: 65bade2024691c9c7527f6249294d01714563ff35c211472e6d984e82ba5acd0767251d33e05d8ade4208eabc8b1326eb47fc4f932b4699bf0b986e208fffcea
+  metadata.gz: 7cba0b749c9f5b5e76f990731017d18c550407215f851877129d2c6b1c9872fccfb3d0e088b01db19a92064f92592971a085ca9eecca3bcd8742e44b7374a9e5
+  data.tar.gz: 211b4d9ed455e19688bbb29acc7beb5043150703e144bb38f973b68f6bbf5fb3aa942c7fd2d77faa4332df243cb5f0d50e4a06813c7786b7c954f5a8eb674900

data/CHANGELOG.md

@@ -7,6 +7,58 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.9.1] - 2026-02-16
+
+### Changed
+- Replace raw arrays and hashes with FiberProtocol Data classes for typed protocol messages ([#175](https://github.com/ahogappa/taski/pull/175))
+- Add AST-guided start_dep speculative parallel execution for improved performance ([#175](https://github.com/ahogappa/taski/pull/175))
+- Add TaskProxy for lazy dependency resolution with unsafe proxy usage detection ([#175](https://github.com/ahogappa/taski/pull/175))
+- Remove static-graph-based task scheduling from Executor in favor of Fiber pull model ([#176](https://github.com/ahogappa/taski/pull/176))
+- Replace inline `Class.new(Taski::Task)` with named fixture classes in tests ([#174](https://github.com/ahogappa/taski/pull/174))
+- Add custom export methods section to README ([#172](https://github.com/ahogappa/taski/pull/172))
+
+### Fixed
+- Fix data race on `@next_thread_index` in enqueue/enqueue_clean ([#175](https://github.com/ahogappa/taski/pull/175))
+
+## [0.9.0] - 2026-02-08
+
+### Added
+- Fiber-based lazy dependency resolution replacing Monitor-based approach ([#157](https://github.com/ahogappa/taski/pull/157))
+- Layout/Theme architecture for progress display ([#150](https://github.com/ahogappa/taski/pull/150))
+- Layout::Tree for hierarchical task display with TTY/non-TTY dual mode ([#151](https://github.com/ahogappa/taski/pull/151))
+- Structured logging support for debugging and monitoring ([#141](https://github.com/ahogappa/taski/pull/141))
+- Skipped task reporting in progress display and logging ([#157](https://github.com/ahogappa/taski/pull/157))
+- `clean_on_failure` option for `run_and_clean` ([#169](https://github.com/ahogappa/taski/pull/169))
+- `short_name` filter for template name formatting ([#151](https://github.com/ahogappa/taski/pull/151))
+- TaskDrop and ExecutionDrop for structured template variables ([#151](https://github.com/ahogappa/taski/pull/151))
+- Group duration computation in Layout::Base ([#167](https://github.com/ahogappa/taski/pull/167))
+- `mark_clean_failed` in Scheduler for symmetric failure tracking ([#167](https://github.com/ahogappa/taski/pull/167))
+- Ruby 4.0 support in CI ([#160](https://github.com/ahogappa/taski/pull/160))
+
+### Changed
+- Replace ExecutionContext with ExecutionFacade/TaskObserver architecture ([#167](https://github.com/ahogappa/taski/pull/167))
+- Remove SharedState, unify task state in TaskWrapper ([#167](https://github.com/ahogappa/taski/pull/167))
+- Remove Section API in favor of simple if-statement selection (BREAKING) ([#157](https://github.com/ahogappa/taski/pull/157))
+- Simplify clean API by removing `Task.clean` and `Task.new` (BREAKING) ([#163](https://github.com/ahogappa/taski/pull/163))
+- Simplify progress display configuration to single setter API ([#161](https://github.com/ahogappa/taski/pull/161))
+- Rename `completed?`/`clean_completed?` to `finished?`/`clean_finished?` (BREAKING) ([#167](https://github.com/ahogappa/taski/pull/167))
+- Unify `STATE_ERROR` to `STATE_FAILED` across execution layer (BREAKING) ([#167](https://github.com/ahogappa/taski/pull/167))
+- Rename Template to Theme, Layout::Plain to Layout::Log ([#151](https://github.com/ahogappa/taski/pull/151))
+- Rename `execution_context` to `execution_facade` across codebase ([#167](https://github.com/ahogappa/taski/pull/167))
+- Merge FiberExecutor into Executor, rename FiberWorkerPool to WorkerPool ([#157](https://github.com/ahogappa/taski/pull/157))
+- Replace inline `Class.new(Taski::Task)` with named fixture classes in tests ([#166](https://github.com/ahogappa/taski/pull/166))
+- Drop Ruby 3.2 from CI ([#160](https://github.com/ahogappa/taski/pull/160))
+
+### Fixed
+- Recursively add transitive dependencies in `merge_runtime_dependencies` ([#142](https://github.com/ahogappa/taski/pull/142))
+- Handle `Errno::EBADF` in TaskOutputRouter pipe operations ([#159](https://github.com/ahogappa/taski/pull/159))
+- Truncate simple progress line to terminal width ([#152](https://github.com/ahogappa/taski/pull/152))
+- Improve thread safety in Registry and WorkerPool ([#167](https://github.com/ahogappa/taski/pull/167))
+- Restore fiber context on resume, scope output capture per-fiber ([#157](https://github.com/ahogappa/taski/pull/157))
+- Prevent duplicate `:start` responses and ensure observer event ordering ([#157](https://github.com/ahogappa/taski/pull/157))
+- Route observer errors through structured logger instead of `warn` ([#167](https://github.com/ahogappa/taski/pull/167))
+- Resolve Bundler permission error on Ruby 4.0 CI ([#162](https://github.com/ahogappa/taski/pull/162))
+
 ## [0.8.3] - 2026-01-26
 
 ### Fixed

data/README.md

@@ -12,9 +12,10 @@
 
 - **Automatic Dependency Resolution**: Dependencies detected via static analysis
 - **Parallel Execution**: Independent tasks run concurrently for maximum performance
-- **Two Simple APIs**: Exports (value sharing) and Section (runtime selection)
+- **Exports API**: Simple value sharing between tasks
 - **Real-time Progress**: Visual feedback with parallel task progress display
-- **Thread-Safe**: Built on Monitor-based synchronization for reliable concurrent execution
+- **Fiber-Based Execution**: Lightweight Fiber-based dependency resolution for efficient parallel execution
+- **Lazy Dependency Resolution**: Dependencies return lightweight proxies that defer resolution until the value is actually used, enabling better parallelism
 
 ## Quick Start
 
@@ -77,42 +78,72 @@ class Server < Taski::Task
 end
 ```
 
-### Section - Runtime Implementation Selection
+### Custom Export Methods
 
-Switch implementations based on environment:
+By default, `exports` generates a reader that returns the instance variable (e.g., `exports :value` reads `@value`). You can override this by defining your own instance method with the same name:
+
+**Fixed values** — no computation needed in `run`:
 
 ```ruby
-class DatabaseSection < Taski::Section
-  interfaces :host, :port
+class Config < Taski::Task
+  exports :timeout
 
-  class Production < Taski::Task
-    def run
-      @host = "prod.example.com"
-      @port = 5432
-    end
+  def timeout
+    30
+  end
+
+  def run; end
+end
+
+Config.timeout  # => 30
+```
+
+**Shared logic between `run` and `clean`** — the method works as both an export and a regular instance method:
+
+```ruby
+class DatabaseSetup < Taski::Task
+  exports :connection
+
+  def connection
+    @connection ||= Database.connect
   end
 
-  class Development < Taski::Task
-    def run
+  def run
+    connection.setup_schema
+  end
+
+  def clean
+    connection.close
+  end
+end
+```
+
+### Conditional Logic - Runtime Selection
+
+Use `if` statements to switch behavior based on environment:
+
+```ruby
+class DatabaseConfig < Taski::Task
+  exports :host, :port
+
+  def run
+    if ENV['RAILS_ENV'] == 'production'
+      @host = "prod.example.com"
+      @port = 5432
+    else
       @host = "localhost"
       @port = 5432
     end
   end
-
-  def impl
-    ENV['RAILS_ENV'] == 'production' ? Production : Development
-  end
 end
 
 class App < Taski::Task
   def run
-    puts "Connecting to #{DatabaseSection.host}:#{DatabaseSection.port}"
+    puts "Connecting to #{DatabaseConfig.host}:#{DatabaseConfig.port}"
   end
 end
 ```
 
-> **Note**: Nested implementation classes automatically inherit Section's `interfaces` as `exports`.
-
 ## Best Practices
 
 ### Keep Tasks Small and Focused
@@ -236,16 +267,49 @@ Env API (execution environment):
 RandomTask.value  # => 42
 RandomTask.value  # => 99 (different value - fresh execution)
 
-# Instance-level caching
-instance = RandomTask.new
-instance.run        # => 42
-instance.run        # => 42 (cached within instance)
-instance.value      # => 42
-
 # Dependencies within same execution share results
 DoubleConsumer.run  # RandomTask runs once, both accesses get same value
 ```
 
+When a task accesses a dependency (e.g., `SomeDep.value`), the result may be a lightweight proxy. The actual resolution is deferred until the value is used, allowing independent dependencies to execute in parallel transparently. This is automatic and requires no changes to your task code. Dependencies used in conditions or as arguments are automatically resolved synchronously for safety.
+
+### Error Handling
+
+When a task fails, Taski wraps the error with task-specific context. Each task class automatically gets a `::Error` subclass for targeted rescue:
+
+```ruby
+class FetchData < Taski::Task
+  exports :data
+  def run
+    @data = API.fetch  # may raise
+  end
+end
+
+class ProcessData < Taski::Task
+  def run
+    FetchData.data
+  end
+end
+
+# Rescue a specific task's error
+begin
+  ProcessData.run
+rescue FetchData::Error => e
+  puts "FetchData failed: #{e.cause.message}"
+end
+
+# Rescue all task failures with AggregateError
+begin
+  ProcessData.run
+rescue Taski::AggregateError => e
+  e.errors.each do |failure|
+    puts "#{failure.task_class}: #{failure.error.message}"
+  end
+end
+```
+
+`AggregateError` collects all failures from parallel execution. Task-specific `::Error` classes work transparently with `rescue` — even when errors are wrapped inside an `AggregateError`.
+
 ### Aborting Execution
 
 Stop all pending tasks when a critical error occurs:
@@ -282,17 +346,24 @@ end
 # Run then clean in one call
 DatabaseSetup.run_and_clean
 
-# Or separately
-DatabaseSetup.run
-# ... do work ...
-DatabaseSetup.clean
+# Run, do something with exported values, then clean
+DatabaseSetup.run_and_clean do
+  deploy(DatabaseSetup.connection)
+end
 ```
 
-See [docs/guide.md](docs/guide.md#lifecycle-management) for details.
+See [docs/GUIDE.md](docs/GUIDE.md#lifecycle-management) for details.
 
 ### Progress Display
 
-Tree-based progress visualization is enabled by default:
+Simple progress display is enabled by default:
+
+```text
+⠹ [3/5] DeployTask | Uploading files...
+✓ [5/5] All tasks completed (1234ms)
+```
+
+**Tree mode** provides full dependency tree visualization:
 
 ```
 WebServer (Task)
@@ -302,14 +373,7 @@ WebServer (Task)
 └── ◻ Server (Task)
 ```
 
-**Simple mode** provides a compact single-line display:
-
-```
-⠹ [3/5] DeployTask | Uploading files...
-✓ [5/5] All tasks completed (1234ms)
-```
-
-**Plain mode** provides text output without escape codes (for CI/logs):
+**Log mode** provides text output without escape codes (for CI/logs):
 
 ```
 [START] DatabaseSetup
@@ -322,18 +386,12 @@ WebServer (Task)
 **Configuration:**
 
 ```ruby
-# Via API
-Taski.progress_mode = :tree    # Tree display (default)
-Taski.progress_mode = :simple  # Single-line display
-Taski.progress_mode = :plain   # Plain text (CI/logs)
-
-# Via environment variable
-TASKI_PROGRESS_MODE=simple ruby your_script.rb
-TASKI_PROGRESS_MODE=plain ruby your_script.rb
+Taski.progress_display = Taski::Progress::Layout::Simple.new  # Simple display (default)
+Taski.progress_display = Taski::Progress::Layout::Tree.new     # Tree display
+Taski.progress_display = Taski::Progress::Layout::Log.new      # Log output (CI/logs)
+Taski.progress_display = nil                                    # Disable
 ```
 
-To disable: `TASKI_PROGRESS_DISABLE=1 ruby your_script.rb`
-
 ### Tree Visualization
 
 ```ruby

data/docs/GUIDE.md

@@ -7,6 +7,7 @@ This guide provides detailed documentation beyond the basics covered in the READ
 - [Error Handling](#error-handling)
 - [Lifecycle Management](#lifecycle-management)
 - [Progress Display](#progress-display)
+- [Lazy Dependency Resolution](#lazy-dependency-resolution)
 - [Debugging](#debugging)
 
 ---
@@ -87,7 +88,9 @@ rescue DatabaseTask::Error => e
 end
 ```
 
-This works transparently with `AggregateError` - when you rescue `DatabaseTask::Error`, it matches an `AggregateError` that contains a `DatabaseTask::Error`.
+This works transparently with `AggregateError` — when you rescue `DatabaseTask::Error`, it matches an `AggregateError` that contains a `DatabaseTask::Error`.
+
+**How this works:** Ruby's `rescue` uses the `===` operator to match exceptions. Taski's `AggregateAware` module (extended by `TaskError` and all `TaskClass::Error` classes) overrides `===` to check whether an `AggregateError` *contains* an error of that type. This means `rescue Taski::TaskError` will match an `AggregateError` wrapping TaskError instances, even though `AggregateError` does not inherit from `TaskError`.
 
 ### TaskAbortException
 
@@ -140,7 +143,7 @@ end
 
 ## Lifecycle Management
 
-Taski supports resource cleanup with `run`, `clean`, and `run_and_clean` methods.
+Taski supports resource cleanup with `run_and_clean`, which executes the run phase followed by the clean phase in a single operation.
 
 ### Basic Lifecycle
 
@@ -168,27 +171,24 @@ class WebServer < Taski::Task
   end
 end
 
-# Start
-WebServer.run
+# Run then clean in one call
+WebServer.run_and_clean
 # => Database connected
-# => Server started with postgresql://localhost:5432/myapp
-
-# Clean (reverse dependency order)
-WebServer.clean
+# => Server started
 # => Server stopped
 # => Database disconnected
 ```
 
-### run_and_clean
+### run_and_clean with Block
 
-Execute run followed by clean in a single operation:
+Use a block to execute code between run and clean phases. This is useful when you need to use exported values before cleanup:
 
 ```ruby
-WebServer.run_and_clean
-# => Database connected
-# => Server started
-# => Server stopped
-# => Database disconnected
+DatabaseSetup.run_and_clean do
+  # Exported values are accessible here
+  deploy(DatabaseSetup.connection)
+end
+# Clean runs automatically after the block
 ```
 
 ### Idempotent Clean Methods
@@ -289,21 +289,9 @@ After completion:
 
 ### Display Modes
 
-Taski supports two progress display modes:
+Taski supports three progress display modes:
 
-#### Tree Mode (Default)
-
-Full dependency tree visualization with status for each task:
-
-```
-WebServer (Task)
-├── ⠋ Config (Task) | Reading config.yml...
-│   ├── ✅ Database (Task) 45.2ms
-│   └── ⠙ Cache (Task) | Connecting...
-└── ◻ Server (Task)
-```
-
-#### Simple Mode
+#### Simple Mode (Default)
 
 Compact single-line display showing current progress:
 
@@ -324,7 +312,19 @@ On failure:
 ✗ [3/5] DeployTask failed: Connection refused
 ```
 
-#### Plain Mode
+#### Tree Mode
+
+Full dependency tree visualization with status for each task:
+
+```
+WebServer (Task)
+├── ⠋ Config (Task) | Reading config.yml...
+│   ├── ✅ Database (Task) 45.2ms
+│   └── ⠙ Cache (Task) | Connecting...
+└── ◻ Server (Task)
+```
+
+#### Log Mode
 
 Plain text output without escape codes, designed for CI/logs:
 
@@ -336,49 +336,73 @@ Plain text output without escape codes, designed for CI/logs:
 [TASKI] Completed: 2/2 tasks (165ms)
 ```
 
-### Configuring Progress Mode
-
-**Via API:**
+### Configuring Progress Display
 
 ```ruby
-Taski.progress_mode = :tree    # Tree display (default)
-Taski.progress_mode = :simple  # Single-line display
-Taski.progress_mode = :plain   # Plain text (CI/logs)
+Taski.progress_display = Taski::Progress::Layout::Simple.new  # Simple display (default)
+Taski.progress_display = Taski::Progress::Layout::Tree.new     # Tree display
+Taski.progress_display = Taski::Progress::Layout::Log.new      # Log output (CI/logs)
+Taski.progress_display = nil                                    # Disable
 ```
 
-**Via environment variable:**
+### File Output Mode
+
+When output is redirected, interactive spinners are automatically disabled:
 
 ```bash
-TASKI_PROGRESS_MODE=tree ruby your_script.rb
-TASKI_PROGRESS_MODE=simple ruby your_script.rb
-TASKI_PROGRESS_MODE=plain ruby your_script.rb
+ruby build.rb > build.log 2>&1
 ```
 
-### Disabling Progress Display
+---
 
-```bash
-TASKI_PROGRESS_DISABLE=1 ruby your_script.rb
-```
+## Lazy Dependency Resolution
 
-### File Output Mode
+### How It Works
 
-When output is redirected, interactive spinners are automatically disabled:
+When a task accesses a dependency's exported value (e.g., `DepTask.value`), Taski may return a lightweight **proxy object** instead of the actual value. This proxy defers dependency resolution until you call a method on it, at which point it transparently resolves the real value and forwards the method call.
 
-```bash
-ruby build.rb > build.log 2>&1
+```ruby
+class FetchData < Taski::Task
+  exports :data
+  def run
+    @data = expensive_api_call
+  end
+end
+
+class ProcessData < Taski::Task
+  exports :result
+  def run
+    raw = FetchData.data       # May return a proxy (no blocking yet)
+    setup_environment          # Task continues while FetchData runs
+    @result = raw.transform    # Proxy resolves here — blocks if needed
+  end
+end
 ```
 
+From the user's perspective, the proxy is completely transparent — it behaves exactly like the real value.
+
+### Why It Matters
+
+Proxy-based resolution enables better parallelism. A task can continue executing setup logic while its dependencies are still running, only blocking when the dependency value is actually used. This can significantly reduce total execution time when tasks have independent setup work before they need their dependencies.
+
+### Automatic Safety
+
+Taski uses static analysis (Prism AST parsing) to determine when proxy resolution is safe. Dependencies used in positions where the proxy could cause issues — such as conditions (`if dep_value`), method arguments, or other contexts where truthiness or identity matters — are automatically resolved synchronously instead of returning a proxy.
+
+You do not need to think about this in normal usage. The static analyzer examines your task's `run` method and only enables proxy resolution for dependency accesses that are confirmed safe (e.g., simple assignments like `x = Dep.value` followed by method calls on `x`).
+
 ---
 
 ## Debugging
 
-### Environment Variables
+### Structured Logging
+
+```ruby
+require "logger"
+Taski.logger = Logger.new($stdout, level: Logger::DEBUG)
+```
 
-| Variable | Purpose |
-|----------|---------|
-| `TASKI_PROGRESS_DISABLE=1` | Disable progress display |
-| `TASKI_PROGRESS_MODE=tree\|simple\|plain` | Set progress display mode (default: tree) |
-| `TASKI_DEBUG=1` | Enable debug output |
+Set `Taski.logger` to a Ruby `Logger` instance to enable structured logging of execution events.
 
 ### Dependency Tree Visualization
 
@@ -405,4 +429,4 @@ end
 
 **Static Analysis Requirements**
 
-Tasks must be defined in source files (not dynamically with `Class.new`) because static analysis uses Prism AST parsing which requires actual source files.
+Tasks must be defined in source files (not dynamically with `Class.new`) because static analysis uses Prism AST parsing which requires actual source files. Static analysis is used for dependency tree visualization, circular dependency detection, and optimizing dependency resolution (determining when lazy proxy resolution is safe vs. when synchronous resolution is required).

data/examples/README.md

@@ -19,22 +19,7 @@ ruby examples/quick_start.rb
 
 ---
 
-### 2. section_demo.rb - Runtime Implementation Selection
-
-Switch implementations based on environment using the Section API.
-
-```bash
-ruby examples/section_demo.rb
-```
-
-**Covers:**
-- `interfaces` for defining contracts
-- Environment-specific implementations
-- Dependency tree visualization with `.tree`
-
----
-
-### 3. args_demo.rb - Runtime Args and Options
+### 2. args_demo.rb - Runtime Args and Options
 
 Access execution args and pass custom options to tasks.
 
@@ -52,22 +37,21 @@ ruby examples/args_demo.rb
 
 ---
 
-### 4. reexecution_demo.rb - Scope-Based Execution
+### 3. reexecution_demo.rb - Scope-Based Execution
 
 Understand scope-based execution and caching behavior.
 
 ```bash
-TASKI_PROGRESS_DISABLE=1 ruby examples/reexecution_demo.rb
+ruby examples/reexecution_demo.rb
 ```
 
 **Covers:**
 - Fresh execution for each class method call
-- Instance-level caching with `Task.new`
 - Scope-based dependency caching
 
 ---
 
-### 5. clean_demo.rb - Lifecycle Management
+### 4. clean_demo.rb - Lifecycle Management
 
 Demonstrates resource cleanup with clean methods.
 
@@ -79,10 +63,11 @@ ruby examples/clean_demo.rb
 - Defining `clean` methods for resource cleanup
 - Reverse dependency order execution
 - `run_and_clean` combined operation
+- `run_and_clean` with block support
 
 ---
 
-### 6. group_demo.rb - Task Output Grouping
+### 5. group_demo.rb - Task Output Grouping
 
 Organize task output into logical phases with groups.
 
@@ -97,7 +82,7 @@ ruby examples/group_demo.rb
 
 ---
 
-### 7. message_demo.rb - User-Facing Messages
+### 6. message_demo.rb - User-Facing Messages
 
 Output messages that bypass the progress display capture.
 
@@ -112,14 +97,12 @@ ruby examples/message_demo.rb
 
 ---
 
-### 8. progress_demo.rb - Progress Display Modes
+### 7. progress_demo.rb - Progress Display Modes
 
 Real-time progress visualization during parallel execution.
 
 ```bash
-ruby examples/progress_demo.rb                              # Tree mode
-TASKI_PROGRESS_MODE=simple ruby examples/progress_demo.rb   # Simple mode
-TASKI_PROGRESS_DISABLE=1 ruby examples/progress_demo.rb     # Disabled
+ruby examples/progress_demo.rb   # Simple mode (default)
 ```
 
 **Covers:**
@@ -136,7 +119,6 @@ TASKI_PROGRESS_DISABLE=1 ruby examples/progress_demo.rb     # Disabled
 | Example | Feature | Complexity |
 |---------|---------|------------|
 | quick_start | Exports API | Basic |
-| section_demo | Section API | Intermediate |
 | args_demo | Args/Env API | Intermediate |
 | reexecution_demo | Scope-Based Execution | Intermediate |
 | clean_demo | Lifecycle Management | Intermediate |
@@ -150,8 +132,7 @@ TASKI_PROGRESS_DISABLE=1 ruby examples/progress_demo.rb     # Disabled
 # Run each example
 for f in examples/*.rb; do echo "=== $f ===" && ruby "$f" && echo; done
 
-# Disable progress display if needed
-TASKI_PROGRESS_DISABLE=1 ruby examples/progress_demo.rb
+# Disable progress display if needed (add Taski.progress_display = nil in script)
 ```
 
 ## Next Steps