saga_forge-dashboard 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7719d60b0d6882e37ba1f707fc29d070fba4a1a54ee5db65deade6e0b6d9c968
+  data.tar.gz: 5e984750302fe98e6bd31f34f2f366ced66cb82b6567ba8ea01c8db6849ec6aa
+SHA512:
+  metadata.gz: 484a6086e73172225fc30fee4bd8591c8542c9d874fe162c030a1c4e33d589fe9fcace03cbdaa851727bf3391bcb4f6a50967ee091b1e57627b86ea401545dc4
+  data.tar.gz: e25cd46d7d0e2ab6b84f79bdbdfc8d094c6e2b59b31a0184b4192f427cdb1e91ff7fc7396283fcc7240606fb8ac0f60c3acf1676d7224040923ee9b373f3c6ec

data/CHANGELOG.md

@@ -0,0 +1,47 @@
+## [0.1.0] - 2026-08-26
+
+### Bug Fixes
+
+- Test-env CSRF knob, schema staleness note, narrowed asset_digest rescue
+- Working relative/absolute time toggle, a11y chrome, format_bytes guard
+- Render aria-current as a real attribute, not an escaped string
+- Memoize show presenters, deterministic comp order, timeline cap, context preview guard
+- Make TimelinePresenter#truncated? side-effect-free
+- Danger-style Compensate, clarify bulk button covers the whole class
+- Remove em dashes from operator-facing UI copy; realistic seed backtrace
+- Close forward-only guard hole in TimeoutJob; stamp last_active_at on timeout/compensation paths
+
+### Documentation
+
+- Comment why the asset route regex stays unanchored + test-env show_exceptions scoping
+- Drop stale cf/task residue comment, fix README port example
+
+### Features
+
+- Engine scaffold, config, combustion harness
+- Fail-closed auth tests and controller-served digest-busted assets
+- Layout chrome, view helpers, tailwind styles, poll refresh
+- Sagas index with keyset query and capped stats
+- Saga show with merged timeline and context tree
+- Overview, stalled, and suspended pages
+- State-machine graph with per-instance overlay
+- Operator actions and bulk recovery
+- Preview server, README, packaging
+- Finalized/active filters + stat; drop stay fixture; use persisted finalized_at
+
+### Miscellaneous Tasks
+
+- Add cliff-driven release tooling for both gems
+- Tidy gemspecs for release
+- Require MFA to push the gems (rubygems_mfa_required)
+
+### Refactoring
+
+- Reuse core State scopes in queries; cover keyset Newer path
+- Reword sibling-gem comments to saga terms; reuse ledger_order scope
+
+### Testing
+
+- Cover graph overlay per-node isolation, stale events, namespaced classes
+
+## [Unreleased]

data/MIT-LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Stefan Froelich
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,205 @@
+# SagaForge::Dashboard
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](MIT-LICENSE)
+
+**A mountable Rails engine that answers the question a saga-based workflow
+raises once it's live: which instances are stuck, and why?** It gives
+SagaForge a triage-first dashboard with the recovery controls to act on what
+it surfaces.
+
+It is built on the event ledger every saga already keeps. The dashboard reads
+that ledger per instance (every processed, parked, and failed event, with any
+traceback inlined on the event that raised it), rolls it up into a fleet
+overview and per-class lists, and gives you one-click retry, resume, and
+compensate so recovery doesn't mean a Rails console session.
+
+> Requires [`saga_forge`](https://github.com/radioactive-labs/saga_forge). See
+> the [main README](https://github.com/radioactive-labs/saga_forge#readme) for
+> saga documentation.
+
+Early release: the UI and config API may change before `1.0`.
+
+## Screenshots
+
+Not captured yet. The plan is to run `bin/dev` against the seeded preview
+fixtures (every saga health state, across two saga classes) and screenshot
+each page from there, the same way the core gem's site does.
+
+## Installation
+
+Add to your application's Gemfile (requires `saga_forge`):
+
+```ruby
+gem "saga_forge-dashboard"
+```
+
+Then run `bundle install`, and mount the engine in `config/routes.rb`:
+
+```ruby
+mount SagaForge::Dashboard::Engine => "/saga_forge"
+```
+
+The dashboard is fail-closed: mount it without configuring
+[authentication](#authentication) and every URL raises. Configure one of the
+auth options below before you rely on it.
+
+## Authentication
+
+The dashboard is fail-closed. If you mount it without configuring
+authentication, hitting any dashboard URL raises
+`SagaForge::Dashboard::AuthenticationNotConfigured`. Configure one of the
+following in an initializer (e.g. `config/initializers/saga_forge_dashboard.rb`).
+Resolution order: custom hook, then HTTP Basic, then `:none`, else raise.
+
+### Custom hook
+
+```ruby
+SagaForge::Dashboard.configure do |c|
+  c.authenticate { |controller| controller.head(:forbidden) unless controller.current_user&.admin? }
+end
+```
+
+The block runs in the controller's own context (so `instance_exec`, not a
+plain call), and receives the controller instance too. Call `head(:forbidden)`
+or `redirect_to` to deny access; return normally to allow it.
+
+### HTTP Basic Auth
+
+```ruby
+SagaForge::Dashboard.configure do |c|
+  c.http_basic = { username: ENV["SF_USER"], password: ENV["SF_PASS"] }
+end
+```
+
+### Disable (guard the mount point instead)
+
+Set authentication to `:none` and guard the mount point with a routing
+constraint:
+
+```ruby
+SagaForge::Dashboard.configure do |c|
+  c.authentication = :none
+end
+```
+
+```ruby
+# config/routes.rb
+authenticate :user, ->(u) { u.admin? } do
+  mount SagaForge::Dashboard::Engine => "/saga_forge"
+end
+```
+
+## Configuration
+
+```ruby
+SagaForge::Dashboard.configure do |c|
+  c.polling_interval         = 15                          # seconds; default auto-refresh interval. 0 to disable.
+  c.polling_interval_options = [0, 5, 10, 15, 30, 60, 300] # selectable intervals in the nav "refresh" control
+  c.page_size                = 50                          # sagas per page on the per-class index
+end
+```
+
+| Option | Default | Notes |
+| --- | --- | --- |
+| `polling_interval` | `15` | Seconds between auto-refreshes. A viewer can override it with the nav "refresh" control (stored in a cookie). `0` disables. |
+| `polling_interval_options` | `[0, 5, 10, 15, 30, 60, 300]` | Intervals (seconds; `0` = off) offered by the nav refresh control. |
+| `page_size` | `50` | Sagas per page on the per-class list. |
+
+> **The dashboard has no thresholds of its own.** Whether an instance shows up
+> as stalled, suspended, or compensating comes entirely from the saga's own
+> event ledger (`Event#status`) and `State#current_state`, governed by
+> [`SagaForge.config`](https://github.com/radioactive-labs/saga_forge#configuration):
+> `stall_wait` / `stall_budget` decide how long an early event spins before it
+> parks as stalled, and `sweep_interval` decides how quickly a stranded
+> compensation is picked back up. The dashboard only displays what those
+> settings produce; tune them on the core gem, not here.
+
+## Pages
+
+- **Sagas** (`/saga_forge`): one saga class at a time (switch classes from the
+  dropdown), state badges, filter by state or by the derived `stalled` /
+  `suspended` / `compensating` scopes, a correlation-id prefix search, and
+  keyset pagination.
+- **Saga detail**: a summary banner (class, version, timestamps, and a warning
+  when the instance is stalled, suspended, or stuck mid-compensation), a
+  context inspector for the persisted JSON context, and a timeline merging the
+  event ledger with compensation progress read from
+  `context["__saga_forge"]`, chronological, with the operator actions for that
+  instance.
+- **Overview** (`/saga_forge/overview`): fleet-wide totals (all / stalled /
+  suspended / compensating), each linking into the matching filtered list,
+  plus a per-class breakdown loaded in its own turbo-frame so the cards paint
+  before the heavier GROUP BY resolves.
+- **Stalled** (`/saga_forge/stalled`): every instance, across every saga
+  class, with at least one parked event, the parked event name(s), and a
+  **Retry all stalled** button per class.
+- **Suspended** (`/saga_forge/suspended`): every instance with at least one
+  event that ran out of retries, the failed event's error class and message,
+  and a **Resume all** button per class.
+- **Definition graph** (`/saga_forge/definitions/:class`): a static diagram of
+  one saga class's declared chain (`start_with` / `during` / `finish_with`),
+  compiled from the class's own declarations, never executed. Chain edges,
+  `transition_to` jumps, and `stay` self-loops are drawn distinctly, and
+  passing `?correlation_id=` overlays one instance's actual progress on top:
+  which events are processed, stalled, or failed, and where it currently
+  sits.
+
+## Operator actions
+
+Available from a saga's detail page, and in bulk from the Stalled/Suspended
+lists:
+
+- **Retry stalled**: re-delivers every parked event for the instance.
+- **Resume**: clears a failed event's attempts and error, then re-fires it,
+  for after you've fixed the bug that caused it.
+- **Compensate**: runs the instance's owed compensations from wherever it
+  currently sits, landing it in `:compensated`.
+- **Cancel**: the same rollback, but landing in `:cancelled` instead, with an
+  optional reason.
+- **Bulk retry / resume**: the stalled and suspended pages offer a
+  class-scoped "act on all" button, fanned out by a background job so the
+  request stays fast against a large backlog.
+
+Each of these is a thin wrapper over the model methods described in the core
+gem's [Operator API](https://github.com/radioactive-labs/saga_forge#operator-api);
+`retry_stalled!` and `resume!` are no-ops (not errors) on an instance with
+nothing eligible, so a stale button just flashes "Nothing to do."
+
+## Development
+
+Run a seeded preview locally (compiles the stylesheet, then boots a demo app
+covering every saga health state across two saga classes):
+
+```bash
+bin/dev          # PORT=9090 bin/dev to use a different port
+```
+
+It serves at `http://localhost:9977/saga_forge` by default.
+
+```bash
+bundle exec rake   # test + standard
+```
+
+## Releasing
+
+The dashboard is released from the monorepo root with `release:dashboard:*`
+(defined in `../lib/tasks/release.rake`), which tags with the prefix
+`saga_forge-dashboard-v`:
+
+```bash
+cd ..                             # monorepo root
+rake release:dashboard:version    # show the next version (conventional commits)
+rake release:dashboard:prepare    # bump + changelog + recompile dashboard.css (uncommitted)
+git diff                          # review
+rake release:dashboard:publish    # commit, build + push gem, tag + push → CI cuts the Release
+```
+
+Release **core before dashboard** — bump the dashboard's `saga_forge` floor
+first if it should require the new core version. `prepare` recompiles
+`dashboard.css` (`bundle exec rake tailwind:build`) so a release never ships a
+stale stylesheet. See the header of `../lib/tasks/release.rake` for the full
+flow.
+
+## License
+
+SagaForge::Dashboard is released under the [MIT License](MIT-LICENSE).

data/app/assets/saga_forge/dashboard/cytoscape-dagre.js

@@ -0,0 +1,397 @@
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory(require("dagre"));
+	else if(typeof define === 'function' && define.amd)
+		define(["dagre"], factory);
+	else if(typeof exports === 'object')
+		exports["cytoscapeDagre"] = factory(require("dagre"));
+	else
+		root["cytoscapeDagre"] = factory(root["dagre"]);
+})(this, function(__WEBPACK_EXTERNAL_MODULE__4__) {
+return /******/ (function(modules) { // webpackBootstrap
+/******/ 	// The module cache
+/******/ 	var installedModules = {};
+/******/
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/
+/******/ 		// Check if module is in cache
+/******/ 		if(installedModules[moduleId]) {
+/******/ 			return installedModules[moduleId].exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = installedModules[moduleId] = {
+/******/ 			i: moduleId,
+/******/ 			l: false,
+/******/ 			exports: {}
+/******/ 		};
+/******/
+/******/ 		// Execute the module function
+/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/
+/******/ 		// Flag the module as loaded
+/******/ 		module.l = true;
+/******/
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/
+/******/
+/******/ 	// expose the modules object (__webpack_modules__)
+/******/ 	__webpack_require__.m = modules;
+/******/
+/******/ 	// expose the module cache
+/******/ 	__webpack_require__.c = installedModules;
+/******/
+/******/ 	// define getter function for harmony exports
+/******/ 	__webpack_require__.d = function(exports, name, getter) {
+/******/ 		if(!__webpack_require__.o(exports, name)) {
+/******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
+/******/ 		}
+/******/ 	};
+/******/
+/******/ 	// define __esModule on exports
+/******/ 	__webpack_require__.r = function(exports) {
+/******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ 		}
+/******/ 		Object.defineProperty(exports, '__esModule', { value: true });
+/******/ 	};
+/******/
+/******/ 	// create a fake namespace object
+/******/ 	// mode & 1: value is a module id, require it
+/******/ 	// mode & 2: merge all properties of value into the ns
+/******/ 	// mode & 4: return value when already ns object
+/******/ 	// mode & 8|1: behave like require
+/******/ 	__webpack_require__.t = function(value, mode) {
+/******/ 		if(mode & 1) value = __webpack_require__(value);
+/******/ 		if(mode & 8) return value;
+/******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
+/******/ 		var ns = Object.create(null);
+/******/ 		__webpack_require__.r(ns);
+/******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
+/******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
+/******/ 		return ns;
+/******/ 	};
+/******/
+/******/ 	// getDefaultExport function for compatibility with non-harmony modules
+/******/ 	__webpack_require__.n = function(module) {
+/******/ 		var getter = module && module.__esModule ?
+/******/ 			function getDefault() { return module['default']; } :
+/******/ 			function getModuleExports() { return module; };
+/******/ 		__webpack_require__.d(getter, 'a', getter);
+/******/ 		return getter;
+/******/ 	};
+/******/
+/******/ 	// Object.prototype.hasOwnProperty.call
+/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
+/******/
+/******/ 	// __webpack_public_path__
+/******/ 	__webpack_require__.p = "";
+/******/
+/******/
+/******/ 	// Load entry module and return exports
+/******/ 	return __webpack_require__(__webpack_require__.s = 0);
+/******/ })
+/************************************************************************/
+/******/ ([
+/* 0 */
+/***/ (function(module, exports, __webpack_require__) {
+
+var impl = __webpack_require__(1); // registers the extension on a cytoscape lib ref
+
+
+var register = function register(cytoscape) {
+  if (!cytoscape) {
+    return;
+  } // can't register if cytoscape unspecified
+
+
+  cytoscape('layout', 'dagre', impl); // register with cytoscape.js
+};
+
+if (typeof cytoscape !== 'undefined') {
+  // expose to global cytoscape (i.e. window.cytoscape)
+  register(cytoscape);
+}
+
+module.exports = register;
+
+/***/ }),
+/* 1 */
+/***/ (function(module, exports, __webpack_require__) {
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+var isFunction = function isFunction(o) {
+  return typeof o === 'function';
+};
+
+var defaults = __webpack_require__(2);
+
+var assign = __webpack_require__(3);
+
+var dagre = __webpack_require__(4); // constructor
+// options : object containing layout options
+
+
+function DagreLayout(options) {
+  this.options = assign({}, defaults, options);
+} // runs the layout
+
+
+DagreLayout.prototype.run = function () {
+  var options = this.options;
+  var layout = this;
+  var cy = options.cy; // cy is automatically populated for us in the constructor
+
+  var eles = options.eles;
+
+  var getVal = function getVal(ele, val) {
+    return isFunction(val) ? val.apply(ele, [ele]) : val;
+  };
+
+  var bb = options.boundingBox || {
+    x1: 0,
+    y1: 0,
+    w: cy.width(),
+    h: cy.height()
+  };
+
+  if (bb.x2 === undefined) {
+    bb.x2 = bb.x1 + bb.w;
+  }
+
+  if (bb.w === undefined) {
+    bb.w = bb.x2 - bb.x1;
+  }
+
+  if (bb.y2 === undefined) {
+    bb.y2 = bb.y1 + bb.h;
+  }
+
+  if (bb.h === undefined) {
+    bb.h = bb.y2 - bb.y1;
+  }
+
+  var g = new dagre.graphlib.Graph({
+    multigraph: true,
+    compound: true
+  });
+  var gObj = {};
+
+  var setGObj = function setGObj(name, val) {
+    if (val != null) {
+      gObj[name] = val;
+    }
+  };
+
+  setGObj('nodesep', options.nodeSep);
+  setGObj('edgesep', options.edgeSep);
+  setGObj('ranksep', options.rankSep);
+  setGObj('rankdir', options.rankDir);
+  setGObj('align', options.align);
+  setGObj('ranker', options.ranker);
+  setGObj('acyclicer', options.acyclicer);
+  g.setGraph(gObj);
+  g.setDefaultEdgeLabel(function () {
+    return {};
+  });
+  g.setDefaultNodeLabel(function () {
+    return {};
+  }); // add nodes to dagre
+
+  var nodes = eles.nodes();
+
+  if (isFunction(options.sort)) {
+    nodes = nodes.sort(options.sort);
+  }
+
+  for (var i = 0; i < nodes.length; i++) {
+    var node = nodes[i];
+    var nbb = node.layoutDimensions(options);
+    g.setNode(node.id(), {
+      width: nbb.w,
+      height: nbb.h,
+      name: node.id()
+    }); // console.log( g.node(node.id()) );
+  } // set compound parents
+
+
+  for (var _i = 0; _i < nodes.length; _i++) {
+    var _node = nodes[_i];
+
+    if (_node.isChild()) {
+      g.setParent(_node.id(), _node.parent().id());
+    }
+  } // add edges to dagre
+
+
+  var edges = eles.edges().stdFilter(function (edge) {
+    return !edge.source().isParent() && !edge.target().isParent(); // dagre can't handle edges on compound nodes
+  });
+
+  if (isFunction(options.sort)) {
+    edges = edges.sort(options.sort);
+  }
+
+  for (var _i2 = 0; _i2 < edges.length; _i2++) {
+    var edge = edges[_i2];
+    g.setEdge(edge.source().id(), edge.target().id(), {
+      minlen: getVal(edge, options.minLen),
+      weight: getVal(edge, options.edgeWeight),
+      name: edge.id()
+    }, edge.id()); // console.log( g.edge(edge.source().id(), edge.target().id(), edge.id()) );
+  }
+
+  dagre.layout(g);
+  var gNodeIds = g.nodes();
+
+  for (var _i3 = 0; _i3 < gNodeIds.length; _i3++) {
+    var id = gNodeIds[_i3];
+    var n = g.node(id);
+    cy.getElementById(id).scratch().dagre = n;
+  }
+
+  var dagreBB;
+
+  if (options.boundingBox) {
+    dagreBB = {
+      x1: Infinity,
+      x2: -Infinity,
+      y1: Infinity,
+      y2: -Infinity
+    };
+    nodes.forEach(function (node) {
+      var dModel = node.scratch().dagre;
+      dagreBB.x1 = Math.min(dagreBB.x1, dModel.x);
+      dagreBB.x2 = Math.max(dagreBB.x2, dModel.x);
+      dagreBB.y1 = Math.min(dagreBB.y1, dModel.y);
+      dagreBB.y2 = Math.max(dagreBB.y2, dModel.y);
+    });
+    dagreBB.w = dagreBB.x2 - dagreBB.x1;
+    dagreBB.h = dagreBB.y2 - dagreBB.y1;
+  } else {
+    dagreBB = bb;
+  }
+
+  var constrainPos = function constrainPos(p) {
+    if (options.boundingBox) {
+      var xPct = dagreBB.w === 0 ? 0 : (p.x - dagreBB.x1) / dagreBB.w;
+      var yPct = dagreBB.h === 0 ? 0 : (p.y - dagreBB.y1) / dagreBB.h;
+      return {
+        x: bb.x1 + xPct * bb.w,
+        y: bb.y1 + yPct * bb.h
+      };
+    } else {
+      return p;
+    }
+  };
+
+  nodes.layoutPositions(layout, options, function (ele) {
+    ele = _typeof(ele) === "object" ? ele : this;
+    var dModel = ele.scratch().dagre;
+    return constrainPos({
+      x: dModel.x,
+      y: dModel.y
+    });
+  });
+  return this; // chaining
+};
+
+module.exports = DagreLayout;
+
+/***/ }),
+/* 2 */
+/***/ (function(module, exports) {
+
+var defaults = {
+  // dagre algo options, uses default value on undefined
+  nodeSep: undefined,
+  // the separation between adjacent nodes in the same rank
+  edgeSep: undefined,
+  // the separation between adjacent edges in the same rank
+  rankSep: undefined,
+  // the separation between adjacent nodes in the same rank
+  rankDir: undefined,
+  // 'TB' for top to bottom flow, 'LR' for left to right,
+  align: undefined,
+  // alignment for rank nodes. Can be 'UL', 'UR', 'DL', or 'DR', where U = up, D = down, L = left, and R = right
+  acyclicer: undefined,
+  // If set to 'greedy', uses a greedy heuristic for finding a feedback arc set for a graph.
+  // A feedback arc set is a set of edges that can be removed to make a graph acyclic.
+  ranker: undefined,
+  // Type of algorithm to assigns a rank to each node in the input graph.
+  // Possible values: network-simplex, tight-tree or longest-path
+  minLen: function minLen(edge) {
+    return 1;
+  },
+  // number of ranks to keep between the source and target of the edge
+  edgeWeight: function edgeWeight(edge) {
+    return 1;
+  },
+  // higher weight edges are generally made shorter and straighter than lower weight edges
+  // general layout options
+  fit: true,
+  // whether to fit to viewport
+  padding: 30,
+  // fit padding
+  spacingFactor: undefined,
+  // Applies a multiplicative factor (>0) to expand or compress the overall area that the nodes take up
+  nodeDimensionsIncludeLabels: false,
+  // whether labels should be included in determining the space used by a node
+  animate: false,
+  // whether to transition the node positions
+  animateFilter: function animateFilter(node, i) {
+    return true;
+  },
+  // whether to animate specific nodes when animation is on; non-animated nodes immediately go to their final positions
+  animationDuration: 500,
+  // duration of animation in ms if enabled
+  animationEasing: undefined,
+  // easing of animation if enabled
+  boundingBox: undefined,
+  // constrain layout bounds; { x1, y1, x2, y2 } or { x1, y1, w, h }
+  transform: function transform(node, pos) {
+    return pos;
+  },
+  // a function that applies a transform to the final node position
+  ready: function ready() {},
+  // on layoutready
+  sort: undefined,
+  // a sorting function to order the nodes and edges; e.g. function(a, b){ return a.data('weight') - b.data('weight') }
+  // because cytoscape dagre creates a directed graph, and directed graphs use the node order as a tie breaker when
+  // defining the topology of a graph, this sort function can help ensure the correct order of the nodes/edges.
+  // this feature is most useful when adding and removing the same nodes and edges multiple times in a graph.
+  stop: function stop() {} // on layoutstop
+
+};
+module.exports = defaults;
+
+/***/ }),
+/* 3 */
+/***/ (function(module, exports) {
+
+// Simple, internal Object.assign() polyfill for options objects etc.
+module.exports = Object.assign != null ? Object.assign.bind(Object) : function (tgt) {
+  for (var _len = arguments.length, srcs = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    srcs[_key - 1] = arguments[_key];
+  }
+
+  srcs.forEach(function (src) {
+    Object.keys(src).forEach(function (k) {
+      return tgt[k] = src[k];
+    });
+  });
+  return tgt;
+};
+
+/***/ }),
+/* 4 */
+/***/ (function(module, exports) {
+
+module.exports = __WEBPACK_EXTERNAL_MODULE__4__;
+
+/***/ })
+/******/ ]);
+});