@expressive/mvc 1.0.0-beta.25 → 1.0.0-beta.29

package/lib/index.esm.js

@@ -20,7 +20,7 @@ function issues(register) {
     return Library;
 }
 
-const Oops$9 = issues({
+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;
@@ -49,7 +49,7 @@ function createEffect(callback) {
         if (unSet instanceof Promise)
             unSet = undefined;
         if (unSet && typeof unSet !== "function")
-            throw Oops$9.BadEffectCallback();
+            throw Oops$8.BadEffectCallback();
     };
 }
 function createValueEffect(callback) {
@@ -65,7 +65,7 @@ function createValueEffect(callback) {
         if (typeof out == "function")
             unSet = out;
         else
-            throw Oops$9.BadEffectCallback();
+            throw Oops$8.BadEffectCallback();
     };
 }
 function select(source, select) {
@@ -92,14 +92,34 @@ class Subscriber {
     constructor(parent, onUpdate) {
         this.onUpdate = onUpdate;
         this.active = false;
-        this.follows = {};
+        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);
     }
@@ -119,43 +139,47 @@ class Subscriber {
             enumerable: true
         });
     }
-    follow(key, cb) {
-        this.follows[key] = cb || this.onUpdate;
+    follow(key, callback) {
+        this.handle[key] = callback || true;
     }
     commit() {
-        const { dependant, follows, parent } = this;
-        const onDone = parent.addListener(follows);
+        const onDone = this.parent.addListener(this.listen);
         this.active = true;
-        dependant.forEach(x => x.commit());
+        this.dependant.forEach(x => x.commit());
         return this.release = () => {
-            dependant.forEach(x => x.release());
+            this.dependant.forEach(x => x.release());
             onDone();
         };
     }
 }
 
-const Oops$8 = issues({
+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 ComputedInit = new WeakSet();
-const ComputedInfo = new WeakMap();
-const ComputedUsed = new WeakMap();
-const ComputedKeys = new WeakMap();
+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];
-    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();
+            Oops$7.ComputeFailed(subject, key, !!initial).warn();
             throw err;
         }
     }
@@ -174,8 +198,19 @@ function prepare(parent, key, source, setter, getter) {
             }
         }
     }
+    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);
+        }
+    }
     function create(early) {
-        sub = new Subscriber(source(), update);
+        sub = new Subscriber(source(), defer);
         defineProperty(state, key, {
             value: undefined,
             writable: true
@@ -190,21 +225,24 @@ function prepare(parent, key, source, setter, getter) {
         }
         catch (e) {
             if (early)
-                Oops$8.ComputedEarly(key).warn();
+                Oops$7.ComputedEarly(key).warn();
             throw e;
         }
         finally {
             sub.commit();
-            for (const key in sub.follows)
-                prioritize(key);
+            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}`);
-    ComputedInit.add(create);
-    ComputedInfo.set(update, info);
+    INIT.add(create);
+    INFO.set(update, info);
     for (const on of [state, subject])
         defineProperty(on, key, {
             get: create,
@@ -212,53 +250,27 @@ function prepare(parent, key, source, setter, getter) {
             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))
+        if (INIT.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 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 = {
@@ -309,6 +321,7 @@ function eventsFor(prefix) {
 }
 
 const CONTROL = Symbol("control");
+const UPDATE = Symbol("update");
 const LOCAL = Symbol("local");
 const STATE = Symbol("state");
 function manage(src) {
@@ -337,8 +350,8 @@ class Controller {
         this.subject = subject;
         this.state = {};
         this.frame = new Set();
-        this.handles = new Set();
-        this.waiting = [];
+        this.waiting = new Set();
+        this.followers = new Set();
     }
     static setup(onto) {
         const control = new this(onto);
@@ -404,18 +417,12 @@ class Controller {
             this.update(key, value);
         };
     }
-    addListener(batch) {
-        this.handles.add(batch);
+    addListener(listener) {
+        this.followers.add(listener);
         return () => {
-            this.handles.delete(batch);
+            this.followers.delete(listener);
         };
     }
-    include(to) {
-        if (capture(this, to))
-            return;
-        else
-            this.waiting.push(to);
-    }
     update(key, value) {
         if (1 in arguments)
             this.state[key] = value;
@@ -424,15 +431,22 @@ class Controller {
         if (!this.frame.size)
             setTimeout(() => this.emit(), 0);
         this.frame.add(key);
-        for (const subscription of this.handles)
-            if (key in subscription)
-                this.include(subscription[key]);
+        for (const subscription of this.followers) {
+            const notify = subscription(key, this);
+            if (notify)
+                this.waiting.add(notify);
+        }
     }
     emit() {
         flush(this);
-        const keys = Array.from(this.frame);
-        const handle = new Set(this.waiting.splice(0));
+        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);
@@ -444,104 +458,52 @@ class Controller {
 function keys(from, using) {
     if (typeof using == "string")
         return [using];
-    if (typeof using == "object")
-        return Array.from(using);
+    if (typeof using == "object") {
+        using = Array.from(using);
+        if (using.length === 0)
+            using = undefined;
+        else
+            return using;
+    }
     return from.select(using);
 }
 
-function child(from, name) {
+function child(source, name) {
     return apply(function child(key) {
-        const proxyCache = new WeakMap();
-        const getCurrent = from.call(this, key);
+        const context = new WeakMap();
+        const current = source.call(this, key);
         function subscribe(sub) {
             let child;
             function start() {
-                const instance = getCurrent();
+                const instance = current();
                 if (instance) {
                     child = new Subscriber(instance, sub.onUpdate);
                     if (sub.active)
                         child.commit();
                     sub.dependant.add(child);
-                    proxyCache.set(sub, child.proxy);
+                    context.set(sub, child.proxy);
                 }
             }
-            function refresh() {
+            function restart() {
                 if (child) {
                     child.release();
                     sub.dependant.delete(child);
-                    proxyCache.set(sub, undefined);
+                    context.set(sub, undefined);
                     child = undefined;
                 }
                 start();
-                sub.onUpdate();
             }
             start();
-            sub.follow(key, refresh);
+            sub.follow(key, restart);
         }
         return (local) => {
             if (!local)
-                return getCurrent();
-            if (!proxyCache.has(local))
+                return current();
+            if (!context.has(local))
                 subscribe(local);
-            return proxyCache.get(local);
+            return context.get(local);
         };
-    }, name || from.name);
-}
-
-const Oops$7 = issues({
-    HasPropertyUndefined: (control, property) => `${control}.${property} is marked as required for this render.`
-});
-function use$1(init) {
-    const [state, update] = useState(() => [
-        init(() => update(state.concat()))
-    ]);
-    return state[0];
-}
-function useLazy(Type, callback) {
-    const instance = useMemo(() => {
-        const instance = Type.create();
-        if (callback)
-            callback(instance);
-        return instance;
-    }, []);
-    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;
-    });
-    useLayoutEffect(() => hook.commit(), []);
-    return hook.proxy;
-}
-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({
-            [Lifecycle.WILL_UNMOUNT]() {
-                instance.destroy();
-                release();
-            }
-        });
-        if (callback)
-            callback(instance);
-        return sub;
-    });
-    return hook.proxy;
+    }, name || source.name);
 }
 
 const Oops$6 = issues({
@@ -594,6 +556,219 @@ function getPending(subject) {
     return pending;
 }
 
+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);
+            });
+        };
+        setAlias(invoke, `run ${key}`);
+        defineProperty(invoke, "active", {
+            get: () => pending
+        });
+        return {
+            value: invoke,
+            writable: false
+        };
+    });
+}
+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;
+        }
+        // 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
+    });
+}
+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 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] = useState(() => [
+        init(() => update(state.concat()))
+    ]);
+    return state[0];
+}
+function useLazy(Type, callback) {
+    const instance = useMemo(() => {
+        const instance = Type.create();
+        if (callback)
+            callback(instance);
+        return instance;
+    }, []);
+    useLayoutEffect(() => () => instance.destroy(), []);
+    return instance;
+}
+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;
+    });
+    useLayoutEffect(() => hook.commit(), []);
+    return hook.proxy;
+}
+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;
+    });
+    return hook.proxy;
+}
+
 class Lookup {
     constructor() {
         this.table = new Map();
@@ -649,7 +824,7 @@ class Lookup {
     }
 }
 
-const Oops$5 = issues({
+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.`
@@ -659,7 +834,7 @@ const useLookup = () => useContext(LookupContext);
 function useFromContext(Type, strict) {
     const instance = useLookup().get(Type);
     if (!instance && strict)
-        throw Oops$5.NothingInContext(Type.name);
+        throw Oops$3.NothingInContext(Type.name);
     return instance;
 }
 function Consumer(props) {
@@ -670,13 +845,13 @@ function Consumer(props) {
     if (typeof callback == "function")
         callback(Control.get(!!has));
     else
-        throw Oops$5.BadConsumerProps();
+        throw Oops$3.BadConsumerProps();
     return null;
 }
 function useNewContext(from, inject) {
     return useMemo(() => {
         if (!inject)
-            throw Oops$5.NoProviderType();
+            throw Oops$3.NoProviderType();
         const context = from.push(inject);
         for (const instance of context.local)
             for (const apply of getPending(instance))
@@ -701,7 +876,7 @@ function RenderFunction(props) {
     const hook = use$1(refresh => {
         const targets = props.context.local;
         if (targets.length == 1)
-            return new Subscriber(targets[0], refresh);
+            return new Subscriber(targets[0], () => refresh);
         return {};
     });
     if (hook.commit)
@@ -719,7 +894,7 @@ function Provider(props) {
         : render);
 }
 
-const Oops$4 = issues({
+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.`
 });
@@ -732,7 +907,7 @@ class Model {
         define(this, "set", this);
         defer(control, "on");
         defer(control, "effect");
-        control.include(() => {
+        control.waiting.add(() => {
             delete this.on;
             delete this.effect;
         });
@@ -744,7 +919,7 @@ class Model {
     }
     tag(id) {
         const hook = use$1(refresh => {
-            return new Subscriber(this, refresh);
+            return new Subscriber(this, () => refresh);
         });
         useElementLifecycle(hook, id || 0);
         return hook.proxy;
@@ -753,29 +928,27 @@ class Model {
         const hook = use$1(refresh => {
             if (callback)
                 callback(this);
-            return new Subscriber(this, refresh);
+            return new Subscriber(this, () => refresh);
         });
         useComponentLifecycle(hook);
         return hook.proxy;
     }
     on(subset, handler, squash, once) {
         const control = manage(this);
-        const set = keys(control, subset);
-        const batch = {};
-        const remove = control.addListener(batch);
+        const request = keys(control, subset);
         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); }
+            : frame => frame
+                .filter(k => request.includes(k))
+                .forEach(k => handler.call(this, control.state[k], k));
+        const trigger = once
+            ? frame => { remove(); callback(frame); }
             : callback;
-        for (const key of set)
-            batch[key] = handle;
-        ensure(control, set);
+        ensure(control, request);
+        const remove = control.addListener(key => {
+            if (request.includes(key))
+                return trigger;
+        });
         return remove;
     }
     once(select, callback, squash) {
@@ -796,7 +969,7 @@ class Model {
             return this.on(select, invoke, true);
         }
         else {
-            const sub = new Subscriber(control, invoke);
+            const sub = new Subscriber(control, () => invoke);
             target = sub.proxy;
             invoke();
             return sub.commit();
@@ -820,7 +993,7 @@ class Model {
             arg = select(this, arg);
         if (typeof arg == "boolean") {
             if (!control.pending === arg)
-                return Promise.reject(Oops$4.StrictUpdate(arg));
+                return Promise.reject(Oops$2.StrictUpdate(arg));
         }
         else if (arg) {
             control.update(arg);
@@ -837,11 +1010,11 @@ class Model {
             then(callback) {
                 if (callback)
                     if (control.pending)
-                        control.include(callback);
+                        control.waiting.add(callback);
                     else
                         callback(false);
                 else
-                    throw Oops$4.NoChaining();
+                    throw Oops$2.NoChaining();
             }
         };
     }
@@ -905,6 +1078,7 @@ class Model {
 Model.CONTROL = CONTROL;
 Model.STATE = STATE;
 Model.LOCAL = LOCAL;
+Model.WHY = UPDATE;
 defineLazy(Model, CONTROL, function () {
     return new Controller(this).start();
 });
@@ -913,7 +1087,7 @@ function defer(on, method) {
     const real = subject[method];
     subject[method] = (...args) => {
         let done;
-        waiting.push(() => {
+        waiting.add(() => {
             done = real.apply(subject, args);
         });
         return () => done();
@@ -921,7 +1095,7 @@ function defer(on, method) {
 }
 
 const Parent = new WeakMap();
-const Oops$3 = issues({
+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.`,
@@ -946,7 +1120,7 @@ function use(input, argument) {
         let current;
         const onUpdate = (next, initial) => {
             if (mode === true && !initial)
-                throw Oops$3.IsReadOnly(subject, key);
+                throw Oops$1.IsReadOnly(subject, key);
             if (next) {
                 current = next instanceof Model
                     ? next : bootstrap(next);
@@ -954,7 +1128,7 @@ function use(input, argument) {
                 manage(current);
             }
             else if (mode === undefined)
-                throw Oops$3.UndefinedNotAllowed(key);
+                throw Oops$1.UndefinedNotAllowed(key);
             else
                 current = undefined;
             if (typeof argument == "function")
@@ -966,11 +1140,11 @@ function use(input, argument) {
                     input instanceof Model ? input :
                         typeof input === "function" ? input() :
                             typeof input === "object" ? bootstrap(input) :
-                                Oops$3.BadArgument(typeof input).throw();
+                                Oops$1.BadArgument(typeof input).throw();
             if (current)
                 mode = onUpdate(current, true) || mode;
             else if (mode == true)
-                throw Oops$3.MustBeDefined(subject, key);
+                throw Oops$1.MustBeDefined(subject, key);
         }
         else
             mode = false;
@@ -985,40 +1159,14 @@ function parent(Expects, required) {
         const value = Parent.get(this.subject);
         if (!value) {
             if (required)
-                throw Oops$3.ParentRequired(expected, child);
+                throw Oops$1.ParentRequired(expected, child);
         }
         else if (!(value instanceof Expects))
-            throw Oops$3.UnexpectedParent(expected, child, value);
+            throw Oops$1.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.`
-});
-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 on(initial, cb) {
     return apply(function on(key) {
         this.manage(key, initial, cb && createValueEffect(cb));
@@ -1042,132 +1190,6 @@ function lazy(value) {
             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
-        });
-        return {
-            value: invoke,
-            writable: false
-        };
-    });
-}
-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$2.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;
-        }
-        // 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$2.BadComputedSource(subject, key, source);
-        prepare(this, key, getSource, setter, getter);
-    });
-}
-
-const Oops$1 = 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)
-        return value;
-    const error = Oops$1.ValueNotReady(via.subject, key);
-    const promise = new Promise(resolve => {
-        const release = via.addListener({
-            [key](value) {
-                if (value !== undefined) {
-                    release();
-                    resolve();
-                }
-            }
-        });
-    });
-    throw Object.assign(promise, {
-        toString: () => String(error),
-        message: error.message,
-        stack: error.stack
-    });
-}
-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 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$1.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
-            });
-        };
-    });
 }
 
 const Oops = issues({