igniter 0.5.0 → 0.5.2

data/examples/contracts/capabilities.rb

@@ -0,0 +1,34 @@
+# 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::CapabilitiesPack)
+
+database_lookup = Igniter::Extensions::Contracts.declare_capabilities(:database) do |sku:|
+  { sku: sku.upcase }
+end
+
+compiled = environment.compile do
+  input :sku
+  compute :fetched, depends_on: [:sku], capabilities: [:network], callable: database_lookup
+  output :fetched
+end
+
+report = Igniter::Extensions::Contracts.capability_report(
+  compiled,
+  profile: environment.profile,
+  policy: Igniter::Extensions::Contracts.capability_policy(denied: [:network])
+)
+
+strict = Igniter::Extensions::Contracts.capability_report(
+  compiled,
+  policy: Igniter::Extensions::Contracts.capability_policy(on_undeclared: :error)
+)
+
+puts "contracts_capabilities_required=#{Igniter::Extensions::Contracts.required_capabilities(compiled).inspect}"
+puts "contracts_capabilities_invalid=#{report.invalid?}"
+puts "contracts_capabilities_violation_kinds=#{report.violations.map(&:kind).inspect}"
+puts "contracts_capabilities_undeclared=#{strict.undeclared_nodes.inspect}"

data/examples/contracts/class_callable.rb

@@ -0,0 +1,45 @@
+#!/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"
+
+class QuoteSubtotal
+  def self.call(line_items:)
+    line_items.sum { |item| item.fetch(:quantity) * item.fetch(:unit_price) }
+  end
+end
+
+class QuoteContract < Igniter::Contract
+  define do
+    input :line_items
+    input :discount_rate
+
+    compute :subtotal, depends_on: [:line_items], call: QuoteSubtotal
+
+    compute :discount, depends_on: %i[subtotal discount_rate] do |subtotal:, discount_rate:|
+      subtotal * discount_rate
+    end
+
+    compute :total, depends_on: %i[subtotal discount] do |subtotal:, discount:|
+      subtotal - discount
+    end
+
+    output :subtotal
+    output :total
+  end
+end
+
+contract = QuoteContract.new(
+  line_items: [
+    { quantity: 2, unit_price: 15 },
+    { quantity: 1, unit_price: 10 }
+  ],
+  discount_rate: 0.1
+)
+
+puts "contracts_class_callable_subtotal=#{contract.result.subtotal}"
+puts "contracts_class_callable_total=#{contract.result.total}"
+puts "contracts_class_callable_outputs=#{contract.outputs.keys.sort.join(",")}"

data/examples/contracts/class_pricing.rb

@@ -0,0 +1,32 @@
+#!/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"
+
+class ClassPricingContract < Igniter::Contract
+  define do
+    input :order_total, type: :numeric
+    input :country, type: :string
+
+    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
+end
+
+contract = ClassPricingContract.new(order_total: 100, country: "UA")
+puts "contracts_class_gross_total=#{contract.result.gross_total}"
+puts "contracts_class_output=#{contract.output(:gross_total)}"
+
+contract.update_inputs(order_total: 150)
+puts "contracts_class_updated_gross_total=#{contract.result.gross_total}"
+puts "contracts_class_success=#{contract.success?}"

data/examples/contracts/collection.rb

@@ -0,0 +1,44 @@
+#!/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::CollectionPack)
+
+result = environment.run(inputs: {
+                           items: [
+                             { sku: "a", amount: 10 },
+                             { sku: "b", amount: 20 }
+                           ],
+                           tax_rate: 0.2
+                         }) do
+  input :items
+  input :tax_rate
+
+  collection :priced_items, from: :items, key: :sku, inputs: { tax_rate: :tax_rate } do
+    input :sku
+    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
+
+  compute :grand_total, depends_on: [:priced_items] do |priced_items:|
+    priced_items.values.sum { |item| item.output(:total) }
+  end
+
+  output :priced_items
+  output :grand_total
+end
+
+puts "contracts_collection_total=#{result.output(:grand_total)}"
+puts "contracts_collection_keys=#{result.output(:priced_items).keys.join(",")}"
+puts "contracts_collection_summary=#{result.output(:priced_items).summary}"

data/examples/contracts/commerce.rb

@@ -0,0 +1,44 @@
+#!/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::Extensions::Contracts.with_preset(:commerce)
+
+result = environment.run(inputs: {
+                           order: {
+                             items: [
+                               { amount: 10 },
+                               { amount: 20 }
+                             ]
+                           },
+                           tax_rate: 0.2,
+                           shipping: 5,
+                           discount: 3
+                         }) do
+  input :order
+  input :tax_rate
+  input :shipping
+  input :discount
+
+  order_items from: :order
+  subtotal from: :items
+  tax_amount amount: :subtotal, rate: :tax_rate
+  grand_total subtotal: :subtotal, tax: :tax, shipping: :shipping, discount: :discount
+
+  output :subtotal
+  output :tax
+  output :grand_total
+end
+
+diagnostics = environment.diagnose(result)
+
+puts "commerce_subtotal=#{result.output(:subtotal)}"
+puts "commerce_tax=#{result.output(:tax)}"
+puts "commerce_grand_total=#{result.output(:grand_total)}"
+puts "commerce_packs=#{environment.profile.pack_names.join(",")}"
+puts "execution_report_sections=#{diagnostics.sections.keys.join(",")}"

data/examples/contracts/compose_your_own_packs.rb

@@ -0,0 +1,110 @@
+#!/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 shows pack composition in one place:
+# 1. a foundational pack adds a node kind (`slug`)
+# 2. a higher-level pack depends on it and adds a richer DSL keyword
+
+module ExampleSlugPack
+  class << self
+    def manifest
+      Igniter::Contracts::PackManifest.new(
+        name: :example_slug_foundation,
+        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
+      state.fetch(source_name)
+           .to_s
+           .downcase
+           .gsub(/[^a-z0-9]+/, "-")
+           .gsub(/\A-+|-+\z/, "")
+    end
+  end
+end
+
+module ExampleSeoPack
+  class << self
+    def manifest
+      Igniter::Contracts::PackManifest.new(
+        name: :example_seo,
+        requires_packs: [ExampleSlugPack],
+        registry_contracts: [
+          Igniter::Contracts::PackManifest.dsl_keyword(:canonical_page)
+        ]
+      )
+    end
+
+    def install_into(kernel)
+      kernel.dsl_keywords.register(:canonical_page, canonical_page_keyword)
+      kernel
+    end
+
+    def canonical_page_keyword
+      Igniter::Contracts::DslKeyword.new(:canonical_page) do |name = :canonical_url, title:, host:, builder:, slug_name: :slug|
+        slug_name = slug_name.to_sym
+        host = host.to_s
+
+        builder.add_operation(kind: :slug, name: slug_name, from: title.to_sym)
+        builder.add_operation(
+          kind: :compute,
+          name: name,
+          depends_on: [slug_name],
+          callable: lambda do |**values|
+            "#{host}/#{values.fetch(slug_name)}"
+          end
+        )
+      end
+    end
+  end
+end
+
+environment = Igniter::Contracts.with(ExampleSeoPack)
+
+result = environment.run(inputs: { title: "Hello, Pack Composition!" }) do
+  input :title
+  canonical_page title: :title, host: "https://docs.example.test"
+  output :canonical_url
+end
+
+puts "composed_pack_profile=#{environment.profile.pack_names.join(",")}"
+puts "composed_pack_has_slug=#{environment.profile.supports_node_kind?(:slug)}"
+puts "composed_pack_url=#{result.output(:canonical_url)}"

data/examples/contracts/composition.rb

@@ -0,0 +1,61 @@
+#!/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::ComposePack)
+
+pricing_contract = environment.compile do
+  input :amount
+  input :tax_rate
+
+  compute :tax, depends_on: %i[amount tax_rate] do |amount:, tax_rate:|
+    amount * tax_rate
+  end
+
+  compute :total, depends_on: %i[amount tax] do |amount:, tax:|
+    amount + tax
+  end
+
+  output :tax
+  output :total
+end
+
+result = environment.run(inputs: { subtotal: 100, rate: 0.2 }) do
+  input :subtotal
+  input :rate
+
+  compose :pricing, contract: pricing_contract, inputs: {
+    amount: :subtotal,
+    tax_rate: :rate
+  }
+
+  compose :pricing_total, inputs: {
+    amount: :subtotal,
+    tax_rate: :rate
+  }, output: :total do
+    input :amount
+    input :tax_rate
+
+    compute :tax, depends_on: %i[amount tax_rate] do |amount:, tax_rate:|
+      amount * tax_rate
+    end
+
+    compute :total, depends_on: %i[amount tax] do |amount:, tax:|
+      amount + tax
+    end
+
+    output :total
+  end
+
+  output :pricing
+  output :pricing_total
+end
+
+puts "contracts_compose_tax=#{result.output(:pricing).output(:tax)}"
+puts "contracts_compose_total=#{result.output(:pricing_total)}"
+puts "contracts_compose_nested_outputs=#{result.output(:pricing).outputs.keys.sort.join(",")}"

data/examples/contracts/content_addressing.rb

@@ -0,0 +1,33 @@
+# 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"
+
+Igniter::Extensions::Contracts.reset_content_cache!
+
+calls = []
+
+tax = Igniter::Extensions::Contracts.content_addressed(fingerprint: "tax_v1") do |country:, amount:|
+  calls << :called
+  rate = { ua: 0.2, us: 0.1 }.fetch(country)
+  amount * rate
+end
+
+environment = Igniter::Contracts.with(Igniter::Extensions::Contracts::ContentAddressingPack)
+compiled = environment.compile do
+  input :country
+  input :amount
+  compute :tax, depends_on: %i[country amount], callable: tax
+  output :tax
+end
+
+environment.execute(compiled, inputs: { country: :ua, amount: 100 })
+second = environment.execute(compiled, inputs: { amount: 100, country: :ua })
+key = Igniter::Extensions::Contracts.content_key(callable: tax, inputs: { amount: 100, country: :ua })
+
+puts "contracts_content_addressing_tax=#{second.output(:tax)}"
+puts "contracts_content_addressing_calls=#{calls.length}"
+puts "contracts_content_addressing_key=#{key}"
+puts "contracts_content_addressing_stats=#{Igniter::Extensions::Contracts::ContentAddressingPack.stats.inspect}"

data/examples/contracts/contractable_service.rb

@@ -0,0 +1,43 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path("../../packages/igniter-contracts/lib", __dir__))
+
+require "igniter/contracts"
+
+class BodyBatteryScorer
+  include Igniter::Contracts::Contractable
+
+  contractable :call do
+    input :sleep_hours
+    input :training_minutes
+    output :score
+  end
+
+  def call(sleep_hours:, training_minutes:)
+    sleep_score = observe(:sleep_score) do
+      [[sleep_hours / 8.0, 1.0].min * 40, 0].max
+    end
+    training_score = observe(:training_score) do
+      training_minutes <= 45 ? 10 : 2
+    end
+
+    success(score: [[45 + sleep_score + training_score, 100].min, 0].max.round)
+  end
+end
+
+result = Igniter::Contracts.with.run(inputs: { sleep_hours: 7.5, training_minutes: 30 }) do
+  input :sleep_hours
+  input :training_minutes
+  compute :body_battery, depends_on: %i[sleep_hours training_minutes], using: BodyBatteryScorer
+  compute :score, depends_on: %i[sleep_hours training_minutes], using: BodyBatteryScorer, output: :score
+  output :body_battery
+  output :score
+end
+
+payload = result.output(:body_battery)
+
+puts "contracts_contractable_service_success=#{payload.fetch(:success)}"
+puts "contracts_contractable_service_score=#{payload.fetch(:outputs).fetch(:score)}"
+puts "contracts_contractable_service_scalar_score=#{result.output(:score)}"
+puts "contracts_contractable_service_observations=#{payload.fetch(:observations).map { |entry| entry.fetch(:name) }.join(",")}"

data/examples/contracts/contractable_shadow.rb

@@ -0,0 +1,69 @@
+#!/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-embed/lib", __dir__))
+
+require "igniter/embed"
+
+class ContractableMemoryStore
+  attr_reader :observations
+
+  def initialize
+    @observations = []
+  end
+
+  def record(observation)
+    observations << observation
+  end
+end
+
+QuoteNormalizer = lambda do |result|
+  {
+    status: :ok,
+    outputs: {
+      total: result.fetch(:total),
+      status: result.fetch(:status)
+    },
+    metadata: {}
+  }
+end
+
+store = ContractableMemoryStore.new
+
+quote_shadow = Igniter::Embed.contractable(:quote) do |config|
+  config.role :migration_candidate
+  config.stage :shadowed
+  config.primary ->(amount:) { { total: amount * 1.2, status: "accepted" } }
+  config.candidate ->(amount:) { { total: amount * 1.25, status: "accepted" } }
+  config.async false
+  config.store store
+  config.redact_inputs ->(**inputs) { inputs }
+  config.normalize_primary QuoteNormalizer
+  config.normalize_candidate QuoteNormalizer
+  config.accept :shape, outputs: { total: Numeric, status: String }
+end
+
+observed_store = ContractableMemoryStore.new
+observed_quote = Igniter::Embed.contractable(:observed_quote) do |config|
+  config.role :observed_service
+  config.stage :profiled
+  config.primary ->(amount:) { { total: amount * 1.2, status: "accepted" } }
+  config.async false
+  config.store observed_store
+  config.redact_inputs ->(**inputs) { inputs }
+  config.normalize_primary QuoteNormalizer
+end
+
+primary_result = quote_shadow.call(amount: 100)
+observed_quote.call(amount: 50)
+shadow_observation = store.observations.fetch(0)
+observed_observation = observed_store.observations.fetch(0)
+
+puts "contractable_primary_total=#{primary_result.fetch(:total)}"
+puts "contractable_shadow_match=#{shadow_observation.fetch(:match)}"
+puts "contractable_shadow_accepted=#{shadow_observation.fetch(:accepted)}"
+puts "contractable_shadow_policy=#{shadow_observation.fetch(:acceptance).fetch(:policy)}"
+puts "contractable_observed_mode=#{observed_observation.fetch(:mode)}"

data/examples/contracts/create_pack.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "tmpdir"
+
+$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"
+
+module ExampleDraftPack
+  class << self
+    def manifest
+      Igniter::Contracts::PackManifest.new(
+        name: :example_draft_pack,
+        node_contracts: [Igniter::Contracts::PackManifest.node(:draft_slug)],
+        registry_contracts: [Igniter::Contracts::PackManifest.validator(:draft_slug_sources)]
+      )
+    end
+
+    def install_into(kernel)
+      kernel
+    end
+  end
+end
+
+environment = Igniter::Extensions::Contracts.with(Igniter::Extensions::Contracts::CreatorPack)
+
+scaffold = Igniter::Extensions::Contracts.scaffold_pack(
+  name: :slug,
+  profile: :feature_node,
+  scope: :app_local,
+  namespace: "Acme::IgniterPacks"
+)
+
+report = Igniter::Extensions::Contracts.creator_report(
+  name: :draft_slug,
+  profile: :feature_node,
+  scope: :standalone_gem,
+  namespace: "Acme::IgniterPacks",
+  pack: ExampleDraftPack,
+  target: environment
+)
+
+workflow = Igniter::Extensions::Contracts.creator_workflow(
+  name: :draft_slug,
+  profile: :feature_node,
+  scope: :standalone_gem,
+  namespace: "Acme::IgniterPacks",
+  pack: ExampleDraftPack,
+  target: environment
+)
+
+wizard = Igniter::Extensions::Contracts.creator_wizard(
+  name: :delivery,
+  capabilities: %i[effect executor],
+  target: environment
+)
+
+completed_wizard = wizard.apply(scope: :standalone_gem)
+
+write_summary = nil
+Dir.mktmpdir("igniter_creator_example") do |dir|
+  writer = Igniter::Extensions::Contracts.creator_writer(
+    name: :slug,
+    profile: :feature_node,
+    scope: :app_local,
+    namespace: "Acme::IgniterPacks",
+    root: dir
+  )
+
+  plan = writer.plan
+  result = writer.write
+
+  write_summary = {
+    plan_steps: plan.steps.length,
+    files_written: result.files_written,
+    directories_created: result.directories_created
+  }
+end
+
+bundle_scaffold = Igniter::Extensions::Contracts.scaffold_pack(
+  name: :developer_console,
+  profile: :diagnostic_bundle,
+  scope: :monorepo_package,
+  namespace: "Acme::IgniterPacks"
+)
+
+puts "creator_pack_constant=#{scaffold.pack_constant}"
+puts "creator_pack_files=#{scaffold.files.keys.join(",")}"
+puts "creator_profiles=#{Igniter::Extensions::Contracts.creator_profiles.join(",")}"
+puts "creator_scopes=#{Igniter::Extensions::Contracts.creator_scopes.join(",")}"
+puts "creator_report_audit_ok=#{report.audit.ok?}"
+puts "creator_report_missing_nodes=#{report.audit.missing_node_definitions.join(",")}"
+puts "creator_bundle_dependency_hints=#{bundle_scaffold.profile.dependency_hints.join(",")}"
+puts "creator_workflow_stage=#{workflow.current_stage.key}"
+puts "creator_workflow_status=#{workflow.current_stage.status}"
+puts "creator_workflow_development_packs=#{workflow.recommended_packs.fetch(:development).join(",")}"
+puts "creator_wizard_current_decision=#{wizard.current_decision.fetch(:key)}"
+puts "creator_wizard_branching_hint=#{wizard.branching_hints.first}"
+puts "creator_wizard_examples=#{wizard.recommended_examples.join(",")}"
+puts "creator_wizard_ready_for_writer=#{completed_wizard.ready_for_writer?}"
+puts "creator_writer_plan_steps=#{write_summary.fetch(:plan_steps)}"
+puts "creator_writer_files_written=#{write_summary.fetch(:files_written)}"
+puts "creator_scope_root=#{scaffold.scope.root}"
+puts "creator_report_next_steps=#{report.next_steps.length}"

data/examples/contracts/dataflow.rb

@@ -0,0 +1,57 @@
+# 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::Extensions::Contracts.with(
+  Igniter::Extensions::Contracts::DataflowPack,
+  Igniter::Extensions::Contracts::IncrementalPack
+)
+
+session = Igniter::Extensions::Contracts.build_dataflow_session(
+  environment,
+  source: :readings,
+  key: :sensor_id,
+  window: { last: 3 }
+) do
+  item do
+    input :sensor_id
+    input :value
+    input :zone
+
+    compute :status, depends_on: [:value] do |value:|
+      value > 50 ? :critical : :normal
+    end
+
+    output :status
+    output :value
+    output :zone
+  end
+
+  count :total
+  count :alerts, matching: ->(item) { item.output(:status) == :critical }
+  sum :total_value, using: :value
+  group_count :by_zone, using: :zone
+end
+
+round1 = session.run(inputs: {
+                       readings: [
+                         { sensor_id: "s1", value: 10, zone: "north" },
+                         { sensor_id: "s2", value: 70, zone: "north" },
+                         { sensor_id: "s3", value: 90, zone: "south" }
+                       ]
+                     })
+
+round2 = session.feed_diff(
+  update: [{ sensor_id: "s2", value: 40, zone: "north" }],
+  add: [{ sensor_id: "s4", value: 95, zone: "east" }]
+)
+
+puts "contracts_dataflow_round1=#{round1.diff.explain}"
+puts "contracts_dataflow_round2=#{round2.diff.explain}"
+puts "contracts_dataflow_total=#{round2.total}"
+puts "contracts_dataflow_alerts=#{round2.alerts}"
+puts "contracts_dataflow_window_keys=#{round2.processed.keys.join(",")}"
+puts "contracts_dataflow_by_zone=#{round2.by_zone.inspect}"