@expressive/mvc 1.0.0-beta.3 → 1.0.0-beta.30

package/lib/index.js

@@ -9,38 +9,25 @@ class Issue extends Error {
         super(...arguments);
         // drop first line (error factory) in stack trace.
         this.stack = this.stack.replace(/\n.+/, "");
-        this.warn = () => console.warn(this.message);
     }
-    static factory(register) {
-        const Library = {};
-        for (const name in register)
-            Library[name] = (...args) => new this(register[name].apply(null, args));
-        return Library;
+    warn() {
+        console.warn(this.message);
+    }
+    throw() {
+        throw this;
     }
 }
-var Oops = Issue.factory({
-    NothingInContext: (name) => `Couldn't find controller for ${name} in context; did you forget to use a Provider?`,
-    HasPropertyUndefined: (control, property) => `${control}.${property} is marked as required for this render.`,
-    CantAttachGlobal: (parent, child) => `Singleton '${parent}' attempted to attach '${child}'. This is not possible because '${child}' is not also a singleton.`,
-    AssignToGetter: (name) => `Property ${name} is a getter only. Assignment was skipped.`,
-    ComputeFailed: (parent, property, initial) => `An exception was thrown while ${initial ? "getting initial value of" : "refreshing"} ${parent}.${property}. Property will be skipped.`,
-    ComputedEarly: (property) => `Note: Computed values are usually only calculated after first access, except where accessed implicitly by "on" or "export". Your '${property}' getter may have run earlier than intended because of that.`,
-    BadEffectCallback: () => `Callback for property-update may only return a function.`,
-    DestroyNotPossible: (name) => `${name}.destory() was called on an instance which is not active. This is an antipattern and may caused unexpected behavior.`,
-    GlobalExists: (type) => `Shared instance of ${type} already exists! '${type}.use(...)' may only be mounted once at any one time.`,
-    GlobalDoesNotExist: (name) => `Tried to access singleton ${name} but one does not exist! Did you forget to initialize?\nCall ${name}.create() before attempting to access, or consider using ${name}.use() here instead.`,
-    BadHOCArgument: () => `Argument for hoc() is not a component.`,
-    StrictUpdate: () => `Strict requestUpdate() did not find pending updates.`,
-    AmbientRequired: (requested, requester, key) => `Attempted to find an instance of ${requested} in context. It is required for ${requester}.${key} but could not be found.`,
-    ParentRequired: (expects, child) => `New ${child} created standalone but requires parent of type ${expects}. Did you remember to create via use(${child})?`,
-    UnexpectedParent: (expects, child, got) => `New ${child} created as child of ${got} but must be instanceof ${expects}`,
-    SetActionProperty: (key) => `Attempted assignment of ${key}. This is not allowed because an action-property.`,
-    DuplicateAction: (key) => `Invoked action ${key} but one is already active.`,
-    BadProviderProps: () => `Provider expects either 'of' or 'for' props.`,
-    BindNotAvailable: () => `Bind proxies are only available from a subscriber. Did you accessnode  outside of a component?`
-});
+function issues(register) {
+    const Library = {};
+    for (const name in register)
+        Library[name] = (...args) => new Issue(register[name].apply(null, args));
+    return Library;
+}
 
-const { assign, create, defineProperty, entries, getPrototypeOf, getOwnPropertyNames, getOwnPropertyDescriptor, getOwnPropertyDescriptors, keys, values } = Object;
+const Oops$8 = issues({
+    BadEffectCallback: () => `Callback for effect-callback may only return a function.`
+});
+const { assign, create, defineProperty, entries, getPrototypeOf, getOwnPropertyNames, getOwnPropertyDescriptor, getOwnPropertyDescriptors, getOwnPropertySymbols, keys: keys$1, values } = Object;
 function define(target, key, value) {
     defineProperty(target, key, { value });
 }
@@ -54,38 +41,43 @@ function defineLazy(object, property, init) {
         }
     });
 }
-function fn(x) {
-    return typeof x == "function";
-}
-function alias(fn, displayName) {
-    assign(fn, { displayName });
-}
-function entriesIn(object) {
-    return entries(getOwnPropertyDescriptors(object));
-}
-function debounce(callback) {
-    let throttle;
-    return () => {
-        if (!throttle) {
-            throttle = true;
-            callback();
-            setTimeout(() => {
-                throttle = false;
-            }, 0);
-        }
-    };
+function setAlias(func, displayName) {
+    assign(func, { displayName });
 }
 function createEffect(callback) {
     let unSet;
-    return (value, callee = value) => {
-        typeof unSet == "function" && unSet();
-        unSet = callback.call(callee, value);
+    return function (value) {
+        if (typeof unSet == "function")
+            unSet();
+        unSet = callback.call(this, value);
         if (unSet instanceof Promise)
             unSet = undefined;
-        if (unSet && !fn(unSet))
-            throw Oops.BadEffectCallback();
+        if (unSet && typeof unSet !== "function")
+            throw Oops$8.BadEffectCallback();
+    };
+}
+function createValueEffect(callback) {
+    let unSet;
+    return function (value) {
+        if (typeof unSet == "function")
+            unSet(value);
+        const out = callback.call(this, value);
+        if (typeof out == "boolean")
+            return out;
+        if (!out || out instanceof Promise)
+            return;
+        if (typeof out == "function")
+            unSet = out;
+        else
+            throw Oops$8.BadEffectCallback();
     };
 }
+function select(source, select) {
+    const proxy = {};
+    for (const k in source)
+        proxy[k] = k;
+    return select(proxy);
+}
 function selectRecursive(using, keys) {
     const found = new Set();
     const spy = {};
@@ -98,99 +90,191 @@ function selectRecursive(using, keys) {
         });
     using(spy);
     return Array.from(found);
-}
-function insertAfter(into, item, predicate) {
-    const matchIndex = into.findIndex(predicate);
-    into.splice(matchIndex + 1, 0, item);
 }
 
-class Lookup {
-    constructor() {
-        this.table = new Map();
+class Subscriber {
+    constructor(parent, onUpdate) {
+        this.onUpdate = onUpdate;
+        this.active = false;
+        this.handle = {};
+        this.dependant = new Set();
+        this.debug = () => {
+            const update = [];
+            this.notify = keys => {
+                update.splice(0, update.length, ...keys.filter(k => k in this.handle));
+            };
+            return update;
+        };
+        this.listen = (key, from) => {
+            const handler = this.handle[key];
+            if (!handler)
+                return;
+            if (typeof handler == "function")
+                handler();
+            const notify = this.onUpdate(key, from);
+            if (notify)
+                from.waiting.add(notify);
+            if (this.notify)
+                from.waiting.add(this.notify);
+        };
+        if (!(parent instanceof Controller))
+            parent = manage(parent);
+        this.parent = parent;
+        this.source = parent.subject;
+        this.proxy = create(parent.subject);
+        define(this.proxy, LOCAL, this);
+        defineLazy(this.proxy, UPDATE, this.debug);
+        for (const key in parent.state)
+            this.spy(key);
+    }
+    spy(key) {
+        const { proxy, source } = this;
+        const { set } = getOwnPropertyDescriptor(source, key);
+        const intercept = () => {
+            this.follow(key);
+            delete proxy[key];
+            return proxy[key];
+        };
+        setAlias(intercept, `tap ${key}`);
+        defineProperty(proxy, key, {
+            get: intercept,
+            set,
+            configurable: true,
+            enumerable: true
+        });
     }
-    key(T) {
-        let key = this.table.get(T);
-        if (!key) {
-            key = Symbol(T.name);
-            this.table.set(T, key);
-        }
-        return key;
+    follow(key, callback) {
+        this.handle[key] = callback || true;
     }
-    get(T, strict) {
-        const instance = this[this.key(T)];
-        if (!instance && strict)
-            throw Oops.NothingInContext(T.name);
-        return instance;
+    commit() {
+        const onDone = this.parent.addListener(this.listen);
+        this.active = true;
+        this.dependant.forEach(x => x.commit());
+        return this.release = () => {
+            this.dependant.forEach(x => x.release());
+            onDone();
+        };
     }
-    push(items) {
-        const next = create(this);
-        for (const I of items) {
-            let T = I.constructor;
-            do {
-                define(next, this.key(T), I);
-            } while (T = T.inherits);
+}
+
+const Oops$7 = issues({
+    ComputeFailed: (parent, property, initial) => `An exception was thrown while ${initial ? "initializing" : "refreshing"} [${parent}.${property}].`,
+    ComputedEarly: (property) => `Note: Computed values don't run until accessed, except when subscribed to. '${property}' getter may have run earlier than intended.`
+});
+const INIT = new WeakSet();
+const INFO = new WeakMap();
+const USED = new WeakMap();
+const KEYS = new WeakMap();
+function prepare(parent, key, source, setter, getter) {
+    let sub;
+    const { state, subject } = parent;
+    const info = { key, parent, priority: 1 };
+    let register = USED.get(parent);
+    if (!register) {
+        register = new Map();
+        USED.set(parent, register);
+    }
+    register.set(key, info);
+    const current = getter
+        ? () => getter.call(subject, state[key], key)
+        : () => state[key];
+    function compute(initial) {
+        try {
+            return setter.call(sub.proxy, sub.proxy);
+        }
+        catch (err) {
+            Oops$7.ComputeFailed(subject, key, !!initial).warn();
+            throw err;
         }
-        return next;
     }
-    pop() {
-        for (const c of values(this))
-            c.destroy();
+    function update() {
+        let value;
+        try {
+            value = compute(false);
+        }
+        catch (e) {
+            console.error(e);
+        }
+        finally {
+            if (state[key] !== value) {
+                parent.update(key, value);
+                return value;
+            }
+        }
     }
-}
-const LookupContext = react.createContext(new Lookup());
-const LookupProvider = LookupContext.Provider;
-function useLookup() {
-    return react.useContext(LookupContext);
-}
-function useIncluding(insert, dependancy) {
-    const current = useLookup();
-    function next() {
-        const provide = insert instanceof Model
-            ? [insert] : values(insert).map(T => Model.isTypeof(T) ? T.create() : T);
-        return current.push(provide);
+    function defer(_key, from) {
+        let pending = KEYS.get(from);
+        if (!pending)
+            KEYS.set(from, pending = []);
+        if (info.parent !== from)
+            update();
+        else {
+            const after = pending.findIndex(peer => (info.priority > INFO.get(peer).priority));
+            pending.splice(after + 1, 0, update);
+        }
     }
-    return react.useMemo(next, [dependancy]);
-}
-const Consumer = (props) => {
-    const { get, has, children: render, of: Control } = props;
-    if (fn(render))
-        return render(Control.tap());
-    const callback = has || get;
-    if (fn(callback))
-        callback(Control.get(!!has));
-    return null;
-};
-function Provider(props) {
-    const { children, of: target } = props;
-    const data = assign({}, props, { children: null, of: null });
-    if (Model.isTypeof(target))
-        return react.createElement(ParentProvider, { target, data }, children);
-    else if (target instanceof Model)
-        return react.createElement(DirectProvider, { target, data }, children);
-    else if (typeof target == "object")
-        return react.createElement(MultiProvider, { types: target }, children);
-    else
-        throw Oops.BadProviderProps();
-}
-function ParentProvider(props) {
-    let { children, target, data } = props;
-    const instance = target.using(data);
-    const value = useIncluding(instance.get, target);
-    if (fn(children))
-        children = children(instance);
-    return react.createElement(LookupProvider, { value }, children);
+    function create(early) {
+        sub = new Subscriber(source(), defer);
+        defineProperty(state, key, {
+            value: undefined,
+            writable: true
+        });
+        defineProperty(subject, key, {
+            enumerable: true,
+            configurable: true,
+            get: current
+        });
+        try {
+            state[key] = compute(true);
+        }
+        catch (e) {
+            if (early)
+                Oops$7.ComputedEarly(key).warn();
+            throw e;
+        }
+        finally {
+            sub.commit();
+            for (const key in sub.handle) {
+                const peer = register.get(key);
+                if (peer && peer.priority >= info.priority)
+                    info.priority = peer.priority + 1;
+            }
+        }
+        return current();
+    }
+    setAlias(update, `try ${key}`);
+    setAlias(create, `new ${key}`);
+    setAlias(setter, `run ${key}`);
+    INIT.add(create);
+    INFO.set(update, info);
+    for (const on of [state, subject])
+        defineProperty(on, key, {
+            get: create,
+            configurable: true,
+            enumerable: true
+        });
 }
-function DirectProvider(props) {
-    const { children, data, target } = props;
-    const value = useIncluding(target, target);
-    target.import(data);
-    return react.createElement(LookupProvider, { value }, children);
+function ensure(on, keys) {
+    for (const key of keys) {
+        const desc = getOwnPropertyDescriptor(on.subject, key);
+        const getter = desc && desc.get;
+        if (INIT.has(getter))
+            getter(true);
+    }
 }
-function MultiProvider(props) {
-    const { children, types } = props;
-    const value = useIncluding(types);
-    react.useEffect(() => () => value.pop(), []);
-    return react.createElement(LookupProvider, { value }, children);
+function flush(on) {
+    const handled = on.frame;
+    const pending = KEYS.get(on);
+    if (!pending)
+        return;
+    while (pending.length) {
+        const why = [...handled];
+        const compute = pending.shift();
+        const { key } = INFO.get(compute);
+        if (!handled.has(key))
+            compute(why);
+    }
+    KEYS.delete(on);
 }
 
 const Lifecycle = {
@@ -205,303 +289,256 @@ const lifecycleEvents = [
     "willDestroy",
     ...values(Lifecycle)
 ];
-function forAlias(prefix) {
+function lifecycle(prefix) {
+    const type = eventsFor(prefix);
+    return function useLifecycle(sub, tag) {
+        const emit = react.useMemo(() => {
+            const subject = sub.source;
+            const id = typeof tag == "function" ? tag(subject) : tag;
+            return (name) => {
+                for (const key of [name, type(name)])
+                    subject.update(key, id);
+            };
+        }, [sub, tag]);
+        emit(Lifecycle.WILL_RENDER);
+        emit(sub.active
+            ? Lifecycle.WILL_UPDATE
+            : Lifecycle.WILL_MOUNT);
+        react.useLayoutEffect(() => {
+            sub.commit();
+            emit(Lifecycle.DID_MOUNT);
+            return () => {
+                emit(Lifecycle.WILL_UNMOUNT);
+                sub.release();
+            };
+        }, [sub]);
+    };
+}
+function eventsFor(prefix) {
     const map = new Map();
     for (const name of values(Lifecycle)) {
         const alias = prefix + name[0].toUpperCase() + name.slice(1);
         lifecycleEvents.push(alias);
         map.set(name, alias);
     }
-    return (name) => map.get(name);
+    return (e) => map.get(e);
 }
 
-const Pending = new WeakSet();
-class Observer {
+const CONTROL = Symbol("control");
+const UPDATE = Symbol("update");
+const LOCAL = Symbol("local");
+const STATE = Symbol("state");
+function manage(src) {
+    return src[CONTROL];
+}
+const Pending = new Map();
+function apply(fn, label) {
+    const name = label || fn.name || "pending";
+    const placeholder = Symbol(`${name} instruction`);
+    function setup(key) {
+        let output = fn.call(this, key, this);
+        if (typeof output == "function") {
+            const getter = output;
+            output = Object.assign(Object.assign({}, getOwnPropertyDescriptor(this.subject, key)), { get() {
+                    return getter(this[LOCAL]);
+                } });
+        }
+        if (output)
+            defineProperty(this.subject, key, output);
+    }
+    Pending.set(placeholder, setup);
+    return placeholder;
+}
+class Controller {
     constructor(subject) {
         this.subject = subject;
         this.state = {};
-        this.listeners = new Set();
-        this.waiting = [];
-        implementGetters(this);
+        this.frame = new Set();
+        this.waiting = new Set();
+        this.followers = new Set();
+    }
+    static setup(onto) {
+        const control = new this(onto);
+        defineLazy(onto, CONTROL, () => {
+            onto[STATE] = control.state;
+            control.start();
+            if (onto.didCreate)
+                onto.didCreate();
+            return control;
+        });
+        return control;
     }
-    static define(fn) {
-        Pending.add(fn);
-        return fn;
+    get pending() {
+        return this.frame.size > 0;
     }
     start() {
-        for (const [key, desc] of entriesIn(this.subject)) {
-            const { value, get, enumerable } = desc;
-            if (Pending.has(value))
-                value(key, this);
-            else if (enumerable && !get && (!fn(value) || /^[A-Z]/.test(key)))
-                this.register(key, value);
+        const { subject } = this;
+        for (const key in subject) {
+            const desc = getOwnPropertyDescriptor(subject, key);
+            if (desc && "value" in desc) {
+                const { value } = desc;
+                const instruction = Pending.get(value);
+                if (instruction) {
+                    Pending.delete(value);
+                    delete subject[key];
+                    instruction.call(this, key, this);
+                }
+                else if (typeof value !== "function" || /^[A-Z]/.test(key))
+                    this.manage(key, value);
+            }
         }
         this.emit();
+        return this;
     }
-    register(key, initial, effect) {
-        this.state[key] = initial;
-        this.override(key, {
-            get: () => this.state[key],
+    select(using) {
+        const keys = getOwnPropertyNames(this.state);
+        return using
+            ? selectRecursive(using, keys.concat(lifecycleEvents))
+            : keys;
+    }
+    manage(key, initial, effect) {
+        const { state, subject } = this;
+        state[key] = initial;
+        defineProperty(subject, key, {
+            enumerable: true,
+            configurable: true,
+            get: () => state[key],
             set: this.setter(key, effect)
         });
     }
-    override(key, desc) {
-        defineProperty(this.subject, key, Object.assign({ enumerable: true }, desc));
-    }
-    setter(key, effect) {
-        const callback = effect && createEffect(effect);
+    setter(key, handler) {
+        const { state, subject } = this;
         return (value) => {
-            if (this.state[key] == value)
-                return;
-            this.state[key] = value;
-            if (callback)
-                callback(value, this.subject);
-            this.update(key);
-        };
-    }
-    watch(target, handler, squash, once) {
-        const keys = [].concat(target);
-        const callback = squash
-            ? handler.bind(this.subject)
-            : (frame) => {
-                for (const key of frame)
-                    if (keys.includes(key))
-                        handler.call(this.subject, this.state[key], key);
-            };
-        return this.addListener(keys, callback, once);
-    }
-    addListener(keys, callback, once) {
-        const remove = () => { this.listeners.delete(listener); };
-        const handler = once ? (k) => { remove(); callback(k); } : callback;
-        const listener = {};
-        for (const key of keys) {
-            ensureValue(this.subject, key);
-            listener[key] = handler;
-        }
-        this.listeners.add(listener);
-        return remove;
-    }
-    update(key) {
-        (this.pending || this.sync())(key);
-    }
-    emit(frame) {
-        const { waiting } = this;
-        this.waiting = [];
-        this.pending = undefined;
-        waiting.forEach(x => x(frame));
-    }
-    sync() {
-        const handled = new Set();
-        const { isComputed, flushComputed } = computeContext(this, handled);
-        const include = (key) => {
-            if (handled.has(key))
+            if (state[key] == value)
                 return;
-            handled.add(key);
-            for (const subscription of this.listeners)
-                if (key in subscription) {
-                    const request = subscription[key];
-                    isComputed(request) || this.waiting.push(request);
+            if (handler)
+                switch (handler.call(subject, value)) {
+                    case true:
+                        this.update(key);
+                    case false:
+                        return;
                 }
+            this.update(key, value);
         };
-        const close = () => {
-            flushComputed();
-            this.emit(Array.from(handled));
-        };
-        setTimeout(close, 0);
-        return this.pending = include;
     }
-}
-
-const LOCAL = Symbol("current_subscriber");
-class Subscriber {
-    constructor(subject, callback, metadata) {
-        this.subject = subject;
-        this.callback = callback;
-        this.metadata = metadata;
-        this.dependant = new Set();
-        this.following = {};
-        this.listen = () => {
-            this.dependant.forEach(x => x.listen());
-            this.parent.listeners.add(this.following);
-            // for(const key in this.proxy)
-            //   delete this.proxy[key];
-            return () => this.release();
+    addListener(listener) {
+        this.followers.add(listener);
+        return () => {
+            this.followers.delete(listener);
         };
-        const { state } = this.parent = Controller.get(subject);
-        this.proxy = create(subject);
-        define(this.proxy, LOCAL, this);
-        for (const key in state)
-            this.spyOn(key);
-    }
-    /** Assuming argument is actually a proxy, get the current subscription. */
-    static current(on) {
-        return on[LOCAL];
-    }
-    release() {
-        this.dependant.forEach(x => x.release());
-        this.parent.listeners.delete(this.following);
-    }
-    spyOn(key) {
-        const access = () => {
-            let value = this.subject[key];
-            if (value instanceof Model)
-                return this.delegate(key);
-            this.follow(key, this.callback);
-            delete this.proxy[key];
-            return value;
-        };
-        alias(access, `tap ${key}`);
-        defineProperty(this.proxy, key, {
-            get: access,
-            set: this.parent.setter(key),
-            configurable: true
-        });
     }
-    follow(key, cb) {
-        if (this.metadata)
-            metaData(cb, this.metadata);
-        this.following[key] = cb;
-    }
-    recursive(key, onUpdate) {
-        let child;
-        const start = (mounted) => {
-            child = onUpdate();
-            if (child) {
-                this.dependant.add(child);
-                if (mounted)
-                    child.listen();
-            }
-        };
-        const reset = () => {
-            if (child) {
-                child.release();
-                this.dependant.delete(child);
-            }
-            start(true);
-            this.callback();
-        };
-        this.follow(key, reset);
-        start();
-    }
-    delegate(key) {
-        let sub;
-        this.recursive(key, () => {
-            let value = this.subject[key];
-            if (value instanceof Model) {
-                let child = sub = new Subscriber(value, this.callback, this.metadata);
-                defineProperty(this.proxy, key, {
-                    get: () => child.proxy,
-                    set: it => this.subject[key] = it,
-                    configurable: true
-                });
-                return child;
+    update(key, value) {
+        if (1 in arguments)
+            this.state[key] = value;
+        if (this.frame.has(key))
+            return;
+        if (!this.frame.size)
+            setTimeout(() => this.emit(), 0);
+        this.frame.add(key);
+        for (const subscription of this.followers) {
+            const notify = subscription(key, this);
+            if (notify)
+                this.waiting.add(notify);
+        }
+    }
+    emit() {
+        flush(this);
+        const keys = Object.freeze([...this.frame]);
+        const handle = new Set(this.waiting);
+        this.waiting.clear();
+        this.frame.clear();
+        defineProperty(this.subject, UPDATE, {
+            configurable: true,
+            value: keys
+        });
+        handle.forEach(callback => {
+            try {
+                callback(keys);
             }
+            catch (e) { }
         });
-        return sub && sub.proxy;
     }
+}
+function keys(from, using) {
+    if (typeof using == "string")
+        return [using];
+    if (typeof using == "object") {
+        using = Array.from(using);
+        if (using.length === 0)
+            using = undefined;
+        else
+            return using;
+    }
+    return from.select(using);
 }
 
-const CONTROL = Symbol("controller");
-class Controller extends Observer {
-    constructor() {
-        super(...arguments);
-        this.on = (select, listener, squash, once) => {
-            return this.watch(select, listener, squash, once);
-        };
-        this.once = (select, listener, squash) => {
-            if (listener)
-                return this.watch(select, listener, squash, true);
-            else
-                return new Promise(resolve => {
-                    this.watch(select, resolve, true, true);
-                });
-        };
-        this.effect = (callback, select) => {
-            let target = this.subject;
-            const effect = createEffect(callback);
-            const invoke = debounce(() => effect(target));
-            if (select)
-                return this.watch(select, invoke, true);
-            return this.do(() => {
-                const sub = new Subscriber(target, invoke);
-                effect(target = sub.proxy);
-                return sub.listen();
-            });
-        };
-        this.import = (from, select) => {
-            const keys = this.select(select);
-            for (const key of keys)
-                if (key in from)
-                    this.subject[key] = from[key];
-        };
-        this.export = (select) => {
-            const keys = this.select(select);
-            const data = {};
-            for (const key of keys)
-                data[key] = this.subject[key];
-            return data;
-        };
-        this.update = (select) => {
-            for (const key of this.select(select))
-                super.update(key);
-        };
-        this.requestUpdate = (argument) => {
-            const { pending, waiting } = this;
-            if (fn(argument))
-                waiting.push(argument);
-            else if (!pending === argument)
-                return Promise.reject(Oops.StrictUpdate());
-            else if (pending)
-                return new Promise(cb => waiting.push(cb));
-            else
-                return Promise.resolve(false);
+function child(source, name) {
+    return apply(function child(key) {
+        const context = new WeakMap();
+        const current = source.call(this, key);
+        function subscribe(sub) {
+            let child;
+            function start() {
+                const instance = current();
+                if (instance) {
+                    child = new Subscriber(instance, sub.onUpdate);
+                    if (sub.active)
+                        child.commit();
+                    sub.dependant.add(child);
+                    context.set(sub, child.proxy);
+                }
+            }
+            function restart() {
+                if (child) {
+                    child.release();
+                    sub.dependant.delete(child);
+                    context.set(sub, undefined);
+                    child = undefined;
+                }
+                start();
+            }
+            start();
+            sub.follow(key, restart);
+        }
+        return (local) => {
+            if (!local)
+                return current();
+            if (!context.has(local))
+                subscribe(local);
+            return context.get(local);
         };
-    }
-    static get(from) {
-        return from[CONTROL];
-    }
-    do(fn) {
-        return fn();
-    }
-    select(using) {
-        const keys = getOwnPropertyNames(this.state);
-        if (!using)
-            return keys;
-        if (typeof using == "string")
-            return [using];
-        if (fn(using))
-            return selectRecursive(using, keys.concat(lifecycleEvents));
-        return Array.from(using);
-    }
-    watch(target, handler, squash, once) {
-        return this.do(() => super.watch(this.select(target), handler, squash, once));
-    }
+    }, name || source.name);
 }
 
+const Oops$6 = issues({
+    CantAttachGlobal: (parent, child) => `Singleton '${parent}' attempted to attach '${child}' but it is not also a singleton.`,
+    AmbientRequired: (requested, requester, key) => `Attempted to find an instance of ${requested} in context. It is required for [${requester}.${key}], but one could not be found.`
+});
 const PendingContext = new WeakMap();
 const ContextWasUsed = new WeakMap();
-function setPeer(type, required) {
-    return Observer.define((key, { subject }) => {
-        const Self = subject.constructor.name;
-        if ("current" in type)
-            defineLazy(subject, key, () => type.current);
-        else if ("current" in subject.constructor)
-            throw Oops.CantAttachGlobal(subject.constructor.name, type.name);
-        else {
-            let pending = PendingContext.get(subject);
-            if (!pending)
-                PendingContext.set(subject, pending = []);
-            function insert(context) {
-                const remote = context.get(type);
-                if (!remote && required)
-                    throw Oops.AmbientRequired(type.name, Self, key);
-                define(subject, key, remote);
-            }
-            pending.push(insert);
+function tap(type, argument) {
+    return child(function tap(key) {
+        return pendingAccess(this.subject, type, key, argument);
+    });
+}
+function pendingAccess(from, type, key, argument) {
+    if ("current" in type)
+        return () => type.current;
+    if ("current" in from.constructor)
+        throw Oops$6.CantAttachGlobal(from, type.name);
+    let instance;
+    getPending(from).push(context => {
+        instance = context.get(type);
+        if (typeof argument == "function") {
+            if (argument(instance) === false)
+                instance = undefined;
         }
+        else if (!instance && argument)
+            throw Oops$6.AmbientRequired(type.name, from, key);
     });
+    return () => instance;
 }
-function usePeers(subject) {
+function usePeerContext(subject) {
     if (ContextWasUsed.has(subject)) {
         if (ContextWasUsed.get(subject))
             useLookup();
@@ -515,554 +552,707 @@ function usePeers(subject) {
         PendingContext.delete(subject);
     }
     ContextWasUsed.set(subject, !!pending);
+}
+function getPending(subject) {
+    let pending = PendingContext.get(subject);
+    if (!pending)
+        PendingContext.set(subject, pending = []);
+    return pending;
 }
 
-const subscriberEvent = forAlias("element");
-const componentEvent = forAlias("component");
-class HookSubscriber extends Subscriber {
-    constructor(subject, callback, tag) {
-        super(subject, callback);
-        this.subject = subject;
-        this.callback = callback;
-        this.tag = tag;
-        this.alias = subscriberEvent;
-        this.isMounted = false;
-        this.useLifecycle = () => {
-            this.at(Lifecycle.WILL_RENDER);
-            this.at(this.isMounted
-                ? Lifecycle.WILL_UPDATE
-                : Lifecycle.WILL_MOUNT);
-            react.useLayoutEffect(() => {
-                this.listen();
-                this.isMounted = true;
-                this.at(Lifecycle.DID_MOUNT);
-                return () => {
-                    this.at(Lifecycle.WILL_UNMOUNT);
-                    this.release();
-                };
+const Oops$5 = issues({
+    DuplicateAction: (key) => `Invoked action ${key} but one is already active.`,
+    BadComputedSource: (model, property, got) => `Bad from-instruction provided to ${model}.${property}. Expects an arrow-function or a Model as source. Got ${got}.`,
+    PeerNotAllowed: (model, property) => `Attempted to use an instruction result (probably use or tap) as computed source for ${model}.${property}. This is not possible.`
+});
+function createRef(key, cb) {
+    const refObjectFunction = this.setter(key, cb && createValueEffect(cb));
+    defineProperty(refObjectFunction, "current", {
+        set: refObjectFunction,
+        get: () => this.state[key]
+    });
+    return refObjectFunction;
+}
+function ref(arg) {
+    return apply(function ref(key) {
+        let value = {};
+        if (typeof arg == "object") {
+            const source = manage(arg);
+            for (const key in source.state)
+                defineLazy(value, key, createRef.bind(source, key));
+        }
+        else
+            value = createRef.call(this, key, arg);
+        return { value };
+    });
+}
+function act(task) {
+    return apply(function act(key) {
+        let pending = false;
+        const invoke = (...args) => {
+            if (pending)
+                return Promise.reject(Oops$5.DuplicateAction(key));
+            pending = true;
+            this.update(key);
+            return new Promise(res => {
+                res(task.apply(this.subject, args));
+            }).finally(() => {
+                pending = false;
+                this.update(key);
             });
         };
-    }
-    at(name) {
-        const also = this.alias(name);
-        for (const key of [name, also]) {
-            const on = this.subject;
-            const handle = on[key];
-            handle && handle.call(on, this.tag);
-            this.parent.update(key);
-        }
-    }
+        this.state[key] = undefined;
+        setAlias(invoke, `run ${key}`);
+        defineProperty(invoke, "active", {
+            get: () => pending
+        });
+        return {
+            value: invoke,
+            writable: false
+        };
+    });
 }
-class ElementSubscriber extends HookSubscriber {
-    focus(key, expect) {
-        const source = this.subject;
-        if (fn(key)) {
-            const available = {};
-            for (const key in source)
-                available[key] = key;
-            key = key(available);
+function from(source, setter, getter) {
+    return apply(function from(key) {
+        const { subject } = this;
+        let getSource;
+        // Easy mistake, using a peer, will always be unresolved.
+        if (typeof source == "symbol")
+            throw Oops$5.PeerNotAllowed(subject, key);
+        // replace source controller in-case different
+        if (typeof source == "object")
+            getSource = () => manage(source);
+        // specifically an arrow function (getter factory)
+        else if (!source.prototype) {
+            setter = source.call(subject, key);
+            getSource = () => this;
         }
-        this.recursive(key, () => {
-            let value = source[key];
-            if (value instanceof Model) {
-                const child = new Subscriber(value, this.callback);
-                this.proxy = child.proxy;
-                return child;
-            }
-            if (value === undefined && expect)
-                throw Oops.HasPropertyUndefined(source.constructor.name, key);
-            this.proxy = value;
+        // is a peer Model (constructor)
+        else if (Model.isTypeof(source))
+            getSource = pendingAccess(subject, source, key, true);
+        // Regular function is to ambiguous so not allowed.
+        else
+            throw Oops$5.BadComputedSource(subject, key, source);
+        prepare(this, key, getSource, setter, getter);
+    });
+}
+
+const Oops$4 = issues({
+    ValueNotReady: (model, key) => `Value ${model}.${key} value is not yet available.`
+});
+function pending(source, compute) {
+    return (source === undefined ?
+        suspendForValue() :
+        typeof source == "function" && !source.prototype ?
+            suspendForAsync(source) :
+            suspendForComputed(source, compute));
+}
+/**
+ * Get value, suspend instead if undefined.
+ *
+ * Throws suspense promise also interpretable as an error.
+ * React could handle it but other contexts probably not.
+ */
+function pendingValue(via, key) {
+    const value = via.state[key];
+    if (value === undefined)
+        throw suspend(via, key);
+    return value;
+}
+function suspend(source, key) {
+    const error = Oops$4.ValueNotReady(source.subject, key);
+    const promise = new Promise(resolve => {
+        const release = source.addListener(forKey => {
+            if (forKey == key)
+                return () => {
+                    if (source.state[key] !== undefined) {
+                        release();
+                        resolve();
+                    }
+                };
         });
-    }
+    });
+    return Object.assign(promise, {
+        toString: () => String(error),
+        name: "Suspense",
+        message: error.message,
+        stack: error.stack
+    });
 }
-class ComponentSubscriber extends HookSubscriber {
-    constructor() {
-        super(...arguments);
-        this.alias = componentEvent;
-    }
-    release() {
-        super.release();
-        this.subject.destroy();
+function suspendForComputed(source, compute) {
+    function getter(_value, key) {
+        return pendingValue(manage(this), key);
     }
+    return from(source, compute, getter);
+}
+function suspendForValue() {
+    return apply(function pending(key) {
+        this.state[key] = undefined;
+        return {
+            set: this.setter(key),
+            get: () => pendingValue(this, key)
+        };
+    });
 }
-function useRefresh(init) {
+function suspendForAsync(source) {
+    return apply(function suspense(key) {
+        const subject = this.subject;
+        let waiting = true;
+        let value;
+        let error;
+        return () => {
+            if (error)
+                throw error;
+            if (!waiting)
+                return value;
+            const issue = Oops$4.ValueNotReady(subject, key);
+            let suspend = source
+                .call(subject, key)
+                .catch(err => error = err)
+                .then(out => value = out)
+                .finally(() => waiting = false);
+            throw Object.assign(suspend, {
+                message: issue.message,
+                stack: issue.stack
+            });
+        };
+    });
+}
+
+function use$1(init) {
     const [state, update] = react.useState(() => [
         init(() => update(state.concat()))
     ]);
     return state[0];
 }
-function useLazy(Type, args) {
-    const instance = react.useMemo(() => Type.create(...args), []);
-    react.useEffect(() => () => instance.destroy(), []);
-    return instance;
-}
-function usePassive(target, select) {
-    const instance = target.find(!!select);
-    if (!instance)
-        return;
-    if (fn(select))
-        return select(instance);
-    if (typeof select == "string")
-        return instance[select];
+function useLazy(Type, callback) {
+    const instance = react.useMemo(() => {
+        const instance = Type.create();
+        if (callback)
+            callback(instance);
+        return instance;
+    }, []);
+    react.useLayoutEffect(() => () => instance.destroy(), []);
     return instance;
 }
-function useWatcher(target, path, expected) {
-    const hook = useRefresh(trigger => {
-        const sub = new ElementSubscriber(target, trigger);
-        if (path)
-            sub.focus(path, expected);
+function useWatcher(target, focus, expected) {
+    const hook = use$1(refresh => {
+        const sub = new Subscriber(target, () => refresh);
+        if (focus) {
+            const source = sub.proxy;
+            const key = keys(sub.parent, focus)[0];
+            defineProperty(sub, "proxy", {
+                get() {
+                    const value = source[key];
+                    if (value === undefined && expected)
+                        throw suspend(sub.parent, key);
+                    return value;
+                }
+            });
+        }
         return sub;
     });
-    react.useEffect(hook.listen, []);
-    return hook.proxy;
-}
-function useSubscriber(target, tag) {
-    const hook = useRefresh(trigger => {
-        const key = fn(tag) ? tag(target) : tag || 0;
-        return new HookSubscriber(target, trigger, key);
-    });
-    hook.useLifecycle();
+    react.useLayoutEffect(() => hook.commit(), []);
     return hook.proxy;
 }
-function useModel(Type, args, callback) {
-    const hook = useRefresh(trigger => {
-        const instance = Type.create(...args);
-        const sub = new ComponentSubscriber(instance, trigger);
+function useModel(Type, callback) {
+    const hook = use$1(refresh => {
+        const instance = new Type();
+        const control = manage(instance);
+        const sub = new Subscriber(control, () => refresh);
+        const release = control.addListener((key) => {
+            if (key == Lifecycle.WILL_UNMOUNT)
+                return () => {
+                    instance.destroy();
+                    release();
+                };
+        });
         if (callback)
             callback(instance);
         return sub;
     });
-    usePeers(hook.subject);
-    hook.useLifecycle();
     return hook.proxy;
 }
 
-class Model {
+class Lookup {
     constructor() {
-        const control = new Controller(this);
-        for (const [key, value] of entries(control))
-            if (fn(value))
-                define(this, key, value);
-        control.do = (fn) => {
-            let release;
-            this.requestUpdate(() => release = fn());
-            return () => release();
+        this.table = new Map();
+    }
+    get local() {
+        return getOwnPropertySymbols(this).map((symbol) => this[symbol]);
+    }
+    key(T) {
+        let key = this.table.get(T);
+        if (!key) {
+            key = Symbol(T.name);
+            this.table.set(T, key);
+        }
+        return key;
+    }
+    get(T) {
+        return this[this.key(T)];
+    }
+    push(I) {
+        const next = create(this);
+        if (I instanceof Model || typeof I == "function")
+            next.register(I);
+        else
+            for (const i of values(I))
+                next.register(i);
+        return next;
+    }
+    register(I) {
+        let writable = true;
+        let T;
+        if (I instanceof Model) {
+            T = I.constructor;
+            writable = false;
+        }
+        else {
+            T = I;
+            I = I.create();
+        }
+        do {
+            defineProperty(this, this.key(T), {
+                value: I, writable
+            });
+            T = getPrototypeOf(T);
+        } while (T !== Model);
+        return I;
+    }
+    pop() {
+        for (const key of getOwnPropertySymbols(this)) {
+            const entry = getOwnPropertyDescriptor(this, key);
+            if (entry.writable)
+                entry.value.destroy();
+        }
+    }
+}
+
+const Oops$3 = issues({
+    NoProviderType: () => `Provider 'of' prop must be Model, typeof Model or a collection of them.`,
+    NothingInContext: (name) => `Couldn't find ${name} in context; did you forget to use a Provider?`,
+    BadConsumerProps: () => `Provider expects either a render function, 'get' or 'has' props.`
+});
+const LookupContext = react.createContext(new Lookup());
+const useLookup = () => react.useContext(LookupContext);
+function useFromContext(Type, strict) {
+    const instance = useLookup().get(Type);
+    if (!instance && strict)
+        throw Oops$3.NothingInContext(Type.name);
+    return instance;
+}
+function Consumer(props) {
+    const { get, has, children, of: Control } = props;
+    if (typeof children == "function")
+        return children(Control.tap());
+    const callback = has || get;
+    if (typeof callback == "function")
+        callback(Control.get(!!has));
+    else
+        throw Oops$3.BadConsumerProps();
+    return null;
+}
+function useNewContext(from, inject) {
+    return react.useMemo(() => {
+        if (!inject)
+            throw Oops$3.NoProviderType();
+        const context = from.push(inject);
+        for (const instance of context.local)
+            for (const apply of getPending(instance))
+                apply(context);
+        return context;
+    }, []);
+}
+function useAppliedProps(within, props) {
+    const update = react.useMemo(() => {
+        const targets = within.local;
+        return function integrate(props) {
+            for (const [key, value] of entries(props))
+                if (key != "of" && key != "children")
+                    for (const into of targets)
+                        if (key in into)
+                            into[key] = value;
         };
-        defineLazy(this, CONTROL, () => {
-            delete control.do;
-            control.start();
-            if (this.didCreate)
-                this.didCreate();
-            return control;
-        });
+    }, []);
+    update(props);
+}
+function RenderFunction(props) {
+    const hook = use$1(refresh => {
+        const targets = props.context.local;
+        if (targets.length == 1)
+            return new Subscriber(targets[0], () => refresh);
+        return {};
+    });
+    if (hook.commit)
+        react.useLayoutEffect(() => hook.commit(), []);
+    return props.render(hook.proxy);
+}
+function Provider(props) {
+    const render = props.children;
+    const current = useLookup();
+    const context = useNewContext(current, props.of);
+    useAppliedProps(context, props);
+    react.useLayoutEffect(() => () => context.pop(), []);
+    return react.createElement(LookupContext.Provider, { value: context }, typeof render == "function"
+        ? react.createElement(RenderFunction, { context, render })
+        : render);
+}
+
+const Oops$2 = issues({
+    StrictUpdate: (expected) => `Strict update() did ${expected ? "not " : ""}find pending updates.`,
+    NoChaining: () => `Then called with undefined; update promise will never catch nor supports chaining.`
+});
+const useElementLifecycle = lifecycle("element");
+const useComponentLifecycle = lifecycle("component");
+class Model {
+    constructor() {
+        const control = Controller.setup(this);
         define(this, "get", this);
         define(this, "set", this);
+        defer(control, "on");
+        defer(control, "effect");
+        control.waiting.add(() => {
+            delete this.on;
+            delete this.effect;
+        });
     }
     tap(path, expect) {
-        return useWatcher(this, path, expect);
+        const proxy = useWatcher(this, path, expect);
+        this.update("willRender", true);
+        return proxy;
     }
     tag(id) {
-        return useSubscriber(this, id);
+        const hook = use$1(refresh => {
+            return new Subscriber(this, () => refresh);
+        });
+        useElementLifecycle(hook, id || 0);
+        return hook.proxy;
+    }
+    use(callback) {
+        const hook = use$1(refresh => {
+            if (callback)
+                callback(this);
+            return new Subscriber(this, () => refresh);
+        });
+        useComponentLifecycle(hook);
+        return hook.proxy;
+    }
+    on(subset, handler, squash, once) {
+        const control = manage(this);
+        const request = keys(control, subset);
+        const callback = squash
+            ? handler.bind(this)
+            : frame => frame
+                .filter(k => request.includes(k))
+                .forEach(k => handler.call(this, control.state[k], k));
+        const trigger = once
+            ? frame => { remove(); callback(frame); }
+            : callback;
+        ensure(control, request);
+        const remove = control.addListener(key => {
+            if (request.includes(key))
+                return trigger;
+        });
+        return remove;
+    }
+    once(select, callback, squash) {
+        if (callback)
+            return this.on(select, callback, squash, true);
+        else
+            return new Promise(resolve => {
+                this.on(select, resolve, true, true);
+            });
+    }
+    effect(callback, select) {
+        const control = manage(this);
+        let target = this;
+        const effect = createEffect(callback);
+        const invoke = () => effect.call(target, target);
+        if (select) {
+            invoke();
+            return this.on(select, invoke, true);
+        }
+        else {
+            const sub = new Subscriber(control, () => invoke);
+            target = sub.proxy;
+            invoke();
+            return sub.commit();
+        }
+    }
+    import(from, subset) {
+        for (const key of keys(manage(this), subset))
+            if (key in from)
+                this[key] = from[key];
+    }
+    export(subset) {
+        const control = manage(this);
+        const output = {};
+        for (const key of keys(control, subset))
+            output[key] = control.state[key];
+        return output;
+    }
+    update(arg, tag) {
+        const control = manage(this);
+        if (typeof arg == "function")
+            arg = select(this, arg);
+        if (typeof arg == "boolean") {
+            if (!control.pending === arg)
+                return Promise.reject(Oops$2.StrictUpdate(arg));
+        }
+        else if (arg) {
+            control.update(arg);
+            if (1 in arguments && arg in this) {
+                const method = this[arg];
+                if (typeof method == "function")
+                    if (typeof tag != "boolean")
+                        method.call(this, tag);
+                    else if (tag)
+                        method.call(this);
+            }
+        }
+        return {
+            then(callback) {
+                if (callback)
+                    if (control.pending)
+                        control.waiting.add(callback);
+                    else
+                        callback(false);
+                else
+                    throw Oops$2.NoChaining();
+            }
+        };
     }
     destroy() {
-        if (this.willDestroy)
-            this.willDestroy();
+        this.update("willDestroy", true);
+    }
+    toString() {
+        return this.constructor.name;
     }
     static create(...args) {
         const instance = new this(...args);
-        Controller.get(instance);
+        manage(instance);
         return instance;
     }
-    static use(...args) {
-        return useModel(this, args);
-    }
-    static uses(props, only) {
-        return useModel(this, [], instance => {
-            instance.import(props, only);
-        });
-    }
-    static using(props, only) {
-        const instance = useModel(this, []);
-        instance.import(props, only);
+    static new(callback) {
+        const instance = useLazy(this, callback);
+        instance.update("willRender", true);
         return instance;
     }
-    static new(...args) {
-        return useLazy(this, args);
+    static find(strict) {
+        return useFromContext(this, strict);
     }
     static get(key) {
-        return usePassive(this, key);
+        const instance = this.find(!!key);
+        return (typeof key == "function" ?
+            key(instance) :
+            typeof key == "string" ?
+                instance[key] :
+                instance);
     }
     static tap(key, expect) {
-        return useWatcher(this.find(true), key, expect);
+        return this.find(true).tap(key, expect);
     }
     static tag(id) {
-        return useSubscriber(this.find(true), id);
+        return this.find(true).tag(id);
+    }
+    static use(callback) {
+        const instance = useModel(this, callback);
+        useComponentLifecycle(instance[LOCAL]);
+        usePeerContext(instance.get);
+        return instance;
+    }
+    static uses(props, only) {
+        return this.use(instance => {
+            instance.import(props, only);
+        });
+    }
+    static using(props, only) {
+        const instance = this.use();
+        instance.import(props, only);
+        return instance;
     }
     static meta(path) {
         return useWatcher(this, path);
     }
-    static find(strict) {
-        return useLookup().get(this, strict);
-    }
     static isTypeof(maybe) {
-        return (fn(maybe) &&
+        return (typeof maybe == "function" &&
             maybe.prototype instanceof this);
     }
-    static get inherits() {
-        const I = getPrototypeOf(this);
-        if (I !== Model)
-            return I;
-    }
 }
+Model.CONTROL = CONTROL;
+Model.STATE = STATE;
+Model.LOCAL = LOCAL;
+Model.WHY = UPDATE;
 defineLazy(Model, CONTROL, function () {
-    const dispatch = new Controller(this);
-    dispatch.start();
-    return dispatch;
-});
+    return new Controller(this).start();
+});
+function defer(on, method) {
+    const { subject, waiting } = on;
+    const real = subject[method];
+    subject[method] = (...args) => {
+        let done;
+        waiting.add(() => {
+            done = real.apply(subject, args);
+        });
+        return () => done();
+    };
+}
 
-const ComputedInit = new WeakSet();
-const ComputedInfo = new WeakMap();
-const ComputedFor = new WeakMap();
-function metaData(x, set) {
-    if (set)
-        ComputedInfo.set(x, set);
-    else
-        return ComputedInfo.get(x);
-}
-function implementGetters(on) {
-    let scan = on.subject;
-    while (scan !== Model && scan.constructor !== Model) {
-        for (let [key, { get, set }] of entriesIn(scan))
-            if (get)
-                prepareComputed(on, key, get, set);
-        scan = getPrototypeOf(scan);
-    }
+const Parent = new WeakMap();
+const Oops$1 = issues({
+    ParentRequired: (expects, child) => `New ${child} created standalone but requires parent of type ${expects}. Did you remember to create via use(${child})?`,
+    UnexpectedParent: (expects, child, got) => `New ${child} created as child of ${got}, but must be instanceof ${expects}.`,
+    UndefinedNotAllowed: (key) => `Child property ${key} may not be undefined.`,
+    BadArgument: (type) => `Instruction \`use\` cannot accept argument type of ${type}.`,
+    IsReadOnly: (owner, key) => `${owner}.${key} is set to read-only, but tried to reassign assign.`,
+    MustBeDefined: (owner, key) => `${owner}.${key} must have initial value, as a read-only property.`
+});
+function bootstrap(object) {
+    const breakdown = getOwnPropertyDescriptors(object);
+    const control = new Model();
+    for (const key in breakdown)
+        defineProperty(control, key, breakdown[key]);
+    return control;
 }
-function prepareComputed(on, key, getter, setter) {
-    let sub;
-    let defined = ComputedFor.get(on);
-    if (!defined)
-        ComputedFor.set(on, defined = new Map());
-    if (defined.has(key))
-        return;
-    const { state, subject } = on;
-    const info = {
-        key,
-        parent: on,
-        priority: 1
-    };
-    defined.set(key, info);
-    const update = (initial) => {
-        try {
-            const value = getter.call(sub.proxy, sub.proxy);
-            if (state[key] == value)
-                return;
-            if (!initial)
-                on.update(key);
-            return state[key] = value;
-        }
-        catch (err) {
-            Oops.ComputeFailed(subject.constructor.name, key, false).warn();
-            throw err;
-        }
-    };
-    const create = (early) => {
-        sub = new Subscriber(subject, debounce(update), info);
-        defineProperty(state, key, {
-            value: undefined,
-            writable: true
-        });
-        on.override(key, {
-            get: () => state[key],
-            set: setter
-        });
-        try {
-            return update(true);
-        }
-        catch (e) {
-            if (early)
-                Oops.ComputedEarly(key).warn();
-            throw e;
-        }
-        finally {
-            sub.listen();
-            for (const key in sub.following) {
-                const compute = defined.get(key);
-                if (compute && compute.priority >= info.priority)
-                    info.priority = compute.priority + 1;
+function use(input, argument) {
+    return child(function use(key) {
+        const { subject } = this;
+        // `true` => readonly
+        // `false` => writable, may be undefined
+        // `undefined` => writable (default)
+        let mode = argument;
+        let current;
+        const onUpdate = (next, initial) => {
+            if (mode === true && !initial)
+                throw Oops$1.IsReadOnly(subject, key);
+            if (next) {
+                current = next instanceof Model
+                    ? next : bootstrap(next);
+                Parent.set(current, subject);
+                manage(current);
             }
+            else if (mode === undefined)
+                throw Oops$1.UndefinedNotAllowed(key);
+            else
+                current = undefined;
+            if (typeof argument == "function")
+                return argument(current);
+        };
+        if (input) {
+            current =
+                Model.isTypeof(input) ? new input() :
+                    input instanceof Model ? input :
+                        typeof input === "function" ? input() :
+                            typeof input === "object" ? bootstrap(input) :
+                                Oops$1.BadArgument(typeof input).throw();
+            if (current)
+                mode = onUpdate(current, true) || mode;
+            else if (mode == true)
+                throw Oops$1.MustBeDefined(subject, key);
         }
-    };
-    alias(update, `try ${key}`);
-    alias(create, `new ${key}`);
-    alias(getter, `run ${key}`);
-    if (!setter)
-        setter = Oops.AssignToGetter(key).warn;
-    for (const sub of on.listeners)
-        if (key in sub) {
-            on.waiting.push(() => create());
-            return;
-        }
-    ComputedInit.add(create);
-    const initial = {
-        get: create,
-        set: setter,
-        configurable: true,
-        enumerable: true
-    };
-    defineProperty(state, key, initial);
-    defineProperty(subject, key, initial);
-}
-function ensureValue(from, key) {
-    const desc = getOwnPropertyDescriptor(from, key);
-    const getter = desc && desc.get;
-    if (ComputedInit.has(getter))
-        getter(true);
-}
-function computeContext(parent, handled) {
-    const pending = [];
-    function isComputed(request) {
-        const compute = metaData(request);
-        if (!compute)
-            return false;
-        if (compute.parent !== parent)
-            request();
         else
-            insertAfter(pending, request, sib => compute.priority > metaData(sib).priority);
-        return true;
-    }
-    function flushComputed() {
-        while (pending.length) {
-            const compute = pending.shift();
-            const { key } = metaData(compute);
-            if (!handled.has(key))
-                compute();
-        }
-    }
-    return {
-        isComputed,
-        flushComputed
-    };
-}
-
-const ParentRelationship = new WeakMap();
-function setChild(Peer, callback) {
-    return Observer.define((key, on) => {
-        const instance = new Peer();
-        on.register(key, instance);
-        ParentRelationship.set(instance, on.subject);
-        Controller.get(instance);
-        if (callback)
-            callback(instance);
+            mode = false;
+        this.manage(key, current, onUpdate);
+        return () => current;
     });
 }
-function setParent(Expects, required) {
-    return Observer.define((key, { subject }) => {
-        const expectsType = Expects.name;
-        const onType = subject.constructor.name;
-        const parent = ParentRelationship.get(subject);
-        if (!parent) {
+function parent(Expects, required) {
+    return apply(function parent() {
+        const child = this.subject;
+        const expected = Expects.name;
+        const value = Parent.get(this.subject);
+        if (!value) {
             if (required)
-                throw Oops.ParentRequired(expectsType, onType);
-        }
-        else if (!(parent instanceof Expects)) {
-            const gotType = parent.constructor.name;
-            throw Oops.UnexpectedParent(expectsType, onType, gotType);
+                throw Oops$1.ParentRequired(expected, child);
         }
-        define(subject, key, parent);
+        else if (!(value instanceof Expects))
+            throw Oops$1.UnexpectedParent(expected, child, value);
+        return { value };
     });
-}
-function setRefMediator(effect) {
-    return Observer.define((key, on) => {
-        const refObjectFunction = on.setter(key, effect);
-        defineProperty(refObjectFunction, "current", {
-            set: refObjectFunction,
-            get: () => on.state[key]
-        });
-        on.override(key, {
-            value: refObjectFunction
-        });
-    });
-}
-function setEffect(value, effect) {
-    return Observer.define((key, on) => {
-        if (!effect) {
-            effect = value;
-            value = undefined;
-        }
-        on.register(key, value, effect);
+}
+
+function on(initial, cb) {
+    return apply(function on(key) {
+        this.manage(key, initial, cb && createValueEffect(cb));
     });
 }
-function setMemo(factory, defer) {
-    return Observer.define((key, { subject }) => {
-        const get = () => factory.call(subject);
+function memo(factory, defer) {
+    return apply(function memo(key) {
+        const source = this.subject;
+        const get = () => factory.call(source);
         if (defer)
-            defineLazy(subject, key, get);
+            defineLazy(source, key, get);
         else
-            define(subject, key, get());
+            define(source, key, get());
     });
 }
-function setIgnored(value) {
-    return Observer.define((key, on) => {
-        const real = on.subject;
-        real[key] = value;
-        define(on.state, key, {
-            get: () => real[key]
-        });
-    });
-}
-function setAction(action) {
-    return Observer.define((key, on) => {
-        let pending = false;
-        function invoke(...args) {
-            if (pending)
-                return Promise.reject(Oops.DuplicateAction(key));
-            pending = true;
-            on.update(key);
-            return action
-                .apply(on.subject, args)
-                .finally(() => {
-                pending = false;
-                on.update(key);
-            });
-        }
-        alias(invoke, `run ${key}`);
-        defineProperty(invoke, "active", {
-            get: () => pending
-        });
-        on.override(key, {
-            get: () => invoke,
-            set: () => {
-                throw Oops.SetActionProperty(key);
-            }
-        });
-    });
-}
-function setComputed(fn) {
-    return Observer.define((key, on) => {
-        prepareComputed(on, key, fn);
-    });
-}
-
-function setBindings(target) {
-    return Observer.define((key, on) => {
-        defineLazy(target, key, function () {
-            const subscriber = Subscriber.current(this);
-            if (!subscriber)
-                throw Oops.BindNotAvailable();
-            const agent = bindRefFunctions(on);
-            subscriber.dependant.add(agent);
-            return agent.proxy;
+function lazy(value) {
+    return apply(function lazy(key) {
+        const source = this.subject;
+        source[key] = value;
+        defineProperty(this.state, key, {
+            get: () => source[key]
         });
     });
-}
-function bindRefFunctions(on) {
-    const proxy = {};
-    let index = 0;
-    const gc = new Set();
-    const refs = [];
-    function bind(key) {
-        let cleanup;
-        return (e) => {
-            if (cleanup) {
-                cleanup();
-                gc.delete(cleanup);
-                cleanup = undefined;
-            }
-            if (e)
-                gc.add(cleanup = createBinding(e, on, key));
-        };
-    }
-    for (const key in on.state)
-        defineProperty(proxy, key, {
-            get() {
-                try {
-                    return refs[index] || (refs[index] = bind(key));
-                }
-                finally {
-                    if (++index > refs.length)
-                        index = 0;
-                }
-            }
-        });
-    return {
-        proxy,
-        listen() { },
-        release() {
-            gc.forEach(x => x());
-        }
-    };
-}
-function createBinding(e, control, key) {
-    if (e instanceof HTMLInputElement)
-        return createTwoWayBinding(e, control, key);
-    else
-        return createOneWayBinding(e, control, key);
-}
-function createOneWayBinding(element, parent, key) {
-    function sync(to) {
-        element.innerHTML = String(to);
-    }
-    sync(parent.state[key]);
-    return parent.watch(key, sync);
-}
-function createTwoWayBinding(input, parent, key) {
-    let last;
-    function onUpdate() {
-        last = parent.subject[key] = this.value;
-    }
-    function sync(to) {
-        if (to !== last)
-            input.value = String(to);
-    }
-    sync(parent.state[key]);
-    const release = parent.watch(key, sync);
-    input.addEventListener("input", onUpdate);
-    return () => {
-        release();
-        input.removeEventListener("input", onUpdate);
-    };
 }
 
+const Oops = issues({
+    GlobalDoesNotExist: (name) => `Tried to access singleton ${name}, but none exist! Did you forget to initialize?\nCall ${name}.create() before attempting to access, or consider using ${name}.use() instead.`,
+    GlobalExists: (name) => `Shared instance of ${name} already exists! Consider unmounting existing, or use ${name}.reset() to force-delete it.`
+});
+const Active = new WeakMap();
 class Singleton extends Model {
+    static get current() {
+        return Active.get(this);
+    }
     static create(...args) {
         const Type = this;
-        let instance = Type.current;
-        if (instance)
+        if (Active.has(Type))
             throw Oops.GlobalExists(this.name);
-        instance = super.create(...args);
-        return Type.current = instance;
+        let instance = super.create(...args);
+        Active.set(Type, instance);
+        return instance;
+    }
+    static update(updates) {
+        const instance = this.current || this.create();
+        instance.import(updates);
+        return instance.update();
     }
-    static find() {
-        const { current } = this;
-        if (!current)
+    static is() {
+        return this.find(true);
+    }
+    static find(strict) {
+        const instance = this.current;
+        if (!instance && strict)
             throw Oops.GlobalDoesNotExist(this.name);
-        else
-            return current;
+        return instance;
+    }
+    static reset() {
+        if (this.current)
+            this.current.destroy();
     }
     destroy() {
         super.destroy();
-        const meta = this.constructor;
-        if (this === meta.current)
-            meta.current = undefined;
-        else
-            Oops.DestroyNotPossible(meta.name).warn();
+        Active.delete(this.constructor);
     }
-}
-Singleton.current = undefined;
+}
 
 exports.Consumer = Consumer;
 exports.Model = Model;
 exports.Provider = Provider;
 exports.Singleton = Singleton;
-exports.act = setAction;
-exports.binds = setBindings;
-exports.default = Model;
-exports.from = setComputed;
-exports.lazy = setIgnored;
-exports.memo = setMemo;
-exports.on = setEffect;
-exports.parent = setParent;
-exports.ref = setRefMediator;
-exports.tap = setPeer;
-exports.use = setChild;
+exports.act = act;
+exports.apply = apply;
+exports.child = child;
+exports["default"] = Model;
+exports.from = from;
+exports.lazy = lazy;
+exports.memo = memo;
+exports.on = on;
+exports.parent = parent;
+exports.pending = pending;
+exports.ref = ref;
+exports.tap = tap;
+exports.use = use;
+//# sourceMappingURL=index.js.map