@expressive/mvc 1.0.0-beta.10 → 1.0.0-beta.14

package/lib/index.js

@@ -13,6 +13,9 @@ class Issue extends Error {
     warn() {
         console.warn(this.message);
     }
+    throw() {
+        throw this;
+    }
 }
 function issues(register) {
     const Library = {};
@@ -41,9 +44,6 @@ function defineLazy(object, property, init) {
 function setAlias(func, displayName) {
     assign(func, { displayName });
 }
-function entriesIn(object) {
-    return entries(getOwnPropertyDescriptors(object));
-}
 function createEffect(callback) {
     let unSet;
     return function (value) {
@@ -55,6 +55,12 @@ function createEffect(callback) {
             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 = {};
@@ -85,16 +91,11 @@ function lifecycle(prefix) {
     const type = eventsFor(prefix);
     return function useLifecycle(sub, tag) {
         const emit = react.useMemo(() => {
-            const { parent } = sub;
-            const { subject } = parent;
+            const subject = sub.source;
             const id = typeof tag == "function" ? tag(subject) : tag;
             return (name) => {
-                for (const key of [name, type(name)]) {
-                    const handler = subject[key];
-                    if (handler)
-                        handler.call(subject, id);
-                    parent.update(key);
-                }
+                for (const key of [name, type(name)])
+                    subject.update(key, id);
             };
         }, [sub, tag]);
         emit(Lifecycle.WILL_RENDER);
@@ -121,6 +122,19 @@ function eventsFor(prefix) {
     return (e) => map.get(e);
 }
 
+const CONTROL = Symbol("control");
+const CREATE = Symbol("start");
+const LOCAL = Symbol("local");
+const STATE = Symbol("state");
+const Pending = new Map();
+function manage(src) {
+    return src[CONTROL];
+}
+function does(instruction, label) {
+    const placeholder = Symbol(`${label} instruction`);
+    Pending.set(placeholder, instruction);
+    return placeholder;
+}
 class Controller {
     constructor(subject) {
         this.subject = subject;
@@ -128,14 +142,41 @@ class Controller {
         this.frame = new Set();
         this.handles = new Set();
         this.waiting = [];
-        bootstrap(this);
+    }
+    static setup(onto) {
+        const create = onto[CREATE];
+        const control = new this(onto);
+        const after = create && create.call(onto, control);
+        defineLazy(onto, CONTROL, () => {
+            onto[STATE] = control.state;
+            control.start();
+            if (after)
+                after();
+            if (onto.didCreate)
+                onto.didCreate();
+            return control;
+        });
+        return control;
     }
     get pending() {
         return this.frame.size > 0;
     }
     start() {
-        getOwnPropertyNames(this.subject)
-            .forEach(k => this.add(k));
+        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;
     }
@@ -145,16 +186,6 @@ class Controller {
             ? selectRecursive(using, keys.concat(lifecycleEvents))
             : keys;
     }
-    add(key) {
-        const desc = getOwnPropertyDescriptor(this.subject, key);
-        if (desc && "value" in desc) {
-            const { value } = desc;
-            if (apply(this, key, value))
-                return;
-            if (desc.enumerable && typeof value !== "function" || /^[A-Z]/.test(key))
-                this.manage(key, value);
-        }
-    }
     manage(key, initial, effect) {
         const { state, subject } = this;
         state[key] = initial;
@@ -162,10 +193,10 @@ class Controller {
             enumerable: true,
             configurable: true,
             get: () => state[key],
-            set: this.sets(key, effect)
+            set: this.setter(key, effect)
         });
     }
-    sets(key, handler) {
+    setter(key, handler) {
         const { state, subject } = this;
         return (value) => {
             if (state[key] == value)
@@ -180,25 +211,6 @@ class Controller {
             this.update(key, value);
         };
     }
-    watch(subset, handler, squash, once) {
-        const set = keys(this, subset);
-        const batch = {};
-        const remove = this.addListener(batch);
-        const callback = squash
-            ? handler.bind(this.subject)
-            : (frame) => {
-                for (const key of frame)
-                    if (set.includes(key))
-                        handler.call(this.subject, this.state[key], key);
-            };
-        const handle = once
-            ? (k) => { remove(); callback(k); }
-            : callback;
-        for (const key of set)
-            batch[key] = handle;
-        ensure(this, set);
-        return remove;
-    }
     addListener(batch) {
         this.handles.add(batch);
         return () => {
@@ -228,9 +240,9 @@ class Controller {
         const keys = Array.from(this.frame);
         const handle = new Set(this.waiting.splice(0));
         this.frame.clear();
-        handle.forEach(cb => {
+        handle.forEach(callback => {
             try {
-                cb(keys);
+                callback(keys);
             }
             catch (e) { }
         });
@@ -244,50 +256,6 @@ function keys(from, using) {
     return from.select(using);
 }
 
-const Oops$7 = 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();
-const tap = (type, required) => child(function tap(key) {
-    const to = this.subject;
-    let getInstance;
-    if ("current" in type)
-        getInstance = () => type.current;
-    else if ("current" in to.constructor)
-        throw Oops$7.CantAttachGlobal(to, type.name);
-    else
-        getPending(to).push(context => {
-            const remote = context.get(type);
-            if (!remote && required)
-                throw Oops$7.AmbientRequired(type.name, to, key);
-            getInstance = () => remote;
-        });
-    return () => getInstance();
-});
-function usePeerContext(subject) {
-    if (ContextWasUsed.has(subject)) {
-        if (ContextWasUsed.get(subject))
-            useLookup();
-        return;
-    }
-    const pending = PendingContext.get(subject);
-    if (pending) {
-        const local = useLookup();
-        for (const init of pending)
-            init(local);
-        PendingContext.delete(subject);
-    }
-    ContextWasUsed.set(subject, !!pending);
-}
-function getPending(subject) {
-    let pending = PendingContext.get(subject);
-    if (!pending)
-        PendingContext.set(subject, pending = []);
-    return pending;
-}
-
 class Subscriber {
     constructor(parent, onUpdate) {
         this.onUpdate = onUpdate;
@@ -297,14 +265,15 @@ class Subscriber {
         if (!(parent instanceof Controller))
             parent = manage(parent);
         this.parent = parent;
+        this.source = parent.subject;
         this.proxy = create(parent.subject);
         define(this.proxy, LOCAL, this);
         for (const key in parent.state)
             this.spy(key);
     }
     spy(key) {
-        const { proxy } = this;
-        const { set } = getOwnPropertyDescriptor(this.parent.subject, key);
+        const { proxy, source } = this;
+        const { set } = getOwnPropertyDescriptor(source, key);
         const intercept = () => {
             this.follow(key);
             delete proxy[key];
@@ -333,145 +302,401 @@ class Subscriber {
     }
 }
 
-const Oops$6 = issues({
-    HasPropertyUndefined: (control, property) => `${control}.${property} is marked as required for this render.`
+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 useElementLifecycle = lifecycle("element");
-const useComponentLifecycle = lifecycle("component");
-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.useLayoutEffect(() => () => instance.destroy(), []);
-    return instance;
+const ComputedInit = new WeakSet();
+const ComputedInfo = new WeakMap();
+const ComputedUsed = new WeakMap();
+const ComputedKeys = new WeakMap();
+function getRegister(on) {
+    let register = ComputedUsed.get(on);
+    if (!register)
+        ComputedUsed.set(on, register = new Map());
+    return register;
 }
-function useWatcher(target, focus, expected) {
-    const hook = use$1(refresh => {
-        const sub = new Subscriber(target, refresh);
-        if (focus) {
-            const src = sub.proxy;
-            const key = keys(sub.parent, focus)[0];
-            defineProperty(sub, "proxy", {
-                get() {
-                    if (src[key] === undefined && expected)
-                        throw Oops$6.HasPropertyUndefined(target, key);
-                    return src[key];
-                }
-            });
+function prepareGetters(on) {
+    const defined = getRegister(on);
+    for (let scan = on.subject; scan.constructor !== Object; scan = getPrototypeOf(scan))
+        for (const key of getOwnPropertyNames(scan)) {
+            const { get, set } = getOwnPropertyDescriptor(scan, key);
+            if (get && !defined.has(key))
+                prepare(on, key, get, set);
         }
-        return sub;
-    });
-    react.useLayoutEffect(() => hook.commit(), []);
-    return hook.proxy;
 }
-function useSubscriber(target, tag) {
-    const hook = use$1(refresh => new Subscriber(target, refresh));
-    useElementLifecycle(hook, tag || 0);
-    return hook.proxy;
-}
-function useModel(Type, args, callback) {
-    const hook = use$1(refresh => {
-        const instance = new Type(...args);
-        const sub = new Subscriber(instance, refresh);
-        instance.on(Lifecycle.WILL_UNMOUNT, () => {
-            instance.destroy();
-        });
-        if (callback)
-            callback(instance);
-        return sub;
-    });
-    usePeerContext(hook.parent.subject);
-    useComponentLifecycle(hook);
-    return hook.proxy;
-}
-
-class Lookup {
-    constructor() {
-        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);
+function prepare(on, key, getter, setter) {
+    const { state, subject } = on;
+    const defined = getRegister(on);
+    const info = {
+        key, parent: on, priority: 1
+    };
+    let sub;
+    defined.set(key, info);
+    function compute(initial) {
+        try {
+            return getter.call(sub.proxy, sub.proxy);
+        }
+        catch (err) {
+            Oops$7.ComputeFailed(subject, key, !!initial).warn();
+            throw err;
         }
-        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;
+    function update() {
+        let value;
+        try {
+            value = compute(false);
         }
-        else {
-            T = I;
-            I = I.create();
+        catch (e) {
+            console.error(e);
+        }
+        finally {
+            if (state[key] !== value) {
+                on.update(key, value);
+                return value;
+            }
         }
-        do {
-            defineProperty(this, this.key(T), {
-                value: I,
-                writable
-            });
-        } while (T = T.inherits);
-        return I;
     }
-    pop() {
-        for (const key of getOwnPropertySymbols(this)) {
-            const entry = getOwnPropertyDescriptor(this, key);
-            if (entry.writable)
-                entry.value.destroy();
+    function create(early) {
+        sub = new Subscriber(on, update);
+        ComputedInfo.set(update, info);
+        defineProperty(state, key, {
+            value: undefined,
+            writable: true
+        });
+        defineProperty(subject, key, {
+            enumerable: true,
+            configurable: true,
+            get: () => state[key],
+            set: setter
+        });
+        try {
+            return state[key] = compute(true);
+        }
+        catch (e) {
+            if (early)
+                Oops$7.ComputedEarly(key).warn();
+            throw e;
+        }
+        finally {
+            sub.commit();
+            for (const key in sub.follows) {
+                const peer = defined.get(key);
+                if (peer && peer.priority >= info.priority)
+                    info.priority = peer.priority + 1;
+            }
         }
     }
-}
-
-const Oops$5 = 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$5.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$5.BadConsumerProps();
-    return null;
+    function revert(value) {
+        delete state[key];
+        defineProperty(subject, key, {
+            enumerable: true,
+            configurable: true,
+            value
+        });
+    }
+    setAlias(update, `try ${key}`);
+    setAlias(create, `new ${key}`);
+    setAlias(getter, `run ${key}`);
+    ComputedInit.add(create);
+    for (const on of [state, subject])
+        defineProperty(on, key, {
+            get: create,
+            set: setter || revert,
+            configurable: true,
+            enumerable: true
+        });
+    return info;
 }
-function useNewContext(from, inject) {
-    return react.useMemo(() => {
-        if (!inject)
-            throw Oops$5.NoProviderType();
+function ensure(on, keys) {
+    for (const key of keys) {
+        const desc = getOwnPropertyDescriptor(on.subject, key);
+        const getter = desc && desc.get;
+        if (ComputedInit.has(getter))
+            getter(true);
+    }
+}
+function capture(on, request) {
+    const compute = ComputedInfo.get(request);
+    const callback = request;
+    if (!compute)
+        return;
+    let pending = ComputedKeys.get(on);
+    if (!pending)
+        ComputedKeys.set(on, pending = []);
+    if (compute.parent !== on)
+        callback();
+    else {
+        const queue = pending.findIndex(peer => compute.priority > ComputedInfo.get(peer).priority);
+        pending.splice(queue + 1, 0, callback);
+    }
+    return true;
+}
+function flush(on) {
+    const handled = on.frame;
+    let pending = ComputedKeys.get(on);
+    if (pending) {
+        while (pending.length) {
+            const compute = pending.shift();
+            const { key } = ComputedInfo.get(compute);
+            if (!handled.has(key))
+                compute();
+        }
+        ComputedKeys.delete(on);
+    }
+}
+
+const Oops$6 = issues({
+    DuplicateAction: (key) => `Invoked action ${key} but one is already active.`
+});
+const set = (instruction, name) => does(function set(key) {
+    let output = instruction.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);
+}, name || instruction.name || "pending");
+const ref = (cb) => set(function ref(key) {
+    const refObjectFunction = this.setter(key, cb && createEffect(cb));
+    defineProperty(refObjectFunction, "current", {
+        set: refObjectFunction,
+        get: () => this.state[key]
+    });
+    return {
+        value: refObjectFunction
+    };
+});
+const on = (value, cb) => set(function on(key) {
+    this.manage(key, value, cb && createEffect(cb));
+});
+const memo = (factory, defer) => set(function memo(key) {
+    const source = this.subject;
+    const get = () => factory.call(source);
+    if (defer)
+        defineLazy(source, key, get);
+    else
+        define(source, key, get());
+});
+const lazy = (value) => set(function lazy(key) {
+    const source = this.subject;
+    source[key] = value;
+    defineProperty(this.state, key, {
+        get: () => source[key]
+    });
+});
+const act = (task) => set(function act(key) {
+    let pending = false;
+    const invoke = (...args) => {
+        if (pending)
+            return Promise.reject(Oops$6.DuplicateAction(key));
+        pending = true;
+        this.update(key);
+        return new Promise(res => {
+            res(task.apply(this.subject, args));
+        }).finally(() => {
+            pending = false;
+            this.update(key);
+        });
+    };
+    setAlias(invoke, `run ${key}`);
+    defineProperty(invoke, "active", {
+        get: () => pending
+    });
+    return {
+        value: invoke,
+        writable: false
+    };
+});
+const from = (getter) => set(function from(key) {
+    prepare(this, key, getter);
+});
+
+const attach = (from, name) => set(function attach(key) {
+    const proxyCache = new WeakMap();
+    const getCurrent = from.call(this, key);
+    function subscribe(sub) {
+        let child;
+        function start() {
+            const instance = getCurrent();
+            if (instance) {
+                child = new Subscriber(instance, sub.onUpdate);
+                if (sub.active)
+                    child.commit();
+                sub.dependant.add(child);
+                proxyCache.set(sub, child.proxy);
+            }
+        }
+        function refresh() {
+            if (child) {
+                child.release();
+                sub.dependant.delete(child);
+                proxyCache.set(sub, undefined);
+                child = undefined;
+            }
+            start();
+            sub.onUpdate();
+        }
+        start();
+        sub.follow(key, refresh);
+    }
+    return (local) => {
+        if (!local)
+            return getCurrent();
+        if (!proxyCache.has(local))
+            subscribe(local);
+        return proxyCache.get(local);
+    };
+}, name || from.name);
+
+const Oops$5 = issues({
+    HasPropertyUndefined: (control, property) => `${control}.${property} is marked as required for this render.`
+});
+const useElementLifecycle = lifecycle("element");
+function use$1(init) {
+    const [state, update] = react.useState(() => [
+        init(() => update(state.concat()))
+    ]);
+    return state[0];
+}
+function useLazy(Type, args, callback) {
+    const instance = react.useMemo(() => {
+        const instance = Type.create(...args || []);
+        if (callback)
+            callback(instance);
+        return instance;
+    }, []);
+    react.useLayoutEffect(() => () => instance.destroy(), []);
+    return instance;
+}
+function useWatcher(target, focus, expected) {
+    const hook = use$1(refresh => {
+        const sub = new Subscriber(target, refresh);
+        if (focus) {
+            const src = sub.proxy;
+            const key = keys(sub.parent, focus)[0];
+            defineProperty(sub, "proxy", {
+                get() {
+                    if (src[key] === undefined && expected)
+                        throw Oops$5.HasPropertyUndefined(target, key);
+                    return src[key];
+                }
+            });
+        }
+        return sub;
+    });
+    react.useLayoutEffect(() => hook.commit(), []);
+    return hook.proxy;
+}
+function useSubscriber(target, tag) {
+    const hook = use$1(refresh => new Subscriber(target, refresh));
+    useElementLifecycle(hook, tag || 0);
+    return hook.proxy;
+}
+function useModel(Type, args, callback) {
+    const hook = use$1(refresh => {
+        const instance = new Type(...args || []);
+        const control = manage(instance);
+        const sub = new Subscriber(control, refresh);
+        const release = control.addListener({
+            [Lifecycle.WILL_UNMOUNT]() {
+                instance.destroy();
+                release();
+            }
+        });
+        if (callback)
+            callback(instance);
+        return sub;
+    });
+    return hook.proxy;
+}
+
+class Lookup {
+    constructor() {
+        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$4 = 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$4.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$4.BadConsumerProps();
+    return null;
+}
+function useNewContext(from, inject) {
+    return react.useMemo(() => {
+        if (!inject)
+            throw Oops$4.NoProviderType();
         const context = from.push(inject);
         for (const instance of context.local)
             for (const apply of getPending(instance))
@@ -514,44 +739,194 @@ function Provider(props) {
         : render);
 }
 
-const Oops$4 = issues({
-    StrictUpdate: (expected) => `Strict update() did ${expected ? "not " : ""}find pending updates.`
+const Oops$3 = 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 CONTROL = Symbol("control");
-const LOCAL = Symbol("local");
-const STATE = Symbol("state");
-function manage(src) {
-    return src[CONTROL];
+const PendingContext = new WeakMap();
+const ContextWasUsed = new WeakMap();
+const tap = (type, argument) => attach(function tap(key) {
+    if ("current" in type)
+        return () => type.current;
+    const to = this.subject;
+    if ("current" in to.constructor)
+        throw Oops$3.CantAttachGlobal(to, type.name);
+    let instance;
+    getPending(to).push(context => {
+        instance = context.get(type);
+        if (typeof argument == "function") {
+            if (argument(instance) === false)
+                instance = undefined;
+        }
+        else if (!instance && argument)
+            throw Oops$3.AmbientRequired(type.name, to, key);
+    });
+    return () => instance;
+});
+function usePeerContext(subject) {
+    if (ContextWasUsed.has(subject)) {
+        if (ContextWasUsed.get(subject))
+            useLookup();
+        return;
+    }
+    const pending = PendingContext.get(subject);
+    if (pending) {
+        const local = useLookup();
+        for (const init of pending)
+            init(local);
+        PendingContext.delete(subject);
+    }
+    ContextWasUsed.set(subject, !!pending);
 }
-class Model {
-    constructor() {
-        const control = new Controller(this);
+function getPending(subject) {
+    let pending = PendingContext.get(subject);
+    if (!pending)
+        PendingContext.set(subject, pending = []);
+    return pending;
+}
+
+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.`
+});
+class State {
+    constructor(computeGetters) {
+        const control = Controller.setup(this);
         define(this, "get", this);
         define(this, "set", this);
-        defer(control, "on");
-        defer(control, "effect");
-        defineLazy(this, CONTROL, () => {
-            delete this.on;
-            delete this.effect;
-            this[STATE] = control.state;
-            control.start();
-            if (this.didCreate)
-                this.didCreate();
-            return control;
-        });
+        if (computeGetters !== false)
+            prepareGetters(control);
+    }
+    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)
+                if (typeof tag != "boolean")
+                    this[arg](tag);
+                else if (tag)
+                    this[arg]();
+        }
+        return {
+            then(callback) {
+                if (callback)
+                    if (control.pending)
+                        control.include(callback);
+                    else
+                        callback(false);
+                else
+                    throw Oops$2.NoChaining();
+            }
+        };
+    }
+    destroy() {
+        this.update("willDestroy", true);
+    }
+    toString() {
+        return this.constructor.name;
     }
     tap(path, expect) {
         return useWatcher(this, path, expect);
     }
-    tag(id) {
-        return useSubscriber(this, id);
+    static create(...args) {
+        const instance = new this(...args);
+        manage(instance);
+        return instance;
+    }
+    static new(args, callback) {
+        return useLazy(this, args, callback);
+    }
+    static use(args, callback) {
+        return useModel(this, args, callback);
     }
-    on(select, does, squash, once) {
-        return manage(this).watch(select, does, squash, once);
+    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 find(strict) {
+        return useFromContext(this, strict);
+    }
+    static get(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);
+    }
+    static isTypeof(maybe) {
+        return (typeof maybe == "function" &&
+            maybe.prototype instanceof this);
+    }
+}
+State.CONTROL = CONTROL;
+State.STATE = STATE;
+State.INIT = CREATE;
+State.LOCAL = LOCAL;
+
+const useComponentLifecycle = lifecycle("component");
+class Model extends State {
+    constructor() {
+        super(false);
+    }
+    [CREATE](using) {
+        defer(using, "on");
+        defer(using, "effect");
+        return () => {
+            delete this.on;
+            delete this.effect;
+        };
+    }
+    on(subset, handler, squash, once) {
+        const control = manage(this);
+        const set = keys(control, subset);
+        const batch = {};
+        const remove = control.addListener(batch);
+        const callback = squash
+            ? handler.bind(this)
+            : (frame) => {
+                for (const key of frame)
+                    if (set.includes(key))
+                        handler.call(this, control.state[key], key);
+            };
+        const handle = once
+            ? (k) => { remove(); callback(k); }
+            : callback;
+        for (const key of set)
+            batch[key] = handle;
+        ensure(control, set);
+        return remove;
     }
-    once(select, does, squash) {
-        if (does)
-            return this.on(select, does, squash, true);
+    once(select, callback, squash) {
+        if (callback)
+            return this.on(select, callback, squash, true);
         else
             return new Promise(resolve => {
                 this.on(select, resolve, true, true);
@@ -573,92 +948,22 @@ class Model {
             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) {
-        const control = manage(this);
-        if (typeof arg == "boolean") {
-            if (!control.pending === arg)
-                return Promise.reject(Oops$4.StrictUpdate(arg));
-        }
-        else if (arg)
-            for (const key of keys(control, arg))
-                control.update(key);
-        if (control.pending)
-            return new Promise(cb => control.include(cb));
-        return Promise.resolve(false);
-    }
-    destroy() {
-        if (this.willDestroy)
-            this.willDestroy();
-    }
-    toString() {
-        return this.constructor.name;
-    }
-    static create(...args) {
-        const instance = new this(...args);
-        manage(instance);
-        return instance;
-    }
-    static use(...args) {
-        return useModel(this, args);
-    }
-    static uses(props, only) {
-        return useModel(this, [], instance => {
-            instance.import(props, only);
-        });
+    tag(id) {
+        return useSubscriber(this, id);
     }
-    static using(props, only) {
-        const instance = useModel(this, []);
-        instance.import(props, only);
+    static use(args, callback) {
+        const instance = useModel(this, args, callback);
+        useComponentLifecycle(instance[LOCAL]);
+        usePeerContext(instance.get);
         return instance;
     }
-    static new(...args) {
-        return useLazy(this, args);
-    }
-    static get(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);
-    }
     static tag(id) {
         return useSubscriber(this.find(true), id);
     }
     static meta(path) {
         return useWatcher(this, path);
     }
-    static find(strict) {
-        return useFromContext(this, strict);
-    }
-    static isTypeof(maybe) {
-        return (typeof maybe == "function" &&
-            maybe.prototype instanceof this);
-    }
-    static get inherits() {
-        const I = getPrototypeOf(this);
-        if (I !== Model)
-            return I;
-    }
 }
-Model.STATE = STATE;
-Model.CONTROL = CONTROL;
-Model.LOCAL = LOCAL;
 defineLazy(Model, CONTROL, function () {
     return new Controller(this).start();
 });
@@ -674,239 +979,27 @@ function defer(on, method) {
     };
 }
 
-const Oops$3 = 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 ComputedInit = new WeakSet();
-const ComputedInfo = new WeakMap();
-const ComputedFor = new WeakMap();
-const ComputedKeys = new WeakMap();
-function bootstrap(on) {
-    const defined = new Map();
-    let scan = on.subject;
-    ComputedFor.set(on, defined);
-    while (scan !== Model && scan.constructor !== Model) {
-        for (let [key, { get, set }] of entriesIn(scan))
-            if (get && !defined.has(key))
-                defined.set(key, prepare(on, key, get, set));
-        scan = getPrototypeOf(scan);
-    }
-}
-function prepare(on, key, getter, setter) {
-    const { state, subject } = on;
-    const info = {
-        key, parent: on, priority: 1
-    };
-    let sub;
-    function compute(initial) {
-        try {
-            return getter.call(sub.proxy, sub.proxy);
-        }
-        catch (err) {
-            Oops$3.ComputeFailed(subject, key, !!initial).warn();
-            throw err;
-        }
-    }
-    function update() {
-        let value;
-        try {
-            value = compute(false);
-        }
-        catch (e) {
-            console.error(e);
-        }
-        finally {
-            if (state[key] !== value) {
-                on.update(key, value);
-                return value;
-            }
-        }
-    }
-    function create(early) {
-        sub = new Subscriber(on, update);
-        ComputedInfo.set(update, info);
-        defineProperty(state, key, {
-            value: undefined,
-            writable: true
-        });
-        defineProperty(subject, key, {
-            enumerable: true,
-            configurable: true,
-            get: () => state[key],
-            set: setter
-        });
-        try {
-            return state[key] = compute(true);
-        }
-        catch (e) {
-            if (early)
-                Oops$3.ComputedEarly(key).warn();
-            throw e;
-        }
-        finally {
-            let defined = ComputedFor.get(on);
-            sub.commit();
-            for (const key in sub.follows) {
-                const compute = defined.get(key);
-                if (compute && compute.priority >= info.priority)
-                    info.priority = compute.priority + 1;
-            }
-        }
-    }
-    function revert(value) {
-        delete state[key];
-        defineProperty(subject, key, {
-            enumerable: true,
-            configurable: true,
-            value
-        });
-    }
-    setAlias(update, `try ${key}`);
-    setAlias(create, `new ${key}`);
-    setAlias(getter, `run ${key}`);
-    ComputedInit.add(create);
-    for (const on of [state, subject])
-        defineProperty(on, key, {
-            get: create,
-            set: setter || revert,
-            configurable: true,
-            enumerable: true
-        });
-    return info;
-}
-function ensure(on, keys) {
-    for (const key of keys) {
-        const desc = getOwnPropertyDescriptor(on.subject, key);
-        const getter = desc && desc.get;
-        if (ComputedInit.has(getter))
-            getter(true);
-    }
-}
-function capture(on, request) {
-    const compute = ComputedInfo.get(request);
-    if (!compute)
-        return;
-    let pending = ComputedKeys.get(on);
-    if (!pending)
-        ComputedKeys.set(on, pending = []);
-    if (compute.parent !== on)
-        request();
-    else {
-        const byPriorty = (sib) => compute.priority > ComputedInfo.get(sib).priority;
-        pending.splice(pending.findIndex(byPriorty) + 1, 0, request);
-    }
-    return true;
-}
-function flush(on) {
-    const handled = on.frame;
-    let pending = ComputedKeys.get(on);
-    if (pending) {
-        while (pending.length) {
-            const compute = pending.shift();
-            const { key } = ComputedInfo.get(compute);
-            if (!handled.has(key))
-                compute();
-        }
-        ComputedKeys.delete(on);
-    }
-}
-
-const Oops$2 = issues({
-    DuplicateAction: (key) => `Invoked action ${key} but one is already active.`
-});
-const Pending = new Map();
-function apply(on, key, value) {
-    const instruction = Pending.get(value);
-    if (instruction) {
-        Pending.delete(value);
-        delete on.subject[key];
-        instruction.call(on, key);
-        return true;
-    }
-}
-function set(instruction, name = instruction.name || "pending") {
-    const placeholder = Symbol(`${name} instruction`);
-    function apply(key) {
-        let output = instruction.call(this, key);
-        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, apply);
-    return placeholder;
-}
-const ref = (cb) => set(function ref(key) {
-    const refObjectFunction = this.sets(key, cb && createEffect(cb));
-    defineProperty(refObjectFunction, "current", {
-        set: refObjectFunction,
-        get: () => this.state[key]
-    });
-    return {
-        value: refObjectFunction
-    };
-});
-const on = (value, cb) => set(function on(key) {
-    this.manage(key, value, cb && createEffect(cb));
-});
-const memo = (factory, defer) => set(function memo(key) {
-    const source = this.subject;
-    const get = () => factory.call(source);
-    if (defer)
-        defineLazy(source, key, get);
-    else
-        define(source, key, get());
-});
-const lazy = (value) => set(function lazy(key) {
-    const source = this.subject;
-    source[key] = value;
-    defineProperty(this.state, key, {
-        get: () => source[key]
-    });
-});
-const act = (task) => set(function act(key) {
-    let pending = false;
-    const invoke = (...args) => {
-        if (pending)
-            return Promise.reject(Oops$2.DuplicateAction(key));
-        pending = true;
-        this.update(key);
-        return new Promise(res => {
-            res(task.apply(this.subject, args));
-        }).finally(() => {
-            pending = false;
-            this.update(key);
-        });
-    };
-    setAlias(invoke, `run ${key}`);
-    defineProperty(invoke, "active", {
-        get: () => pending
-    });
-    return {
-        value: invoke,
-        writable: false
-    };
-});
-const from = (getter) => set(function from(key) {
-    prepare(this, key, getter);
-});
-
 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.`
+    UndefinedNotAllowed: (key) => `Child property ${key} may not be undefined.`,
+    BadArgument: (type) => `Instruction \`use\` cannot accept argument type of ${type}.`
 });
-const use = (Peer, argument) => child(function use(key) {
+function bootstrap(object) {
+    const breakdown = getOwnPropertyDescriptors(object);
+    const control = new Model();
+    for (const key in breakdown)
+        defineProperty(control, key, breakdown[key]);
+    return control;
+}
+const use = (input, argument) => attach(function use(key) {
     let instance;
     const update = (next) => {
-        instance = next;
-        if (next) {
+        instance =
+            next instanceof Model ? next :
+                next && bootstrap(next);
+        if (instance) {
             Parent.set(instance, this.subject);
             manage(instance);
         }
@@ -915,9 +1008,13 @@ const use = (Peer, argument) => child(function use(key) {
         else if (!instance && argument !== false)
             throw Oops$1.UndefinedNotAllowed(key);
     };
-    if (Peer) {
-        instance = Model.isTypeof(Peer)
-            ? new Peer() : Peer();
+    if (input) {
+        instance =
+            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 (instance)
             update(instance);
     }
@@ -926,45 +1023,6 @@ const use = (Peer, argument) => child(function use(key) {
     this.manage(key, instance, update);
     return () => instance;
 });
-const child = (from, name) => {
-    function child(key) {
-        const proxyCache = new WeakMap();
-        const getCurrent = from.call(this, key);
-        function attach(sub) {
-            let child;
-            function create() {
-                const instance = getCurrent();
-                if (!instance)
-                    return;
-                child = new Subscriber(instance, sub.onUpdate);
-                if (sub.active)
-                    child.commit();
-                sub.dependant.add(child);
-                proxyCache.set(sub, child.proxy);
-            }
-            function refresh() {
-                if (child) {
-                    child.release();
-                    sub.dependant.delete(child);
-                    proxyCache.set(sub, undefined);
-                    child = undefined;
-                }
-                create();
-                sub.onUpdate();
-            }
-            create();
-            sub.follow(key, refresh);
-        }
-        return (local) => {
-            if (!local)
-                return getCurrent();
-            if (!proxyCache.has(local))
-                attach(local);
-            return proxyCache.get(local);
-        };
-    }
-    return set(child, name || from.name);
-};
 const parent = (Expects, required) => set(function parent() {
     const child = this.subject;
     const expected = Expects.name;
@@ -995,10 +1053,16 @@ class Singleton extends Model {
         Active.set(Type, instance);
         return instance;
     }
-    static find() {
-        if (this.current)
-            return this.current;
-        throw Oops.GlobalDoesNotExist(this.name);
+    static update(updates) {
+        const instance = this.current || this.create();
+        instance.import(updates);
+        return instance.update();
+    }
+    static find(strict) {
+        const instance = this.current;
+        if (!instance && strict)
+            throw Oops.GlobalDoesNotExist(this.name);
+        return instance;
     }
     static reset() {
         if (this.current)
@@ -1014,8 +1078,9 @@ exports.Consumer = Consumer;
 exports.Model = Model;
 exports.Provider = Provider;
 exports.Singleton = Singleton;
+exports.State = State;
 exports.act = act;
-exports.child = child;
+exports.attach = attach;
 exports.default = Model;
 exports.from = from;
 exports.lazy = lazy;