here's the problem... we need to have the state set up before we can do anything

as in

deepStorage({
  test: { state: 'Started' }
});

but we want { state: 'Started' } to come from somewhere else...

this is the problem...

class MyService {

  constructor(public storage) {
  }

  runSomething() {
    storage.setState('...');
  }

}

async function() {
  storage = deepStorage({});
  return new MyService(storage);
}

but we kind of want my service to initialise storage? or something better encapsulated

ok... so perhaps we don't keep handing it down... should we find a way to combine storages...

i guess so...

so what do we want here... ideally we want to have as few subscriptions
as possible... following the pattern from above, though... we 
then just subscribe to a deep state at that point...
and we can start by just subscribing twice... but say we have this:

```javascript
const storage = deepStorage({ top: { left: 'one', right: 'two' }});
const topSubscription = storage.subscribe();
const leftSubscription = storage.deep('top').deep('left').subscribe();
const rightSubscription = storage.deep('top').deep('right').subscribe();

await storage.set({
  top: { left: 'blah', right: 'blork' }
});

// this would trigger 3 different subscription events... but could we combine them
// somehow...
// what could that look like...
// it's only going to relevant when they have the same root storage...

// this is vs

await storage.deep('top').deep('left').set('brank');

// which should only trigger leftSubscription

// so what about in the parent... when we have something change...
// we just pick the biggest or smallest ah... no... we have to pick all
// the ones... unless we know it's the same subscription...
// subscription: { paths: [['top'], ['top', 'left'], ['top', 'right']]}
// should collapse into 
// subscription: { paths: [['top']]}
// ok, so how about:
// subscription: { paths: [['top', 'left'], ['top', 'right']]}
// right we have subscription ids but they don't really help with multiple 
// storages...
const subscriber = new Subscriber();
storage.addSubscriber(subscriber);
storage.deep('top').deep('left').subscribe(subscriber);
subscriber.onChange((storages) => { /* do stuff */ });
storage.removeSubscriber(subscriber);
storage2.addSubscriber(subscriber);
storage2.removeSubscriber(subscriber);

subscriber.listenTo(storage.deep('top'));
subscriber.listenTo(storage.deep('top').deep('left'));
subscriber.listenTo(storage.deep('top').deep('right'));

```