igniter 0.5.1 → 0.5.2

data/examples/cluster/incident_workflow.rb

@@ -0,0 +1,70 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path("../../lib", __dir__))
+$LOAD_PATH.unshift(File.expand_path("../../packages/igniter-contracts/lib", __dir__))
+$LOAD_PATH.unshift(File.expand_path("../../packages/igniter-extensions/lib", __dir__))
+$LOAD_PATH.unshift(File.expand_path("../../packages/igniter-application/lib", __dir__))
+$LOAD_PATH.unshift(File.expand_path("../../packages/igniter-cluster/lib", __dir__))
+
+require "igniter/cluster"
+
+noop_transport = lambda do |request:|
+  Igniter::Application::TransportResponse.new(
+    result: request,
+    metadata: { adapter: :noop_peer }
+  )
+end
+
+profile = Igniter::Cluster.build_kernel(Igniter::Extensions::Contracts::ComposePack)
+                          .capability(:pricing, traits: [:financial], labels: { domain: "commerce" })
+                          .topology_policy(
+                            :locality,
+                            required_labels: { tier: "gold" },
+                            preferred_zone: :eu_west_1a
+                          )
+                          .ownership_policy(:distributed, owner_limit: 1)
+                          .health_policy(:availability_aware, trigger_statuses: [:unhealthy])
+                          .finalize
+
+environment = Igniter::Cluster::Environment.new(profile: profile)
+
+environment.register_peer(
+  :fallback_node,
+  capabilities: %i[pricing compose],
+  labels: { tier: "silver" },
+  region: :eu_west,
+  zone: :eu_west_1b,
+  health_status: :unhealthy,
+  transport: noop_transport
+)
+environment.register_peer(
+  :pricing_node,
+  capabilities: %i[pricing compose],
+  labels: { tier: "gold" },
+  region: :eu_west,
+  zone: :eu_west_1a,
+  transport: noop_transport
+)
+
+plan = environment.plan_failover(target: "order-42", capabilities: [:pricing], traits: [:financial])
+environment.execute_failover_plan(plan) do
+  raise "simulated failover failure"
+end
+
+environment.acknowledge_incident("degraded_health/1", actor: :operator, note: "triaged")
+environment.assign_incident("degraded_health/1", assignee: :sre, actor: :operator)
+environment.silence_incident("degraded_health/1", actor: :operator, metadata: { minutes: 15 })
+
+workflow_before_resolution = environment.incident_workflow("degraded_health/1")
+active_before_resolution = environment.active_incidents.count
+
+environment.resolve_incident("degraded_health/1", actor: :operator, note: "manual recovery confirmed")
+
+workflow_after_resolution = environment.incident_workflow("degraded_health/1")
+
+puts "cluster_incident_workflow_before=#{workflow_before_resolution.state}"
+puts "cluster_incident_workflow_actions=#{workflow_after_resolution.action_kinds.join(",")}"
+puts "cluster_incident_workflow_active_before=#{active_before_resolution}"
+puts "cluster_incident_workflow_after=#{workflow_after_resolution.state}"
+puts "cluster_incident_workflow_active_after=#{environment.active_incidents.count}"

data/examples/cluster/incidents.rb

@@ -0,0 +1,63 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path("../../lib", __dir__))
+$LOAD_PATH.unshift(File.expand_path("../../packages/igniter-contracts/lib", __dir__))
+$LOAD_PATH.unshift(File.expand_path("../../packages/igniter-extensions/lib", __dir__))
+$LOAD_PATH.unshift(File.expand_path("../../packages/igniter-application/lib", __dir__))
+$LOAD_PATH.unshift(File.expand_path("../../packages/igniter-cluster/lib", __dir__))
+
+require "igniter/cluster"
+
+noop_transport = lambda do |request:|
+  Igniter::Application::TransportResponse.new(
+    result: request,
+    metadata: { adapter: :noop_peer }
+  )
+end
+
+profile = Igniter::Cluster.build_kernel(Igniter::Extensions::Contracts::ComposePack)
+                          .capability(:pricing, traits: [:financial], labels: { domain: "commerce" })
+                          .topology_policy(
+                            :locality,
+                            required_labels: { tier: "gold" },
+                            preferred_zone: :eu_west_1a
+                          )
+                          .ownership_policy(:distributed, owner_limit: 1)
+                          .health_policy(:availability_aware, trigger_statuses: [:unhealthy])
+                          .finalize
+
+environment = Igniter::Cluster::Environment.new(profile: profile)
+
+environment.register_peer(
+  :fallback_node,
+  capabilities: %i[pricing compose],
+  labels: { tier: "silver" },
+  region: :eu_west,
+  zone: :eu_west_1b,
+  health_status: :unhealthy,
+  transport: noop_transport
+)
+environment.register_peer(
+  :pricing_node,
+  capabilities: %i[pricing compose],
+  labels: { tier: "gold" },
+  region: :eu_west,
+  zone: :eu_west_1a,
+  transport: noop_transport
+)
+
+plan = environment.plan_failover(target: "order-42", capabilities: [:pricing], traits: [:financial])
+failed_report = environment.execute_failover_plan(plan) do
+  raise "peer write failed"
+end
+resolved_report = environment.execute_failover_plan(plan)
+last_entry = environment.incidents.last
+
+puts "cluster_incident_plan_targets=#{plan.targets.join(",")}"
+puts "cluster_incident_failed_status=#{failed_report.status}"
+puts "cluster_active_incidents_before=#{environment.incidents.first.active? ? 1 : 0}"
+puts "cluster_incident_history=#{environment.incidents.size}"
+puts "cluster_incident_resolved_status=#{resolved_report.status}"
+puts "cluster_incident_last_resolution=#{last_entry.resolution}"
+puts "cluster_active_incidents_after=#{environment.active_incidents.count}"

data/examples/cluster/mesh_diagnostics.rb

@@ -0,0 +1,89 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path("../../lib", __dir__))
+$LOAD_PATH.unshift(File.expand_path("../../packages/igniter-contracts/lib", __dir__))
+$LOAD_PATH.unshift(File.expand_path("../../packages/igniter-extensions/lib", __dir__))
+$LOAD_PATH.unshift(File.expand_path("../../packages/igniter-application/lib", __dir__))
+$LOAD_PATH.unshift(File.expand_path("../../packages/igniter-cluster/lib", __dir__))
+
+require "igniter/cluster"
+
+accepting_transport = lambda do |request:|
+  Igniter::Cluster::MeshExecutionResponse.new(
+    status: :completed,
+    metadata: {
+      accepted_by: request.metadata.fetch(:peer).fetch(:name),
+      trace_id: request.trace_id
+    },
+    explanation: Igniter::Cluster::DecisionExplanation.new(
+      code: :mesh_peer_accept,
+      message: "mesh peer accepted #{request.plan_kind}",
+      metadata: { peer: request.metadata.fetch(:peer).fetch(:name) }
+    )
+  )
+end
+
+failing_transport = lambda do |request:|
+  Igniter::Cluster::MeshExecutionResponse.new(
+    status: :failed,
+    metadata: {
+      rejected_by: request.metadata.fetch(:peer).fetch(:name),
+      trace_id: request.trace_id
+    },
+    explanation: Igniter::Cluster::DecisionExplanation.new(
+      code: :mesh_peer_reject,
+      message: "mesh peer rejected #{request.plan_kind}",
+      metadata: { peer: request.metadata.fetch(:peer).fetch(:name) }
+    )
+  )
+end
+
+profile = Igniter::Cluster.build_kernel(Igniter::Extensions::Contracts::ComposePack)
+                          .capability(:pricing, traits: [:financial], labels: { domain: "commerce" })
+                          .topology_policy(
+                            :locality,
+                            required_labels: { tier: "gold" },
+                            preferred_zone: :eu_west_1a
+                          )
+                          .ownership_policy(:distributed, owner_limit: 1)
+                          .finalize
+
+environment = Igniter::Cluster::Environment.new(profile: profile)
+
+environment.register_peer(
+  :pricing_node_a,
+  capabilities: %i[pricing compose],
+  labels: { tier: "gold" },
+  region: :eu_west,
+  zone: :eu_west_1a,
+  transport: failing_transport
+)
+environment.register_peer(
+  :pricing_node_b,
+  capabilities: %i[pricing compose],
+  labels: { tier: "gold" },
+  region: :eu_west,
+  zone: :eu_west_1a,
+  transport: accepting_transport
+)
+
+plan = environment.plan_ownership(target: "order-42", capabilities: [:pricing], traits: [:financial])
+report = environment.execute_plan_via_mesh(
+  plan,
+  executor: environment.mesh_executor(
+    retry_policy: Igniter::Cluster::MeshRetryPolicy.new(name: :fallback, max_attempts: 2)
+  ),
+  metadata: { source: :example }
+)
+
+mesh = report.action_results.first.metadata.fetch(:mesh)
+attempts = mesh.fetch(:attempts)
+diagnostics = mesh.dig(:metadata, :diagnostics_report)
+
+puts "cluster_mesh_plan_kind=#{report.plan_kind}"
+puts "cluster_mesh_status=#{report.status}"
+puts "cluster_mesh_attempts=#{attempts.map { |attempt| "#{attempt.fetch(:peer)}:#{attempt.fetch(:status)}" }.join(",")}"
+puts "cluster_mesh_projection_mode=#{mesh.dig(:metadata, :candidate_projection_report, :mode)}"
+puts "cluster_mesh_diagnostics_events=#{diagnostics.dig(:event_log, :events).map { |event| event.fetch(:kind) }.join(",")}"
+puts "cluster_mesh_trace_id=#{mesh.fetch(:trace_id)}"

data/examples/cluster/remediation.rb

@@ -0,0 +1,63 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path("../../lib", __dir__))
+$LOAD_PATH.unshift(File.expand_path("../../packages/igniter-contracts/lib", __dir__))
+$LOAD_PATH.unshift(File.expand_path("../../packages/igniter-extensions/lib", __dir__))
+$LOAD_PATH.unshift(File.expand_path("../../packages/igniter-application/lib", __dir__))
+$LOAD_PATH.unshift(File.expand_path("../../packages/igniter-cluster/lib", __dir__))
+
+require "igniter/cluster"
+
+noop_transport = lambda do |request:|
+  Igniter::Application::TransportResponse.new(
+    result: request,
+    metadata: { adapter: :noop_peer }
+  )
+end
+
+profile = Igniter::Cluster.build_kernel(Igniter::Extensions::Contracts::ComposePack)
+                          .capability(:pricing, traits: [:financial], labels: { domain: "commerce" })
+                          .topology_policy(
+                            :locality,
+                            required_labels: { tier: "gold" },
+                            preferred_zone: :eu_west_1a
+                          )
+                          .ownership_policy(:distributed, owner_limit: 1)
+                          .health_policy(:availability_aware, trigger_statuses: [:unhealthy])
+                          .remediation_policy(:default)
+                          .finalize
+
+environment = Igniter::Cluster::Environment.new(profile: profile)
+
+environment.register_peer(
+  :fallback_node,
+  capabilities: %i[pricing compose],
+  labels: { tier: "silver" },
+  region: :eu_west,
+  zone: :eu_west_1b,
+  health_status: :unhealthy,
+  transport: noop_transport
+)
+environment.register_peer(
+  :pricing_node,
+  capabilities: %i[pricing compose],
+  labels: { tier: "gold" },
+  region: :eu_west,
+  zone: :eu_west_1a,
+  transport: noop_transport
+)
+
+incident_plan = environment.plan_failover(target: "order-42", capabilities: [:pricing], traits: [:financial])
+environment.execute_failover_plan(incident_plan) do
+  raise "simulated failover failure"
+end
+
+remediation_plan = environment.plan_remediation
+remediation_report = environment.execute_remediation_plan(remediation_plan)
+
+puts "cluster_remediation_mode=#{remediation_plan.mode}"
+puts "cluster_remediation_steps=#{remediation_plan.steps.length}"
+puts "cluster_remediation_actions=#{remediation_plan.action_kinds.join(",")}"
+puts "cluster_remediation_target=#{remediation_plan.targets.join(",")}"
+puts "cluster_remediation_status=#{remediation_report.status}"

data/examples/cluster/routing.rb

@@ -0,0 +1,65 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path("../../lib", __dir__))
+$LOAD_PATH.unshift(File.expand_path("../../packages/igniter-contracts/lib", __dir__))
+$LOAD_PATH.unshift(File.expand_path("../../packages/igniter-extensions/lib", __dir__))
+$LOAD_PATH.unshift(File.expand_path("../../packages/igniter-application/lib", __dir__))
+$LOAD_PATH.unshift(File.expand_path("../../packages/igniter-cluster/lib", __dir__))
+
+require "igniter/cluster"
+
+cluster = Igniter::Cluster.with(Igniter::Extensions::Contracts::ComposePack)
+
+peer_transport = lambda do |request:|
+  result = Igniter::Contracts.execute(
+    request.compiled_graph,
+    inputs: request.inputs,
+    profile: cluster.application.profile.contracts_profile
+  )
+
+  Igniter::Application::TransportResponse.new(
+    result: result,
+    metadata: { adapter: :in_memory_peer, target: :pricing_node }
+  )
+end
+
+cluster.register_peer(
+  :pricing_node,
+  capabilities: %i[pricing compose],
+  transport: peer_transport,
+  metadata: { zone: "eu-west" }
+)
+
+query = Igniter::Cluster::CapabilityQuery.new(
+  required_capabilities: [:pricing],
+  metadata: { region: "eu-west" }
+)
+
+result = cluster.run(inputs: { subtotal: 100, rate: 0.2 }) do
+  input :subtotal
+  input :rate
+
+  compose :pricing_total,
+          inputs: { amount: :subtotal, tax_rate: :rate },
+          output: :total,
+          via: cluster.compose_invoker(query: query, namespace: :mesh) do
+    input :amount
+    input :tax_rate
+
+    compute :total, depends_on: %i[amount tax_rate] do |amount:, tax_rate:|
+      amount + (amount * tax_rate)
+    end
+
+    output :total
+  end
+
+  output :pricing_total
+end
+
+entry = cluster.application.fetch_session("mesh/pricing_total/1")
+
+puts "cluster_compose_total=#{result.output(:pricing_total)}"
+puts "cluster_query_capabilities=#{entry.payload.fetch(:transport).dig(:cluster, :query, :required_capabilities).inspect}"
+puts "cluster_route_peer=#{entry.payload.fetch(:transport).dig(:cluster, :route, :peer)}"
+puts "cluster_route_mode=#{entry.payload.fetch(:transport).dig(:cluster, :route, :mode)}"

data/examples/contracts/aggregates.rb

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path("../../lib", __dir__))
+$LOAD_PATH.unshift(File.expand_path("../../packages/igniter-contracts/lib", __dir__))
+$LOAD_PATH.unshift(File.expand_path("../../packages/igniter-extensions/lib", __dir__))
+
+require "igniter/extensions/contracts"
+
+environment = Igniter::Contracts.with(
+  Igniter::Extensions::Contracts::LookupPack,
+  Igniter::Extensions::Contracts::AggregatePack
+)
+
+result = environment.run(inputs: {
+                           order: {
+                             items: [
+                               { amount: 10, taxable: true },
+                               { amount: 20, taxable: false },
+                               { amount: 30, taxable: true }
+                             ]
+                           }
+                         }) do
+  input :order
+  lookup :items, from: :order, key: :items
+  count :item_count, from: :items
+  count :taxable_count, from: :items, matching: ->(item) { item.fetch(:taxable) }
+  sum :total_amount, from: :items, using: :amount
+  avg :average_amount, from: :items, using: :amount
+  output :item_count
+  output :taxable_count
+  output :total_amount
+  output :average_amount
+end
+
+puts "aggregate_item_count=#{result.output(:item_count)}"
+puts "aggregate_taxable_count=#{result.output(:taxable_count)}"
+puts "aggregate_total_amount=#{result.output(:total_amount)}"
+puts "aggregate_average_amount=#{result.output(:average_amount)}"

data/examples/contracts/auditing.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path("../../packages/igniter-contracts/lib", __dir__))
+$LOAD_PATH.unshift(File.expand_path("../../packages/igniter-extensions/lib", __dir__))
+
+require "igniter/extensions/contracts"
+
+environment = Igniter::Contracts.with(
+  Igniter::Extensions::Contracts::AuditPack,
+  Igniter::Extensions::Contracts::IncrementalPack
+)
+
+session = Igniter::Extensions::Contracts.build_incremental_session(environment) do
+  input :order_total
+  input :country
+
+  compute :vat_rate, depends_on: [:country] do |country:|
+    country == "UA" ? 0.2 : 0.0
+  end
+
+  compute :gross_total, depends_on: %i[order_total vat_rate] do |order_total:, vat_rate:|
+    (order_total * (1 + vat_rate)).round(2)
+  end
+
+  output :gross_total
+end
+
+result = session.run(inputs: { order_total: 100, country: "UA" })
+snapshot = Igniter::Extensions::Contracts.audit_snapshot(result)
+diagnostics = environment.diagnose(result.execution_result)
+
+puts "contracts_auditing_event_types=#{snapshot.event_types.inspect}"
+puts "contracts_auditing_state=#{snapshot.state(:gross_total).slice(:status, :value).inspect}"
+puts "contracts_auditing_event_count=#{snapshot.event_count}"
+puts "contracts_auditing_sections=#{diagnostics.section_names.join(",")}"

data/examples/contracts/basic_pricing.rb

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path("../../lib", __dir__))
+$LOAD_PATH.unshift(File.expand_path("../../packages/igniter-contracts/lib", __dir__))
+
+require "igniter/contracts"
+
+environment = Igniter::Contracts.with
+
+compiled = environment.compile do
+  input :order_total
+  input :country
+
+  compute :vat_rate, depends_on: [:country] do |country:|
+    country == "UA" ? 0.2 : 0.0
+  end
+
+  compute :gross_total, depends_on: %i[order_total vat_rate] do |order_total:, vat_rate:|
+    order_total * (1 + vat_rate)
+  end
+
+  output :gross_total
+end
+
+first_result = environment.execute(compiled, inputs: { order_total: 100, country: "UA" })
+updated_result = environment.execute(compiled, inputs: { order_total: 150, country: "UA" })
+
+puts "contracts_basic_gross_total=#{first_result.output(:gross_total)}"
+puts "contracts_basic_updated_gross_total=#{updated_result.output(:gross_total)}"
+puts "contracts_basic_profile=#{environment.profile.pack_names.join(",")}"

data/examples/contracts/branching.rb

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path("../../packages/igniter-contracts/lib", __dir__))
+$LOAD_PATH.unshift(File.expand_path("../../packages/igniter-extensions/lib", __dir__))
+
+require "igniter/extensions/contracts"
+
+environment = Igniter::Contracts.with(
+  Igniter::Contracts::ProjectPack,
+  Igniter::Extensions::Contracts::BranchPack
+)
+
+result = environment.run(inputs: { country: "DE", vip: true }) do
+  input :country
+  input :vip
+
+  branch :delivery_strategy, on: :country, depends_on: [:vip] do
+    on "UA", id: :local, value: :local
+    on in: %w[CA MX], id: :regional, value: :regional
+    on matches: /\A[A-Z]{2}\z/, id: :international do |vip:|
+      vip ? :priority_international : :international
+    end
+    default value: :fallback
+  end
+
+  project :delivery_mode, from: :delivery_strategy, key: :value
+  project :selected_case, from: :delivery_strategy, key: :case
+
+  output :delivery_mode
+  output :selected_case
+end
+
+puts "contracts_branch_case=#{result.output(:selected_case)}"
+puts "contracts_branch_value=#{result.output(:delivery_mode)}"
+puts "contracts_branch_matcher=#{result.state.fetch(:delivery_strategy).fetch(:matcher)}"

data/examples/contracts/build_effect_executor_pack.rb

@@ -0,0 +1,88 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path("../../lib", __dir__))
+$LOAD_PATH.unshift(File.expand_path("../../packages/igniter-contracts/lib", __dir__))
+$LOAD_PATH.unshift(File.expand_path("../../packages/igniter-extensions/lib", __dir__))
+
+require "igniter/contracts"
+
+# This file is intentionally self-contained. It shows the smallest useful shape
+# of a custom operational pack:
+# 1. declare effect/executor contracts in the manifest
+# 2. register an effect adapter
+# 3. register an executor
+# 4. route executor work back through invocation.runtime
+module AuditTrailPack
+  class << self
+    def manifest
+      Igniter::Contracts::PackManifest.new(
+        name: :example_audit_trail,
+        registry_contracts: [
+          Igniter::Contracts::PackManifest.effect(:audit_trail),
+          Igniter::Contracts::PackManifest.executor(:audited_inline)
+        ]
+      )
+    end
+
+    def install_into(kernel)
+      kernel.effects.register(:audit_trail, method(:apply_audit_trail))
+      kernel.executors.register(:audited_inline, method(:execute_audited_inline))
+      kernel
+    end
+
+    def journal
+      @journal ||= {
+        effects: [],
+        executions: [],
+        results: []
+      }
+    end
+
+    def reset_journal!
+      journal.each_value(&:clear)
+    end
+
+    def apply_audit_trail(invocation:)
+      journal[:effects] << invocation.to_h
+      invocation.payload
+    end
+
+    def execute_audited_inline(invocation:)
+      journal[:executions] << invocation.to_h
+      result = invocation.runtime.execute(
+        invocation.compiled_graph,
+        inputs: invocation.inputs,
+        profile: invocation.profile
+      )
+      journal[:results] << result.to_h
+      result
+    end
+  end
+end
+
+AuditTrailPack.reset_journal!
+environment = Igniter::Contracts.with(AuditTrailPack)
+
+compiled = environment.compile do
+  input :amount
+  output :amount
+end
+
+effect_result = environment.apply_effect(
+  :audit_trail,
+  payload: { amount: 10, event: "quoted" },
+  context: { source: :example }
+)
+
+execution_result = environment.execute_with(
+  :audited_inline,
+  compiled,
+  inputs: { amount: 15 }
+)
+
+puts "custom_effect_payload=#{effect_result.inspect}"
+puts "custom_executor_output=#{execution_result.output(:amount)}"
+puts "custom_effect_entries=#{AuditTrailPack.journal[:effects].length}"
+puts "custom_execution_entries=#{AuditTrailPack.journal[:executions].length}"
+puts "custom_result_entries=#{AuditTrailPack.journal[:results].length}"

data/examples/contracts/build_your_own_pack.rb

@@ -0,0 +1,82 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path("../../lib", __dir__))
+$LOAD_PATH.unshift(File.expand_path("../../packages/igniter-contracts/lib", __dir__))
+$LOAD_PATH.unshift(File.expand_path("../../packages/igniter-extensions/lib", __dir__))
+
+require "igniter/contracts"
+
+# This file is intentionally self-contained. It shows the smallest useful shape
+# of a custom external pack:
+# 1. declare a manifest
+# 2. register a node kind + DSL keyword
+# 3. add a validator
+# 4. add a runtime handler
+module SlugPack
+  class << self
+    def manifest
+      Igniter::Contracts::PackManifest.new(
+        name: :example_slug,
+        node_contracts: [Igniter::Contracts::PackManifest.node(:slug)],
+        registry_contracts: [Igniter::Contracts::PackManifest.validator(:slug_sources)]
+      )
+    end
+
+    def install_into(kernel)
+      kernel.nodes.register(:slug, Igniter::Contracts::NodeType.new(kind: :slug, metadata: { category: :text }))
+      kernel.dsl_keywords.register(:slug, slug_keyword)
+      kernel.validators.register(:slug_sources, method(:validate_slug_sources))
+      kernel.runtime_handlers.register(:slug, method(:handle_slug))
+      kernel
+    end
+
+    def slug_keyword
+      Igniter::Contracts::DslKeyword.new(:slug) do |name, from:, builder:|
+        builder.add_operation(kind: :slug, name: name, from: from.to_sym)
+      end
+    end
+
+    def validate_slug_sources(operations:, profile: nil) # rubocop:disable Lint/UnusedMethodArgument
+      available = operations.reject(&:output?).map(&:name)
+      missing = operations.select { |operation| operation.kind == :slug }
+                          .map { |operation| operation.attributes.fetch(:from).to_sym }
+                          .reject { |name| available.include?(name) }
+                          .uniq
+      return [] if missing.empty?
+
+      [Igniter::Contracts::ValidationFinding.new(
+        code: :missing_slug_sources,
+        message: "slug sources are not defined: #{missing.map(&:to_s).join(", ")}",
+        subjects: missing
+      )]
+    end
+
+    def handle_slug(operation:, state:, **)
+      source_name = operation.attributes.fetch(:from).to_sym
+      value = state.fetch(source_name).to_s
+
+      value
+        .downcase
+        .gsub(/[^a-z0-9]+/, "-")
+        .gsub(/\A-+|-+\z/, "")
+    end
+  end
+end
+
+environment = Igniter::Contracts.with(SlugPack)
+
+result = environment.run(inputs: { title: "Hello, Igniter Contracts!" }) do
+  input :title
+  slug :permalink, from: :title
+  output :permalink
+end
+
+report = environment.validation_report do
+  slug :permalink, from: :missing_title
+  output :permalink
+end
+
+puts "custom_pack_profile=#{environment.profile.pack_names.join(",")}"
+puts "custom_pack_slug=#{result.output(:permalink)}"
+puts "custom_pack_findings=#{report.findings.map(&:code).join(",")}"