@expressive/mvc 1.0.0-beta.19 → 1.0.0-beta.22

package/lib/index.js

@@ -24,7 +24,7 @@ function issues(register) {
     return Library;
 }
 
-const Oops$8 = issues({
+const Oops$9 = 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;
@@ -53,7 +53,7 @@ function createEffect(callback) {
         if (unSet instanceof Promise)
             unSet = undefined;
         if (unSet && typeof unSet !== "function")
-            throw Oops$8.BadEffectCallback();
+            throw Oops$9.BadEffectCallback();
     };
 }
 function createValueEffect(callback) {
@@ -69,7 +69,7 @@ function createValueEffect(callback) {
         if (typeof out == "function")
             unSet = out;
         else
-            throw Oops$8.BadEffectCallback();
+            throw Oops$9.BadEffectCallback();
     };
 }
 function select(source, select) {
@@ -92,6 +92,179 @@ function selectRecursive(using, keys) {
     return Array.from(found);
 }
 
+class Subscriber {
+    constructor(parent, onUpdate) {
+        this.onUpdate = onUpdate;
+        this.active = false;
+        this.follows = {};
+        this.dependant = new Set();
+        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, 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
+        });
+    }
+    follow(key, cb) {
+        this.follows[key] = cb || this.onUpdate;
+    }
+    commit() {
+        const { dependant, follows, parent } = this;
+        const onDone = parent.addListener(follows);
+        this.active = true;
+        dependant.forEach(x => x.commit());
+        return this.release = () => {
+            dependant.forEach(x => x.release());
+            onDone();
+        };
+    }
+}
+
+const Oops$8 = 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 ComputedUsed = new WeakMap();
+const ComputedKeys = new WeakMap();
+function prepare(parent, key, source, setter, getter) {
+    let sub;
+    const { state, subject } = parent;
+    const info = { key, parent, priority: 1 };
+    const current = getter
+        ? () => getter.call(subject, state[key], key)
+        : () => state[key];
+    const prioritize = register(parent, key, info);
+    function compute(initial) {
+        try {
+            return setter.call(sub.proxy, sub.proxy);
+        }
+        catch (err) {
+            Oops$8.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) {
+                parent.update(key, value);
+                return value;
+            }
+        }
+    }
+    function create(early) {
+        sub = new Subscriber(source(), update);
+        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$8.ComputedEarly(key).warn();
+            throw e;
+        }
+        finally {
+            sub.commit();
+            for (const key in sub.follows)
+                prioritize(key);
+        }
+        return current();
+    }
+    setAlias(update, `try ${key}`);
+    setAlias(create, `new ${key}`);
+    setAlias(setter, `run ${key}`);
+    ComputedInit.add(create);
+    ComputedInfo.set(update, info);
+    for (const on of [state, subject])
+        defineProperty(on, key, {
+            get: create,
+            configurable: true,
+            enumerable: true
+        });
+}
+function register(on, key, info) {
+    let register = ComputedUsed.get(on);
+    if (!register)
+        ComputedUsed.set(on, register = new Map());
+    register.set(key, info);
+    return (key) => {
+        const peer = register.get(key);
+        if (peer && peer.priority >= info.priority)
+            info.priority = peer.priority + 1;
+    };
+}
+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 Lifecycle = {
     WILL_RENDER: "willRender",
     WILL_UPDATE: "willUpdate",
@@ -140,16 +313,27 @@ function eventsFor(prefix) {
 }
 
 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);
+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 {
@@ -161,14 +345,10 @@ class Controller {
         this.waiting = [];
     }
     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;
@@ -273,210 +453,78 @@ function keys(from, using) {
     return from.select(using);
 }
 
-class Subscriber {
-    constructor(parent, onUpdate) {
-        this.onUpdate = onUpdate;
-        this.active = false;
-        this.follows = {};
-        this.dependant = new Set();
-        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, 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
-        });
-    }
-    follow(key, cb) {
-        this.follows[key] = cb || this.onUpdate;
-    }
-    commit() {
-        const { dependant, follows, parent } = this;
-        const onDone = parent.addListener(follows);
-        this.active = true;
-        dependant.forEach(x => x.commit());
-        return this.release = () => {
-            dependant.forEach(x => x.release());
-            onDone();
+function child(from, name) {
+    return apply(function child(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$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.`
+    HasPropertyUndefined: (control, property) => `${control}.${property} is marked as required for this render.`
 });
-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;
+const useElementLifecycle = lifecycle("element");
+function use$1(init) {
+    const [state, update] = react.useState(() => [
+        init(() => update(state.concat()))
+    ]);
+    return state[0];
 }
-function prepare(control, key, getter, getSource) {
-    const { state, subject } = control;
-    const defined = getRegister(control);
-    const info = {
-        key, parent: control, 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;
-        }
-    }
-    function update() {
-        let value;
-        try {
-            value = compute(false);
-        }
-        catch (e) {
-            console.error(e);
-        }
-        finally {
-            if (state[key] !== value) {
-                control.update(key, value);
-                return value;
-            }
-        }
-    }
-    function create(early) {
-        sub = new Subscriber(getSource(), update);
-        ComputedInfo.set(update, info);
-        defineProperty(state, key, {
-            value: undefined,
-            writable: true
-        });
-        defineProperty(subject, key, {
-            enumerable: true,
-            configurable: true,
-            get: () => state[key]
-        });
-        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;
-            }
-        }
-    }
-    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,
-            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);
-    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({
-    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$6.HasPropertyUndefined(target, key);
-                    return src[key];
-                }
-            });
+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$7.HasPropertyUndefined(target, key);
+                    return src[key];
+                }
+            });
         }
         return sub;
     });
@@ -506,6 +554,56 @@ function useModel(Type, args, callback) {
     return hook.proxy;
 }
 
+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 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 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 Lookup {
     constructor() {
         this.table = new Map();
@@ -632,62 +730,73 @@ function Provider(props) {
 }
 
 const Oops$4 = 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, argument) => attach(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$4.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$4.AmbientRequired(type.name, from, 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);
-}
-function getPending(subject) {
-    let pending = PendingContext.get(subject);
-    if (!pending)
-        PendingContext.set(subject, pending = []);
-    return pending;
-}
-
-const Oops$3 = 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 {
+const useComponentLifecycle = lifecycle("component");
+class Model {
     constructor() {
-        Controller.setup(this);
+        const control = Controller.setup(this);
         define(this, "get", this);
         define(this, "set", this);
+        defer(control, "on");
+        defer(control, "effect");
+        control.include(() => {
+            delete this.on;
+            delete this.effect;
+        });
+    }
+    tap(path, expect) {
+        const proxy = useWatcher(this, path, expect);
+        this.update("willRender", true);
+        return proxy;
+    }
+    tag(id) {
+        return useSubscriber(this, id);
+    }
+    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, 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))
@@ -707,15 +816,18 @@ class State {
             arg = select(this, arg);
         if (typeof arg == "boolean") {
             if (!control.pending === arg)
-                return Promise.reject(Oops$3.StrictUpdate(arg));
+                return Promise.reject(Oops$4.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]();
+            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) {
@@ -725,7 +837,7 @@ class State {
                     else
                         callback(false);
                 else
-                    throw Oops$3.NoChaining();
+                    throw Oops$4.NoChaining();
             }
         };
     }
@@ -735,28 +847,14 @@ class State {
     toString() {
         return this.constructor.name;
     }
-    tap(path, expect) {
-        return useWatcher(this, path, expect);
-    }
     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);
-    }
-    static uses(props, only) {
-        return this.use([], instance => {
-            instance.import(props, only);
-        });
-    }
-    static using(props, only) {
-        const instance = this.use([]);
-        instance.import(props, only);
+        const instance = useLazy(this, args, callback);
+        instance.update("willRender", true);
         return instance;
     }
     static find(strict) {
@@ -771,74 +869,10 @@ class State {
                 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 {
-    [CREATE](using) {
-        defer(using, "on");
-        defer(using, "effect");
-        return () => {
-            delete this.on;
-            delete this.effect;
-        };
+        return this.find(true).tap(key, expect);
     }
-    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, 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();
-        }
-    }
-    tag(id) {
-        return useSubscriber(this, id);
+    static tag(id) {
+        return this.find(true).tag(id);
     }
     static use(args, callback) {
         const instance = useModel(this, args, callback);
@@ -846,13 +880,27 @@ class Model extends State {
         usePeerContext(instance.get);
         return instance;
     }
-    static tag(id) {
-        return useSubscriber(this.find(true), id);
+    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 isTypeof(maybe) {
+        return (typeof maybe == "function" &&
+            maybe.prototype instanceof this);
+    }
 }
+Model.CONTROL = CONTROL;
+Model.STATE = STATE;
+Model.LOCAL = LOCAL;
 defineLazy(Model, CONTROL, function () {
     return new Controller(this).start();
 });
@@ -868,194 +916,218 @@ function defer(on, method) {
     };
 }
 
+const Parent = new WeakMap();
+const Oops$3 = 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}.`
+});
+function bootstrap(object) {
+    const breakdown = getOwnPropertyDescriptors(object);
+    const control = new Model();
+    for (const key in breakdown)
+        defineProperty(control, key, breakdown[key]);
+    return control;
+}
+function use(input, argument) {
+    return child(function use(key) {
+        let instance;
+        const update = (next) => {
+            instance =
+                next instanceof Model ? next :
+                    next && bootstrap(next);
+            if (instance) {
+                Parent.set(instance, this.subject);
+                manage(instance);
+            }
+            if (typeof argument == "function")
+                argument(instance);
+            else if (!instance && argument !== false)
+                throw Oops$3.UndefinedNotAllowed(key);
+        };
+        if (input) {
+            instance =
+                Model.isTypeof(input) ? new input() :
+                    input instanceof Model ? input :
+                        typeof input === "function" ? input() :
+                            typeof input === "object" ? bootstrap(input) :
+                                Oops$3.BadArgument(typeof input).throw();
+            if (instance)
+                update(instance);
+        }
+        else
+            argument = false;
+        this.manage(key, instance, update);
+        return () => instance;
+    });
+}
+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$3.ParentRequired(expected, child);
+        }
+        else if (!(value instanceof Expects))
+            throw Oops$3.UnexpectedParent(expected, child, value);
+        return { value };
+    });
+}
+
 const Oops$2 = 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.'
+    PeerNotAllowed: (model, property) => `Attempted to use an instruction result (probably use or tap) as computed source for ${model}.${property}. This is not possible.`
 });
-const set = (fn, name) => does(function set(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);
-}, name || fn.name || "pending");
-const ref = (cb) => set(function ref(key) {
+function createRef(key, cb) {
     const refObjectFunction = this.setter(key, cb && createValueEffect(cb));
     defineProperty(refObjectFunction, "current", {
         set: refObjectFunction,
         get: () => this.state[key]
     });
-    return {
-        value: refObjectFunction
-    };
-});
-const on = (initial, cb) => set(function on(key) {
-    this.manage(key, initial, cb && createValueEffect(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]
+    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 };
     });
-});
-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;
+}
+function on(initial, cb) {
+    return apply(function on(key) {
+        this.manage(key, initial, cb && createValueEffect(cb));
+    });
+}
+function memo(factory, defer) {
+    return apply(function memo(key) {
+        const source = this.subject;
+        const get = () => factory.call(source);
+        if (defer)
+            defineLazy(source, key, get);
+        else
+            define(source, key, get());
+    });
+}
+function lazy(value) {
+    return apply(function lazy(key) {
+        const source = this.subject;
+        source[key] = value;
+        defineProperty(this.state, key, {
+            get: () => source[key]
+        });
+    });
+}
+function act(task) {
+    return apply(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
         });
-    };
-    setAlias(invoke, `run ${key}`);
-    defineProperty(invoke, "active", {
-        get: () => pending
+        return {
+            value: invoke,
+            writable: false
+        };
     });
-    return {
-        value: invoke,
-        writable: false
-    };
-});
-function from(source, fn) {
-    return set(function from(key) {
+}
+function from(source, setter, getter) {
+    return apply(function from(key) {
         const { subject } = this;
-        let getter;
-        let getSource = () => this;
-        // Easy mistake, using a peer - will always be unresolved.
+        let getSource;
+        // Easy mistake, using a peer, will always be unresolved.
         if (typeof source == "symbol")
             throw Oops$2.PeerNotAllowed(subject, key);
-        if (typeof source == "object") {
-            getter = fn;
-            // replace source controller incase different
-            getSource = () => source[CONTROL];
+        // 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;
         }
-        // is an arrow function (getter factory)
-        else if (!source.prototype)
-            getter = source(key);
         // is a peer Model (constructor)
-        else if (Model.isTypeof(source)) {
-            getter = fn;
+        else if (Model.isTypeof(source))
             getSource = pendingAccess(subject, source, key, true);
-        }
-        // Vanilla function is to ambiguous so not allowed.
+        // Regular function is to ambiguous so not allowed.
         else
             throw Oops$2.BadComputedSource(subject, key, source);
-        prepare(this, key, getter, getSource);
+        prepare(this, key, getSource, setter, 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 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}.`
+    ValueNotReady: (model, key) => `Value ${model}.${key} value is not yet available.`
 });
-function bootstrap(object) {
-    const breakdown = getOwnPropertyDescriptors(object);
-    const control = new Model();
-    for (const key in breakdown)
-        defineProperty(control, key, breakdown[key]);
-    return control;
+/**
+ * Create suspense promise also interpretable as an error.
+ * React will handle it but other contexts probably won't.
+ */
+function suspense(model, key) {
+    const { message, stack } = Oops$1.ValueNotReady(model, key);
+    const promise = new Promise(resolve => {
+        const release = model.on(key, (value) => {
+            if (value !== undefined)
+                release(), resolve();
+        });
+    });
+    return Object.assign(promise, { message, stack });
 }
-const use = (input, argument) => attach(function use(key) {
-    let instance;
-    const update = (next) => {
-        instance =
-            next instanceof Model ? next :
-                next && bootstrap(next);
-        if (instance) {
-            Parent.set(instance, this.subject);
-            manage(instance);
-        }
-        if (typeof argument == "function")
-            argument(instance);
-        else if (!instance && argument !== false)
-            throw Oops$1.UndefinedNotAllowed(key);
-    };
-    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);
-    }
+function pending(source, compute) {
+    if (typeof source == "function" && !source.prototype)
+        return suspendForAsync(source);
     else
-        argument = false;
-    this.manage(key, instance, update);
-    return () => instance;
-});
-const parent = (Expects, required) => set(function parent() {
-    const child = this.subject;
-    const expected = Expects.name;
-    const value = Parent.get(this.subject);
-    if (!value) {
-        if (required)
-            throw Oops$1.ParentRequired(expected, child);
-    }
-    else if (!(value instanceof Expects))
-        throw Oops$1.UnexpectedParent(expected, child, value);
-    return { value };
-});
+        return from(source, compute, function getter(value, key) {
+            if (value === undefined)
+                throw suspense(this, key);
+            return value;
+        });
+}
+function suspendForAsync(source) {
+    return apply(function suspense(key) {
+        let waiting = true;
+        let output;
+        let error;
+        return () => {
+            if (waiting) {
+                const issue = Oops$1.ValueNotReady(this.subject, key);
+                const promise = source
+                    .call(this.subject, key)
+                    .catch(err => error = err)
+                    .then((value) => output = value)
+                    .finally(() => waiting = false);
+                throw Object.assign(promise, {
+                    message: issue.message,
+                    stack: issue.stack
+                });
+            }
+            if (error)
+                throw error;
+            return output;
+        };
+    });
+}
 
 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.`,
@@ -1102,16 +1174,16 @@ exports.Consumer = Consumer;
 exports.Model = Model;
 exports.Provider = Provider;
 exports.Singleton = Singleton;
-exports.State = State;
 exports.act = act;
-exports.attach = attach;
+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.set = set;
 exports.tap = tap;
 exports.use = use;