@expressive/mvc 1.0.0-beta.42 → 1.0.0-beta.45

package/lib/index.js

@@ -25,7 +25,7 @@ function issues(register) {
     return Library;
 }
 
-const Oops$d = issues({
+const Oops$c = issues({
     BadEffectCallback: () => `Callback for effect-callback may only return a function.`
 });
 const { assign, create, defineProperty, entries, getPrototypeOf, getOwnPropertyNames, getOwnPropertyDescriptor, getOwnPropertySymbols, values } = Object;
@@ -42,9 +42,6 @@ function defineLazy(object, property, init) {
         }
     });
 }
-function setAlias(func, displayName) {
-    assign(func, { displayName });
-}
 function createEffect(callback) {
     let unSet;
     return function (value) {
@@ -54,7 +51,7 @@ function createEffect(callback) {
         if (unSet instanceof Promise)
             unSet = undefined;
         if (unSet && typeof unSet !== "function")
-            throw Oops$d.BadEffectCallback();
+            throw Oops$c.BadEffectCallback();
     };
 }
 function createValueEffect(callback) {
@@ -70,8 +67,28 @@ function createValueEffect(callback) {
         if (typeof out == "function")
             unSet = out;
         else
-            throw Oops$d.BadEffectCallback();
+            throw Oops$c.BadEffectCallback();
+    };
+}
+function suspenseBoundary(fn) {
+    const retry = (err) => {
+        if (err instanceof Promise)
+            return err.then(compute);
+        else
+            throw err;
+    };
+    const compute = () => {
+        try {
+            const output = fn();
+            return output instanceof Promise
+                ? output.catch(retry)
+                : output;
+        }
+        catch (err) {
+            return retry(err);
+        }
     };
+    return compute();
 }
 
 const UPDATE = new WeakMap();
@@ -84,174 +101,148 @@ function applyUpdate(subject, keys) {
     };
 }
 
-const Oops$c = issues({
-    StrictUpdate: (expected) => `Strict update() did ${expected ? "not " : ""}find pending updates.`,
-    NoChaining: () => `Then called with undefined; update promise will never catch nor supports chaining.`
-});
-const READY = new WeakSet();
-class Controller {
-    constructor(subject) {
-        this.subject = subject;
-        this.state = {};
-        this.frame = new Set();
-        this.waiting = new Set();
-        this.onDestroy = new Set();
-        this.followers = new Set();
-        this.proxy = Object.create(subject);
+const CONTROL = Symbol("CONTROL");
+const WHY = Symbol("UPDATE");
+const LOCAL = Symbol("LOCAL");
+const STATE = Symbol("STATE");
+class Model {
+    constructor() {
+        define(this, CONTROL, new Controller(this));
+        define(this, "get", this);
+        define(this, "set", this);
     }
-    start() {
-        for (const key in this.subject)
-            this.manage(key);
-        this.emit([]);
+    get [STATE]() {
+        return this[CONTROL].state;
     }
-    stop() {
-        this.followers.clear();
-        this.onDestroy.forEach(x => x());
+    get [WHY]() {
+        return UPDATE.get(this);
     }
-    manage(key) {
-        const { proxy, state, subject } = this;
-        const { value: entry } = getOwnPropertyDescriptor(subject, key);
-        if (typeof entry == "function")
-            return;
-        let onGet;
-        let onSet;
-        let enumerable;
-        const instruction = Pending.get(entry);
-        if (instruction) {
-            Pending.delete(entry);
-            delete subject[key];
-            const desc = instruction.call(this, key, this);
-            if (desc === false)
-                return;
-            if (typeof desc == "object") {
-                if ("value" in desc)
-                    state[key] = desc.value;
-                onSet = desc.set;
-                onGet = desc.get;
-                enumerable = desc.enumerable;
-            }
-        }
-        else
-            state[key] = entry;
-        const set = onSet !== false
-            ? this.ref(key, onSet)
-            : undefined;
-        function get() {
-            const local = this[LOCAL];
-            const value = state[key];
-            if (local && !local.watch[key])
-                local.watch[key] = true;
-            return onGet ? onGet(value, local) : value;
-        }
-        setAlias(get, `tap ${key}`);
-        defineProperty(subject, key, {
-            enumerable,
-            set,
-            get: onGet
-                ? () => onGet(state[key])
-                : () => state[key]
-        });
-        defineProperty(proxy, key, {
-            enumerable,
-            set,
-            get
+    on(select, handler, squash, once) {
+        return control(this, control => {
+            if (typeof select == "function")
+                return control.addListener(select);
+            const keys = typeof select == "string" ? [select] :
+                !select.length ? getOwnPropertyNames(control.state) :
+                    select;
+            ensure(control, keys);
+            const callback = squash
+                ? handler.bind(this)
+                : frame => frame
+                    .filter(k => keys.includes(k))
+                    .forEach(k => handler.call(this, control.state[k], k));
+            const trigger = once
+                ? frame => { remove(); callback(frame); }
+                : callback;
+            const remove = control.addListener(key => {
+                if (keys.includes(key))
+                    return trigger;
+            });
+            return remove;
         });
     }
-    ref(key, handler) {
-        const { state, subject } = this;
-        return (value) => {
-            if (state[key] == value)
-                return;
-            if (handler)
-                switch (handler.call(subject, value, state)) {
-                    case true:
-                        this.update(key);
-                    case false:
-                        return;
-                }
-            this.update(key, value);
-        };
-    }
-    addListener(listener) {
-        this.followers.add(listener);
-        return () => {
-            this.followers.delete(listener);
-        };
+    once(select, callback, squash) {
+        if (callback)
+            return this.on(select, callback, squash, true);
+        return new Promise(resolve => {
+            this.on(select, resolve, true, true);
+        });
     }
-    emit(keys) {
-        const waiting = [...this.waiting];
-        this.waiting.clear();
-        applyUpdate(this.subject, keys)();
-        for (const callback of waiting)
-            try {
-                callback(keys);
+    effect(callback, select) {
+        const effect = createEffect(callback);
+        return control(this, control => {
+            if (!select) {
+                const sub = new Subscriber(control, () => invoke);
+                const invoke = () => {
+                    const x = sub.proxy;
+                    effect.call(x, x);
+                };
+                invoke();
+                return sub.commit();
             }
-            catch (err) {
-                console.error(err);
+            const invoke = () => {
+                effect.call(this.get, this.get);
+            };
+            invoke();
+            if (!select.length) {
+                control.onDestroy.add(invoke);
+                return () => {
+                    control.onDestroy.delete(invoke);
+                };
             }
+            return control.addListener(key => {
+                if (select.includes(key))
+                    return invoke;
+            });
+        });
     }
-    update(key, value) {
-        if (1 in arguments)
-            this.state[key] = value;
-        if (this.frame.has(key))
-            return;
-        if (!this.frame.size)
-            setTimeout(() => {
-                flush(this);
-                const keys = Object.freeze([...this.frame]);
-                this.frame.clear();
-                this.emit(keys);
-            }, 0);
-        this.frame.add(key);
-        for (const callback of this.followers) {
-            const event = callback(key, this);
-            if (typeof event == "function")
-                this.waiting.add(event);
-        }
+    // TODO: account for exotic properties
+    import(source, select) {
+        const { subject } = control(this);
+        if (!select)
+            select = getOwnPropertyNames(subject);
+        for (const key of select)
+            if (key in source)
+                this[key] = source[key];
     }
-    requestUpdate(arg) {
-        if (typeof arg == "function") {
-            this.waiting.add(arg);
-            return;
-        }
-        if (typeof arg == "boolean" && arg !== this.frame.size > 0)
-            return Promise.reject(Oops$c.StrictUpdate(arg));
-        return {
-            then: (callback) => {
-                if (callback)
-                    if (this.frame.size)
-                        this.waiting.add(callback);
-                    else
-                        callback(false);
-                else
-                    throw Oops$c.NoChaining();
+    export(subset) {
+        const { state } = control(this);
+        const output = {};
+        if (!subset)
+            subset = getOwnPropertyNames(state);
+        for (const key of subset)
+            output[key] = state[key];
+        return output;
+    }
+    update(arg, tag) {
+        const target = control(this);
+        if (typeof arg == "string") {
+            target.update(arg);
+            if (1 in arguments && arg in this) {
+                const method = this[arg];
+                if (typeof method == "function")
+                    if (typeof tag != "boolean")
+                        method.call(this, tag);
+                    else if (tag)
+                        method.call(this);
             }
-        };
+            arg = undefined;
+        }
+        return target.requestUpdate(arg);
     }
-}
-function control(subject, cb) {
-    let control = subject[CONTROL];
-    const ready = READY.has(control);
-    if (!control) {
-        control = new Controller(subject);
-        define(subject, CONTROL, control);
+    /**
+     * Mark this instance for garbage-collection and send `willDestroy` event to all listeners.
+     */
+    destroy() {
+        control(this).stop();
     }
-    if (!cb) {
-        if (!ready) {
-            READY.add(control);
-            control.start();
-        }
-        return control;
+    toString() {
+        return this.constructor.name;
     }
-    if (!ready) {
-        let done;
-        control.requestUpdate(() => {
-            done = cb(control);
-        });
-        return () => done && done();
+    /**
+     * Creates a new instance of this controller.
+     *
+     * Beyond `new this(...)`, method will activate managed-state.
+     *
+     * @param args - arguments sent to constructor
+     */
+    static create(...args) {
+        const instance = new this(...args);
+        control(instance);
+        return instance;
     }
-    return cb(control);
-}
+    /**
+     * Static equivalent of `x instanceof this`.
+     *
+     * Will determine if provided class is a subtype of this one.
+     */
+    static isTypeof(maybe) {
+        return (typeof maybe == "function" &&
+            maybe.prototype instanceof this);
+    }
+}
+defineLazy(Model, CONTROL, function () {
+    return new Controller(this);
+});
 
 class Subscriber {
     constructor(target, onUpdate) {
@@ -300,6 +291,32 @@ class Subscriber {
 }
 
 const Oops$b = issues({
+    ValueNotReady: (model, key) => `Value ${model}.${key} value is not yet available.`,
+});
+function suspend(source, key) {
+    const error = Oops$b.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
+    });
+}
+
+const Oops$a = issues({
+    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.`,
     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.`
 });
@@ -307,86 +324,109 @@ 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);
-    function compute(initial) {
-        try {
-            return setter.call(sub.proxy, sub.proxy);
+function from(source, arg1, arg2) {
+    return apply(function from(key) {
+        const parent = this;
+        const { subject, state } = this;
+        let getSource;
+        let required = arg2 === true || arg1 === true;
+        if (typeof arg1 == "boolean")
+            arg1 = undefined;
+        // Easy mistake, using a peer, will always be unresolved.
+        if (typeof source == "symbol")
+            throw Oops$a.PeerNotAllowed(subject, key);
+        // replace source controller in-case it is different
+        if (typeof source == "object")
+            getSource = () => control(source);
+        // specifically an arrow function (getter factory)
+        else if (!source.prototype) {
+            arg1 = source.call(subject, key);
+            getSource = () => this;
         }
-        catch (err) {
-            Oops$b.ComputeFailed(subject, key, !!initial).warn();
-            throw err;
+        // Regular function is too ambiguous so not allowed.
+        else
+            throw Oops$a.BadComputedSource(subject, key, source);
+        let sub;
+        const setter = arg1;
+        const info = { key, parent, priority: 1 };
+        let register = USED.get(parent);
+        if (!register) {
+            register = new Map();
+            USED.set(parent, register);
         }
-    }
-    function update() {
-        let value;
-        try {
-            value = compute(false);
+        register.set(key, info);
+        function compute(initial) {
+            try {
+                return setter.call(sub.proxy, sub.proxy);
+            }
+            catch (err) {
+                Oops$a.ComputeFailed(subject, key, !!initial).warn();
+                throw err;
+            }
         }
-        catch (e) {
-            console.error(e);
+        function update() {
+            let value;
+            try {
+                value = compute(false);
+            }
+            catch (e) {
+                console.error(e);
+            }
+            finally {
+                if (state[key] !== value) {
+                    parent.update(key, value);
+                    return value;
+                }
+            }
         }
-        finally {
-            if (state[key] !== value) {
-                parent.update(key, value);
-                return value;
+        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 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(getSource(), defer);
+            defineProperty(state, key, {
+                value: undefined,
+                writable: true
+            });
+            try {
+                return state[key] = compute(true);
+            }
+            catch (e) {
+                if (early)
+                    Oops$a.ComputedEarly(key).warn();
+                throw e;
+            }
+            finally {
+                sub.commit();
+                for (const key in sub.watch) {
+                    const peer = register.get(key);
+                    if (peer && peer.priority >= info.priority)
+                        info.priority = peer.priority + 1;
+                }
+            }
         }
-    }
-    function create(early) {
-        sub = new Subscriber(source(), defer);
+        INIT.add(create);
+        INFO.set(update, info);
         defineProperty(state, key, {
-            value: undefined,
-            writable: true
+            get: create,
+            configurable: true,
+            enumerable: true
         });
-        try {
-            return state[key] = compute(true);
-        }
-        catch (e) {
-            if (early)
-                Oops$b.ComputedEarly(key).warn();
-            throw e;
-        }
-        finally {
-            sub.commit();
-            for (const key in sub.watch) {
-                const peer = register.get(key);
-                if (peer && peer.priority >= info.priority)
-                    info.priority = peer.priority + 1;
-            }
-        }
-    }
-    setAlias(update, `try ${key}`);
-    setAlias(create, `new ${key}`);
-    setAlias(setter, `run ${key}`);
-    INIT.add(create);
-    INFO.set(update, info);
-    defineProperty(state, key, {
-        get: create,
-        configurable: true,
-        enumerable: true
+        return () => {
+            const value = parent.state[key];
+            if (value === undefined && required)
+                throw suspend(this, key);
+            return value;
+        };
     });
-    if (getter)
-        return () => getter(parent, key);
 }
 function ensure(on, keys) {
     for (const key of keys) {
@@ -411,175 +451,205 @@ function flush(on) {
     KEYS.delete(on);
 }
 
-const CONTROL = Symbol("CONTROL");
-const WHY = Symbol("UPDATE");
-const LOCAL = Symbol("LOCAL");
-const STATE = Symbol("STATE");
-class Model {
-    constructor() {
-        define(this, CONTROL, new Controller(this));
-        define(this, "get", this);
-        define(this, "set", this);
-    }
-    get [STATE]() {
-        return this[CONTROL].state;
+const Oops$9 = issues({
+    StrictUpdate: () => `Strict update() did not find pending updates.`,
+    NoChaining: () => `Then called with undefined; update promise will never catch nor supports chaining.`
+});
+const PENDING = new Map();
+const READY = new WeakSet();
+class Controller {
+    constructor(subject) {
+        this.subject = subject;
+        this.state = {};
+        this.frame = new Set();
+        this.waiting = new Set();
+        this.onDestroy = new Set();
+        this.followers = new Set();
+        this.proxy = Object.create(subject);
     }
-    get [WHY]() {
-        return UPDATE.get(this);
+    start() {
+        for (const key in this.subject)
+            this.manage(key);
+        this.emit([]);
     }
-    on(select, handler, squash, once) {
-        return control(this, control => {
-            if (typeof select == "function")
-                return control.addListener(select);
-            const keys = typeof select == "string" ? [select] :
-                !select.length ? getOwnPropertyNames(control.state) :
-                    select;
-            ensure(control, keys);
-            const callback = squash
-                ? handler.bind(this)
-                : frame => frame
-                    .filter(k => keys.includes(k))
-                    .forEach(k => handler.call(this, control.state[k], k));
-            const trigger = once
-                ? frame => { remove(); callback(frame); }
-                : callback;
-            const remove = control.addListener(key => {
-                if (keys.includes(key))
-                    return trigger;
-            });
-            return remove;
-        });
+    stop() {
+        this.followers.clear();
+        this.onDestroy.forEach(x => x());
     }
-    once(select, callback, squash) {
-        if (callback)
-            return this.on(select, callback, squash, true);
-        return new Promise(resolve => {
-            this.on(select, resolve, true, true);
+    manage(key) {
+        const { proxy, state, subject } = this;
+        const { value: entry } = getOwnPropertyDescriptor(subject, key);
+        if (typeof entry == "function")
+            return;
+        if (typeof entry == "symbol") {
+            const instruction = PENDING.get(entry);
+            if (instruction)
+                instruction.call(this, key, this);
+            return;
+        }
+        state[key] = entry;
+        const set = this.ref(key);
+        defineProperty(subject, key, {
+            enumerable: false,
+            get: () => state[key],
+            set
         });
-    }
-    effect(callback, select) {
-        const effect = createEffect(callback);
-        return control(this, control => {
-            if (!select) {
-                const sub = new Subscriber(control, () => invoke);
-                const invoke = () => {
-                    const x = sub.proxy;
-                    effect.call(x, x);
-                };
-                invoke();
-                return sub.commit();
-            }
-            const invoke = () => {
-                effect.call(this.get, this.get);
-            };
-            invoke();
-            if (!select.length) {
-                control.onDestroy.add(invoke);
-                return () => {
-                    control.onDestroy.delete(invoke);
-                };
-            }
-            return control.addListener(key => {
-                if (select.includes(key))
-                    return invoke;
-            });
+        defineProperty(proxy, key, {
+            enumerable: false,
+            get() {
+                const local = this[LOCAL];
+                if (local && !local.watch[key])
+                    local.watch[key] = true;
+                return state[key];
+            },
+            set
         });
     }
-    // TODO: account for exotic properties
-    import(source, select) {
-        const { subject } = control(this);
-        if (!select)
-            select = getOwnPropertyNames(subject);
-        for (const key of select)
-            if (key in source)
-                this[key] = source[key];
+    ref(key, handler) {
+        const { state, subject } = this;
+        return (value) => {
+            if (state[key] == value)
+                return;
+            if (handler)
+                switch (handler.call(subject, value, state)) {
+                    case true:
+                        this.update(key);
+                    case false:
+                        return;
+                }
+            this.update(key, value);
+        };
     }
-    export(subset) {
-        const { state } = control(this);
-        const output = {};
-        if (!subset)
-            subset = getOwnPropertyNames(state);
-        for (const key of subset)
-            output[key] = state[key];
-        return output;
+    addListener(listener) {
+        this.followers.add(listener);
+        return () => {
+            this.followers.delete(listener);
+        };
     }
-    update(arg, tag) {
-        const target = control(this);
-        if (typeof arg == "string") {
-            target.update(arg);
-            if (1 in arguments && arg in this) {
-                const method = this[arg];
-                if (typeof method == "function")
-                    if (typeof tag != "boolean")
-                        method.call(this, tag);
-                    else if (tag)
-                        method.call(this);
+    emit(keys) {
+        const waiting = [...this.waiting];
+        this.waiting.clear();
+        applyUpdate(this.subject, keys)();
+        for (const callback of waiting)
+            try {
+                callback(keys);
             }
-            arg = undefined;
+            catch (err) {
+                console.error(err);
+            }
+    }
+    update(key, value) {
+        if (1 in arguments)
+            this.state[key] = value;
+        if (this.frame.has(key))
+            return;
+        if (!this.frame.size)
+            setTimeout(() => {
+                flush(this);
+                const keys = Object.freeze([...this.frame]);
+                this.frame.clear();
+                this.emit(keys);
+            }, 0);
+        this.frame.add(key);
+        for (const callback of this.followers) {
+            const event = callback(key, this);
+            if (typeof event == "function")
+                this.waiting.add(event);
         }
-        return target.requestUpdate(arg);
     }
-    /**
-     * Mark this instance for garbage-collection and send `willDestroy` event to all listeners.
-     */
-    destroy() {
-        control(this).stop();
+    requestUpdate(arg) {
+        if (typeof arg == "function") {
+            this.waiting.add(arg);
+            return;
+        }
+        if (arg === true && this.frame.size < 1)
+            return Promise.reject(Oops$9.StrictUpdate());
+        return {
+            then: (callback) => {
+                if (callback)
+                    if (this.frame.size || arg !== false)
+                        this.waiting.add(callback);
+                    else
+                        callback(false);
+                else
+                    throw Oops$9.NoChaining();
+            }
+        };
     }
-    toString() {
-        return this.constructor.name;
+}
+function control(subject, cb) {
+    let control = subject[CONTROL];
+    const ready = READY.has(control);
+    if (!control) {
+        control = new Controller(subject);
+        define(subject, CONTROL, control);
     }
-    /**
-     * Creates a new instance of this controller.
-     *
-     * Beyond `new this(...)`, method will activate managed-state.
-     *
-     * @param args - arguments sent to constructor
-     */
-    static create(...args) {
-        const instance = new this(...args);
-        control(instance);
-        return instance;
+    if (!cb) {
+        if (!ready) {
+            READY.add(control);
+            control.start();
+        }
+        return control;
     }
-    /**
-     * Static equivalent of `x instanceof this`.
-     *
-     * Will determine if provided class is a subtype of this one.
-     */
-    static isTypeof(maybe) {
-        return (typeof maybe == "function" &&
-            maybe.prototype instanceof this);
+    if (!ready) {
+        let done;
+        control.requestUpdate(() => {
+            done = cb(control);
+        });
+        return () => done && done();
     }
-}
-defineLazy(Model, CONTROL, function () {
-    return new Controller(this);
-});
+    return cb(control);
+}
 
-const Pending = new Map();
 function apply(fn, label) {
     const name = label || fn.name || "pending";
     const placeholder = Symbol(`${name} instruction`);
     function setup(key) {
+        const { proxy, state, subject } = this;
+        const control = this;
+        PENDING.delete(placeholder);
+        delete subject[key];
         let output = fn.call(this, key, this);
         if (typeof output == "function")
-            return { get: output };
-        if (typeof output !== "object")
-            return output || undefined;
+            output = { get: output };
+        if (typeof output != "object")
+            return;
         if ("explicit" in output && output.explicit) {
-            defineProperty(this.subject, key, output);
+            defineProperty(subject, key, output);
             return false;
         }
-        if ("recursive" in output)
+        if ("recursive" in output && output.recursive)
             output = Object.assign(Object.assign({}, output), { get: recursive(this, key) });
-        return output;
+        const desc = output;
+        if ("value" in desc)
+            state[key] = desc.value;
+        const { get: onGet, set: onSet, enumerable, suspense } = desc;
+        let set = onSet === false
+            ? undefined
+            : this.ref(key, onSet);
+        function get() {
+            if (!(key in state) && suspense)
+                throw suspend(control, key);
+            const local = this[LOCAL];
+            if (local && !(key in local.watch))
+                local.watch[key] = true;
+            const value = state[key];
+            if (!onGet)
+                return value;
+            return local
+                ? onGet(value, local)
+                : onGet(value);
+        }
+        for (const x of [subject, proxy])
+            defineProperty(x, key, { enumerable, get, set });
     }
-    Pending.set(placeholder, setup);
+    PENDING.set(placeholder, setup);
     return placeholder;
 }
 function recursive(source, key) {
-    const context = new WeakMap();
-    const subscribe = (parent) => {
+    return forSubscriber((parent, context) => {
         let child;
-        const init = () => {
+        function init() {
             if (child) {
                 child.release();
                 parent.dependant.delete(child);
@@ -594,20 +664,28 @@ function recursive(source, key) {
                 parent.dependant.add(child);
                 context.set(parent, child.proxy);
             }
-        };
+        }
         init();
         parent.watch[key] = init;
-    };
+    });
+}
+function forSubscriber(fn) {
+    const context = new WeakMap();
     return (value, local) => {
         if (!local)
             return value;
-        if (!context.has(local))
-            subscribe(local);
+        if (!context.has(local)) {
+            const output = fn(local, context);
+            if (output) {
+                context.set(local, output);
+                return output;
+            }
+        }
         return context.get(local);
     };
 }
 
-const Oops$a = issues({
+const Oops$8 = issues({
     DuplicateAction: (key) => `Invoked action ${key} but one is already active.`
 });
 function act(task) {
@@ -615,7 +693,7 @@ function act(task) {
         let pending = false;
         const invoke = (...args) => {
             if (pending)
-                return Promise.reject(Oops$a.DuplicateAction(key));
+                return Promise.reject(Oops$8.DuplicateAction(key));
             pending = true;
             this.update(key);
             return new Promise(res => {
@@ -626,7 +704,6 @@ function act(task) {
             });
         };
         this.state[key] = undefined;
-        setAlias(invoke, `run ${key}`);
         defineProperty(invoke, "active", {
             get: () => pending
         });
@@ -637,104 +714,62 @@ function act(task) {
     });
 }
 
-const Oops$9 = issues({
-    ValueNotReady: (model, key) => `Value ${model}.${key} value is not yet available.`
-});
-/**
- * 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 pendingFactory(via, key, fn) {
-    const { subject, state } = via;
-    let waiting;
-    let error;
-    return () => {
-        if (waiting)
-            throw waiting;
-        if (error)
-            throw error;
-        if (key in state)
-            return state[key];
-        let output;
-        try {
-            output = fn.call(subject, key, subject);
-        }
-        catch (err) {
-            throw error = err;
-        }
-        if (output instanceof Promise) {
-            const issue = Oops$9.ValueNotReady(subject, key);
-            output
-                .catch(err => error = err)
-                .then(out => state[key] = out)
-                .finally(() => waiting = undefined);
-            throw waiting = Object.assign(output, {
-                message: issue.message,
-                stack: issue.stack
-            });
-        }
-        else {
-            return state[key] = output;
-        }
-    };
+class Managed extends Array {
+    constructor(onUpdate) {
+        super();
+        this.lastUpdate = [0, 0];
+        this.update = (from, to) => {
+            this.lastUpdate = [from, to];
+            onUpdate();
+        };
+    }
+    push(...items) {
+        const length = this.length;
+        const end = super.push(...items);
+        this.update(length, end);
+        return end;
+    }
+    unshift(...items) {
+        const end = super.push(...items);
+        this.update(0, end);
+        return end;
+    }
+    splice(start, deleteCount, ...rest) {
+        this.update(start, deleteCount !== rest.length ? Infinity : deleteCount);
+        return super.splice(start, deleteCount, ...rest);
+    }
 }
-function suspend(source, key) {
-    const error = Oops$9.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();
-                    }
-                };
+function array() {
+    return apply(function array(key) {
+        const array = new Managed(() => this.update(key));
+        const access = forSubscriber(context => {
+            const local = Object.create(array);
+            const update = context.onUpdate(key, this);
+            let rangeA = 0;
+            let rangeB = 0;
+            function onUpdate() {
+                const [lastA, lastB] = array.lastUpdate;
+                if (rangeA <= lastB && rangeB >= lastA)
+                    return update;
+            }
+            function listen(eventA, eventB) {
+                if (context.active)
+                    return;
+                context.watch[key] = onUpdate;
+                rangeA = Math.min(rangeA, eventA);
+                rangeB = Math.max(rangeB, eventB);
+            }
+            local[Symbol.iterator] = () => {
+                listen(0, Infinity);
+                return array[Symbol.iterator]();
+            };
+            return local;
         });
-    });
-    return Object.assign(promise, {
-        toString: () => String(error),
-        name: "Suspense",
-        message: error.message,
-        stack: error.stack
-    });
-}
-
-const Oops$8 = issues({
-    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 from(source, setter, arg) {
-    return apply(function from(key) {
-        const { subject } = this;
-        let getSource;
-        let getter;
-        if (arg === true || setter === true)
-            getter = pendingValue;
-        if (typeof setter == "boolean")
-            setter = undefined;
-        // Easy mistake, using a peer, will always be unresolved.
-        if (typeof source == "symbol")
-            throw Oops$8.PeerNotAllowed(subject, key);
-        // replace source controller in-case it is different
-        if (typeof source == "object")
-            getSource = () => control(source);
-        // specifically an arrow function (getter factory)
-        else if (!source.prototype) {
-            setter = source.call(subject, key);
-            getSource = () => this;
-        }
-        // Regular function is too ambiguous so not allowed.
-        else
-            throw Oops$8.BadComputedSource(subject, key, source);
-        return prepare(this, key, getSource, setter, getter);
+        return {
+            get: access,
+            set: false,
+            value: array
+        };
     });
 }
 
@@ -763,32 +798,21 @@ function createRef(key, cb) {
 const Oops$7 = issues({
     NonOptional: (Parent, key) => `Property ${Parent}.${key} is marked as required.`,
     BadFactory: () => `Set instruction can only accept a factory or undefined.`,
+    ValueNotReady: (model, key) => `Value ${model}.${key} value is not yet available.`,
     FactoryFailed: (model, key) => `Generating initial value for ${model}.${key} failed.`
 });
 function set(factory, argument) {
     return apply(function set(key) {
         let set;
         let get;
+        let suspense;
         const required = argument === true || argument === undefined;
         if (factory === undefined)
-            get = () => pendingValue(this, key);
-        else if (typeof factory !== "function")
+            suspense = true;
+        else if (typeof factory === "function")
+            get = pendingFactory(this, key, factory, required);
+        else
             throw Oops$7.BadFactory();
-        else {
-            get = pendingFactory(this, key, factory);
-            if (required)
-                try {
-                    get();
-                }
-                catch (err) {
-                    if (err instanceof Promise)
-                        ;
-                    else {
-                        Oops$7.FactoryFailed(this.subject, key).warn();
-                        throw err;
-                    }
-                }
-        }
         if (typeof argument == "function")
             set = createValueEffect(argument);
         else
@@ -796,8 +820,63 @@ function set(factory, argument) {
                 if (value === undefined && required)
                     throw Oops$7.NonOptional(this.subject, key);
             };
-        return { set, get };
+        return {
+            set,
+            get,
+            suspense
+        };
     });
+}
+function pendingFactory(parent, key, fn, required) {
+    const { subject, state } = parent;
+    let pending;
+    let error;
+    const init = () => {
+        const output = suspenseBoundary(() => {
+            return fn.call(subject, key, subject);
+        });
+        if (output instanceof Promise) {
+            pending = output
+                .catch(err => error = err)
+                .then(val => state[key] = val)
+                .finally(() => {
+                pending = undefined;
+                parent.update(key);
+            });
+            return;
+        }
+        return state[key] = output;
+    };
+    const suspend = () => {
+        if (required === false)
+            return undefined;
+        const issue = Oops$7.ValueNotReady(subject, key);
+        Object.assign(pending, {
+            message: issue.message,
+            stack: issue.stack
+        });
+        throw pending;
+    };
+    if (required)
+        try {
+            init();
+        }
+        catch (err) {
+            Oops$7.FactoryFailed(subject, key).warn();
+            throw err;
+        }
+    return () => {
+        if (pending)
+            return suspend();
+        if (error)
+            throw error;
+        if (key in state)
+            return state[key];
+        let output = init();
+        return pending
+            ? suspend()
+            : output;
+    };
 }
 
 const Parent = new WeakMap();
@@ -940,24 +1019,26 @@ const ContextWasUsed = new WeakMap();
 function tap(type, argument) {
     return apply(function tap(key) {
         if ("set" in type)
-            this.state[key] = type.get();
-        else {
-            const { subject } = this;
-            if ("set" in subject.constructor)
-                throw Oops$3.CantAttachGlobal(subject, type.name);
-            getPending(subject).push(context => {
-                let instance = context.get(type);
-                if (typeof argument == "function") {
-                    if (argument(instance) === false)
-                        instance = undefined;
-                }
-                else if (!instance && argument)
-                    throw Oops$3.AmbientRequired(type.name, subject, key);
-                this.update(key, instance);
-            });
-        }
+            return {
+                recursive: true,
+                value: type.get()
+            };
+        const { subject } = this;
+        if ("set" in subject.constructor)
+            throw Oops$3.CantAttachGlobal(subject, type.name);
+        getPending(subject).push(context => {
+            let instance = context.get(type);
+            if (typeof argument == "function") {
+                if (argument(instance) === false)
+                    instance = undefined;
+            }
+            else if (!instance && argument)
+                throw Oops$3.AmbientRequired(type.name, subject, key);
+            this.update(key, instance);
+        });
         return {
-            recursive: true
+            recursive: true,
+            suspense: true
         };
     });
 }
@@ -1255,7 +1336,7 @@ class Global extends MVC {
     static set(updates) {
         const instance = Active.get(this) || this.create();
         instance.import(updates);
-        return instance.update();
+        return instance.update(false);
     }
     static get(arg) {
         const instance = Active.get(this);
@@ -1287,6 +1368,7 @@ exports.STATE = STATE;
 exports.WHY = WHY;
 exports.act = act;
 exports.apply = apply;
+exports.array = array;
 exports["default"] = MVC;
 exports.from = from;
 exports.parent = parent;