@expressive/mvc 0.19.2 → 0.21.0

package/lib/index.d.ts

@@ -14,35 +14,127 @@ declare class Issue extends Error {
 }
 declare function issues<M extends Issue.Messages>(register: M): Issue.Output<M>;
 
-declare const LOCAL = "__local";
+type Async<T = any> = (...args: any[]) => Promise<T>;
+/**
+ * Sets an exotic method with managed ready-state. Property accepts an async function.
+ *
+ * When a run-method is invoked, its `active` property to true for duration of call.
+ * This is emitted as an update to property, both when called and after returns (or throws).
+ *
+ * **Note:** Subsequent calls will immediately throw if one is still pending.
+ *
+ * @param action - Action to fire when resulting property is invoked.
+ */
+declare function run(action: Async): typeof action & {
+    active: boolean;
+};
+declare function run<S>(action: Async<S>): typeof action & {
+    active: boolean;
+};
+
+type Callback = () => void;
+
+declare global {
+  namespace jest {
+    interface Matchers<R> {
+      /** Assert model does have one or more updates pending. */
+      toUpdate(): Promise<R>;
+
+      /** Assert model did update with keys specified. */
+      toHaveUpdated<R>(keys: string[]): Promise<R>; 
+    }
+  }
+}
+
+type Observer<T extends Model = any> = (key: Model.Event<T> | null | undefined, source: Control) => Callback | null | void;
+declare namespace Control {
+    /**
+     * Property initializer, will run upon instance creation.
+     * Optional returned callback will run when once upon first access.
+     */
+    type Instruction<T> = (this: Control, key: string, thisArg: Control) => PropertyDescriptor<T> | Getter<T> | void;
+    type Getter<T> = (source: Model) => T;
+    type Setter<T> = (value: T) => boolean | void;
+    type PropertyDescriptor<T = any> = {
+        enumerable?: boolean;
+        value?: T;
+        get?: Getter<T>;
+        set?: Setter<T> | false;
+    };
+    /**
+     * Callback for Controller.for() static method.
+     * Returned callback is forwarded.
+     */
+    type OnReady<T extends Model> = (control: Control<T>) => Callback | void;
+    type GetAdapter<T> = (update: () => void, source: (request: (got: Model | undefined) => void) => void) => {
+        mount: () => (() => void) | void;
+        render: () => T;
+    } | void;
+    type GetHook = <T extends Model, R>(type: Model.Type<T>, adapter: GetAdapter<R>) => R | null;
+    type UseAdapter<T extends Model> = (update: () => void) => {
+        instance: T;
+        mount: () => (() => void) | void;
+        render: (props: Model.Compat<T>) => T;
+    };
+    type UseHook = <T extends Model>(adapter: UseAdapter<T>) => (props: Model.Compat<T>) => T;
+    type HasHook = (type: typeof Model, relativeTo: Model, callback: (got: Model | undefined) => void) => void;
+}
+declare class Control<T extends Model = any> {
+    subject: T;
+    id: string | number;
+    static after: Set<Callback>;
+    static before: Set<Callback>;
+    static pending: Set<Callback>;
+    static get: Control.GetHook;
+    static use: Control.UseHook;
+    static has: Control.HasHook;
+    static for: typeof control;
+    static apply: typeof apply;
+    static watch: typeof watch;
+    state: {
+        [key: string]: any;
+    };
+    latest?: Model.Event<T>[];
+    frame: Set<string>;
+    followers: Set<Observer<any>>;
+    observers: Map<string, Set<Observer<any>>>;
+    constructor(subject: T, id?: string | number);
+    add(key: Extract<keyof T, string>): void;
+    watch(key: keyof T & string, output: Control.PropertyDescriptor<any>): void;
+    ref<K extends Model.Key<T>>(key: K, callback?: (this: T, value: T[K]) => boolean | void): (value: any) => void;
+    update(key: string): void;
+    addListener(fn: Observer): () => boolean;
+    clear(): void;
+}
+declare function control<T extends Model>(subject: T, ready: Control.OnReady<T>): Callback;
+declare function control<T extends Model>(subject: T, ready?: boolean): Control<T>;
+declare function watch<T extends Model>(on: T, cb: Observer): T;
+declare function apply<T = any>(instruction: Control.Instruction<any>): T;
+
 declare const STATE = "__state";
 declare const UPDATE = "__update";
 declare const CONTROL = "__control";
+declare const PARENT = "__parent";
 declare const Debug: {
-    /** Use to access Model's local Subscriber (if exists). */
-    LOCAL: "__local";
     /** Use to access snapshot of Model's current state. */
     STATE: "__state";
     /**
      * Use to access snapshot of Model's latest update.
-     *
-     * Note: If used within a Subscriber, update will be narrowed to the specific keys
-     * which triggered a refresh (if one did).
      */
     UPDATE: "__update";
     /** Use to access a Model's controller. */
     CONTROL: "__control";
+    /** Use to access a Model's parent, if exists. */
+    PARENT: "__parent";
 };
 /**
  * Generic will declare debug properties on a given Model.
  *
  * These properties always exist at runtime, however are hidden unless you cast your Model as `Debug<T>`.
  */
-type Debug<T extends Model> = T & {
+type Debug<T extends Model = Model> = T & {
     /** Controller for this instance. */
     [CONTROL]?: Control<T>;
-    /** Current subscriber (if present) while used in a live context (e.g. hook or effect). */
-    [LOCAL]?: Subscriber<T>;
     /** Current state of this instance. */
     [STATE]?: Model.Export<T>;
     /**
@@ -52,75 +144,78 @@ type Debug<T extends Model> = T & {
      * If within a subscribed function, will contain only keys which explicitly caused a refresh.
      */
     [UPDATE]?: readonly Model.Event<T>[];
+    /**
+     * Parent currently assigned to parent. Usually the model which this one is a property of.
+     */
+    [PARENT]?: Model;
 };
 
-type Callback = () => void;
-type Class = new (...args: any[]) => any;
-type InstanceOf<T> = T extends { prototype: infer U } ? U : never;
-
-type MaybePromise<T> = T | Promise<T>;
-
 /** Type may not be undefined - instead will be null.  */
 type NoVoid<T> = T extends undefined ? null : T;
+declare function get$1<T extends Model>(this: Model.Type<T>): T;
+/** Fetch instance of this class in passive mode. Will not subscribe to events. */
+declare function get$1<T extends Model>(this: Model.Type<T>, ignoreUpdates?: true): T;
+/** Fetch instance of this class optionally. May be undefined, but will never subscribe. */
+declare function get$1<T extends Model>(this: Model.Type<T>, required: boolean): T | undefined;
+declare function get$1<T extends Model, R extends []>(this: Model.Type<T>, factory: Model.GetCallback<T, R | (() => R)>, expect?: boolean): R;
+declare function get$1<T extends Model, R extends []>(this: Model.Type<T>, factory: Model.GetCallback<T, Promise<R> | (() => R) | null>, expect?: boolean): R | null;
+declare function get$1<T extends Model, R extends []>(this: Model.Type<T>, factory: Model.GetCallback<T, Promise<R> | R>, expect: true): Exclude<R, undefined>;
+declare function get$1<T extends Model, R>(this: Model.Type<T>, init: Model.GetCallback<T, () => R>): NoVoid<R>;
+declare function get$1<T extends Model, R>(this: Model.Type<T>, init: Model.GetCallback<T, (() => R) | null>): NoVoid<R> | null;
+declare function get$1<T extends Model, R>(this: Model.Type<T>, compute: Model.GetCallback<T, Promise<R> | R>, expect: true): Exclude<R, undefined>;
+declare function get$1<T extends Model, R>(this: Model.Type<T>, compute: Model.GetCallback<T, Promise<R>>, expect?: boolean): NoVoid<R> | null;
+declare function get$1<T extends Model, R>(this: Model.Type<T>, compute: Model.GetCallback<T, R>, expect?: boolean): NoVoid<R>;
 
+declare function use$1<T extends Model>(this: Model.New<T>, callback?: (instance: T) => void): T;
+declare function use$1<T extends Model>(this: Model.New<T>, apply?: Model.Compat<T>, repeat?: boolean): T;
+
+type InstanceOf<T> = T extends {
+    prototype: infer U;
+} ? U : never;
 declare namespace Model {
-    export { Control };
-    export { Subscriber };
-    /** Including but not limited to T. */
-    type Extends<T> = T | (string & Record<never, never>);
     /** Any typeof Model, using class constructor as the reference. */
-    export type Type<T extends Model = Model> = abstract new () => T;
-    export type Class<T extends Model> = (abstract new () => T) & typeof Model;
-    /** A typeof Model, specifically one which may be created without arguments. */
-    export type New<T extends Model = Model> = (new () => T) & typeof Model;
-    export type Effect<T> = (this: T, argument: T) => Callback | Promise<any> | void;
+    type Type<T extends Model = Model> = abstract new (...args: any[]) => T;
+    /** A typeof Model, specifically one which can be created without any arguments. */
+    type New<T extends Model = Model> = (new () => T) & typeof Model;
+    type Effect<T> = (this: T, argument: T) => Callback | Promise<any> | void;
     /** Exotic value, actual value is contained. */
-    export type Ref<T = any> = {
+    type Ref<T = any> = {
         (next: T): void;
         current: T | null;
     };
-    /** Properties of T which are methods. */
-    export type Methods<T> = {
-        [K in keyof T]: T[K] extends Ref ? never : T[K] extends Function ? K : never;
-    }[keyof T];
-    type BuiltIn = keyof Model | keyof Debug<Model>;
     /**
      * Subset of `keyof T` which are not methods or defined by base Model U.
-     *
-     * **Note**: This excludes all keys which are not of type `string` (only those are managed).
-     *
-     * TODO: Should exclude methods
-     **/
-    export type Key<T> = Exclude<keyof T, BuiltIn> & string;
-    /**
-     * Including but not limited to `keyof T` which are not methods or defined by base Model.
      **/
-    export type Event<T> = Extends<Key<T>>;
+    type Key<T, U = Model> = Extract<Exclude<keyof T, keyof U | keyof Debug>, string>;
+    /** Including but not limited to `keyof T` which are not methods or defined by base Model. */
+    type Event<T> = Key<T> | (string & {});
+    /** Actual value stored in state. */
+    type Value<R> = R extends Ref<infer T> ? T : R;
+    /** Actual value belonging to a managed property. */
+    type ValueOf<T extends {}, K> = K extends keyof T ? Value<T[K]> : undefined;
+    type Export<T> = {
+        [P in Key<T>]: Value<T[P]>;
+    };
     /** Object containing managed entries found in T. */
-    export type Entries<T> = {
+    type Entries<T> = {
         [K in Key<T>]: T[K];
     };
     /** Object comperable to data found in T. */
-    export type Compat<T> = {
+    type Compat<T> = {
         [K in Key<T>]?: T[K];
     };
-    /** Actual value stored in state. */
-    export type Value<R> = R extends Ref<infer T> ? T : R;
-    /** Actual value belonging to a managed property. */
-    export type ValueOf<T extends {}, K> = K extends keyof T ? Value<T[K]> : undefined;
     /**
      * Values from current state of given controller.
      *
      * Differs from `Entries` as values here will drill into "real" values held by exotics like ref.
      */
-    export type Get<T, K extends Key<T> = Key<T>> = {
+    type Get<T, K extends Key<T> = Key<T>> = {
         [P in K]: Value<T[P]>;
     };
-    export type Export<T> = {
-        [P in Key<T>]: Value<T[P]>;
-    };
-    export type FindFunction = <T extends Model>(type: Model.Type<T>, relativeTo: Model, required: boolean) => (_refresh: (x: T) => void) => T | undefined;
-    export type GetCallback<T extends Model, R> = (this: T, model: T, update: ForceUpdate) => R;
+    /** Promise thrown by something which is not yet ready. */
+    type Suspense = Promise<void> & Error;
+    type OnCallback<T extends Model> = (this: T, keys: Model.Event<T>[] | null) => void;
+    type GetCallback<T extends Model, R> = (this: T, model: T, update: ForceUpdate) => R;
     type ForceUpdate = {
         /** Force an update in current component. */
         (): void;
@@ -128,51 +223,38 @@ declare namespace Model {
          * Force an update and again after promise either resolves or rejects.
          * Will return a duplicate of given Promise, which resolves after refresh.
          */
-        <T = void>(passthru?: Promise<T>): Promise<T>;
+        <T = void>(passthru: Promise<T>): Promise<T>;
         /**
          * Force a update while calling async function.
          * A refresh will occur both before and after given function.
          * Any actions performed before first `await` will occur before refresh!
          */
-        <T = void>(invoke?: () => Promise<T>): Promise<T>;
+        <T = void>(invoke: () => Promise<T>): Promise<T>;
     };
-    export type Suspense = Promise<void> & Error;
 }
 declare class Model {
+    constructor(id?: string | number);
     /**
      * Reference to `this` without a subscription.
      * Use to obtain full reference from a destructure.
      */
-    is: this;
-    /** Unique identifier for Model instance. */
-    id: string;
-    constructor(id?: string);
-    on<P extends Model.Event<this>>(keys?: P | Iterable<P>, timeout?: number): Promise<P[]>;
-    on<P extends Model.Event<this>>(keys: P | Iterable<P>, listener: (this: this, keys: Model.Event<this>[]) => void, once?: boolean): Callback;
+    get is(): this;
+    on(): Promise<Model.Event<this>[]>;
+    on(timeout?: number): Promise<Model.Event<this>[] | false>;
+    on<P extends Model.Event<this>>(keys?: P | P[], timeout?: number): Promise<P[] | false>;
+    on<P extends Model.Event<this>>(keys: P | P[], listener: Model.OnCallback<this>, once?: boolean): Callback;
     on(effect: Model.Effect<this>): Callback;
-    on(effect: Model.Effect<this>, watch?: []): Callback;
-    on(effect: Model.Effect<this>, watch?: Model.Event<this>[]): Callback;
-    on(key?: undefined, timeout?: number): Promise<Model.Event<this>[]>;
-    on(current?: boolean): Promise<Model.Event<this>[] | null>;
-    on(current: true): Promise<Model.Event<this>[]>;
-    on(current: null): Promise<null>;
     get(): Model.Export<this>;
     get<P extends Model.Key<this>>(select: P): this[P];
     get<P extends Model.Key<this>>(select: Iterable<P>): Model.Get<this, P>;
-    get<P extends Model.Key<this>>(select: P, timeout: number): Promise<this[P]>;
-    get<P extends Model.Key<this>>(select: Iterable<P>, timeout: number): Promise<Model.Get<this, P>>;
-    get<P extends Model.Key<this>>(select: P, onChange: true): Promise<this[P]>;
-    get<P extends Model.Key<this>>(select: Iterable<P>, onChange: true): Promise<Model.Get<this, P>>;
-    get<P extends Model.Key<this>>(select: P, onChange: boolean): MaybePromise<this[P]>;
-    get<P extends Model.Key<this>>(select: Iterable<P>, onChange: boolean): MaybePromise<Model.Get<this, P>>;
-    get<P extends Model.Key<this>>(select: P, listener: (this: this, value: this[P], key: P[]) => void): Callback;
-    get<P extends Model.Key<this>>(select: Iterable<P>, listener: (this: this, value: Model.Get<this, P>, key: P[]) => void): Callback;
-    set(key: Model.Event<this>): PromiseLike<readonly Model.Event<this>[]>;
-    set<K extends Model.Event<this>>(key: Model.Event<this>, value: Model.ValueOf<this, K>): PromiseLike<readonly Model.Event<this>[]>;
-    set<T extends Model.Compat<this>>(source: T, select: (keyof T)[]): PromiseLike<(keyof T)[]>;
-    set<T extends Model.Compat<this>>(source: T, force?: boolean): PromiseLike<(keyof T)[]>;
+    get<P extends Model.Key<this>>(select: P, listener: (this: this, value: this[P]) => void): Callback;
+    get<P extends Model.Key<this>>(select: Iterable<P>, listener: (this: this, value: Model.Get<this, P>) => void): Callback;
+    set<T extends Model.Compat<this>>(source: T, select?: (keyof T)[]): Promise<Model.Key<T>[]>;
+    set<K extends Model.Event<this>>(key: K, value?: Model.ValueOf<this, K>): Promise<Model.Event<this>[] | false>;
     /** Mark this instance for garbage collection. */
-    gc(): void;
+    null(): void;
+    static get: typeof get$1;
+    static use: typeof use$1;
     /**
      * Creates a new instance of this controller.
      *
@@ -180,23 +262,7 @@ declare class Model {
      *
      * @param args - arguments sent to constructor
      */
-    static new<T extends Class>(this: T, ...args: ConstructorParameters<T>): InstanceOf<T>;
-    static find<T extends Model>(this: Model.Type<T>, required?: boolean): T;
-    static find<T extends Model>(this: Model.Type<T>, required: false): T | undefined;
-    static get<T extends Model>(this: Model.Type<T>): T;
-    static get<T extends Model>(this: Model.Type<T>, passive: true): T;
-    static get<T extends Model>(this: Model.Type<T>, required: false): T | undefined;
-    static get<T extends Model, R extends []>(this: Model.Type<T>, compute: Model.GetCallback<T, R | (() => R)>, expect?: boolean): R;
-    static get<T extends Model, R extends []>(this: Model.Type<T>, compute: Model.GetCallback<T, Promise<R> | (() => R) | null>, expect?: boolean): R | null;
-    static get<T extends Model, R extends []>(this: Model.Type<T>, compute: Model.GetCallback<T, Promise<R> | R>, expect: true): Exclude<R, undefined>;
-    static get<T extends Model, R>(this: Model.Type<T>, init: Model.GetCallback<T, () => R>): NoVoid<R>;
-    static get<T extends Model, R>(this: Model.Type<T>, init: Model.GetCallback<T, (() => R) | null>): NoVoid<R> | null;
-    static get<T extends Model, R>(this: Model.Type<T>, compute: Model.GetCallback<T, Promise<R> | R>, expect: true): Exclude<R, undefined>;
-    static get<T extends Model, R>(this: Model.Type<T>, compute: Model.GetCallback<T, Promise<R>>, expect?: boolean): NoVoid<R> | null;
-    static get<T extends Model, R>(this: Model.Type<T>, compute: Model.GetCallback<T, R>, expect?: boolean): NoVoid<R>;
-    static use<I extends Model>(this: Model.Type<I>, watch: Model.Key<I>[], callback?: (instance: I) => void): I;
-    static use<I extends Model>(this: Model.Type<I>, callback?: (instance: I) => void): I;
-    static use<I extends Model>(this: Model.Type<I>, apply: Model.Compat<I>, keys?: Model.Event<I>[]): I;
+    static new<T extends new (...args: any[]) => any>(this: T, ...args: ConstructorParameters<T>): InstanceOf<T>;
     /**
      * Static equivalent of `x instanceof this`.
      *
@@ -205,120 +271,10 @@ declare class Model {
     static isTypeof<T extends Model.Type>(this: T, maybe: any): maybe is T;
 }
 
-type Listener = {
-    commit(): void;
-    release(): void;
-};
-declare namespace Subscriber {
-    type OnEvent<T = any> = (key: Model.Event<T> | null, source: Control) => Callback | void;
-    type Getter<T extends Model> = (within?: Subscriber<T> | undefined) => any;
-}
-declare class Subscriber<T extends Model = any> {
-    onUpdate: Subscriber.OnEvent;
-    proxy: T;
-    clear: () => void;
-    latest?: Model.Event<T>[];
-    active: boolean;
-    dependant: Set<Listener>;
-    watch: Map<any, boolean | (() => boolean | void)>;
-    parent: Control<T>;
-    constructor(parent: Control<T> | T, onUpdate: Subscriber.OnEvent);
-    get using(): Model.Key<T>[];
-    get(key: string, using?: Subscriber.Getter<T>): any;
-    follow(key: any, value?: boolean | (() => boolean | void)): void;
-    commit(): void;
-    release(): void;
-    private notify;
-}
-
-/**
- * Property initializer, will run upon instance creation.
- * Optional returned callback will run when once upon first access.
- */
-type Instruction<T> = (this: Control, key: string, thisArg: Control) => Instruction.Getter<T> | Instruction.Descriptor<T> | void;
-declare namespace Instruction {
-    type Getter<T> = (within?: Subscriber) => T;
-    type Setter<T> = (value: T) => boolean | void;
-    type Runner = (on: Control, key: string) => Instruction.Descriptor<any> | undefined;
-    interface Descriptor<T> {
-        enumerable?: boolean;
-        value?: T;
-        get?: Getter<T>;
-        set?: Setter<T> | false;
-    }
-}
-/**
- * Run instruction as controller sets itself up.
- * This will specialize the behavior of a given property.
- */
-declare function add<T = any>(instruction: Instruction<any>, label?: string): T;
-
-declare namespace Control {
-    /**
-     * Called immediately when any key is changed or emitted.
-     * Returned callback is notified when update is complete.
-     */
-    type OnSync<T = any> = (key: Model.Event<T> | null, source: Control) => OnAsync<T> | void;
-    /** Called at the end of an event frame with all keys affected. */
-    type OnAsync<T = any> = (keys: Model.Event<T>[]) => void;
-    type OnValue<T = any> = (this: T, value: any) => boolean | void;
-}
-declare class Control<T extends {} = any> {
-    subject: T;
-    state: Map<any, any>;
-    frame: Set<string>;
-    waiting: Set<Model.Control.OnAsync<T>>;
-    followers: Set<Model.Control.OnSync<any>>;
-    latest?: Model.Event<T>[];
-    constructor(subject: T);
-    watch(key: keyof T & string): void;
-    /** Throw suspense which resolves when key is set. */
-    waitFor(key: string): never;
-    addListener(listener: Control.OnSync<T>): () => void;
-    ref<K extends Model.Key<T>>(key: K, handler?: (this: T, value: T[K]) => boolean | void): (value: any) => void;
-    update(key: Model.Key<T>): void;
-    clear(): void;
-    static get: typeof controller;
-    static for: typeof control;
-}
-declare function controller<T extends Model>(from: T): Control<T> | undefined;
-declare namespace control {
-    /**
-     * Callback for Controller.for() static method.
-     * Returned callback is forwarded.
-     */
-    type OnReady<T extends Model> = (control: Control<T>) => Callback | void;
-}
-declare function control<T extends Model>(subject: T): Control<T>;
-declare function control<T extends Model>(subject: T, cb: control.OnReady<T>): Callback;
-
-declare function getParent<T extends Model>(from: Model, type?: Model.Class<T>): T;
-
-type Async<T = any> = (...args: any[]) => Promise<T>;
-/**
- * Sets an exotic method with managed ready-state. Property accepts an async function.
- *
- * When a run-method is invoked, its `active` property to true for duration of call.
- * This is emitted as an update to property, both when called and after returns (or throws).
- *
- * **Note:** Subsequent calls will immediately throw if one is still pending.
- *
- * @param action - Action to fire when resulting property is invoked.
- */
-declare function run(action: Async): typeof action & {
-    active: boolean;
-};
-declare function run<S>(action: Async<S>): typeof action & {
-    active: boolean;
-};
-
 declare namespace get {
     type Function<T, S = any> = (this: S, on: S) => T;
     type Factory<R, T> = (this: T, property: string, on: T) => Function<R, T>;
-    type FindFunction<T extends Model = Model> = (type: Model.Class<T>, relativeTo: Model, required: boolean) => Source<T>;
     type Source<T extends Model = Model> = (callback: (x: T) => void) => void;
-    /** Assign fetch algorithm for get instruction. */
-    let using: (fn: FindFunction) => typeof get;
 }
 /**
  * Fetches and assigns the controller which spawned this host.
@@ -338,8 +294,8 @@ declare function get<R, T extends Model>(Type: Model.Type<T>, compute: (this: T,
  * @param source - Source model from which computed value will be a subscriber.
  * @param compute - Compute function. Bound to a subscriber-proxy of source, returns output value. Will update automatically as input values change.
  */
-declare function get<R, T>(source: T, compute: (this: T, on: T) => R): Exclude<R, undefined>;
-declare function get<R, T>(source: T, compute: (this: T, on: T) => R): R;
+declare function get<R, T extends Model>(source: T, compute: (this: T, on: T) => R): Exclude<R, undefined>;
+declare function get<R, T extends Model>(source: T, compute: (this: T, on: T) => R): R;
 /**
  * Implement a computed value; output is returned by function from provided factory.
  *
@@ -349,7 +305,7 @@ declare function get<R, T>(compute: (property: string, on: T) => (this: T, state
 declare function get<R, T>(compute: (property: string, on: T) => (this: T, state: T) => R): R;
 
 declare namespace ref {
-    type Callback<T, S = any> = (this: S, argument: T) => ((next: T) => void) | Promise<void> | void | boolean;
+    type Callback<T> = (argument: T) => ((next: T) => void) | Promise<void> | void | boolean;
     interface Object<T = any> {
         (next: T): void;
         current: T | null;
@@ -389,11 +345,10 @@ declare function ref<O extends Model, R>(target: O, mapper: (key: Model.Key<O>)
  * @param callback - Optional callback to synchronously fire when reference is first set or does update.
  */
 declare function ref<T = HTMLElement>(callback?: ref.Callback<T>): ref.Object<T>;
-declare function ref<T, S>(callback?: ref.Callback<T, S>): ref.Object<T>;
 
 declare namespace set {
     type Callback<T, S = any> = (this: S, argument: T) => ((next: T) => void) | Promise<any> | void | boolean;
-    type Factory<T, S = unknown> = (this: S, key: string, thisArg: S) => T;
+    type Factory<T, S = any> = (this: S, key: string, thisArg: S) => Promise<T> | T;
 }
 /**
  * Set property with a placeholder.
@@ -402,28 +357,12 @@ declare namespace set {
  * `Promise`/`Error` (ala: [Suspense](https://reactjs.org/docs/concurrent-mode-suspense.html)) will be thrown.
  */
 declare function set<T = any>(): T;
-/**
- * Set property with an async function.
- *
- * Property cannot be accessed until factory resolves, yeilding a result.
- * If accessed while processing, React Suspense will be thrown.
- *
- * - `required: true` (default) -
- *      Run factory immediately upon creation of model instance.
- * - `required: false` -
- *      Run factory only if/when accessed.
- *      Value will always throw suspense at least once - use with caution.
- *
- * @param factory - Callback run to derrive property value.
- * @param required - (default: true) Run factory immediately on creation, otherwise on access.
- */
-declare function set<T>(factory: set.Factory<Promise<T>>, required: false): T | undefined;
-declare function set<T, S>(factory: set.Factory<Promise<T>, S>, required: false): T | undefined;
-declare function set<T>(factory: set.Factory<Promise<T>>, required?: boolean): T;
-declare function set<T, S>(factory: set.Factory<Promise<T>, S>, required?: boolean): T;
 /**
  * Set property with a factory function.
  *
+ * If async, poperty cannot be accessed until resolves, yeilding a result.
+ * If accessed while still processing, React Suspense will be thrown.
+ *
  * - `required: true` (default) -
  *      Run factory immediately upon creation of model instance.
  * - `required: false` -
@@ -433,70 +372,45 @@ declare function set<T, S>(factory: set.Factory<Promise<T>, S>, required?: boole
  * @param factory - Callback run to derrive property value.
  * @param required - (default: true) Run factory immediately on creation, otherwise on access.
  */
-declare function set<T>(factory: set.Factory<T>, required: false): T | undefined;
-declare function set<T, S>(factory: set.Factory<T, S>, required: false): T | undefined;
-declare function set<T>(factory: set.Factory<T>, required?: boolean): T;
-declare function set<T, S>(factory: set.Factory<T, S>, required?: boolean): T;
-declare function set<T>(factory: Promise<T>, required: false): T | undefined;
-declare function set<T>(factory: Promise<T>, required?: boolean): T;
+declare function set<T>(factory: set.Factory<T> | Promise<T>, required: false): T | undefined;
+declare function set<T>(factory: set.Factory<T> | Promise<T>, required?: boolean): T;
 declare function set<T>(value: undefined, onUpdate: set.Callback<T>): T;
-declare function set<T, S>(value: undefined, onUpdate: set.Callback<T, S>): T;
 declare function set<T>(value: T, onUpdate: set.Callback<T>): T;
-declare function set<T, S>(value: T, onUpdate: set.Callback<T, S>): T;
 
-type MapFunction<T, R> = T extends Map<infer K, infer V> ? (value: V, key: K, map: T) => R | void : T extends Set<infer K> ? (value: K, key: K, set: T) => R | void : never;
-type Managed<T> = Exclude<T, "forEach"> & {
-    from?: T;
-    forEach<R>(mapFunction: MapFunction<T, R>, thisArg?: any): Exclude<R, undefined>[] | void;
-};
-
-declare function use<K = any>(initial: SetConstructor): Managed<Set<K>>;
-declare function use<K = any, V = any>(initial: MapConstructor): Managed<Map<K, V>>;
-declare function use(initial: Set<unknown>): Managed<Set<any>>;
-declare function use(initial: Map<unknown, unknown>): Managed<Map<any, any>>;
-declare function use(from: () => Set<unknown>): Managed<Set<any>>;
-declare function use(from: () => Map<unknown, unknown>): Managed<Map<any, any>>;
-declare function use<T extends Set<any> | Map<any, any>>(initial: T): Managed<T>;
-declare function use<T extends Set<any> | Map<any, any>>(from: () => T): Managed<T>;
-/**
- * Create a placeholder for specified Model type.
- */
+/** Create a placeholder for specified Model type. */
 declare function use<T extends Model>(): T | undefined;
-declare function use<T extends Model>(from: () => T, required: false): T | undefined;
-declare function use<T extends Model>(from: () => T, required: boolean): T;
-/**
- * Create a new child instance of model.
- */
+/** Create a new child instance of model. */
 declare function use<T extends Model>(Type: Model.New<T>, callback?: (i: T) => void): T;
+/** Assign the result of a factory as a child model. */
+declare function use<T extends Model>(from: () => Promise<T> | T, required?: true): T;
+/** Assign the result of a factory as a child model. */
+declare function use<T extends Model>(from: () => Promise<T> | T, required: boolean): T | undefined;
+/** Create a managed child from factory function. */
+declare function use<T extends Model>(from: () => Promise<T> | T, callback?: (i: T) => void): T;
 /**
- * Create a managed child from factory function.
- */
-declare function use<T extends {}>(from: () => Promise<T>, required: false): T | undefined;
-declare function use<T extends {}>(from: () => Promise<T>, required: boolean): T;
-declare function use<T extends {}>(from: () => Promise<T>, callback?: (i: T) => void): T;
-declare function use<T extends {}>(from: () => T, callback?: (i: T) => void): T;
-/**
- * Create child-instance relationship with provided model.
- *
- * Note: If `peer` is not already initialized before parent is
- * (created with `new` as opposed to create method), that model will
- * attach this via `parent()` instruction. It will not, however, if
- * already active.
- */
-declare function use<T extends {}>(peer: T, callback?: (i: T) => void): T;
+  * Create child-instance relationship with provided model.
+  *
+  * Note: If `peer` is not already initialized before parent is
+  * (created with `new` as opposed to create method), that model will
+  * attach this via `parent()` instruction. It will not, however, if
+  * already active.
+  */
+declare function use<T extends Model>(peer: T, callback?: (i: T) => void): T;
 
-declare class Register {
+declare namespace Context {
+    type Inputs = {
+        [key: string | number]: Model | Model.New;
+    };
+}
+declare class Context {
     private table;
-    register: Map<string | number, Model | Model.Type>;
+    private input;
     private has;
     get<T extends Model>(Type: Model.Type<T>): T | undefined;
-    add(input: Model.New | Model, key?: number | string): Model;
+    include(inputs: Context.Inputs): Map<Model, boolean>;
+    add<T extends Model>(input: T | Model.New<T>, implicit?: boolean): T;
     push(): this;
     pop(): void;
 }
 
-declare const Internal: {
-    getParent: typeof getParent;
-};
-
-export { Control, Debug, Internal, Model, Register, Subscriber, add, Model as default, get, issues, ref, run, set, use };
+export { Context, Control, Debug, Model, Model as default, get, issues, ref, run, set, use };