@expressive/mvc 0.71.0 → 0.72.0

package/dist/index.d.ts

@@ -6,9 +6,9 @@
  *   - `false` - a normal update has completed.
  *   - `true` - initial event; instance is ready.
  *   - `null` - terminal event; instance is expired.
- * @param source - Instance of Model for which update has occured.
+ * @param source - Instance of State for which update has occured.
  */
-type OnUpdate<T extends Observable = any> = (this: T, key: Event, source: T) => (() => void) | null | void;
+type Notify<T extends Observable = any> = (this: T, key: Event, source: T) => (() => void) | null | void;
 type Effect<T extends Observable> = (proxy: T) => ((update: boolean | null) => void) | Promise<void> | null | void;
 type Event = number | string | null | boolean | symbol;
 type PromiseLite<T = void> = {
@@ -21,61 +21,74 @@ interface Observable {
     [Observable](callback: Observable.Callback, required?: boolean): this | void;
 }
 declare const Observable: unique symbol;
-declare function addListener<T extends Observable>(subject: T, callback: OnUpdate<T>, select?: Event | Set<Event>): () => boolean;
+declare function addListener<T extends Observable>(subject: T, callback: Notify<T>, select?: Event | Set<Event>): () => boolean;
 declare function event(subject: Observable, key?: string | number | symbol | null, silent?: boolean): void;
 /**
  * Create a side-effect which will update whenever values accessed change.
  * Callback is called immediately and whenever values are stale.
  *
- * @param target - Instance of Model to observe.
+ * @param target - Instance of State to observe.
  * @param callback - Function to invoke when values change.
  * @param requireValues - If `true` will throw if accessing a value which is `undefined`.
  */
-declare function createEffect<T extends Model>(target: T, callback: Effect<Required<T>>, requireValues: true): () => void;
-declare function createEffect<T extends Model>(target: T, callback: Effect<T>, recursive?: boolean): () => void;
+declare function watch<T extends State>(target: T, callback: Effect<Required<T>>, requireValues: true): () => void;
+declare function watch<T extends State>(target: T, callback: Effect<T>, recursive?: boolean): () => void;
 
 /** Reference bound instance methods to real ones. */
 declare const METHOD: WeakMap<any, any>;
-declare namespace Model {
-    /** Any type of Model, using own class constructor as its identifier. */
-    type Type<T extends Model = Model> = (abstract new (...args: any[]) => T) & typeof Model;
-    /** A Model constructor, but which is not abstract. */
-    type Init<T extends Model = Model> = (new (...args: Model.Args<T>) => T) & Omit<typeof Model, never>;
+declare namespace State {
     /**
-     * Model constructor callback - is called when Model finishes intializing.
-     * Returned function will run when model is destroyed.
+     * State which is valid to create.
+     *
+     * This interface may be augmented to add dditional
+     * constraints on states, such as special hooks or properties,
+     * to interact with environment or helper frameworks.
+     **/
+    interface Valid extends State {
+        'new'?(): void | (() => void);
+    }
+    /**
+     * A State class which is valid and may be instantiated.
      */
-    type Callback<T extends Model = Model> = (this: T, thisArg: T) => Promise<void> | (() => void) | Assign<T> | void;
-    /** Model constructor argument */
-    type Argument<T extends Model = Model> = Assign<T> | Callback<T> | string | void;
-    /** Model constructor arguments */
-    type Args<T extends Model = any> = (Argument<T> | Args<T>)[];
-    /** Subset of `keyof T` which are not methods or defined by base Model U. **/
-    type Field<T> = Exclude<keyof T, keyof Model>;
-    /** Any valid key for model, including but not limited to Field<T>. */
-    type Event<T> = Field<T> | (string & {}) | number | symbol;
-    /** Object overlay to override values and methods on a model. */
-    type Assign<T> = {
+    type New<T extends State> = State.Class<T & Valid>;
+    /** Any type of State, using own class constructor as its identifier. */
+    type Extends<T extends State = State> = (abstract new (...args: any[]) => T) & typeof State;
+    /** A State constructor which is not abstract. */
+    type Class<T extends State = State> = (new (...args: State.Args<T>) => T) & Omit<typeof State, never>;
+    /** State constructor arguments */
+    type Args<T extends State = any> = (Args<T> | Init<T> | Assign<T> | string | void)[];
+    /**
+     * State constructor callback - is called when State finishes intializing.
+     * Returned function will run when state is destroyed.
+     */
+    type Init<T extends State = State> = (this: T, thisArg: T) => Promise<void> | (() => void) | Args<T> | Assign<T> | void;
+    /** Object overlay to override values and methods on a state. */
+    type Assign<T> = Record<string, unknown> & {
         [K in Field<T>]?: T[K] extends (...args: infer A) => infer R ? (this: T, ...args: A) => R : T[K];
-    } & Record<string, unknown>;
-    /** Export/Import compatible value for a given property in a Model. */
+    };
+    /** Subset of `keyof T` which are not methods or defined by base State U. **/
+    type Field<T> = Exclude<keyof T, keyof State>;
+    /** Any valid key for state, including but not limited to Field<T>. */
+    type Event<T> = Field<T> | number | symbol | (string & {});
+    /** Export/Import compatible value for a given property in a State. */
     type Export<R> = R extends {
         get(): infer T;
     } ? T : R;
-    /** Value for a property managed by a model. */
-    type Value<T extends Model, K extends Event<T>> = K extends keyof T ? Export<T[K]> : unknown;
-    type OnEvent<T extends Model> = (this: T, key: unknown, source: T) => (() => void) | void | null;
-    type OnUpdate<T extends Model, K extends Event<T>> = (this: T, key: K, thisArg: K) => void;
+    /** Value for a property managed by a state. */
+    type Value<T extends State, K extends Event<T>> = K extends keyof T ? Export<T[K]> : unknown;
+    type Setter<T> = (value: T, previous: T) => boolean | void | (() => T);
+    type OnEvent<T extends State> = (this: T, key: unknown, source: T) => void | (() => void) | null;
+    type OnUpdate<T extends State, K extends Event<T>> = (this: T, key: K, thisArg: K) => void;
     /**
-     * Values from current state of given model.
+     * Values from current state of given state.
      * Differs from `Values` as values here will drill
      * into "real" values held by exotics like ref.Object.
      */
-    type State<T> = {
+    type Values<T> = {
         [P in Field<T>]: Export<T[P]>;
     };
     /** Object comperable to data found in T. */
-    type Values<T> = {
+    type Partial<T> = {
         [P in Field<T>]?: Export<T[P]>;
     };
     /** Exotic value, where actual value is contained within. */
@@ -86,7 +99,7 @@ declare namespace Model {
     /**
      * A callback function which is subscribed to parent and updates when accessed properties change.
      *
-     * @param current - Current state of this model. This is a proxy which detects properties which
+     * @param current - Current state of this state. This is a proxy which detects properties which
      * where accessed, and thus depended upon to stay current.
      *
      * @param update - Set of properties which have changed, and events fired, since last update.
@@ -97,48 +110,35 @@ declare namespace Model {
     /**
      * A callback function returned by effect. Will be called when effect is stale.
      *
-     * @param update - `true` if update is pending, `false` effect has been cancelled, `null` if model is destroyed.
-     */
-    type EffectCallback = ((update: boolean | null) => void);
-    /**
-     * Property initializer, will run upon instance creation.
-     * Optional returned callback will run when once upon first access.
+     * @param update - `true` if update is pending, `false` effect has been cancelled, `null` if state is destroyed.
      */
-    type Instruction<T = any, M extends Model = any> = (this: M, key: Extract<Field<M>, string>, thisArg: M, state: State<M>) => Descriptor<T> | ((source: M) => T) | void;
-    type Getter<T> = (source: Model) => T;
-    type Setter<T> = (value: T, previous: T) => boolean | void | (() => T);
-    type Descriptor<T = any> = {
-        get?: Getter<T> | boolean;
-        set?: Setter<T> | boolean;
-        enumerable?: boolean;
-        value?: T;
-    };
+    type EffectCallback = (update: boolean | null) => void;
 }
-interface Model {
+interface State {
     /**
-     * Loopback to instance of this model. This is useful when in a subscribed context,
+     * Loopback to instance of this state. This is useful when in a subscribed context,
      * to keep write access to `this` after a destructure. You can use it to read variables silently as well.
      **/
     is: this;
 }
-declare abstract class Model implements Observable {
-    constructor(...args: Model.Args);
+declare abstract class State implements Observable {
+    constructor(...args: State.Args);
     [Observable](callback: Observable.Callback, required?: boolean): this;
     /**
-     * Pull current values from state. Flattens all models and exotic values recursively.
+     * Pull current values from state. Flattens all states and exotic values recursively.
      *
-     * @returns Object with all values from this model.
+     * @returns Object with all values from this state.
      **/
-    get(): Model.State<this>;
+    get(): State.Values<this>;
     /**
      * Run a function which will run automatically when accessed values change.
      *
      * @param effect Function to run, and again whenever accessed values change.
      *               If effect returns a function, it will be called when a change occurs (syncronously),
-     *               effect is cancelled, or parent model is destroyed.
+     *               effect is cancelled, or parent state is destroyed.
      * @returns Function to cancel listener.
      */
-    get(effect: Model.Effect<this>): () => void;
+    get(effect: State.Effect<this>): () => void;
     /**
      * Get value of a property.
      *
@@ -146,7 +146,7 @@ declare abstract class Model implements Observable {
      * @param required - If true, will throw an error if property is not available.
      * @returns Value of property.
      */
-    get<T extends Model.Event<this>>(key: T, required?: boolean): Model.Value<this, T>;
+    get<T extends State.Event<this>>(key: T, required?: boolean): State.Value<this, T>;
     /**
      * Run a function when a property is updated.
      *
@@ -154,18 +154,18 @@ declare abstract class Model implements Observable {
      * @param callback - Function to call when property is updated.
      * @returns Function to cancel listener.
      */
-    get<T extends Model.Event<this>>(key: T, callback: Model.OnUpdate<this, T>): () => void;
+    get<T extends State.Event<this>>(key: T, callback: State.OnUpdate<this, T>): () => void;
     /**
-     * Check if model is expired.
+     * Check if state is expired.
      *
-     * @param status - `null` to check if model is expired.
-     * @returns `true` if model is expired, `false` otherwise.
+     * @param status - `null` to check if state is expired.
+     * @returns `true` if state is expired, `false` otherwise.
      */
     get(status: null): boolean;
     /**
-     * Callback when model is to be destroyed.
+     * Callback when state is to be destroyed.
      *
-     * @param callback - Function to call when model is destroyed.
+     * @param callback - Function to call when state is destroyed.
      * @returns Function to cancel listener.
      */
     get(status: null, callback: () => void): () => void;
@@ -174,16 +174,16 @@ declare abstract class Model implements Observable {
      *
      * @returns Promise which resolves object with updated values, `undefined` if there no update is pending.
      **/
-    set(): PromiseLike<Model.Event<this>[]> | undefined;
+    set(): PromiseLike<State.Event<this>[]> | undefined;
     /**
      * Update mulitple properties at once. Merges argument with current state.
-     * Properties which are not managed by this model will be ignored.
+     * Properties which are not managed by this state will be ignored.
      *
      * @param assign - Object with properties to update.
      * @param silent - If an update does occur, listeners will not be refreshed automatically.
      * @returns Promise resolving an array of keys updated, `undefined` (immediately) if a noop.
      */
-    set(assign?: Model.Assign<this>, silent?: boolean): PromiseLike<Model.Event<this>[]> | undefined;
+    set(assign?: State.Assign<this>, silent?: boolean): PromiseLike<State.Event<this>[]> | undefined;
     /**
      * Push an update. This will not change the value of associated property.
      *
@@ -198,7 +198,7 @@ declare abstract class Model implements Observable {
      * @param key - Property or event to dispatch.
      * @returns Promise resolves an array of keys updated.
      */
-    set(key: Model.Event<this>): PromiseLike<Model.Event<this>[]>;
+    set(key: State.Event<this>): PromiseLike<State.Event<this>[]>;
     /**
      * Set a value for a property. This will update the value and notify listeners.
      *
@@ -211,10 +211,10 @@ declare abstract class Model implements Observable {
      *
      * @param key - Property to set value for.
      * @param value - Value to set for property.
-     * @param init - If true, model will begin to manage the property if it is not already.
+     * @param init - If true, state will begin to manage the property if it is not already.
      * @returns Promise resolves an array of keys updated.
      */
-    set(key: Model.Event<this>, value: unknown, init?: boolean): PromiseLike<Model.Event<this>[]>;
+    set(key: State.Event<this>, value: unknown, init?: boolean): PromiseLike<State.Event<this>[]>;
     /**
      * Call a function when update occurs.
      *
@@ -226,16 +226,16 @@ declare abstract class Model implements Observable {
      * @param callback - Function to call when update occurs.
      * @returns Function to remove listener. Will return `true` if removed, `false` if inactive already.
      *
-    */
-    set(callback: Model.OnEvent<this>): () => boolean;
+     */
+    set(callback: State.OnEvent<this>): () => boolean;
     /**
      * Call a function when a property is updated.
-     * Unlike `get`, this calsl synchronously and will fire as many times as the property is updated.
+     * Unlike `get`, this calls synchronously and will fire as many times as the property is updated.
      *
      * @param callback - Function to call when property is updated.
      * @param event - Property to watch for updates.
      */
-    set(callback: Model.OnEvent<this>, event: Model.Event<this> | null): () => boolean;
+    set(callback: State.OnEvent<this>, event: State.Event<this> | null): () => boolean;
     /**
      * Declare an end to updates. This event is final and will freeze state.
      * This event can be watched for as well, to run cleanup logic and internally will remove all listeners.
@@ -244,46 +244,60 @@ declare abstract class Model implements Observable {
      */
     set(status: null): void;
     /**
-     * Iterate over managed properties in this instance of Model.
+     * Iterate over managed properties in this instance of State.
      * Yeilds the key and current value for each property.
      */
     [Symbol.iterator](): Iterator<[string, unknown]>;
     /**
-     * Create and activate a new instance of this model.
+     * Create and activate a new instance of this state.
      *
      * **Important** - Unlike `new this(...)` - this method also activates state.
      *
      * @param args - arguments sent to constructor
      */
-    static new<T extends Model>(this: Model.Init<T>, ...args: Model.Args<T>): T;
+    static new<T extends State>(this: State.New<T>, ...args: State.Args<T>): T;
     /**
      * Static equivalent of `x instanceof this`.
      * Determines if provided class is a subtype of this one.
      * If so, language server will make available all static
      * methods and properties of this class.
      */
-    static is<T extends Model.Type>(this: T, maybe: unknown): maybe is T;
+    static is<T extends State.Extends>(this: T, maybe: unknown): maybe is T;
     /**
-     * Register a callback to run when any instance of this Model is updated.
+     * Register a callback to run when any instance of this State is updated.
      */
-    static on<T extends Model>(this: Model.Type<T>, listener: Model.OnEvent<T>): () => boolean;
+    static on<T extends State>(this: State.Extends<T>, listener: State.OnEvent<T>): () => boolean;
+}
+
+/**
+ * Property initializer, will run upon instance creation.
+ * Optional returned callback will run when once upon first access.
+ */
+type Instruction<T = any, M extends State = any> = (this: M, key: Extract<State.Field<M>, string>, thisArg: M, state: State.Values<M>) => Instruction.Descriptor<T> | ((source: M) => T) | void;
+declare namespace Instruction {
+    type Getter<T> = (source: State) => T;
+    type Descriptor<T = any> = {
+        get?: Getter<T> | boolean;
+        set?: State.Setter<T> | boolean;
+        enumerable?: boolean;
+        value?: T;
+    };
 }
+declare function use<T>(instruction: Instruction<T>): T extends void ? unknown : T;
+declare function use<T extends State>(Type: State.New<T>, required: false): T | undefined;
+declare function use<T extends State>(Type: State.New<T>, ready?: (i: T) => void): T;
 
 declare namespace get {
-    type Compute<T, S = any> = (on: S, key: string) => T;
-    type Factory<T, S = any> = (this: S, key: string, thisArg: S) => T;
-    type Source<T extends Model = Model> = (resolve: (x: T) => void) => void;
-    type Effect<T> = (model: T, key: string) => (() => void) | void;
+    type Callback<T = any> = (state: T, subject: State) => void | boolean | (() => void);
 }
 /**
- * Fetches and assigns the controller which spawned this host.
- * When parent assigns an instance via `use()` directive, it
- * will be made available to child upon this request.
+ * Fetches upstream State from context with optional lifecycle callback.
+ * Callback runs on mount and can return cleanup function for unmount.
  *
- * @param Type - Type of controller compatible with this class.
- * @param expectParent - If true, will throw if Model is created without a parent.
+ * @param Type - Type of State to fetch.
+ * @param callback - Optional lifecycle callback, receives (state, subject). Can return cleanup function.
  */
-declare function get<T extends Model>(Type: Model.Type<T>, expectParent?: true): T;
+declare function get<T extends State>(Type: State.Extends<T>, callback?: get.Callback<T>): T;
 /**
  * Fetches and assigns the controller which spawned this host.
  * When parent assigns an instance via `use()` directive, it
@@ -292,39 +306,90 @@ declare function get<T extends Model>(Type: Model.Type<T>, expectParent?: true):
  * @param Type - Type of controller compatible with this class.
  * @param required - If false, property may be undefined. Otherwise will throw suspense.
  */
-declare function get<T extends Model>(Type: Model.Type<T>, required?: false): T | undefined;
+declare function get<T extends State>(Type: State.Extends<T>, required: false): T | undefined;
 /**
- * Implement a computed value from a foreign model. Output will be generated by provided function,
- * where the foreign model will be passed to that function.
+ * Collects downstream States, this will accumulate all instances of specified type for which this is an ancestor.
+ * Returns a frozen array that updates as States are added or removed.
+ * Callback runs on each State registration and can return cleanup or false to prevent registration.
  *
- * @param source - Type of Model to fetch for computation.
- * @param compute - Compute function. Will update automatically as input values change.
+ * @param Type - Type of State to collect.
+ * @param downstream - Must be true to enable downstream mode.
+ * @param callback - Optional lifecycle callback, receives (state, subject). May return false to prevent registration.
  */
-declare function get<T extends Model>(Type: Model.Type<T>, effect: get.Effect<T>): T;
+declare function get<T extends State>(Type: State.Extends<T>, downstream: true, callback?: get.Callback<T>): readonly T[];
+
+declare namespace set {
+    type Callback<T, S = any> = (this: S, next: T, previous: T) => ((next: T) => void) | Promise<any> | void | boolean;
+    type Compute<T, S = any> = (on: S, key: string) => T;
+    type Factory<T, S = any> = (this: S, key: string) => Promise<T> | T;
+}
 /**
- * Implement a computed value; output will be generated by provided function.
+ * Set property as `undefined` but required.
  *
- * @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.
+ * Property cannot be accessed until it is defined. If accessed while undefined, a hybrid
+ * `Promise`/`Error` (aka: [Suspense](https://reactjs.org/docs/concurrent-mode-suspense.html)) will be thrown.
+ */
+declare function set<T = any>(): T;
+/**
+ * Set property with a factory function.
+ *
+ * **Note** Factory is lazy! It will only run if/when property is accessed.
+ * Value will be undefined until factory resolves, which will also dispatch an update for the property.
+ */
+declare function set<T>(factory: set.Factory<T>, required: false): T | undefined;
+/**
+ * Set property with a factory function.
+ *
+ * If async, property cannot be accessed until resolves, yeilding a result.
+ * If accessed while still processing, React Suspense will be thrown.
+ *
+ * @param factory - Callback run to derrive property value.
+ * @param required - If true run factory immediately on creation, otherwise on access.
+ */
+declare function set<T>(factory: set.Factory<T>, required?: boolean): T;
+/**
+ * Set property with a factory function.
+ *
+ * If async, property cannot be accessed until resolves, yeilding a result.
+ * If accessed while still processing, React Suspense will be thrown.
+ *
+ * @param factory - Callback run to derrive property value.
+ * @param onUpdate - Callback run when property is finished computing or is set.
+ */
+declare function set<T>(factory: set.Factory<T>, onUpdate?: set.Callback<T>): T;
+/**
+ * Set a property with empty placeholder and/or update callback.
+ *
+ * @param value - Starting value for property. If undefined, suspense will be thrown on access, until value is set and accepted by callback.
+ * @param onUpdate - Callback run when property is set. If returns false, update is not accepted and property will keep previous value.
  */
-declare function get<R, T extends Model>(source: T, compute: get.Compute<R, T>): R;
+declare function set<T>(value: T | undefined, onUpdate?: set.Callback<T>): T;
 /**
- * Implement a computed value; output is returned by function from provided factory.
+ * Implement a reactive computed value using a method reference.
  *
- * Factory is bound to owner of property.
+ * The method will automatically re-run when any accessed properties change.
+ * Use `true` to indicate reactive mode with implicit `this` as the source.
  *
- * @param compute - Factory function to generate a getter to subscribe dependancies.
+ * @param reactiveToThis - Pass `true` to enable reactive mode with implicit this
+ * @param method - Method reference or compute function to use
+ */
+declare function set<R, T = any>(reactiveToThis: true, method: set.Compute<R, T> | Function): R;
+/**
+ * Implement a computed value; output will be generated by provided function.
+ *
+ * @param reactiveTo - Source state 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>(compute: get.Factory<R, T>): R;
+declare function set<R, T extends State>(reactiveTo: T, compute: set.Compute<R, T>): R;
 
 declare namespace ref {
     type Callback<T> = (argument: T) => ((next: T | null) => void) | Promise<void> | void | boolean;
     interface Object<T = any> {
         /** Current value held by this reference. */
         current: T;
-        /** Model instance this reference belongs to. */
-        is: Model;
-        /** Key of property on model this reference belongs to. */
+        /** State instance this reference belongs to. */
+        is: State;
+        /** Key of property on state this reference belongs to. */
         key: string;
         /**
          * Subscribe to changes of this reference.
@@ -338,13 +403,13 @@ declare namespace ref {
     }
     /** Object with references to all managed values of `T`. */
     /** Object with references to all managed values of `T`. */
-    type Proxy<T extends Model> = {
-        [P in Model.Field<T>]-?: Object<T[P]>;
+    type Proxy<T extends State> = {
+        [P in State.Field<T>]-?: Object<T[P]>;
     } & {
         get(): T;
     };
-    type CustomProxy<T extends Model, R> = {
-        [P in Model.Field<T>]-?: R;
+    type CustomProxy<T extends State, R> = {
+        [P in State.Field<T>]-?: R;
     } & {
         get(): T;
     };
@@ -355,18 +420,18 @@ declare namespace ref {
  *
  * *Properties are simultaneously a ref-function and ref-object, use as needed.*
  *
- * @param target - Source model from which to reference values.
+ * @param target - Source state from which to reference values.
  */
-declare function ref<T extends Model>(target: T): ref.Proxy<T>;
+declare function ref<T extends State>(target: T): ref.Proxy<T>;
 /**
  * Creates an object with values based on managed values.
  * Each property will invoke mapper function on first access supply
  * the its return value going forward.
  *
- * @param target - Source model from which to reference values.
+ * @param target - Source state from which to reference values.
  * @param mapper - Function producing the placeholder value for any given property.
  */
-declare function ref<O extends Model, R>(target: O, mapper: (key: Model.Field<O>) => R): ref.CustomProxy<O, R>;
+declare function ref<O extends State, R>(target: O, mapper: (key: State.Field<O>) => R): ref.CustomProxy<O, R>;
 /**
  * Creates a ref-compatible property.
  * Will persist value, and updates to this are made part of controller event-stream.
@@ -387,91 +452,61 @@ declare function ref<T>(callback?: ref.Callback<T>): ref.Object<T>;
  */
 declare function ref<T>(callback: ref.Callback<T | null>, ignoreNull: boolean): ref.Object<T>;
 
-declare namespace set {
-    type Callback<T, S = any> = (this: S, next: T, previous: T) => ((next: T) => void) | Promise<any> | void | boolean;
-    type Factory<T, S = any> = (this: S, key: string) => Thenable<T> | T;
-    type Thenable<T> = {
-        then: (onFulfilled?: (value: T) => any, onRejected?: (reason: any) => any) => any;
-    };
-}
-/**
- * Set property as `undefined` but required.
- *
- * Property cannot be accessed until it is defined. If accessed while undefined, a hybrid
- * `Promise`/`Error` (aka: [Suspense](https://reactjs.org/docs/concurrent-mode-suspense.html)) will be thrown.
- */
-declare function set<T = any>(): T;
-/**
- * Set property with a factory function.
- *
- * **Note** Factory is lazy! It will only run if/when property is accessed.
- * Value will be undefined until factory resolves, which will also dispatch an update for the property.
- */
-declare function set<T>(factory: set.Factory<T> | set.Thenable<T>, required: false): T | undefined;
-/**
- * Set property with a factory function.
- *
- * If async, property cannot be accessed until resolves, yeilding a result.
- * If accessed while still processing, React Suspense will be thrown.
- *
- * @param factory - Callback run to derrive property value.
- * @param required - If true run factory immediately on creation, otherwise on access.
- */
-declare function set<T>(factory: set.Factory<T> | set.Thenable<T>, required?: boolean): T;
-/**
- * Set property with a factory function.
- *
- * If async, property cannot be accessed until resolves, yeilding a result.
- * If accessed while still processing, React Suspense will be thrown.
- *
- * @param factory - Callback run to derrive property value.
- * @param onUpdate - Callback run when property is finished computing or is set.
- */
-declare function set<T>(factory: set.Factory<T> | set.Thenable<T>, onUpdate?: set.Callback<T>): T;
-/**
- * Set a property with empty placeholder and/or update callback.
- *
- * @param value - Starting value for property. If undefined, suspense will be thrown on access, until value is set and accepted by callback.
- * @param onUpdate - Callback run when property is set. If returns false, update is not accepted and property will keep previous value.
- */
-declare function set<T>(value: T | undefined, onUpdate?: set.Callback<T>): T;
-
-declare function use<T>(instruction: Model.Instruction<T>): T extends void ? unknown : T;
-declare function use<T extends Model>(Type: Model.Init<T>, required: false): T | undefined;
-declare function use<T extends Model>(Type: Model.Init<T>, ready?: (i: T) => void): T;
-
-declare namespace has {
-    type Callback<T = any> = (model: T, recipient: Model) => void | boolean | (() => void);
-}
-declare function has<T extends Model>(type: Model.Type<T>, callback?: has.Callback<T>): readonly T[];
-declare function has(callback?: has.Callback): readonly Model[];
-
 declare namespace Context {
-    type Multiple<T extends Model> = {
-        [key: string | number]: Model.Init<T> | T;
+    type Multiple<T extends State> = {
+        [key: string | number]: State.Class<T> | T;
     };
-    type Accept<T extends Model = Model> = T | Model.Init<T> | Multiple<T>;
-    type Expect<T extends Model = Model> = (model: T) => (() => void) | void;
+    type Accept<T extends State = State> = T | State.Class<T> | Multiple<T>;
+    type Expect<T extends State = State> = (state: T) => (() => void) | void;
 }
 interface Context {
-    [key: symbol]: Model | Context.Expect | null | undefined;
+    [key: symbol]: State | Context.Expect | null | undefined;
 }
 declare class Context {
-    static get<T extends Model>(on: Model, callback: ((got: Context) => void)): void;
-    static get<T extends Model>(on: Model): Context | undefined;
+    /**
+     * Get the context for a specified State. If a callback is provided, it will be run when
+     * the context becomes available.
+     */
+    static get<T extends State>(on: State, callback: (got: Context) => void): void;
+    /**
+     * Get the context for a specified State. Returns undefined if none are found.
+     */
+    static get<T extends State>(on: State): Context | undefined;
     id: string;
-    protected layer: Map<string | number, Model | Model.Type<Model>>;
+    protected inputs: Record<string | number, State | State.Extends>;
     protected cleanup: Set<() => void>;
     constructor(inputs?: Context.Accept);
-    /** Run callback when a specified type is registered to a **child** context. */
-    has<T extends Model>(Type: Model.Type<T>, callback: (model: T) => void): void;
+    /** Find specified type registered to a parent context. Throws if none are found. */
+    get<T extends State>(Type: State.Extends<T>, require: true): T;
     /** Find specified type registered to a parent context. Returns undefined if none are found. */
-    get<T extends Model>(Type: Model.Type<T>, require: true): T;
-    get<T extends Model>(Type: Model.Type<T>, require?: boolean): T | undefined;
+    get<T extends State>(Type: State.Extends<T>, require?: boolean): T | undefined;
+    /** Run callback when a specified type is registered in context downstream. */
+    get<T extends State>(Type: State.Extends<T>, callback: (state: T) => void): () => void;
+    /**
+     * Adds a State to this context.
+     */
+    protected add<T extends State>(input: T | State.Class<T>, implicit?: boolean): T;
+    /**
+     * Register one or more States to this context.
+     *
+     * Context will add or remove States as needed to keep with provided input.
+     *
+     * @param inputs State, State class, or map of States / State classes to register.
+     * @param forEach Optional callback to run for each State registered.
+     */
+    use<T extends State>(inputs: Context.Accept<T>, forEach?: Context.Expect<T>): void;
+    /**
+     * Create a child context, optionally registering one or more States to it.
+     *
+     * @param inputs State, State class, or map of States / State classes to register.
+     */
     push(inputs?: Context.Accept): this;
+    /**
+     * Remove all States from this context.
+     *
+     * Will also run any cleanup callbacks registered when States were added.
+     */
     pop(): void;
-    include<T extends Model>(inputs: Context.Accept<T>, forEach?: Context.Expect<T>): void;
-    protected add<T extends Model>(input: T | Model.Init<T>, implicit?: boolean): T;
 }
 
-export { Context, METHOD, Model, Observable, addListener, createEffect, Model as default, event, get, has, ref, set, use };
+export { Context, Instruction, METHOD, Observable, State, addListener, State as default, event, get, ref, set, use, watch };