@expressive/mvc 0.64.0 → 0.64.2

package/dist/esm/control.js

@@ -77,14 +77,15 @@ function createEffect(target, callback, argument) {
   function invoke() {
     let stale;
     function onUpdate() {
-      if (stale)
-        return null;
+      if (stale || reset === null)
+        return;
       stale = true;
       if (reset && unset) {
         unset(true);
         unset = void 0;
       }
-      return reset;
+      enqueue(invoke);
+      return { then: enqueue };
     }
     const subscriber = target[Observable](onUpdate, argument === true);
     try {
@@ -143,4 +144,4 @@ export {
   enter,
   event
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/control.ts"],
  "sourcesContent": ["/**\n * Update callback function.\n * \n * @param key -\n *   - `string` - property which has updated.\n *   - `false` - a normal update has completed.\n *   - `true` - initial event; instance is ready.\n *   - `null` - terminal event; instance is expired.\n * @param source - Instance of Model for which update has occured.\n */\ntype OnUpdate<T extends Observable = any> = \n  (this: T, key: unknown, source: T) => (() => void) | null | void;\n\ntype Effect<T extends Observable> = (this: T, proxy: T) =>\n  ((update: boolean | null) => void) | Promise<void> | null | void;\n\ntype Event = number | string | null | boolean | symbol;\n\ninterface Observable {\n  [Observable](callback: OnUpdate, required?: boolean): this;\n}\n\nconst Observable = Symbol(\"observe\");\n\n/** Placeholder event determines if model is initialized or not. */\nconst onReady = () => null;\n\nconst LISTENERS = new WeakMap<Observable, Map<OnUpdate, Set<Event> | undefined>>();\n\n/** Events pending for a given object. */\nconst PENDING = new WeakMap<Observable, Set<Event>>();\n\n/** Update register. */\nconst PENDING_KEYS = new WeakMap<Observable, Set<string | number | symbol>>();\n\n/** Central event dispatch. Bunches all updates to occur at same time. */\nconst DISPATCH = new Set<() => void>();\n\nfunction addListener<T extends Observable>(\n  subject: T, callback: OnUpdate<T>, select?: Event | Set<Event>){\n\n  let listeners = LISTENERS.get(subject)!;\n\n  if(!listeners)\n    LISTENERS.set(subject, listeners = new Map([[onReady, undefined]]));\n\n  if(select !== undefined && !(select instanceof Set))\n    select = new Set([select]);\n\n  if(!listeners.has(onReady) && !select)\n    callback.call(subject, true, subject);\n\n  listeners.set(callback, select);\n\n  return () => listeners.delete(callback);\n}\n\nfunction emit(model: Observable, key: Event): void {\n  const listeners = LISTENERS.get(model)!;\n  const notReady = listeners.has(onReady);\n\n  if(key === true && !notReady)\n    return;\n\n  let pending = PENDING.get(model);\n\n  if(pending){\n    pending.add(key);\n    return;\n  }\n\n  PENDING.set(model, pending = new Set(notReady ? [true, key] : [key]));\n\n  for(const key of pending)\n    for(const [callback, filter] of listeners)\n      if(!filter || filter.has(key)){\n        const after = callback.call(model, key, model);\n\n        if(after)\n          enqueue(after);\n\n        else if(after === null)\n          listeners.delete(callback);\n      }\n\n  if(key === null)\n    listeners.clear();\n  \n  PENDING.delete(model);\n}\n\nfunction event(\n  subject: Observable,\n  key?: string | number | symbol | null,\n  silent?: boolean){\n\n  if(key === null)\n    return emit(subject, key);\n\n  if(!key)\n    return emit(subject, true);\n\n  let pending = PENDING_KEYS.get(subject);\n\n  if(!pending){\n    PENDING_KEYS.set(subject, pending = new Set());\n\n    if(!silent)\n      enqueue(() => {\n        emit(subject, false);\n        PENDING_KEYS.delete(subject)\n      })\n  }\n\n  pending.add(key);\n\n  if(!silent)\n    emit(subject, key);\n}\n\nfunction enqueue(eventHandler: (() => void)){\n  if(!DISPATCH.size)\n    setTimeout(() => {\n      DISPATCH.forEach(event => {\n        try {\n          event();\n        }\n        catch(err){\n          console.error(err);\n        }\n      });\n      DISPATCH.clear();\n    }, 0);\n\n  DISPATCH.add(eventHandler);\n}\n\n/**\n * Create a side-effect which will update whenever values accessed change.\n * Callback is called immediately and whenever values are stale.\n * \n * @param target - Instance of Model to observe.\n * @param callback - Function to invoke when values change.\n * @param requireValues - If `true` will throw if accessing a value which is `undefined`.\n */\nfunction createEffect<T extends Observable>(target: T, callback: Effect<Required<T>>, requireValues: true): () => void;\nfunction createEffect<T extends Observable>(target: T, callback: Effect<T>, recursive?: boolean): () => void;\nfunction createEffect<T extends Observable>(target: T, callback: Effect<T>, argument?: boolean){\n  let unset: ((update: boolean | null) => void) | undefined;\n  let reset: (() => void) | null | undefined;\n\n  function invoke(){\n    let stale: boolean | undefined;\n\n    function onUpdate() {\n      if (stale)\n        return null;\n\n      stale = true;\n\n      if (reset && unset) {\n        unset(true);\n        unset = undefined;\n      }\n\n      return reset;\n    }\n\n    const subscriber = target[Observable](onUpdate, argument === true);\n\n    try {\n      const exit = enter(argument === false);\n      const output = callback.call(subscriber, subscriber);\n      const flush = exit();\n\n      reset = output === null ? null : invoke;\n      unset = key => {\n        if(typeof output == \"function\")\n          output(key);\n\n        flush();\n      }\n    }\n    catch(err){\n      if(err instanceof Promise){\n        reset = undefined;\n        err.then(invoke);\n      }\n      else\n        throw err;\n    }\n  }\n\n  function cleanup(){\n    if(unset)\n      unset(false);\n\n    reset = null;\n  };\n\n  if(EffectContext && argument !== false)\n    EffectContext.add(cleanup);\n\n  addListener(target, key => {\n    if(key === true)\n      invoke();\n\n    else if(!reset)\n      return reset;\n\n    if(key === null && unset)\n      unset(null);\n  });\n  \n  return cleanup;\n}\n\nlet EffectContext: Set<() => void> | undefined;\n\nexport function enter(ignore?: boolean){\n  if(ignore)\n    return () => () => {};\n\n  const last = EffectContext;\n  const context = EffectContext = new Set;\n\n  return () => {\n    EffectContext = last;\n    return () => context.forEach(fn => fn());\n  }\n}\n\nexport {\n  addListener,\n  createEffect,\n  event,\n  OnUpdate,\n  PENDING_KEYS,\n  Observable\n}"],
  "mappings": "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",
  "names": ["key", "event"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/control.ts"],
  "sourcesContent": ["/**\n * Update callback function.\n * \n * @param key -\n *   - `string` - property which has updated.\n *   - `false` - a normal update has completed.\n *   - `true` - initial event; instance is ready.\n *   - `null` - terminal event; instance is expired.\n * @param source - Instance of Model for which update has occured.\n */\ntype OnUpdate<T extends Observable = any> = \n  (this: T, key: Event, source: T) => (() => void) | null | void;\n\ntype Effect<T extends Observable> = (this: T, proxy: T) =>\n  ((update: boolean | null) => void) | Promise<void> | null | void;\n\ntype Event = number | string | null | boolean | symbol;\n\ntype PromiseLite<T = void> = { then: (callback: () => T) => T };\n\ndeclare namespace Observable {\n  export type Callback = () => void | PromiseLite;\n}\n\ninterface Observable {\n  [Observable](callback: Observable.Callback, required?: boolean): this;\n}\n\nconst Observable = Symbol(\"observe\");\n\n/** Placeholder event determines if model is initialized or not. */\nconst onReady = () => null;\n\nconst LISTENERS = new WeakMap<Observable, Map<OnUpdate, Set<Event> | undefined>>();\n\n/** Events pending for a given object. */\nconst PENDING = new WeakMap<Observable, Set<Event>>();\n\n/** Update register. */\nconst PENDING_KEYS = new WeakMap<Observable, Set<string | number | symbol>>();\n\n/** Central event dispatch. Bunches all updates to occur at same time. */\nconst DISPATCH = new Set<() => void>();\n\nfunction addListener<T extends Observable>(\n  subject: T, callback: OnUpdate<T>, select?: Event | Set<Event>){\n\n  let listeners = LISTENERS.get(subject)!;\n\n  if(!listeners)\n    LISTENERS.set(subject, listeners = new Map([[onReady, undefined]]));\n\n  if(select !== undefined && !(select instanceof Set))\n    select = new Set([select]);\n\n  if(!listeners.has(onReady) && !select)\n    callback.call(subject, true, subject);\n\n  listeners.set(callback, select);\n\n  return () => listeners.delete(callback);\n}\n\nfunction emit(model: Observable, key: Event): void {\n  const listeners = LISTENERS.get(model)!;\n  const notReady = listeners.has(onReady);\n\n  if(key === true && !notReady)\n    return;\n\n  let pending = PENDING.get(model);\n\n  if(pending){\n    pending.add(key);\n    return;\n  }\n\n  PENDING.set(model, pending = new Set(notReady ? [true, key] : [key]));\n\n  for(const key of pending)\n    for(const [callback, filter] of listeners)\n      if(!filter || filter.has(key)){\n        const after = callback.call(model, key, model);\n\n        if(after)\n          enqueue(after);\n\n        else if(after === null)\n          listeners.delete(callback);\n      }\n\n  if(key === null)\n    listeners.clear();\n  \n  PENDING.delete(model);\n}\n\nfunction event(\n  subject: Observable,\n  key?: string | number | symbol | null,\n  silent?: boolean){\n\n  if(key === null)\n    return emit(subject, key);\n\n  if(!key)\n    return emit(subject, true);\n\n  let pending = PENDING_KEYS.get(subject);\n\n  if(!pending){\n    PENDING_KEYS.set(subject, pending = new Set());\n\n    if(!silent)\n      enqueue(() => {\n        emit(subject, false);\n        PENDING_KEYS.delete(subject)\n      })\n  }\n\n  pending.add(key);\n\n  if(!silent)\n    emit(subject, key);\n}\n\nfunction enqueue(eventHandler: (() => void)){\n  if(!DISPATCH.size)\n    setTimeout(() => {\n      DISPATCH.forEach(event => {\n        try {\n          event();\n        }\n        catch(err){\n          console.error(err);\n        }\n      });\n      DISPATCH.clear();\n    }, 0);\n\n  DISPATCH.add(eventHandler);\n}\n\n/**\n * Create a side-effect which will update whenever values accessed change.\n * Callback is called immediately and whenever values are stale.\n * \n * @param target - Instance of Model to observe.\n * @param callback - Function to invoke when values change.\n * @param requireValues - If `true` will throw if accessing a value which is `undefined`.\n */\nfunction createEffect<T extends Observable>(target: T, callback: Effect<Required<T>>, requireValues: true): () => void;\nfunction createEffect<T extends Observable>(target: T, callback: Effect<T>, recursive?: boolean): () => void;\nfunction createEffect<T extends Observable>(target: T, callback: Effect<T>, argument?: boolean){\n  let unset: ((update: boolean | null) => void) | undefined;\n  let reset: (() => void) | null | undefined;\n\n  function invoke() {\n    let stale: boolean | undefined;\n\n    function onUpdate(): void | PromiseLite<void> {\n      if (stale || reset === null)\n        return;\n\n      stale = true;\n\n      if (reset && unset) {\n        unset(true);\n        unset = undefined;\n      }\n\n      enqueue(invoke);\n      return { then: enqueue }\n    }\n\n    const subscriber = target[Observable](onUpdate, argument === true);\n\n    try {\n      const exit = enter(argument === false);\n      const output = callback.call(subscriber, subscriber);\n      const flush = exit();\n\n      reset = output === null ? null : invoke;\n      unset = key => {\n        if(typeof output == \"function\")\n          output(key);\n\n        flush();\n      }\n    }\n    catch(err){\n      if(err instanceof Promise){\n        reset = undefined;\n        err.then(invoke);\n      }\n      else\n        throw err;\n    }\n  }\n\n  function cleanup(){\n    if(unset)\n      unset(false);\n\n    reset = null;\n  };\n\n  if(EffectContext && argument !== false)\n    EffectContext.add(cleanup);\n\n  addListener(target, key => {\n    if(key === true)\n      invoke();\n\n    else if(!reset)\n      return reset;\n\n    if(key === null && unset)\n      unset(null);\n  });\n  \n  return cleanup;\n}\n\nlet EffectContext: Set<() => void> | undefined;\n\nexport function enter(ignore?: boolean){\n  if(ignore)\n    return () => () => {};\n\n  const last = EffectContext;\n  const context = EffectContext = new Set;\n\n  return () => {\n    EffectContext = last;\n    return () => context.forEach(fn => fn());\n  }\n}\n\nexport {\n  addListener,\n  createEffect,\n  event,\n  OnUpdate,\n  PENDING_KEYS,\n  Observable\n}"],
  "mappings": "AA4BA,MAAM,aAAa,OAAO,SAAS;AAGnC,MAAM,UAAU,MAAM;AAEtB,MAAM,YAAY,oBAAI,QAA2D;AAGjF,MAAM,UAAU,oBAAI,QAAgC;AAGpD,MAAM,eAAe,oBAAI,QAAmD;AAG5E,MAAM,WAAW,oBAAI,IAAgB;AAErC,SAAS,YACP,SAAY,UAAuB,QAA4B;AAE/D,MAAI,YAAY,UAAU,IAAI,OAAO;AAErC,MAAG,CAAC;AACF,cAAU,IAAI,SAAS,YAAY,oBAAI,IAAI,CAAC,CAAC,SAAS,MAAS,CAAC,CAAC,CAAC;AAEpE,MAAG,WAAW,UAAa,EAAE,kBAAkB;AAC7C,aAAS,oBAAI,IAAI,CAAC,MAAM,CAAC;AAE3B,MAAG,CAAC,UAAU,IAAI,OAAO,KAAK,CAAC;AAC7B,aAAS,KAAK,SAAS,MAAM,OAAO;AAEtC,YAAU,IAAI,UAAU,MAAM;AAE9B,SAAO,MAAM,UAAU,OAAO,QAAQ;AACxC;AAEA,SAAS,KAAK,OAAmB,KAAkB;AACjD,QAAM,YAAY,UAAU,IAAI,KAAK;AACrC,QAAM,WAAW,UAAU,IAAI,OAAO;AAEtC,MAAG,QAAQ,QAAQ,CAAC;AAClB;AAEF,MAAI,UAAU,QAAQ,IAAI,KAAK;AAE/B,MAAG,SAAQ;AACT,YAAQ,IAAI,GAAG;AACf;AAAA,EACF;AAEA,UAAQ,IAAI,OAAO,UAAU,IAAI,IAAI,WAAW,CAAC,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC;AAEpE,aAAUA,QAAO;AACf,eAAU,CAAC,UAAU,MAAM,KAAK;AAC9B,UAAG,CAAC,UAAU,OAAO,IAAIA,IAAG,GAAE;AAC5B,cAAM,QAAQ,SAAS,KAAK,OAAOA,MAAK,KAAK;AAE7C,YAAG;AACD,kBAAQ,KAAK;AAAA,iBAEP,UAAU;AAChB,oBAAU,OAAO,QAAQ;AAAA,MAC7B;AAEJ,MAAG,QAAQ;AACT,cAAU,MAAM;AAElB,UAAQ,OAAO,KAAK;AACtB;AAEA,SAAS,MACP,SACA,KACA,QAAiB;AAEjB,MAAG,QAAQ;AACT,WAAO,KAAK,SAAS,GAAG;AAE1B,MAAG,CAAC;AACF,WAAO,KAAK,SAAS,IAAI;AAE3B,MAAI,UAAU,aAAa,IAAI,OAAO;AAEtC,MAAG,CAAC,SAAQ;AACV,iBAAa,IAAI,SAAS,UAAU,oBAAI,IAAI,CAAC;AAE7C,QAAG,CAAC;AACF,cAAQ,MAAM;AACZ,aAAK,SAAS,KAAK;AACnB,qBAAa,OAAO,OAAO;AAAA,MAC7B,CAAC;AAAA,EACL;AAEA,UAAQ,IAAI,GAAG;AAEf,MAAG,CAAC;AACF,SAAK,SAAS,GAAG;AACrB;AAEA,SAAS,QAAQ,cAA2B;AAC1C,MAAG,CAAC,SAAS;AACX,eAAW,MAAM;AACf,eAAS,QAAQ,CAAAC,WAAS;AACxB,YAAI;AACF,UAAAA,OAAM;AAAA,QACR,SACM,KAAI;AACR,kBAAQ,MAAM,GAAG;AAAA,QACnB;AAAA,MACF,CAAC;AACD,eAAS,MAAM;AAAA,IACjB,GAAG,CAAC;AAEN,WAAS,IAAI,YAAY;AAC3B;AAYA,SAAS,aAAmC,QAAW,UAAqB,UAAmB;AAC7F,MAAI;AACJ,MAAI;AAEJ,WAAS,SAAS;AAChB,QAAI;AAEJ,aAAS,WAAqC;AAC5C,UAAI,SAAS,UAAU;AACrB;AAEF,cAAQ;AAER,UAAI,SAAS,OAAO;AAClB,cAAM,IAAI;AACV,gBAAQ;AAAA,MACV;AAEA,cAAQ,MAAM;AACd,aAAO,EAAE,MAAM,QAAQ;AAAA,IACzB;AAEA,UAAM,aAAa,OAAO,UAAU,EAAE,UAAU,aAAa,IAAI;AAEjE,QAAI;AACF,YAAM,OAAO,MAAM,aAAa,KAAK;AACrC,YAAM,SAAS,SAAS,KAAK,YAAY,UAAU;AACnD,YAAM,QAAQ,KAAK;AAEnB,cAAQ,WAAW,OAAO,OAAO;AACjC,cAAQ,SAAO;AACb,YAAG,OAAO,UAAU;AAClB,iBAAO,GAAG;AAEZ,cAAM;AAAA,MACR;AAAA,IACF,SACM,KAAI;AACR,UAAG,eAAe,SAAQ;AACxB,gBAAQ;AACR,YAAI,KAAK,MAAM;AAAA,MACjB;AAEE,cAAM;AAAA,IACV;AAAA,EACF;AAEA,WAAS,UAAS;AAChB,QAAG;AACD,YAAM,KAAK;AAEb,YAAQ;AAAA,EACV;AAAC;AAED,MAAG,iBAAiB,aAAa;AAC/B,kBAAc,IAAI,OAAO;AAE3B,cAAY,QAAQ,SAAO;AACzB,QAAG,QAAQ;AACT,aAAO;AAAA,aAED,CAAC;AACP,aAAO;AAET,QAAG,QAAQ,QAAQ;AACjB,YAAM,IAAI;AAAA,EACd,CAAC;AAED,SAAO;AACT;AAEA,IAAI;AAEG,SAAS,MAAM,QAAiB;AACrC,MAAG;AACD,WAAO,MAAM,MAAM;AAAA,IAAC;AAEtB,QAAM,OAAO;AACb,QAAM,UAAU,gBAAgB,oBAAI;AAEpC,SAAO,MAAM;AACX,oBAAgB;AAChB,WAAO,MAAM,QAAQ,QAAQ,QAAM,GAAG,CAAC;AAAA,EACzC;AACF;",
  "names": ["key", "event"]
}


package/dist/esm/model.js

@@ -15,7 +15,7 @@ class Model {
   [Observable](callback, required) {
     const watch2 = /* @__PURE__ */ new Set();
     const proxy = Object.create(this);
-    addListener(this, callback, watch2);
+    addListener(this, () => void callback(), watch2);
     OBSERVER.set(proxy, (key, value) => {
       if (value === void 0 && required)
         throw new Error(`${this}.${key} is required in this context.`);
@@ -306,4 +306,4 @@ export {
   update,
   watch
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/model.ts"],
  "sourcesContent": ["import { addListener, createEffect, event, Observable, OnUpdate, PENDING_KEYS } from './control';\n\nconst define = Object.defineProperty;\n\n/** Register for all active models via string identifiers (usually unique). */\nconst ID = new WeakMap<Model, string>();\n\n/** Internal state assigned to models. */\nconst STATE = new WeakMap<Model, Record<string | number | symbol, unknown>>();\n\n/** External listeners for any given Model. */\nconst NOTIFY = new WeakMap<Model.Type, Set<OnUpdate>>();\n\n/** Parent-child relationships. */\nconst PARENT = new WeakMap<Model, Model | null>();\n\n/** List of methods defined by a given type. */\nconst METHODS = new WeakMap<Model.Type, Map<string, (value: any) => void>>();\n\n/** Reference bound instance methods to real ones. */\nconst METHOD = new WeakMap<any, any>();\n\ndeclare namespace Model {\n  /** Any type of Model, using own class constructor as its identifier. */\n  type Type<T extends Model = Model> =\n    (abstract new (...args: any[]) => T) & typeof Model;\n\n  /** A Model constructor, but which is not abstract. */\n  type Init<T extends Model = Model> =\n    (new (...args: Model.Args<T>) => T) & Omit<typeof Model, never>;\n\n  /**\n   * Model constructor callback - is called when Model finishes intializing.\n   * Returned function will run when model is destroyed.\n   */\n  type Callback<T extends Model = Model> =\n    (this: T, thisArg: T) => Promise<void> | (() => void) | Assign<T> | void;\n\n  /** Model constructor argument */\n  type Argument<T extends Model = Model> = Assign<T> | Callback<T> | string | void;\n\n  /** Model constructor arguments */\n  type Args<T extends Model = any> = (Argument<T> | Args<T>)[];\n\n  /** Subset of `keyof T` which are not methods or defined by base Model U. **/\n  type Field<T> = Exclude<keyof T, keyof Model>;\n\n  /** Any valid key for model, including but not limited to Field<T>. */\n  type Event<T> = Field<T> | (string & {}) | number | symbol;\n\n  /** Object overlay to override values and methods on a model. */\n  type Assign<T> = {\n    [K in Field<T>]?:\n      T[K] extends (...args: infer A) => infer R \n        ? (this: T, ...args: A) => R\n        : T[K];\n  } & Record<string, unknown>;\n\n  /** Export/Import compatible value for a given property in a Model. */\n  type Export<R> = R extends { get(): infer T } ? T : R;\n\n  /** Value for a property managed by a model. */\n  type Value<T extends Model, K extends Event<T>> =\n    K extends keyof T ? Export<T[K]> : unknown;\n\n  type OnEvent<T extends Model> =\n    (this: T, key: unknown, source: T) => (() => void) | void | null;\n\n  type OnUpdate<T extends Model, K extends Event<T>> =\n    (this: T, key: K, thisArg: K) => void;\n\n  /**\n   * Values from current state of given model.\n   * Differs from `Values` as values here will drill\n   * into \"real\" values held by exotics like ref.Object.\n   */\n  type State<T> = { [P in Field<T>]: Export<T[P]> };\n\n  /** Object comperable to data found in T. */\n  type Values<T> = { [P in Field<T>]?: Export<T[P]> };\n\n  /** Exotic value, where actual value is contained within. */\n  type Ref<T = any> = {\n    (next: T): void;\n    current: T | null;\n  }\n\n  /**\n   * A callback function which is subscribed to parent and updates when accessed properties change.\n   * \n   * @param current - Current state of this model. This is a proxy which detects properties which\n   * where accessed, and thus depended upon to stay current.\n   * \n   * @param update - Set of properties which have changed, and events fired, since last update.\n   * \n   * @returns A callback function which will be called when this effect is stale.\n   */\n  type Effect<T> = (this: T, current: T, update: Set<Event<T>>) =>\n    EffectCallback | Promise<void> | null | void;\n\n  /**\n   * A callback function returned by effect. Will be called when effect is stale.\n   * \n   * @param update - `true` if update is pending, `false` effect has been cancelled, `null` if model is destroyed.\n   */\n  type EffectCallback = ((update: boolean | null) => void);\n\n  /**\n   * Property initializer, will run upon instance creation.\n   * Optional returned callback will run when once upon first access.\n   */\n  type Instruction<T = any, M extends Model = any> =\n    // TODO: Should this allow for numbers/symbol properties?\n    (this: M, key: Extract<Field<M>, string>, thisArg: M, state: State<M>) =>\n      Descriptor<T> | ((source: M) => T) | void;\n\n  type Getter<T> = (source: Model) => T;\n  type Setter<T> = (value: T, previous: T) => boolean | void | (() => T);\n\n  type Descriptor<T = any> = {\n    get?: Getter<T> | boolean;\n    set?: Setter<T> | boolean;\n    enumerable?: boolean;\n    value?: T;\n  }\n}\n\ninterface Model {\n  /**\n   * Loopback to instance of this model. This is useful when in a subscribed context,\n   * to keep write access to `this` after a destructure. You can use it to read variables silently as well.\n   **/\n  is: this;\n}\n\nabstract class Model implements Observable {\n  constructor(...args: Model.Args){\n    prepare(this);\n    define(this, \"is\", { value: this });\n    init(this, args);\n  }\n\n  [Observable](callback: OnUpdate, required?: boolean){\n    const watch = new Set<Model.Event<this>>();\n    const proxy = Object.create(this);\n    \n    addListener(this, callback, watch);\n    OBSERVER.set(proxy, (key, value) => {\n      if(value === undefined && required)\n        throw new Error(`${this}.${key} is required in this context.`);\n\n      watch.add(key);\n\n      if(value instanceof Object && Observable in value)\n        return value[Observable](callback, required);\n\n      return value;\n    });\n\n    return proxy as this;\n  }\n\n  /**\n   * Pull current values from state. Flattens all models and exotic values recursively.\n   * \n   * @returns Object with all values from this model.\n   **/\n  get(): Model.State<this>;\n\n  /**\n   * Run a function which will run automatically when accessed values change.\n   * \n   * @param effect Function to run, and again whenever accessed values change.\n   *               If effect returns a function, it will be called when a change occurs (syncronously),\n   *               effect is cancelled, or parent model is destroyed.\n   * @returns Function to cancel listener.\n   */\n  get(effect: Model.Effect<this>): () => void;\n\n  /**\n   * Get value of a property.\n   * \n   * @param key - Property to get value of.\n   * @param required - If true, will throw an error if property is not available.\n   * @returns Value of property.\n   */\n  get<T extends Model.Event<this>>(key: T, required?: boolean): Model.Value<this, T>;\n\n  /**\n   * Run a function when a property is updated.\n   * \n   * @param key - Property to watch for updates.\n   * @param callback - Function to call when property is updated.\n   * @returns Function to cancel listener.\n   */\n  get<T extends Model.Event<this>>(key: T, callback: Model.OnUpdate<this, T>): () => void;\n\n  /**\n   * Check if model is expired.\n   * \n   * @param status - `null` to check if model is expired.\n   * @returns `true` if model is expired, `false` otherwise.\n   */\n  get(status: null): boolean;\n\n  /**\n   * Callback when model is to be destroyed.\n   * \n   * @param callback - Function to call when model is destroyed.\n   * @returns Function to cancel listener.\n   */\n  get(status: null, callback: () => void): () => void;\n\n  get(arg1?: Model.Effect<this> | string | null, arg2?: boolean | Model.OnUpdate<this, any>){\n    const self = this.is;\n\n    if(typeof arg1 == \"function\"){\n      let pending = new Set<Model.Event<this>>();\n\n      return createEffect(self, (proxy) => {\n        const cb = arg1.call(proxy, proxy, pending);\n\n        return cb === null ? null : ((update) => {\n          pending = PENDING_KEYS.get(self)!;\n          if(typeof cb == \"function\")\n            cb(update);\n        })\n      });\n    }\n\n    return (\n      arg1 === undefined ? snapshot(self) :\n      typeof arg2 == \"function\" ? addListener(self, arg2, arg1) :\n      arg1 === null ? Object.isFrozen(STATE.get(self)) :\n      fetch(self, arg1, arg2)\n    )\n  }\n\n  /**\n   * Get update in progress.\n   *\n   * @returns Promise which resolves object with updated values, `undefined` if there no update is pending.\n   **/\n  set(): PromiseLike<Model.Event<this>[]> | undefined;\n\n  /**\n   * Update mulitple properties at once. Merges argument with current state.\n   * Properties which are not managed by this model will be ignored.\n   * \n   * @param assign - Object with properties to update.\n   * @param silent - If an update does occur, listeners will not be refreshed automatically.\n   * @returns Promise resolving an array of keys updated, `undefined` (immediately) if a noop.\n   */\n  set(assign?: Model.Assign<this>, silent?: boolean): PromiseLike<Model.Event<this>[]> | undefined;\n\n  /**\n   * Push an update. This will not change the value of associated property.\n   * \n   * Useful where a property value internally has changed, but the object is the same.\n   * For example: An array has pushed a new value, or a nested property is updated.\n   * \n   * You can also use this to dispatch arbitrary events.\n   * Symbols are recommended as non-property events, however you can use any string.\n   * If doing so, be sure to avoid collisions with property names! An easy way to do this is\n   * to prefix an event with \"!\" and/or use dash-case. e.g. `set(\"!event\")` or `set(\"my-event\")`.\n   * \n   * @param key - Property or event to dispatch.\n   * @returns Promise resolves an array of keys updated.\n   */\n  set(key: Model.Event<this>): PromiseLike<Model.Event<this>[]>;\n\n  /**\n   * Set a value for a property. This will update the value and notify listeners.\n   * \n   * **Use with caution!** Key nor value are checked for validity.\n   * \n   * This is meant for assigning values programmatically,\n   * where simple assignment is not practicable.\n   * \n   * For example: `(this as any)[myProperty] = value;`\n   * \n   * @param key - Property to set value for.\n   * @param value - Value to set for property.\n   * @param init - If true, model will begin to manage the property if it is not already.\n   * @returns Promise resolves an array of keys updated.\n   */\n  set(key: Model.Event<this>, value: unknown, init?: boolean): PromiseLike<Model.Event<this>[]>;\n\n  /**\n   * Call a function when update occurs.\n   * \n   * Given function is called for every assignment (which changes value) or explicit `set`.\n   * \n   * To run logic on final value only, callback may return a function. Using the same\n   * function for one or more events will ensure it is called only when events are settled.\n   * \n   * @param callback - Function to call when update occurs.\n   * @returns Function to remove listener. Will return `true` if removed, `false` if inactive already.\n   * \n  */\n  set(callback: Model.OnEvent<this>): () => boolean;\n\n  /**\n   * Call a function when a property is updated.\n   * Unlike `get`, this calsl synchronously and will fire as many times as the property is updated.\n   * \n   * @param callback - Function to call when property is updated.\n   * @param event - Property to watch for updates.\n   */\n  set(callback: Model.OnEvent<this>, event: Model.Event<this> | null): () => boolean;\n\n  /**\n   * Declare an end to updates. This event is final and will freeze state.\n   * This event can be watched for as well, to run cleanup logic and internally will remove all listeners.\n   * \n   * @param status - `null` to end updates.\n   */\n  set(status: null): void;\n\n  set(\n    arg1?: Model.OnEvent<this> | Model.Assign<this> | Model.Event<this> | null,\n    arg2?: unknown,\n    arg3?: boolean){\n\n    const self = this.is;\n\n    if(typeof arg1 == \"function\")\n      return addListener(self, key => {\n        if(arg2 === key || arg2 === undefined && typeof key == \"string\")\n          return arg1.call(self, key, self);\n      })\n      \n    if(arg1 && typeof arg1 == \"object\")\n      assign(self, arg1, arg2 === true);\n    else if(!arg2)\n      event(self, arg1);\n    else if(arg3)\n      manage(self, arg1 as string | number, arg2);\n    else\n      update(self, arg1 as string | number, arg2)\n\n    const pending = PENDING_KEYS.get(this);\n\n    if(pending)\n      return <PromiseLike<Model.Event<this>[]>> {\n        then: (res) => new Promise<any>(res => {\n          const remove = addListener(this, key => {\n            if(key !== true){\n              remove();\n              return res.bind(null, Array.from(pending));\n            }\n          });\n        }).then(res)\n      }\n  }\n\n  /**\n   * Iterate over managed properties in this instance of Model.\n   * Yeilds the key and current value for each property.\n   */\n  [Symbol.iterator](): Iterator<[string, unknown]> {\n    return Object.entries(STATE.get(this.is)!)[Symbol.iterator]();\n  }\n\n  /**\n   * Create and activate a new instance of this model.\n   * \n   * **Important** - Unlike `new this(...)` - this method also activates state.\n   * \n   * @param args - arguments sent to constructor\n   */\n  static new<T extends Model>(this: Model.Init<T>, ...args: Model.Args<T>){\n    const instance = new this(...args);\n    event(instance);\n    return instance;\n  }\n\n  /**\n   * Static equivalent of `x instanceof this`.\n   * Determines if provided class is a subtype of this one.\n   * If so, language server will make available all static\n   * methods and properties of this class.\n   */\n  static is<T extends Model.Type>(this: T, maybe: unknown): maybe is T {\n    return maybe === this || typeof maybe == \"function\" && maybe.prototype instanceof this;\n  }\n\n  /**\n   * Register a callback to run when any instance of this Model is updated. \n   */\n  static on<T extends Model>(this: Model.Type<T>, listener: Model.OnEvent<T>){\n    let notify = NOTIFY.get(this);\n\n    if(!notify)\n      NOTIFY.set(this, notify = new Set);\n\n    notify.add(listener);\n\n    return () => notify.delete(listener);\n  }\n}\n\ndefine(Model.prototype, \"toString\", {\n  value(){\n    return ID.get(this.is);\n  }\n});\n\ndefine(Model, \"toString\", {\n  value(){\n    return this.name;\n  }\n});\n\nfunction assign(subject: Model, data: Model.Assign<Model>, silent?: boolean){\n  const methods = METHODS.get(subject.constructor as Model.Type)!;\n    \n  for(const key in data){\n    const bind = methods.get(key);\n\n    if(bind)\n      bind.call(subject, data[key]);\n    else if(key in subject && key !== \"is\"){\n      const desc = Object.getOwnPropertyDescriptor(subject, key)!;\n      const set = desc && desc.set as (value: any, silent?: boolean) => void;\n\n      set.call(subject, data[key], silent);\n    }\n  }\n}\n\n/** Apply instructions and inherited event listeners. Ensure class metadata is ready. */\nfunction prepare(model: Model){\n  let T = model.constructor as Model.Type;\n\n  if(T === Model)\n    throw new Error(\"Cannot create base Model.\");\n\n  const chain = [] as Model.Type[];\n  let keys = new Map<string, (value: any) => void>();\n\n  ID.set(model, `${T}-${uid()}`);\n\n  while(T.name){\n    for(const cb of NOTIFY.get(T) || [])\n      addListener(model, cb);\n\n    if(T === Model) break;\n    else chain.unshift(T);\n\n    T = Object.getPrototypeOf(T)\n  }\n\n  for(const type of chain){\n    if(METHODS.has(type)){\n      keys = METHODS.get(type)!;\n      continue;\n    }\n\n    METHODS.set(type, keys = new Map(keys));\n\n    for(const [key, { value }] of Object.entries(\n      Object.getOwnPropertyDescriptors(type.prototype)\n    )){\n      if(!value || key == \"constructor\")\n        continue;\n      \n      function bind(this: Model, original?: Function){\n        const { is } = this;\n\n        if(is.hasOwnProperty(key) && !original)\n          return value as Function;\n\n        const fn = original || value;\n        const bound = fn.bind(is);\n        \n        METHOD.set(bound, fn);\n        define(is, key, { value: bound, writable: true });\n        \n        return bound;\n      }\n\n      keys.set(key, bind);\n      define(type.prototype, key, { get: bind, set: bind });\n    }\n  }\n}\n\n/**\n * Apply model arguemnts, run callbacks and observe properties.\n * Accumulate and handle cleanup events.\n **/\nfunction init(model: Model, args: Model.Args){\n  const state = {} as Record<string | number | symbol, unknown>;\n\n  STATE.set(model, state);\n\n  args = args.flat().filter(arg => {\n    if(typeof arg != \"string\")\n      return true;\n\n    ID.set(model, arg);\n  });\n\n  addListener(model, () => {\n    if(!PARENT.has(model))\n      PARENT.set(model, null);\n\n    for(const key in model){\n      const desc = Object.getOwnPropertyDescriptor(model, key)!;\n\n      if(\"value\" in desc)\n        manage(model, key, desc.value, true);\n    }\n\n    for(const arg of args){\n      const use = typeof arg == \"function\"\n        ? arg.call(model, model)\n        : arg as Model.Assign<Model>;\n\n      if(use instanceof Promise)\n        use.catch(err => {\n          console.error(`Async error in constructor for ${model}:`);\n          console.error(err);\n        });\n      else if(typeof use == \"function\")\n        addListener(model, use, null)\n      else if(typeof use == \"object\")\n        assign(model, use, true);\n    }\n\n    addListener(model, () => {\n      for(const [_, value] of model)\n        if(value instanceof Model && PARENT.get(value) === model)\n          value.set(null);\n  \n      Object.freeze(state);\n    }, null);\n  \n    return null;\n  });\n}\n\nfunction manage(target: Model, key: string | number, value: any, silent?: boolean){\n  const state = STATE.get(target)!;\n  \n  function get(this: Model){\n    return watch(this, key, state[key]);\n  }\n\n  function set(value: unknown, silent?: boolean){\n    update(target, key, value, silent);\n    if(value instanceof Model && !PARENT.has(value)){\n      PARENT.set(value, target);\n      event(value);\n    }\n  }\n\n  define(target, key, { set, get });\n  set(value, silent);\n}\n\ntype Proxy<T = any> = (key: string | number, value: T) => T;\n\nconst OBSERVER = new WeakMap<Model, Proxy>();\n\nfunction watch(from: Model, key: string | number, value?: any){\n  const access = OBSERVER.get(from);\n  return access ? access(key, value) : value;\n}\n\nfunction fetch(subject: Model, property: string, required?: boolean){\n  const state = STATE.get(subject)!;\n  \n  if(property in state || required === false){\n    const value = state[property];\n\n    if(value !== undefined || !required)\n      return value;\n  }\n\n  const error = new Error(`${subject}.${property} is not yet available.`);\n  const promise = new Promise<any>((resolve, reject) => {\n    addListener(subject, key => {\n      if(key === property){\n        resolve(state[key]);\n        return null;\n      }\n\n      if(key === null)\n        reject(new Error(`${subject} is destroyed.`));\n    });\n  });\n\n  throw Object.assign(promise, {\n    toString: () => String(error),\n    name: \"Suspense\",\n    message: error.message,\n    stack: error.stack\n  });\n}\n\n/** Currently accumulating export. Stores real values of placeholder properties such as ref() or child models. */\nlet EXPORT: Map<any, any> | undefined;\n\nfunction snapshot<T extends Model>(model: T): Model.State<T> {\n  const values = {} as any;\n  let isNotRecursive;\n\n  if(!EXPORT){\n    isNotRecursive = true;\n    EXPORT = new Map([[model, values]]);\n  }\n\n  for(let [key, value] of model){\n    if(EXPORT.has(value))\n      value = EXPORT.get(value);\n    else if(value && typeof value == \"object\" && \"get\" in value && typeof value.get === \"function\")\n      EXPORT.set(value, value = value.get());\n\n    values[key] = value;\n  }\n\n  if(isNotRecursive)\n    EXPORT = undefined;\n\n  return Object.freeze(values);\n}\n\nfunction update<T>(\n  subject: Model,\n  key: string | number | symbol,\n  value: T,\n  arg?: boolean | Model.Setter<T>){\n\n  const state = STATE.get(subject)!;\n\n  if(Object.isFrozen(state))\n    throw new Error(`Tried to update ${String(key)} but ${subject} is destroyed.`);\n\n  const previous = state[key] as T;\n\n  if(typeof arg == \"function\"){\n    const out = arg.call(subject, value, previous);\n\n    if(out === false)\n      return false;\n\n    if(typeof out == \"function\")\n      value = out();\n  }\n\n  if(value === previous && value !== undefined)\n    return;\n\n  state[key] = value;\n\n  if(arg !== true)\n    event(subject, key);\n\n  return true;\n}\n\n/** Random alphanumberic of length 6; always starts with a letter. */\nfunction uid(){\n  return (0.278 + Math.random() * 0.722).toString(36).substring(2, 8).toUpperCase();\n}\n\nexport {\n  event,\n  fetch,\n  METHOD,\n  Model,\n  PARENT,\n  STATE,\n  uid,\n  update,\n  watch\n}"],
  "mappings": "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",
  "names": ["watch", "update", "res", "bind", "value", "silent"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/model.ts"],
  "sourcesContent": ["import { addListener, createEffect, event, Observable, OnUpdate, PENDING_KEYS } from './control';\n\nconst define = Object.defineProperty;\n\n/** Register for all active models via string identifiers (usually unique). */\nconst ID = new WeakMap<Model, string>();\n\n/** Internal state assigned to models. */\nconst STATE = new WeakMap<Model, Record<string | number | symbol, unknown>>();\n\n/** External listeners for any given Model. */\nconst NOTIFY = new WeakMap<Model.Type, Set<OnUpdate>>();\n\n/** Parent-child relationships. */\nconst PARENT = new WeakMap<Model, Model | null>();\n\n/** List of methods defined by a given type. */\nconst METHODS = new WeakMap<Model.Type, Map<string, (value: any) => void>>();\n\n/** Reference bound instance methods to real ones. */\nconst METHOD = new WeakMap<any, any>();\n\ndeclare namespace Model {\n  /** Any type of Model, using own class constructor as its identifier. */\n  type Type<T extends Model = Model> =\n    (abstract new (...args: any[]) => T) & typeof Model;\n\n  /** A Model constructor, but which is not abstract. */\n  type Init<T extends Model = Model> =\n    (new (...args: Model.Args<T>) => T) & Omit<typeof Model, never>;\n\n  /**\n   * Model constructor callback - is called when Model finishes intializing.\n   * Returned function will run when model is destroyed.\n   */\n  type Callback<T extends Model = Model> =\n    (this: T, thisArg: T) => Promise<void> | (() => void) | Assign<T> | void;\n\n  /** Model constructor argument */\n  type Argument<T extends Model = Model> = Assign<T> | Callback<T> | string | void;\n\n  /** Model constructor arguments */\n  type Args<T extends Model = any> = (Argument<T> | Args<T>)[];\n\n  /** Subset of `keyof T` which are not methods or defined by base Model U. **/\n  type Field<T> = Exclude<keyof T, keyof Model>;\n\n  /** Any valid key for model, including but not limited to Field<T>. */\n  type Event<T> = Field<T> | (string & {}) | number | symbol;\n\n  /** Object overlay to override values and methods on a model. */\n  type Assign<T> = {\n    [K in Field<T>]?:\n      T[K] extends (...args: infer A) => infer R \n        ? (this: T, ...args: A) => R\n        : T[K];\n  } & Record<string, unknown>;\n\n  /** Export/Import compatible value for a given property in a Model. */\n  type Export<R> = R extends { get(): infer T } ? T : R;\n\n  /** Value for a property managed by a model. */\n  type Value<T extends Model, K extends Event<T>> =\n    K extends keyof T ? Export<T[K]> : unknown;\n\n  type OnEvent<T extends Model> =\n    (this: T, key: unknown, source: T) => (() => void) | void | null;\n\n  type OnUpdate<T extends Model, K extends Event<T>> =\n    (this: T, key: K, thisArg: K) => void;\n\n  /**\n   * Values from current state of given model.\n   * Differs from `Values` as values here will drill\n   * into \"real\" values held by exotics like ref.Object.\n   */\n  type State<T> = { [P in Field<T>]: Export<T[P]> };\n\n  /** Object comperable to data found in T. */\n  type Values<T> = { [P in Field<T>]?: Export<T[P]> };\n\n  /** Exotic value, where actual value is contained within. */\n  type Ref<T = any> = {\n    (next: T): void;\n    current: T | null;\n  }\n\n  /**\n   * A callback function which is subscribed to parent and updates when accessed properties change.\n   * \n   * @param current - Current state of this model. This is a proxy which detects properties which\n   * where accessed, and thus depended upon to stay current.\n   * \n   * @param update - Set of properties which have changed, and events fired, since last update.\n   * \n   * @returns A callback function which will be called when this effect is stale.\n   */\n  type Effect<T> = (this: T, current: T, update: Set<Event<T>>) =>\n    EffectCallback | Promise<void> | null | void;\n\n  /**\n   * A callback function returned by effect. Will be called when effect is stale.\n   * \n   * @param update - `true` if update is pending, `false` effect has been cancelled, `null` if model is destroyed.\n   */\n  type EffectCallback = ((update: boolean | null) => void);\n\n  /**\n   * Property initializer, will run upon instance creation.\n   * Optional returned callback will run when once upon first access.\n   */\n  type Instruction<T = any, M extends Model = any> =\n    // TODO: Should this allow for numbers/symbol properties?\n    (this: M, key: Extract<Field<M>, string>, thisArg: M, state: State<M>) =>\n      Descriptor<T> | ((source: M) => T) | void;\n\n  type Getter<T> = (source: Model) => T;\n  type Setter<T> = (value: T, previous: T) => boolean | void | (() => T);\n\n  type Descriptor<T = any> = {\n    get?: Getter<T> | boolean;\n    set?: Setter<T> | boolean;\n    enumerable?: boolean;\n    value?: T;\n  }\n}\n\ninterface Model {\n  /**\n   * Loopback to instance of this model. This is useful when in a subscribed context,\n   * to keep write access to `this` after a destructure. You can use it to read variables silently as well.\n   **/\n  is: this;\n}\n\nabstract class Model implements Observable {\n  constructor(...args: Model.Args){\n    prepare(this);\n    define(this, \"is\", { value: this });\n    init(this, args);\n  }\n\n  [Observable](callback: Observable.Callback, required?: boolean){\n    const watch = new Set<Model.Event<this>>();\n    const proxy = Object.create(this);\n    \n    addListener(this, () => void callback(), watch);\n\n    OBSERVER.set(proxy, (key, value) => {\n      if(value === undefined && required)\n        throw new Error(`${this}.${key} is required in this context.`);\n\n      watch.add(key);\n\n      if(value instanceof Object && Observable in value)\n        return value[Observable](callback, required);\n\n      return value;\n    });\n\n    return proxy as this;\n  }\n\n  /**\n   * Pull current values from state. Flattens all models and exotic values recursively.\n   * \n   * @returns Object with all values from this model.\n   **/\n  get(): Model.State<this>;\n\n  /**\n   * Run a function which will run automatically when accessed values change.\n   * \n   * @param effect Function to run, and again whenever accessed values change.\n   *               If effect returns a function, it will be called when a change occurs (syncronously),\n   *               effect is cancelled, or parent model is destroyed.\n   * @returns Function to cancel listener.\n   */\n  get(effect: Model.Effect<this>): () => void;\n\n  /**\n   * Get value of a property.\n   * \n   * @param key - Property to get value of.\n   * @param required - If true, will throw an error if property is not available.\n   * @returns Value of property.\n   */\n  get<T extends Model.Event<this>>(key: T, required?: boolean): Model.Value<this, T>;\n\n  /**\n   * Run a function when a property is updated.\n   * \n   * @param key - Property to watch for updates.\n   * @param callback - Function to call when property is updated.\n   * @returns Function to cancel listener.\n   */\n  get<T extends Model.Event<this>>(key: T, callback: Model.OnUpdate<this, T>): () => void;\n\n  /**\n   * Check if model is expired.\n   * \n   * @param status - `null` to check if model is expired.\n   * @returns `true` if model is expired, `false` otherwise.\n   */\n  get(status: null): boolean;\n\n  /**\n   * Callback when model is to be destroyed.\n   * \n   * @param callback - Function to call when model is destroyed.\n   * @returns Function to cancel listener.\n   */\n  get(status: null, callback: () => void): () => void;\n\n  get(arg1?: Model.Effect<this> | string | null, arg2?: boolean | Model.OnUpdate<this, any>){\n    const self = this.is;\n\n    if(typeof arg1 == \"function\"){\n      let pending = new Set<Model.Event<this>>();\n\n      return createEffect(self, (proxy) => {\n        const cb = arg1.call(proxy, proxy, pending);\n\n        return cb === null ? null : ((update) => {\n          pending = PENDING_KEYS.get(self)!;\n          if(typeof cb == \"function\")\n            cb(update);\n        })\n      });\n    }\n\n    return (\n      arg1 === undefined ? snapshot(self) :\n      typeof arg2 == \"function\" ? addListener(self, arg2, arg1) :\n      arg1 === null ? Object.isFrozen(STATE.get(self)) :\n      fetch(self, arg1, arg2)\n    )\n  }\n\n  /**\n   * Get update in progress.\n   *\n   * @returns Promise which resolves object with updated values, `undefined` if there no update is pending.\n   **/\n  set(): PromiseLike<Model.Event<this>[]> | undefined;\n\n  /**\n   * Update mulitple properties at once. Merges argument with current state.\n   * Properties which are not managed by this model will be ignored.\n   * \n   * @param assign - Object with properties to update.\n   * @param silent - If an update does occur, listeners will not be refreshed automatically.\n   * @returns Promise resolving an array of keys updated, `undefined` (immediately) if a noop.\n   */\n  set(assign?: Model.Assign<this>, silent?: boolean): PromiseLike<Model.Event<this>[]> | undefined;\n\n  /**\n   * Push an update. This will not change the value of associated property.\n   * \n   * Useful where a property value internally has changed, but the object is the same.\n   * For example: An array has pushed a new value, or a nested property is updated.\n   * \n   * You can also use this to dispatch arbitrary events.\n   * Symbols are recommended as non-property events, however you can use any string.\n   * If doing so, be sure to avoid collisions with property names! An easy way to do this is\n   * to prefix an event with \"!\" and/or use dash-case. e.g. `set(\"!event\")` or `set(\"my-event\")`.\n   * \n   * @param key - Property or event to dispatch.\n   * @returns Promise resolves an array of keys updated.\n   */\n  set(key: Model.Event<this>): PromiseLike<Model.Event<this>[]>;\n\n  /**\n   * Set a value for a property. This will update the value and notify listeners.\n   * \n   * **Use with caution!** Key nor value are checked for validity.\n   * \n   * This is meant for assigning values programmatically,\n   * where simple assignment is not practicable.\n   * \n   * For example: `(this as any)[myProperty] = value;`\n   * \n   * @param key - Property to set value for.\n   * @param value - Value to set for property.\n   * @param init - If true, model will begin to manage the property if it is not already.\n   * @returns Promise resolves an array of keys updated.\n   */\n  set(key: Model.Event<this>, value: unknown, init?: boolean): PromiseLike<Model.Event<this>[]>;\n\n  /**\n   * Call a function when update occurs.\n   * \n   * Given function is called for every assignment (which changes value) or explicit `set`.\n   * \n   * To run logic on final value only, callback may return a function. Using the same\n   * function for one or more events will ensure it is called only when events are settled.\n   * \n   * @param callback - Function to call when update occurs.\n   * @returns Function to remove listener. Will return `true` if removed, `false` if inactive already.\n   * \n  */\n  set(callback: Model.OnEvent<this>): () => boolean;\n\n  /**\n   * Call a function when a property is updated.\n   * Unlike `get`, this calsl synchronously and will fire as many times as the property is updated.\n   * \n   * @param callback - Function to call when property is updated.\n   * @param event - Property to watch for updates.\n   */\n  set(callback: Model.OnEvent<this>, event: Model.Event<this> | null): () => boolean;\n\n  /**\n   * Declare an end to updates. This event is final and will freeze state.\n   * This event can be watched for as well, to run cleanup logic and internally will remove all listeners.\n   * \n   * @param status - `null` to end updates.\n   */\n  set(status: null): void;\n\n  set(\n    arg1?: Model.OnEvent<this> | Model.Assign<this> | Model.Event<this> | null,\n    arg2?: unknown,\n    arg3?: boolean){\n\n    const self = this.is;\n\n    if(typeof arg1 == \"function\")\n      return addListener(self, key => {\n        if(arg2 === key || arg2 === undefined && typeof key == \"string\")\n          return arg1.call(self, key, self);\n      })\n      \n    if(arg1 && typeof arg1 == \"object\")\n      assign(self, arg1, arg2 === true);\n    else if(!arg2)\n      event(self, arg1);\n    else if(arg3)\n      manage(self, arg1 as string | number, arg2);\n    else\n      update(self, arg1 as string | number, arg2)\n\n    const pending = PENDING_KEYS.get(this);\n\n    if(pending)\n      return <PromiseLike<Model.Event<this>[]>> {\n        then: (res) => new Promise<any>(res => {\n          const remove = addListener(this, key => {\n            if(key !== true){\n              remove();\n              return res.bind(null, Array.from(pending));\n            }\n          });\n        }).then(res)\n      }\n  }\n\n  /**\n   * Iterate over managed properties in this instance of Model.\n   * Yeilds the key and current value for each property.\n   */\n  [Symbol.iterator](): Iterator<[string, unknown]> {\n    return Object.entries(STATE.get(this.is)!)[Symbol.iterator]();\n  }\n\n  /**\n   * Create and activate a new instance of this model.\n   * \n   * **Important** - Unlike `new this(...)` - this method also activates state.\n   * \n   * @param args - arguments sent to constructor\n   */\n  static new<T extends Model>(this: Model.Init<T>, ...args: Model.Args<T>){\n    const instance = new this(...args);\n    event(instance);\n    return instance;\n  }\n\n  /**\n   * Static equivalent of `x instanceof this`.\n   * Determines if provided class is a subtype of this one.\n   * If so, language server will make available all static\n   * methods and properties of this class.\n   */\n  static is<T extends Model.Type>(this: T, maybe: unknown): maybe is T {\n    return maybe === this || typeof maybe == \"function\" && maybe.prototype instanceof this;\n  }\n\n  /**\n   * Register a callback to run when any instance of this Model is updated. \n   */\n  static on<T extends Model>(this: Model.Type<T>, listener: Model.OnEvent<T>){\n    let notify = NOTIFY.get(this);\n\n    if(!notify)\n      NOTIFY.set(this, notify = new Set);\n\n    notify.add(listener);\n\n    return () => notify.delete(listener);\n  }\n}\n\ndefine(Model.prototype, \"toString\", {\n  value(){\n    return ID.get(this.is);\n  }\n});\n\ndefine(Model, \"toString\", {\n  value(){\n    return this.name;\n  }\n});\n\nfunction assign(subject: Model, data: Model.Assign<Model>, silent?: boolean){\n  const methods = METHODS.get(subject.constructor as Model.Type)!;\n    \n  for(const key in data){\n    const bind = methods.get(key);\n\n    if(bind)\n      bind.call(subject, data[key]);\n    else if(key in subject && key !== \"is\"){\n      const desc = Object.getOwnPropertyDescriptor(subject, key)!;\n      const set = desc && desc.set as (value: any, silent?: boolean) => void;\n\n      set.call(subject, data[key], silent);\n    }\n  }\n}\n\n/** Apply instructions and inherited event listeners. Ensure class metadata is ready. */\nfunction prepare(model: Model){\n  let T = model.constructor as Model.Type;\n\n  if(T === Model)\n    throw new Error(\"Cannot create base Model.\");\n\n  const chain = [] as Model.Type[];\n  let keys = new Map<string, (value: any) => void>();\n\n  ID.set(model, `${T}-${uid()}`);\n\n  while(T.name){\n    for(const cb of NOTIFY.get(T) || [])\n      addListener(model, cb);\n\n    if(T === Model) break;\n    else chain.unshift(T);\n\n    T = Object.getPrototypeOf(T)\n  }\n\n  for(const type of chain){\n    if(METHODS.has(type)){\n      keys = METHODS.get(type)!;\n      continue;\n    }\n\n    METHODS.set(type, keys = new Map(keys));\n\n    for(const [key, { value }] of Object.entries(\n      Object.getOwnPropertyDescriptors(type.prototype)\n    )){\n      if(!value || key == \"constructor\")\n        continue;\n      \n      function bind(this: Model, original?: Function){\n        const { is } = this;\n\n        if(is.hasOwnProperty(key) && !original)\n          return value as Function;\n\n        const fn = original || value;\n        const bound = fn.bind(is);\n        \n        METHOD.set(bound, fn);\n        define(is, key, { value: bound, writable: true });\n        \n        return bound;\n      }\n\n      keys.set(key, bind);\n      define(type.prototype, key, { get: bind, set: bind });\n    }\n  }\n}\n\n/**\n * Apply model arguemnts, run callbacks and observe properties.\n * Accumulate and handle cleanup events.\n **/\nfunction init(model: Model, args: Model.Args){\n  const state = {} as Record<string | number | symbol, unknown>;\n\n  STATE.set(model, state);\n\n  args = args.flat().filter(arg => {\n    if(typeof arg != \"string\")\n      return true;\n\n    ID.set(model, arg);\n  });\n\n  addListener(model, () => {\n    if(!PARENT.has(model))\n      PARENT.set(model, null);\n\n    for(const key in model){\n      const desc = Object.getOwnPropertyDescriptor(model, key)!;\n\n      if(\"value\" in desc)\n        manage(model, key, desc.value, true);\n    }\n\n    for(const arg of args){\n      const use = typeof arg == \"function\"\n        ? arg.call(model, model)\n        : arg as Model.Assign<Model>;\n\n      if(use instanceof Promise)\n        use.catch(err => {\n          console.error(`Async error in constructor for ${model}:`);\n          console.error(err);\n        });\n      else if(typeof use == \"function\")\n        addListener(model, use, null)\n      else if(typeof use == \"object\")\n        assign(model, use, true);\n    }\n\n    addListener(model, () => {\n      for(const [_, value] of model)\n        if(value instanceof Model && PARENT.get(value) === model)\n          value.set(null);\n  \n      Object.freeze(state);\n    }, null);\n  \n    return null;\n  });\n}\n\nfunction manage(target: Model, key: string | number, value: any, silent?: boolean){\n  const state = STATE.get(target)!;\n  \n  function get(this: Model){\n    return watch(this, key, state[key]);\n  }\n\n  function set(value: unknown, silent?: boolean){\n    update(target, key, value, silent);\n    if(value instanceof Model && !PARENT.has(value)){\n      PARENT.set(value, target);\n      event(value);\n    }\n  }\n\n  define(target, key, { set, get });\n  set(value, silent);\n}\n\ntype Proxy<T = any> = (key: string | number, value: T) => T;\n\nconst OBSERVER = new WeakMap<Model, Proxy>();\n\nfunction watch(from: Model, key: string | number, value?: any){\n  const access = OBSERVER.get(from);\n  return access ? access(key, value) : value;\n}\n\nfunction fetch(subject: Model, property: string, required?: boolean){\n  const state = STATE.get(subject)!;\n  \n  if(property in state || required === false){\n    const value = state[property];\n\n    if(value !== undefined || !required)\n      return value;\n  }\n\n  const error = new Error(`${subject}.${property} is not yet available.`);\n  const promise = new Promise<any>((resolve, reject) => {\n    addListener(subject, key => {\n      if(key === property){\n        resolve(state[key]);\n        return null;\n      }\n\n      if(key === null)\n        reject(new Error(`${subject} is destroyed.`));\n    });\n  });\n\n  throw Object.assign(promise, {\n    toString: () => String(error),\n    name: \"Suspense\",\n    message: error.message,\n    stack: error.stack\n  });\n}\n\n/** Currently accumulating export. Stores real values of placeholder properties such as ref() or child models. */\nlet EXPORT: Map<any, any> | undefined;\n\nfunction snapshot<T extends Model>(model: T): Model.State<T> {\n  const values = {} as any;\n  let isNotRecursive;\n\n  if(!EXPORT){\n    isNotRecursive = true;\n    EXPORT = new Map([[model, values]]);\n  }\n\n  for(let [key, value] of model){\n    if(EXPORT.has(value))\n      value = EXPORT.get(value);\n    else if(value && typeof value == \"object\" && \"get\" in value && typeof value.get === \"function\")\n      EXPORT.set(value, value = value.get());\n\n    values[key] = value;\n  }\n\n  if(isNotRecursive)\n    EXPORT = undefined;\n\n  return Object.freeze(values);\n}\n\nfunction update<T>(\n  subject: Model,\n  key: string | number | symbol,\n  value: T,\n  arg?: boolean | Model.Setter<T>){\n\n  const state = STATE.get(subject)!;\n\n  if(Object.isFrozen(state))\n    throw new Error(`Tried to update ${String(key)} but ${subject} is destroyed.`);\n\n  const previous = state[key] as T;\n\n  if(typeof arg == \"function\"){\n    const out = arg.call(subject, value, previous);\n\n    if(out === false)\n      return false;\n\n    if(typeof out == \"function\")\n      value = out();\n  }\n\n  if(value === previous && value !== undefined)\n    return;\n\n  state[key] = value;\n\n  if(arg !== true)\n    event(subject, key);\n\n  return true;\n}\n\n/** Random alphanumberic of length 6; always starts with a letter. */\nfunction uid(){\n  return (0.278 + Math.random() * 0.722).toString(36).substring(2, 8).toUpperCase();\n}\n\nexport {\n  event,\n  fetch,\n  METHOD,\n  Model,\n  PARENT,\n  STATE,\n  uid,\n  update,\n  watch\n}"],
  "mappings": "AAAA,SAAS,aAAa,cAAc,OAAO,YAAsB,oBAAoB;AAErF,MAAM,SAAS,OAAO;AAGtB,MAAM,KAAK,oBAAI,QAAuB;AAGtC,MAAM,QAAQ,oBAAI,QAA0D;AAG5E,MAAM,SAAS,oBAAI,QAAmC;AAGtD,MAAM,SAAS,oBAAI,QAA6B;AAGhD,MAAM,UAAU,oBAAI,QAAuD;AAG3E,MAAM,SAAS,oBAAI,QAAkB;AAmHrC,MAAe,MAA4B;AAAA,EACzC,eAAe,MAAiB;AAC9B,YAAQ,IAAI;AACZ,WAAO,MAAM,MAAM,EAAE,OAAO,KAAK,CAAC;AAClC,SAAK,MAAM,IAAI;AAAA,EACjB;AAAA,EAEA,CAAC,UAAU,EAAE,UAA+B,UAAmB;AAC7D,UAAMA,SAAQ,oBAAI,IAAuB;AACzC,UAAM,QAAQ,OAAO,OAAO,IAAI;AAEhC,gBAAY,MAAM,MAAM,KAAK,SAAS,GAAGA,MAAK;AAE9C,aAAS,IAAI,OAAO,CAAC,KAAK,UAAU;AAClC,UAAG,UAAU,UAAa;AACxB,cAAM,IAAI,MAAM,GAAG,IAAI,IAAI,GAAG,+BAA+B;AAE/D,MAAAA,OAAM,IAAI,GAAG;AAEb,UAAG,iBAAiB,UAAU,cAAc;AAC1C,eAAO,MAAM,UAAU,EAAE,UAAU,QAAQ;AAE7C,aAAO;AAAA,IACT,CAAC;AAED,WAAO;AAAA,EACT;AAAA,EAqDA,IAAI,MAA2C,MAA2C;AACxF,UAAM,OAAO,KAAK;AAElB,QAAG,OAAO,QAAQ,YAAW;AAC3B,UAAI,UAAU,oBAAI,IAAuB;AAEzC,aAAO,aAAa,MAAM,CAAC,UAAU;AACnC,cAAM,KAAK,KAAK,KAAK,OAAO,OAAO,OAAO;AAE1C,eAAO,OAAO,OAAO,OAAQ,CAACC,YAAW;AACvC,oBAAU,aAAa,IAAI,IAAI;AAC/B,cAAG,OAAO,MAAM;AACd,eAAGA,OAAM;AAAA,QACb;AAAA,MACF,CAAC;AAAA,IACH;AAEA,WACE,SAAS,SAAY,SAAS,IAAI,IAClC,OAAO,QAAQ,aAAa,YAAY,MAAM,MAAM,IAAI,IACxD,SAAS,OAAO,OAAO,SAAS,MAAM,IAAI,IAAI,CAAC,IAC/C,MAAM,MAAM,MAAM,IAAI;AAAA,EAE1B;AAAA,EAmFA,IACE,MACA,MACA,MAAe;AAEf,UAAM,OAAO,KAAK;AAElB,QAAG,OAAO,QAAQ;AAChB,aAAO,YAAY,MAAM,SAAO;AAC9B,YAAG,SAAS,OAAO,SAAS,UAAa,OAAO,OAAO;AACrD,iBAAO,KAAK,KAAK,MAAM,KAAK,IAAI;AAAA,MACpC,CAAC;AAEH,QAAG,QAAQ,OAAO,QAAQ;AACxB,aAAO,MAAM,MAAM,SAAS,IAAI;AAAA,aAC1B,CAAC;AACP,YAAM,MAAM,IAAI;AAAA,aACV;AACN,aAAO,MAAM,MAAyB,IAAI;AAAA;AAE1C,aAAO,MAAM,MAAyB,IAAI;AAE5C,UAAM,UAAU,aAAa,IAAI,IAAI;AAErC,QAAG;AACD,aAA0C;AAAA,QACxC,MAAM,CAAC,QAAQ,IAAI,QAAa,CAAAC,SAAO;AACrC,gBAAM,SAAS,YAAY,MAAM,SAAO;AACtC,gBAAG,QAAQ,MAAK;AACd,qBAAO;AACP,qBAAOA,KAAI,KAAK,MAAM,MAAM,KAAK,OAAO,CAAC;AAAA,YAC3C;AAAA,UACF,CAAC;AAAA,QACH,CAAC,EAAE,KAAK,GAAG;AAAA,MACb;AAAA,EACJ;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,CAAC,OAAO,QAAQ,IAAiC;AAC/C,WAAO,OAAO,QAAQ,MAAM,IAAI,KAAK,EAAE,CAAE,EAAE,OAAO,QAAQ,EAAE;AAAA,EAC9D;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,OAAO,OAA6C,MAAoB;AACtE,UAAM,WAAW,IAAI,KAAK,GAAG,IAAI;AACjC,UAAM,QAAQ;AACd,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,OAAO,GAAkC,OAA4B;AACnE,WAAO,UAAU,QAAQ,OAAO,SAAS,cAAc,MAAM,qBAAqB;AAAA,EACpF;AAAA;AAAA;AAAA;AAAA,EAKA,OAAO,GAAyC,UAA2B;AACzE,QAAI,SAAS,OAAO,IAAI,IAAI;AAE5B,QAAG,CAAC;AACF,aAAO,IAAI,MAAM,SAAS,oBAAI,KAAG;AAEnC,WAAO,IAAI,QAAQ;AAEnB,WAAO,MAAM,OAAO,OAAO,QAAQ;AAAA,EACrC;AACF;AAEA,OAAO,MAAM,WAAW,YAAY;AAAA,EAClC,QAAO;AACL,WAAO,GAAG,IAAI,KAAK,EAAE;AAAA,EACvB;AACF,CAAC;AAED,OAAO,OAAO,YAAY;AAAA,EACxB,QAAO;AACL,WAAO,KAAK;AAAA,EACd;AACF,CAAC;AAED,SAAS,OAAO,SAAgB,MAA2B,QAAiB;AAC1E,QAAM,UAAU,QAAQ,IAAI,QAAQ,WAAyB;AAE7D,aAAU,OAAO,MAAK;AACpB,UAAM,OAAO,QAAQ,IAAI,GAAG;AAE5B,QAAG;AACD,WAAK,KAAK,SAAS,KAAK,GAAG,CAAC;AAAA,aACtB,OAAO,WAAW,QAAQ,MAAK;AACrC,YAAM,OAAO,OAAO,yBAAyB,SAAS,GAAG;AACzD,YAAM,MAAM,QAAQ,KAAK;AAEzB,UAAI,KAAK,SAAS,KAAK,GAAG,GAAG,MAAM;AAAA,IACrC;AAAA,EACF;AACF;AAGA,SAAS,QAAQ,OAAa;AAC5B,MAAI,IAAI,MAAM;AAEd,MAAG,MAAM;AACP,UAAM,IAAI,MAAM,2BAA2B;AAE7C,QAAM,QAAQ,CAAC;AACf,MAAI,OAAO,oBAAI,IAAkC;AAEjD,KAAG,IAAI,OAAO,GAAG,CAAC,IAAI,IAAI,CAAC,EAAE;AAE7B,SAAM,EAAE,MAAK;AACX,eAAU,MAAM,OAAO,IAAI,CAAC,KAAK,CAAC;AAChC,kBAAY,OAAO,EAAE;AAEvB,QAAG,MAAM,MAAO;AAAA,QACX,OAAM,QAAQ,CAAC;AAEpB,QAAI,OAAO,eAAe,CAAC;AAAA,EAC7B;AAEA,aAAU,QAAQ,OAAM;AACtB,QAAG,QAAQ,IAAI,IAAI,GAAE;AACnB,aAAO,QAAQ,IAAI,IAAI;AACvB;AAAA,IACF;AAEA,YAAQ,IAAI,MAAM,OAAO,IAAI,IAAI,IAAI,CAAC;AAEtC,eAAU,CAAC,KAAK,EAAE,MAAM,CAAC,KAAK,OAAO;AAAA,MACnC,OAAO,0BAA0B,KAAK,SAAS;AAAA,IACjD,GAAE;AAIA,UAASC,QAAT,SAA2B,UAAoB;AAC7C,cAAM,EAAE,GAAG,IAAI;AAEf,YAAG,GAAG,eAAe,GAAG,KAAK,CAAC;AAC5B,iBAAO;AAET,cAAM,KAAK,YAAY;AACvB,cAAM,QAAQ,GAAG,KAAK,EAAE;AAExB,eAAO,IAAI,OAAO,EAAE;AACpB,eAAO,IAAI,KAAK,EAAE,OAAO,OAAO,UAAU,KAAK,CAAC;AAEhD,eAAO;AAAA,MACT;AAbS,iBAAAA;AAHT,UAAG,CAAC,SAAS,OAAO;AAClB;AAiBF,WAAK,IAAI,KAAKA,KAAI;AAClB,aAAO,KAAK,WAAW,KAAK,EAAE,KAAKA,OAAM,KAAKA,MAAK,CAAC;AAAA,IACtD;AAAA,EACF;AACF;AAMA,SAAS,KAAK,OAAc,MAAiB;AAC3C,QAAM,QAAQ,CAAC;AAEf,QAAM,IAAI,OAAO,KAAK;AAEtB,SAAO,KAAK,KAAK,EAAE,OAAO,SAAO;AAC/B,QAAG,OAAO,OAAO;AACf,aAAO;AAET,OAAG,IAAI,OAAO,GAAG;AAAA,EACnB,CAAC;AAED,cAAY,OAAO,MAAM;AACvB,QAAG,CAAC,OAAO,IAAI,KAAK;AAClB,aAAO,IAAI,OAAO,IAAI;AAExB,eAAU,OAAO,OAAM;AACrB,YAAM,OAAO,OAAO,yBAAyB,OAAO,GAAG;AAEvD,UAAG,WAAW;AACZ,eAAO,OAAO,KAAK,KAAK,OAAO,IAAI;AAAA,IACvC;AAEA,eAAU,OAAO,MAAK;AACpB,YAAM,MAAM,OAAO,OAAO,aACtB,IAAI,KAAK,OAAO,KAAK,IACrB;AAEJ,UAAG,eAAe;AAChB,YAAI,MAAM,SAAO;AACf,kBAAQ,MAAM,kCAAkC,KAAK,GAAG;AACxD,kBAAQ,MAAM,GAAG;AAAA,QACnB,CAAC;AAAA,eACK,OAAO,OAAO;AACpB,oBAAY,OAAO,KAAK,IAAI;AAAA,eACtB,OAAO,OAAO;AACpB,eAAO,OAAO,KAAK,IAAI;AAAA,IAC3B;AAEA,gBAAY,OAAO,MAAM;AACvB,iBAAU,CAAC,GAAG,KAAK,KAAK;AACtB,YAAG,iBAAiB,SAAS,OAAO,IAAI,KAAK,MAAM;AACjD,gBAAM,IAAI,IAAI;AAElB,aAAO,OAAO,KAAK;AAAA,IACrB,GAAG,IAAI;AAEP,WAAO;AAAA,EACT,CAAC;AACH;AAEA,SAAS,OAAO,QAAe,KAAsB,OAAY,QAAiB;AAChF,QAAM,QAAQ,MAAM,IAAI,MAAM;AAE9B,WAAS,MAAgB;AACvB,WAAO,MAAM,MAAM,KAAK,MAAM,GAAG,CAAC;AAAA,EACpC;AAEA,WAAS,IAAIC,QAAgBC,SAAiB;AAC5C,WAAO,QAAQ,KAAKD,QAAOC,OAAM;AACjC,QAAGD,kBAAiB,SAAS,CAAC,OAAO,IAAIA,MAAK,GAAE;AAC9C,aAAO,IAAIA,QAAO,MAAM;AACxB,YAAMA,MAAK;AAAA,IACb;AAAA,EACF;AAEA,SAAO,QAAQ,KAAK,EAAE,KAAK,IAAI,CAAC;AAChC,MAAI,OAAO,MAAM;AACnB;AAIA,MAAM,WAAW,oBAAI,QAAsB;AAE3C,SAAS,MAAM,MAAa,KAAsB,OAAY;AAC5D,QAAM,SAAS,SAAS,IAAI,IAAI;AAChC,SAAO,SAAS,OAAO,KAAK,KAAK,IAAI;AACvC;AAEA,SAAS,MAAM,SAAgB,UAAkB,UAAmB;AAClE,QAAM,QAAQ,MAAM,IAAI,OAAO;AAE/B,MAAG,YAAY,SAAS,aAAa,OAAM;AACzC,UAAM,QAAQ,MAAM,QAAQ;AAE5B,QAAG,UAAU,UAAa,CAAC;AACzB,aAAO;AAAA,EACX;AAEA,QAAM,QAAQ,IAAI,MAAM,GAAG,OAAO,IAAI,QAAQ,wBAAwB;AACtE,QAAM,UAAU,IAAI,QAAa,CAAC,SAAS,WAAW;AACpD,gBAAY,SAAS,SAAO;AAC1B,UAAG,QAAQ,UAAS;AAClB,gBAAQ,MAAM,GAAG,CAAC;AAClB,eAAO;AAAA,MACT;AAEA,UAAG,QAAQ;AACT,eAAO,IAAI,MAAM,GAAG,OAAO,gBAAgB,CAAC;AAAA,IAChD,CAAC;AAAA,EACH,CAAC;AAED,QAAM,OAAO,OAAO,SAAS;AAAA,IAC3B,UAAU,MAAM,OAAO,KAAK;AAAA,IAC5B,MAAM;AAAA,IACN,SAAS,MAAM;AAAA,IACf,OAAO,MAAM;AAAA,EACf,CAAC;AACH;AAGA,IAAI;AAEJ,SAAS,SAA0B,OAA0B;AAC3D,QAAM,SAAS,CAAC;AAChB,MAAI;AAEJ,MAAG,CAAC,QAAO;AACT,qBAAiB;AACjB,aAAS,oBAAI,IAAI,CAAC,CAAC,OAAO,MAAM,CAAC,CAAC;AAAA,EACpC;AAEA,WAAQ,CAAC,KAAK,KAAK,KAAK,OAAM;AAC5B,QAAG,OAAO,IAAI,KAAK;AACjB,cAAQ,OAAO,IAAI,KAAK;AAAA,aAClB,SAAS,OAAO,SAAS,YAAY,SAAS,SAAS,OAAO,MAAM,QAAQ;AAClF,aAAO,IAAI,OAAO,QAAQ,MAAM,IAAI,CAAC;AAEvC,WAAO,GAAG,IAAI;AAAA,EAChB;AAEA,MAAG;AACD,aAAS;AAEX,SAAO,OAAO,OAAO,MAAM;AAC7B;AAEA,SAAS,OACP,SACA,KACA,OACA,KAAgC;AAEhC,QAAM,QAAQ,MAAM,IAAI,OAAO;AAE/B,MAAG,OAAO,SAAS,KAAK;AACtB,UAAM,IAAI,MAAM,mBAAmB,OAAO,GAAG,CAAC,QAAQ,OAAO,gBAAgB;AAE/E,QAAM,WAAW,MAAM,GAAG;AAE1B,MAAG,OAAO,OAAO,YAAW;AAC1B,UAAM,MAAM,IAAI,KAAK,SAAS,OAAO,QAAQ;AAE7C,QAAG,QAAQ;AACT,aAAO;AAET,QAAG,OAAO,OAAO;AACf,cAAQ,IAAI;AAAA,EAChB;AAEA,MAAG,UAAU,YAAY,UAAU;AACjC;AAEF,QAAM,GAAG,IAAI;AAEb,MAAG,QAAQ;AACT,UAAM,SAAS,GAAG;AAEpB,SAAO;AACT;AAGA,SAAS,MAAK;AACZ,UAAQ,QAAQ,KAAK,OAAO,IAAI,OAAO,SAAS,EAAE,EAAE,UAAU,GAAG,CAAC,EAAE,YAAY;AAClF;",
  "names": ["watch", "update", "res", "bind", "value", "silent"]
}


package/dist/index.d.ts

@@ -8,11 +8,17 @@
  *   - `null` - terminal event; instance is expired.
  * @param source - Instance of Model for which update has occured.
  */
-type OnUpdate<T extends Observable = any> = (this: T, key: unknown, source: T) => (() => void) | null | void;
+type OnUpdate<T extends Observable = any> = (this: T, key: Event, source: T) => (() => void) | null | void;
 type Effect<T extends Observable> = (this: T, proxy: T) => ((update: boolean | null) => void) | Promise<void> | null | void;
 type Event = number | string | null | boolean | symbol;
+type PromiseLite<T = void> = {
+    then: (callback: () => T) => T;
+};
+declare namespace Observable {
+    type Callback = () => void | PromiseLite;
+}
 interface Observable {
-    [Observable](callback: OnUpdate, required?: boolean): this;
+    [Observable](callback: Observable.Callback, required?: boolean): this;
 }
 declare const Observable: unique symbol;
 declare function addListener<T extends Observable>(subject: T, callback: OnUpdate<T>, select?: Event | Set<Event>): () => boolean;
@@ -117,7 +123,7 @@ interface Model {
 }
 declare abstract class Model implements Observable {
     constructor(...args: Model.Args);
-    [Observable](callback: OnUpdate, required?: boolean): this;
+    [Observable](callback: Observable.Callback, required?: boolean): this;
     /**
      * Pull current values from state. Flattens all models and exotic values recursively.
      *

package/dist/index.js

@@ -116,14 +116,15 @@ function createEffect(target, callback, argument) {
   function invoke() {
     let stale;
     function onUpdate() {
-      if (stale)
-        return null;
+      if (stale || reset === null)
+        return;
       stale = true;
       if (reset && unset) {
         unset(true);
         unset = void 0;
       }
-      return reset;
+      enqueue(invoke);
+      return { then: enqueue };
     }
     const subscriber = target[Observable](onUpdate, argument === true);
     try {
@@ -192,7 +193,7 @@ var Model = class {
   [Observable](callback, required) {
     const watch2 = /* @__PURE__ */ new Set();
     const proxy = Object.create(this);
-    addListener(this, callback, watch2);
+    addListener(this, () => void callback(), watch2);
     OBSERVER.set(proxy, (key2, value) => {
       if (value === void 0 && required)
         throw new Error(`${this}.${key2} is required in this context.`);

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts","../src/control.ts","../src/model.ts","../src/context.ts","../src/instruction/use.ts","../src/instruction/get.ts","../src/instruction/ref.ts","../src/instruction/set.ts","../src/instruction/has.ts"],"sourcesContent":["export { get } from './instruction/get';\nexport { ref } from './instruction/ref';\nexport { set } from './instruction/set';\nexport { use } from './instruction/use';\nexport { has } from './instruction/has';\n\nexport { Model, Model as default, METHOD } from './model';\nexport { createEffect, addListener, event, Observable } from './control';\nexport { Context } from './context';","/**\n * Update callback function.\n * \n * @param key -\n *   - `string` - property which has updated.\n *   - `false` - a normal update has completed.\n *   - `true` - initial event; instance is ready.\n *   - `null` - terminal event; instance is expired.\n * @param source - Instance of Model for which update has occured.\n */\ntype OnUpdate<T extends Observable = any> = \n  (this: T, key: unknown, source: T) => (() => void) | null | void;\n\ntype Effect<T extends Observable> = (this: T, proxy: T) =>\n  ((update: boolean | null) => void) | Promise<void> | null | void;\n\ntype Event = number | string | null | boolean | symbol;\n\ninterface Observable {\n  [Observable](callback: OnUpdate, required?: boolean): this;\n}\n\nconst Observable = Symbol(\"observe\");\n\n/** Placeholder event determines if model is initialized or not. */\nconst onReady = () => null;\n\nconst LISTENERS = new WeakMap<Observable, Map<OnUpdate, Set<Event> | undefined>>();\n\n/** Events pending for a given object. */\nconst PENDING = new WeakMap<Observable, Set<Event>>();\n\n/** Update register. */\nconst PENDING_KEYS = new WeakMap<Observable, Set<string | number | symbol>>();\n\n/** Central event dispatch. Bunches all updates to occur at same time. */\nconst DISPATCH = new Set<() => void>();\n\nfunction addListener<T extends Observable>(\n  subject: T, callback: OnUpdate<T>, select?: Event | Set<Event>){\n\n  let listeners = LISTENERS.get(subject)!;\n\n  if(!listeners)\n    LISTENERS.set(subject, listeners = new Map([[onReady, undefined]]));\n\n  if(select !== undefined && !(select instanceof Set))\n    select = new Set([select]);\n\n  if(!listeners.has(onReady) && !select)\n    callback.call(subject, true, subject);\n\n  listeners.set(callback, select);\n\n  return () => listeners.delete(callback);\n}\n\nfunction emit(model: Observable, key: Event): void {\n  const listeners = LISTENERS.get(model)!;\n  const notReady = listeners.has(onReady);\n\n  if(key === true && !notReady)\n    return;\n\n  let pending = PENDING.get(model);\n\n  if(pending){\n    pending.add(key);\n    return;\n  }\n\n  PENDING.set(model, pending = new Set(notReady ? [true, key] : [key]));\n\n  for(const key of pending)\n    for(const [callback, filter] of listeners)\n      if(!filter || filter.has(key)){\n        const after = callback.call(model, key, model);\n\n        if(after)\n          enqueue(after);\n\n        else if(after === null)\n          listeners.delete(callback);\n      }\n\n  if(key === null)\n    listeners.clear();\n  \n  PENDING.delete(model);\n}\n\nfunction event(\n  subject: Observable,\n  key?: string | number | symbol | null,\n  silent?: boolean){\n\n  if(key === null)\n    return emit(subject, key);\n\n  if(!key)\n    return emit(subject, true);\n\n  let pending = PENDING_KEYS.get(subject);\n\n  if(!pending){\n    PENDING_KEYS.set(subject, pending = new Set());\n\n    if(!silent)\n      enqueue(() => {\n        emit(subject, false);\n        PENDING_KEYS.delete(subject)\n      })\n  }\n\n  pending.add(key);\n\n  if(!silent)\n    emit(subject, key);\n}\n\nfunction enqueue(eventHandler: (() => void)){\n  if(!DISPATCH.size)\n    setTimeout(() => {\n      DISPATCH.forEach(event => {\n        try {\n          event();\n        }\n        catch(err){\n          console.error(err);\n        }\n      });\n      DISPATCH.clear();\n    }, 0);\n\n  DISPATCH.add(eventHandler);\n}\n\n/**\n * Create a side-effect which will update whenever values accessed change.\n * Callback is called immediately and whenever values are stale.\n * \n * @param target - Instance of Model to observe.\n * @param callback - Function to invoke when values change.\n * @param requireValues - If `true` will throw if accessing a value which is `undefined`.\n */\nfunction createEffect<T extends Observable>(target: T, callback: Effect<Required<T>>, requireValues: true): () => void;\nfunction createEffect<T extends Observable>(target: T, callback: Effect<T>, recursive?: boolean): () => void;\nfunction createEffect<T extends Observable>(target: T, callback: Effect<T>, argument?: boolean){\n  let unset: ((update: boolean | null) => void) | undefined;\n  let reset: (() => void) | null | undefined;\n\n  function invoke(){\n    let stale: boolean | undefined;\n\n    function onUpdate() {\n      if (stale)\n        return null;\n\n      stale = true;\n\n      if (reset && unset) {\n        unset(true);\n        unset = undefined;\n      }\n\n      return reset;\n    }\n\n    const subscriber = target[Observable](onUpdate, argument === true);\n\n    try {\n      const exit = enter(argument === false);\n      const output = callback.call(subscriber, subscriber);\n      const flush = exit();\n\n      reset = output === null ? null : invoke;\n      unset = key => {\n        if(typeof output == \"function\")\n          output(key);\n\n        flush();\n      }\n    }\n    catch(err){\n      if(err instanceof Promise){\n        reset = undefined;\n        err.then(invoke);\n      }\n      else\n        throw err;\n    }\n  }\n\n  function cleanup(){\n    if(unset)\n      unset(false);\n\n    reset = null;\n  };\n\n  if(EffectContext && argument !== false)\n    EffectContext.add(cleanup);\n\n  addListener(target, key => {\n    if(key === true)\n      invoke();\n\n    else if(!reset)\n      return reset;\n\n    if(key === null && unset)\n      unset(null);\n  });\n  \n  return cleanup;\n}\n\nlet EffectContext: Set<() => void> | undefined;\n\nexport function enter(ignore?: boolean){\n  if(ignore)\n    return () => () => {};\n\n  const last = EffectContext;\n  const context = EffectContext = new Set;\n\n  return () => {\n    EffectContext = last;\n    return () => context.forEach(fn => fn());\n  }\n}\n\nexport {\n  addListener,\n  createEffect,\n  event,\n  OnUpdate,\n  PENDING_KEYS,\n  Observable\n}","import { addListener, createEffect, event, Observable, OnUpdate, PENDING_KEYS } from './control';\n\nconst define = Object.defineProperty;\n\n/** Register for all active models via string identifiers (usually unique). */\nconst ID = new WeakMap<Model, string>();\n\n/** Internal state assigned to models. */\nconst STATE = new WeakMap<Model, Record<string | number | symbol, unknown>>();\n\n/** External listeners for any given Model. */\nconst NOTIFY = new WeakMap<Model.Type, Set<OnUpdate>>();\n\n/** Parent-child relationships. */\nconst PARENT = new WeakMap<Model, Model | null>();\n\n/** List of methods defined by a given type. */\nconst METHODS = new WeakMap<Model.Type, Map<string, (value: any) => void>>();\n\n/** Reference bound instance methods to real ones. */\nconst METHOD = new WeakMap<any, any>();\n\ndeclare namespace Model {\n  /** Any type of Model, using own class constructor as its identifier. */\n  type Type<T extends Model = Model> =\n    (abstract new (...args: any[]) => T) & typeof Model;\n\n  /** A Model constructor, but which is not abstract. */\n  type Init<T extends Model = Model> =\n    (new (...args: Model.Args<T>) => T) & Omit<typeof Model, never>;\n\n  /**\n   * Model constructor callback - is called when Model finishes intializing.\n   * Returned function will run when model is destroyed.\n   */\n  type Callback<T extends Model = Model> =\n    (this: T, thisArg: T) => Promise<void> | (() => void) | Assign<T> | void;\n\n  /** Model constructor argument */\n  type Argument<T extends Model = Model> = Assign<T> | Callback<T> | string | void;\n\n  /** Model constructor arguments */\n  type Args<T extends Model = any> = (Argument<T> | Args<T>)[];\n\n  /** Subset of `keyof T` which are not methods or defined by base Model U. **/\n  type Field<T> = Exclude<keyof T, keyof Model>;\n\n  /** Any valid key for model, including but not limited to Field<T>. */\n  type Event<T> = Field<T> | (string & {}) | number | symbol;\n\n  /** Object overlay to override values and methods on a model. */\n  type Assign<T> = {\n    [K in Field<T>]?:\n      T[K] extends (...args: infer A) => infer R \n        ? (this: T, ...args: A) => R\n        : T[K];\n  } & Record<string, unknown>;\n\n  /** Export/Import compatible value for a given property in a Model. */\n  type Export<R> = R extends { get(): infer T } ? T : R;\n\n  /** Value for a property managed by a model. */\n  type Value<T extends Model, K extends Event<T>> =\n    K extends keyof T ? Export<T[K]> : unknown;\n\n  type OnEvent<T extends Model> =\n    (this: T, key: unknown, source: T) => (() => void) | void | null;\n\n  type OnUpdate<T extends Model, K extends Event<T>> =\n    (this: T, key: K, thisArg: K) => void;\n\n  /**\n   * Values from current state of given model.\n   * Differs from `Values` as values here will drill\n   * into \"real\" values held by exotics like ref.Object.\n   */\n  type State<T> = { [P in Field<T>]: Export<T[P]> };\n\n  /** Object comperable to data found in T. */\n  type Values<T> = { [P in Field<T>]?: Export<T[P]> };\n\n  /** Exotic value, where actual value is contained within. */\n  type Ref<T = any> = {\n    (next: T): void;\n    current: T | null;\n  }\n\n  /**\n   * A callback function which is subscribed to parent and updates when accessed properties change.\n   * \n   * @param current - Current state of this model. This is a proxy which detects properties which\n   * where accessed, and thus depended upon to stay current.\n   * \n   * @param update - Set of properties which have changed, and events fired, since last update.\n   * \n   * @returns A callback function which will be called when this effect is stale.\n   */\n  type Effect<T> = (this: T, current: T, update: Set<Event<T>>) =>\n    EffectCallback | Promise<void> | null | void;\n\n  /**\n   * A callback function returned by effect. Will be called when effect is stale.\n   * \n   * @param update - `true` if update is pending, `false` effect has been cancelled, `null` if model is destroyed.\n   */\n  type EffectCallback = ((update: boolean | null) => void);\n\n  /**\n   * Property initializer, will run upon instance creation.\n   * Optional returned callback will run when once upon first access.\n   */\n  type Instruction<T = any, M extends Model = any> =\n    // TODO: Should this allow for numbers/symbol properties?\n    (this: M, key: Extract<Field<M>, string>, thisArg: M, state: State<M>) =>\n      Descriptor<T> | ((source: M) => T) | void;\n\n  type Getter<T> = (source: Model) => T;\n  type Setter<T> = (value: T, previous: T) => boolean | void | (() => T);\n\n  type Descriptor<T = any> = {\n    get?: Getter<T> | boolean;\n    set?: Setter<T> | boolean;\n    enumerable?: boolean;\n    value?: T;\n  }\n}\n\ninterface Model {\n  /**\n   * Loopback to instance of this model. This is useful when in a subscribed context,\n   * to keep write access to `this` after a destructure. You can use it to read variables silently as well.\n   **/\n  is: this;\n}\n\nabstract class Model implements Observable {\n  constructor(...args: Model.Args){\n    prepare(this);\n    define(this, \"is\", { value: this });\n    init(this, args);\n  }\n\n  [Observable](callback: OnUpdate, required?: boolean){\n    const watch = new Set<Model.Event<this>>();\n    const proxy = Object.create(this);\n    \n    addListener(this, callback, watch);\n    OBSERVER.set(proxy, (key, value) => {\n      if(value === undefined && required)\n        throw new Error(`${this}.${key} is required in this context.`);\n\n      watch.add(key);\n\n      if(value instanceof Object && Observable in value)\n        return value[Observable](callback, required);\n\n      return value;\n    });\n\n    return proxy as this;\n  }\n\n  /**\n   * Pull current values from state. Flattens all models and exotic values recursively.\n   * \n   * @returns Object with all values from this model.\n   **/\n  get(): Model.State<this>;\n\n  /**\n   * Run a function which will run automatically when accessed values change.\n   * \n   * @param effect Function to run, and again whenever accessed values change.\n   *               If effect returns a function, it will be called when a change occurs (syncronously),\n   *               effect is cancelled, or parent model is destroyed.\n   * @returns Function to cancel listener.\n   */\n  get(effect: Model.Effect<this>): () => void;\n\n  /**\n   * Get value of a property.\n   * \n   * @param key - Property to get value of.\n   * @param required - If true, will throw an error if property is not available.\n   * @returns Value of property.\n   */\n  get<T extends Model.Event<this>>(key: T, required?: boolean): Model.Value<this, T>;\n\n  /**\n   * Run a function when a property is updated.\n   * \n   * @param key - Property to watch for updates.\n   * @param callback - Function to call when property is updated.\n   * @returns Function to cancel listener.\n   */\n  get<T extends Model.Event<this>>(key: T, callback: Model.OnUpdate<this, T>): () => void;\n\n  /**\n   * Check if model is expired.\n   * \n   * @param status - `null` to check if model is expired.\n   * @returns `true` if model is expired, `false` otherwise.\n   */\n  get(status: null): boolean;\n\n  /**\n   * Callback when model is to be destroyed.\n   * \n   * @param callback - Function to call when model is destroyed.\n   * @returns Function to cancel listener.\n   */\n  get(status: null, callback: () => void): () => void;\n\n  get(arg1?: Model.Effect<this> | string | null, arg2?: boolean | Model.OnUpdate<this, any>){\n    const self = this.is;\n\n    if(typeof arg1 == \"function\"){\n      let pending = new Set<Model.Event<this>>();\n\n      return createEffect(self, (proxy) => {\n        const cb = arg1.call(proxy, proxy, pending);\n\n        return cb === null ? null : ((update) => {\n          pending = PENDING_KEYS.get(self)!;\n          if(typeof cb == \"function\")\n            cb(update);\n        })\n      });\n    }\n\n    return (\n      arg1 === undefined ? snapshot(self) :\n      typeof arg2 == \"function\" ? addListener(self, arg2, arg1) :\n      arg1 === null ? Object.isFrozen(STATE.get(self)) :\n      fetch(self, arg1, arg2)\n    )\n  }\n\n  /**\n   * Get update in progress.\n   *\n   * @returns Promise which resolves object with updated values, `undefined` if there no update is pending.\n   **/\n  set(): PromiseLike<Model.Event<this>[]> | undefined;\n\n  /**\n   * Update mulitple properties at once. Merges argument with current state.\n   * Properties which are not managed by this model will be ignored.\n   * \n   * @param assign - Object with properties to update.\n   * @param silent - If an update does occur, listeners will not be refreshed automatically.\n   * @returns Promise resolving an array of keys updated, `undefined` (immediately) if a noop.\n   */\n  set(assign?: Model.Assign<this>, silent?: boolean): PromiseLike<Model.Event<this>[]> | undefined;\n\n  /**\n   * Push an update. This will not change the value of associated property.\n   * \n   * Useful where a property value internally has changed, but the object is the same.\n   * For example: An array has pushed a new value, or a nested property is updated.\n   * \n   * You can also use this to dispatch arbitrary events.\n   * Symbols are recommended as non-property events, however you can use any string.\n   * If doing so, be sure to avoid collisions with property names! An easy way to do this is\n   * to prefix an event with \"!\" and/or use dash-case. e.g. `set(\"!event\")` or `set(\"my-event\")`.\n   * \n   * @param key - Property or event to dispatch.\n   * @returns Promise resolves an array of keys updated.\n   */\n  set(key: Model.Event<this>): PromiseLike<Model.Event<this>[]>;\n\n  /**\n   * Set a value for a property. This will update the value and notify listeners.\n   * \n   * **Use with caution!** Key nor value are checked for validity.\n   * \n   * This is meant for assigning values programmatically,\n   * where simple assignment is not practicable.\n   * \n   * For example: `(this as any)[myProperty] = value;`\n   * \n   * @param key - Property to set value for.\n   * @param value - Value to set for property.\n   * @param init - If true, model will begin to manage the property if it is not already.\n   * @returns Promise resolves an array of keys updated.\n   */\n  set(key: Model.Event<this>, value: unknown, init?: boolean): PromiseLike<Model.Event<this>[]>;\n\n  /**\n   * Call a function when update occurs.\n   * \n   * Given function is called for every assignment (which changes value) or explicit `set`.\n   * \n   * To run logic on final value only, callback may return a function. Using the same\n   * function for one or more events will ensure it is called only when events are settled.\n   * \n   * @param callback - Function to call when update occurs.\n   * @returns Function to remove listener. Will return `true` if removed, `false` if inactive already.\n   * \n  */\n  set(callback: Model.OnEvent<this>): () => boolean;\n\n  /**\n   * Call a function when a property is updated.\n   * Unlike `get`, this calsl synchronously and will fire as many times as the property is updated.\n   * \n   * @param callback - Function to call when property is updated.\n   * @param event - Property to watch for updates.\n   */\n  set(callback: Model.OnEvent<this>, event: Model.Event<this> | null): () => boolean;\n\n  /**\n   * Declare an end to updates. This event is final and will freeze state.\n   * This event can be watched for as well, to run cleanup logic and internally will remove all listeners.\n   * \n   * @param status - `null` to end updates.\n   */\n  set(status: null): void;\n\n  set(\n    arg1?: Model.OnEvent<this> | Model.Assign<this> | Model.Event<this> | null,\n    arg2?: unknown,\n    arg3?: boolean){\n\n    const self = this.is;\n\n    if(typeof arg1 == \"function\")\n      return addListener(self, key => {\n        if(arg2 === key || arg2 === undefined && typeof key == \"string\")\n          return arg1.call(self, key, self);\n      })\n      \n    if(arg1 && typeof arg1 == \"object\")\n      assign(self, arg1, arg2 === true);\n    else if(!arg2)\n      event(self, arg1);\n    else if(arg3)\n      manage(self, arg1 as string | number, arg2);\n    else\n      update(self, arg1 as string | number, arg2)\n\n    const pending = PENDING_KEYS.get(this);\n\n    if(pending)\n      return <PromiseLike<Model.Event<this>[]>> {\n        then: (res) => new Promise<any>(res => {\n          const remove = addListener(this, key => {\n            if(key !== true){\n              remove();\n              return res.bind(null, Array.from(pending));\n            }\n          });\n        }).then(res)\n      }\n  }\n\n  /**\n   * Iterate over managed properties in this instance of Model.\n   * Yeilds the key and current value for each property.\n   */\n  [Symbol.iterator](): Iterator<[string, unknown]> {\n    return Object.entries(STATE.get(this.is)!)[Symbol.iterator]();\n  }\n\n  /**\n   * Create and activate a new instance of this model.\n   * \n   * **Important** - Unlike `new this(...)` - this method also activates state.\n   * \n   * @param args - arguments sent to constructor\n   */\n  static new<T extends Model>(this: Model.Init<T>, ...args: Model.Args<T>){\n    const instance = new this(...args);\n    event(instance);\n    return instance;\n  }\n\n  /**\n   * Static equivalent of `x instanceof this`.\n   * Determines if provided class is a subtype of this one.\n   * If so, language server will make available all static\n   * methods and properties of this class.\n   */\n  static is<T extends Model.Type>(this: T, maybe: unknown): maybe is T {\n    return maybe === this || typeof maybe == \"function\" && maybe.prototype instanceof this;\n  }\n\n  /**\n   * Register a callback to run when any instance of this Model is updated. \n   */\n  static on<T extends Model>(this: Model.Type<T>, listener: Model.OnEvent<T>){\n    let notify = NOTIFY.get(this);\n\n    if(!notify)\n      NOTIFY.set(this, notify = new Set);\n\n    notify.add(listener);\n\n    return () => notify.delete(listener);\n  }\n}\n\ndefine(Model.prototype, \"toString\", {\n  value(){\n    return ID.get(this.is);\n  }\n});\n\ndefine(Model, \"toString\", {\n  value(){\n    return this.name;\n  }\n});\n\nfunction assign(subject: Model, data: Model.Assign<Model>, silent?: boolean){\n  const methods = METHODS.get(subject.constructor as Model.Type)!;\n    \n  for(const key in data){\n    const bind = methods.get(key);\n\n    if(bind)\n      bind.call(subject, data[key]);\n    else if(key in subject && key !== \"is\"){\n      const desc = Object.getOwnPropertyDescriptor(subject, key)!;\n      const set = desc && desc.set as (value: any, silent?: boolean) => void;\n\n      set.call(subject, data[key], silent);\n    }\n  }\n}\n\n/** Apply instructions and inherited event listeners. Ensure class metadata is ready. */\nfunction prepare(model: Model){\n  let T = model.constructor as Model.Type;\n\n  if(T === Model)\n    throw new Error(\"Cannot create base Model.\");\n\n  const chain = [] as Model.Type[];\n  let keys = new Map<string, (value: any) => void>();\n\n  ID.set(model, `${T}-${uid()}`);\n\n  while(T.name){\n    for(const cb of NOTIFY.get(T) || [])\n      addListener(model, cb);\n\n    if(T === Model) break;\n    else chain.unshift(T);\n\n    T = Object.getPrototypeOf(T)\n  }\n\n  for(const type of chain){\n    if(METHODS.has(type)){\n      keys = METHODS.get(type)!;\n      continue;\n    }\n\n    METHODS.set(type, keys = new Map(keys));\n\n    for(const [key, { value }] of Object.entries(\n      Object.getOwnPropertyDescriptors(type.prototype)\n    )){\n      if(!value || key == \"constructor\")\n        continue;\n      \n      function bind(this: Model, original?: Function){\n        const { is } = this;\n\n        if(is.hasOwnProperty(key) && !original)\n          return value as Function;\n\n        const fn = original || value;\n        const bound = fn.bind(is);\n        \n        METHOD.set(bound, fn);\n        define(is, key, { value: bound, writable: true });\n        \n        return bound;\n      }\n\n      keys.set(key, bind);\n      define(type.prototype, key, { get: bind, set: bind });\n    }\n  }\n}\n\n/**\n * Apply model arguemnts, run callbacks and observe properties.\n * Accumulate and handle cleanup events.\n **/\nfunction init(model: Model, args: Model.Args){\n  const state = {} as Record<string | number | symbol, unknown>;\n\n  STATE.set(model, state);\n\n  args = args.flat().filter(arg => {\n    if(typeof arg != \"string\")\n      return true;\n\n    ID.set(model, arg);\n  });\n\n  addListener(model, () => {\n    if(!PARENT.has(model))\n      PARENT.set(model, null);\n\n    for(const key in model){\n      const desc = Object.getOwnPropertyDescriptor(model, key)!;\n\n      if(\"value\" in desc)\n        manage(model, key, desc.value, true);\n    }\n\n    for(const arg of args){\n      const use = typeof arg == \"function\"\n        ? arg.call(model, model)\n        : arg as Model.Assign<Model>;\n\n      if(use instanceof Promise)\n        use.catch(err => {\n          console.error(`Async error in constructor for ${model}:`);\n          console.error(err);\n        });\n      else if(typeof use == \"function\")\n        addListener(model, use, null)\n      else if(typeof use == \"object\")\n        assign(model, use, true);\n    }\n\n    addListener(model, () => {\n      for(const [_, value] of model)\n        if(value instanceof Model && PARENT.get(value) === model)\n          value.set(null);\n  \n      Object.freeze(state);\n    }, null);\n  \n    return null;\n  });\n}\n\nfunction manage(target: Model, key: string | number, value: any, silent?: boolean){\n  const state = STATE.get(target)!;\n  \n  function get(this: Model){\n    return watch(this, key, state[key]);\n  }\n\n  function set(value: unknown, silent?: boolean){\n    update(target, key, value, silent);\n    if(value instanceof Model && !PARENT.has(value)){\n      PARENT.set(value, target);\n      event(value);\n    }\n  }\n\n  define(target, key, { set, get });\n  set(value, silent);\n}\n\ntype Proxy<T = any> = (key: string | number, value: T) => T;\n\nconst OBSERVER = new WeakMap<Model, Proxy>();\n\nfunction watch(from: Model, key: string | number, value?: any){\n  const access = OBSERVER.get(from);\n  return access ? access(key, value) : value;\n}\n\nfunction fetch(subject: Model, property: string, required?: boolean){\n  const state = STATE.get(subject)!;\n  \n  if(property in state || required === false){\n    const value = state[property];\n\n    if(value !== undefined || !required)\n      return value;\n  }\n\n  const error = new Error(`${subject}.${property} is not yet available.`);\n  const promise = new Promise<any>((resolve, reject) => {\n    addListener(subject, key => {\n      if(key === property){\n        resolve(state[key]);\n        return null;\n      }\n\n      if(key === null)\n        reject(new Error(`${subject} is destroyed.`));\n    });\n  });\n\n  throw Object.assign(promise, {\n    toString: () => String(error),\n    name: \"Suspense\",\n    message: error.message,\n    stack: error.stack\n  });\n}\n\n/** Currently accumulating export. Stores real values of placeholder properties such as ref() or child models. */\nlet EXPORT: Map<any, any> | undefined;\n\nfunction snapshot<T extends Model>(model: T): Model.State<T> {\n  const values = {} as any;\n  let isNotRecursive;\n\n  if(!EXPORT){\n    isNotRecursive = true;\n    EXPORT = new Map([[model, values]]);\n  }\n\n  for(let [key, value] of model){\n    if(EXPORT.has(value))\n      value = EXPORT.get(value);\n    else if(value && typeof value == \"object\" && \"get\" in value && typeof value.get === \"function\")\n      EXPORT.set(value, value = value.get());\n\n    values[key] = value;\n  }\n\n  if(isNotRecursive)\n    EXPORT = undefined;\n\n  return Object.freeze(values);\n}\n\nfunction update<T>(\n  subject: Model,\n  key: string | number | symbol,\n  value: T,\n  arg?: boolean | Model.Setter<T>){\n\n  const state = STATE.get(subject)!;\n\n  if(Object.isFrozen(state))\n    throw new Error(`Tried to update ${String(key)} but ${subject} is destroyed.`);\n\n  const previous = state[key] as T;\n\n  if(typeof arg == \"function\"){\n    const out = arg.call(subject, value, previous);\n\n    if(out === false)\n      return false;\n\n    if(typeof out == \"function\")\n      value = out();\n  }\n\n  if(value === previous && value !== undefined)\n    return;\n\n  state[key] = value;\n\n  if(arg !== true)\n    event(subject, key);\n\n  return true;\n}\n\n/** Random alphanumberic of length 6; always starts with a letter. */\nfunction uid(){\n  return (0.278 + Math.random() * 0.722).toString(36).substring(2, 8).toUpperCase();\n}\n\nexport {\n  event,\n  fetch,\n  METHOD,\n  Model,\n  PARENT,\n  STATE,\n  uid,\n  update,\n  watch\n}","import { addListener } from './control';\nimport { event, Model, PARENT, uid } from './model';\n\nconst LOOKUP = new WeakMap<Model, Context | ((got: Context) => void)[]>();\nconst KEYS = new Map<symbol | Model.Type, symbol>();\n\nfunction key(T: Model.Type | symbol, upstream?: boolean): symbol {\n  let K = KEYS.get(T);\n\n  if(!K)\n    KEYS.set(T, K = Symbol(\n      typeof T == \"symbol\" ? \"get \" + T.description : String(T)\n    ));\n  \n  return upstream ? key(K) : K;\n}\n\nfunction keys(from: Model.Type, upstream?: boolean){\n  const keys = new Set<symbol>();\n\n  do {\n    keys.add(key(from, upstream));\n  }\n  while((from = Object.getPrototypeOf(from)) !== Model);\n\n  return keys;\n}\n\ndeclare namespace Context {\n  type Multiple<T extends Model> = {\n    [key: string | number]: Model.Init<T> | T;\n  };\n\n  type Accept<T extends Model = Model> = T | Model.Init<T> | Multiple<T>;\n\n  type Expect<T extends Model = Model> = (model: T) => (() => void) | void;\n}\n\ninterface Context {\n  [key: symbol]: Model | Context.Expect | null | undefined;\n}\n\nclass Context {\n  static get<T extends Model>(on: Model, callback: ((got: Context) => void)): void;\n  static get<T extends Model>(on: Model): Context | undefined;\n  static get({ is }: Model, callback?: (got: Context) => void){\n    const waiting = LOOKUP.get(is);\n\n    if(waiting instanceof Context){\n      if(callback)\n        callback(waiting);\n\n      return waiting;\n    }\n\n    if(callback)\n      if(waiting) \n        waiting.push(callback);\n      else \n        LOOKUP.set(is, [callback]);\n  }\n\n  public id!: string;\n\n  protected layer = new Map<string | number, Model | Model.Type>();\n  protected cleanup = new Set<() => void>();\n\n  constructor(inputs?: Context.Accept){\n    if(inputs)\n      this.include(inputs);\n  }\n\n  /** Run callback when a specified type is registered to a **child** context. */\n  public has<T extends Model>(Type: Model.Type<T>, callback: (model: T) => void){\n    Object.defineProperty(this, key(Type, true), { value: callback, configurable: true });\n  }\n\n  /** Find specified type registered to a parent context. Returns undefined if none are found. */\n  public get<T extends Model>(Type: Model.Type<T>, require: true): T;\n  public get<T extends Model>(Type: Model.Type<T>, require?: boolean): T | undefined;\n  public get<T extends Model>(Type: Model.Type<T>, require?: boolean){\n    const result = this[key(Type)];\n\n    if(result === null)\n      throw new Error(`Did find ${Type} in context, but multiple were defined.`);\n\n    if(result)\n      return result as T;\n\n    if(require)\n      throw new Error(`Could not find ${Type} in context.`);\n  }\n\n  public push(inputs?: Context.Accept){\n    const next = Object.create(this) as this;\n\n    this.cleanup = new Set([() => next.pop(), ...this.cleanup]);\n\n    next.layer = new Map();\n    next.cleanup = new Set();\n\n    if(inputs)\n      next.include(inputs);\n\n    return next;\n  }\n\n  public pop(){\n    for(const key of Object.getOwnPropertySymbols(this))\n      delete (this as any)[key];\n\n    this.cleanup.forEach(cb => cb());\n    this.cleanup.clear();\n    this.layer.clear();\n  }\n\n  public include<T extends Model>(\n    inputs: Context.Accept<T>,\n    forEach?: Context.Expect<T>\n  ){\n    const init = new Map<Model, boolean>();\n\n    if(typeof inputs == \"function\" || inputs instanceof Model)\n      inputs = { [forEach ? 0 : this.layer.size]: inputs };\n\n    Object.entries(inputs).forEach(([K, V]: [string, Model | Model.Init<Model>]) => {\n      if(Model.is(V) || V instanceof Model){\n        const exists = this.layer.get(K);\n  \n        if(!exists){\n          const instance = this.add(V);\n  \n          this.layer.set(K, V);\n          init.set(instance, true);\n        }\n        // Context must force-reset because inputs are no longer safe.\n        else if(exists !== V){    \n          this.pop();\n          this.id = uid();\n          this.include(inputs);\n        }\n\n        return;\n      }\n\n      throw new Error(\n        `Context may only include instance or class \\`extends Model\\` but got ${\n          K == '0' || K == V ? V : `${V} (as '${K}')`\n        }.`\n      );\n    })\n\n    for(const [model, explicit] of init){\n      model.set();\n\n      if(explicit && forEach)\n        forEach(model as T);\n\n      for(const [_key, value] of model)\n        if(PARENT.get(value as Model) === model){\n          this.add(value as Model, true);\n          init.set(value as Model, false);\n        }\n    }\n  }\n\n  protected add<T extends Model>(\n    input: T | Model.Init<T>,\n    implicit?: boolean){\n\n    const cleanup = new Set<() => void>();\n    let T: Model.Type<T>;\n    let I: T;\n\n    if(typeof input == \"function\"){\n      T = input;\n      I = new input() as T;\n    }\n    else {\n      T = input.constructor as Model.Type<T>;\n      I = input;\n    }\n\n    keys(T, true).forEach(K => {\n      const expects = this[K] as Context.Expect | undefined;\n  \n      if(!expects)\n        return;\n  \n      addListener(I, event => {\n        if(event === true){\n          const callback = expects(I);\n            \n          if(callback)\n            cleanup.add(callback);\n        }\n\n        return null;\n      })  \n    });\n\n    keys(T).forEach(K => {\n      const value = this.hasOwnProperty(K) ? null : I;\n\n      if(value || this[K] !== I && !implicit)\n        Object.defineProperty(this, K, {\n          configurable: true,\n          value\n        });\n    });\n\n    this.cleanup.add(() => {\n      cleanup.forEach(cb => cb());\n\n      if(I !== input)\n        event(I, null);\n    })\n\n    const waiting = LOOKUP.get(I);\n  \n    if(waiting instanceof Array)\n      waiting.forEach(cb => cb(this));\n\n    LOOKUP.set(I, this);\n\n    return I;\n  }\n}\n\nexport { Context }","import { fetch, Model, PARENT, STATE, uid, update, watch } from '../model';\n\nconst INSTRUCTION = new Map<symbol, Model.Instruction>();\n\nfunction use <T> (instruction: Model.Instruction<T>): T extends void ? unknown : T;\n\nfunction use <T extends Model> (Type: Model.Init<T>, required: false): T | undefined;\n\nfunction use <T extends Model> (Type: Model.Init<T>, ready?: (i: T) => void): T;\n\nfunction use(\n  arg1: Model.Init | Model.Instruction,\n  arg2?: ((i: Model) => void) | boolean){\n\n  if(Model.is(arg1))\n    arg1 = childInstruction(arg1, arg2);\n\n  const token = Symbol(\"instruction-\" + uid());\n  INSTRUCTION.set(token, arg1);\n  return token;\n}\n\nfunction childInstruction(\n  type: Model.Init<Model>,\n  arg2?: ((i: Model) => void) | boolean\n): Model.Instruction<any, any> {\n  return (key, subject) => {\n    function set(next: Model | undefined){\n      if(next ? !(next instanceof type) : arg2 !== false)\n        throw new Error(`${subject}.${key} expected Model of type ${type} but got ${next && next.constructor}.`);\n\n      update(subject, key, next);\n\n      if(next && typeof arg2 == \"function\")\n        arg2(next);\n\n      return false;\n    }\n\n    const value = new type();\n\n    set(value);\n    PARENT.set(value, subject);\n    value.set();\n\n    return { set };\n  }\n}\n\nfunction init(this: Model){\n  const state = STATE.get(this)!;\n\n  for(const key in this){\n    const { value } = Object.getOwnPropertyDescriptor(this, key)!;\n    const instruction = INSTRUCTION.get(value);\n\n    if(!instruction)\n      continue;\n\n    INSTRUCTION.delete(value);\n    delete (this as any)[key];\n\n    const output = instruction.call(this, key, this, state);\n\n    if(!output)\n      continue;\n\n    const desc = typeof output == \"object\" ? output : { get: output };\n\n    if(\"value\" in desc)\n      state[key] = desc.value;\n\n    const model = this;\n\n    Object.defineProperty(model, key, {\n      enumerable: desc.enumerable !== false,\n      get(this: Model){\n        return watch(this, key, \n          typeof desc.get == \"function\"\n            ? desc.get(this)\n            : fetch(model, key, desc.get)\n        );\n      },\n      set(next){\n        if(desc.set === false)\n          throw new Error(`${model}.${key} is read-only.`);\n\n        update(model, key, next, desc.set);\n      }\n    })\n  }\n\n  return null;\n}\n\nModel.on(init);\n\nexport { use }","import { Context } from '../context';\nimport { createEffect } from '../control';\nimport { fetch, METHOD, Model, PARENT, event, update } from '../model';\nimport { use } from './use';\n\ntype Type<T extends Model> = Model.Type<T> & typeof Model;\n\nconst STALE = new WeakSet<() => void>();\n\ndeclare namespace get {\n  type Compute<T, S = any> = (on: S, key: string) => T;\n\n  type Factory<T, S = any> = (this: S, key: string, thisArg: S) => T;\n\n  type Source<T extends Model = Model> = (resolve: (x: T) => void) => void;\n\n  type Effect<T> = (model: T, key: string) => (() => void) | void;\n}\n\n/**\n * Fetches and assigns the controller which spawned this host.\n * When parent assigns an instance via `use()` directive, it\n * will be made available to child upon this request.\n *\n * @param Type - Type of controller compatible with this class. \n * @param expectParent - If true, will throw if Model is created without a parent.\n */\nfunction get <T extends Model> (Type: Model.Type<T>, expectParent?: true): T;\n\n/**\n * Fetches and assigns the controller which spawned this host.\n * When parent assigns an instance via `use()` directive, it\n * will be made available to child upon this request.\n *\n * @param Type - Type of controller compatible with this class. \n * @param required - If false, property may be undefined. Otherwise will throw suspense.\n */\nfunction get <T extends Model> (Type: Model.Type<T>, required?: false): T | undefined;\n\n/**\n * Implement a computed value from a foreign model. Output will be generated by provided function,\n * where the foreign model will be passed to that function.\n * \n * @param source - Type of Model to fetch for computation.\n * @param compute - Compute function. Will update automatically as input values change.\n */\nfunction get <T extends Model> (Type: Model.Type<T>, effect: get.Effect<T>): T;\n\n/**\n * Implement a computed value; output will be generated by provided function.\n *\n * @param source - Source model from which computed value will be a subscriber.\n * @param compute - Compute function. Bound to a subscriber-proxy of source, returns output value. Will update automatically as input values change.\n */\nfunction get <R, T extends Model> (source: T, compute: get.Compute<R, T>): R;\n\n/**\n * Implement a computed value; output is returned by function from provided factory.\n * \n * Factory is bound to owner of property.\n *\n * @param compute - Factory function to generate a getter to subscribe dependancies.\n */\nfunction get <R, T> (compute: get.Factory<R, T>): R;\n \nfunction get<R, T extends Model>(\n  arg0: T | get.Factory<R, T> | Type<T>,\n  arg1?: Function | boolean){\n\n  return use((key, subject, state) => {\n    if(typeof arg0 == \"symbol\")\n      throw new Error(`Attempted to use an instruction result (probably use or get) as computed source for ${subject}.${key}. This is not allowed.`)\n\n    if(Model.is(arg0)){\n      const hasParent = PARENT.get(subject) as T;\n\n      // TODO: notify on discovered context \n      function assign(value: T) {\n        if (typeof arg1 == \"function\")\n          value.get(x => (arg1 as Function)(x, key));\n\n        update(subject, key, value);\n      }\n\n      if(!hasParent && arg1 === true)\n        throw new Error(`${subject} may only exist as a child of type ${arg0}.`);\n      else if(hasParent)\n        if(hasParent instanceof arg0){\n          assign(hasParent);\n          return {}\n        }\n        else if(arg1 === true)\n          throw new Error(`New ${subject} created as child of ${hasParent}, but must be instanceof ${arg0}.`);\n \n      Context.get(subject, (context) => {\n        const model = context.get(arg0);\n\n        if(model)\n          assign(model);\n        else if(arg1 !== false)\n          throw new Error(`Required ${arg0} not found in context for ${subject}.`)\n      });\n\n      return {\n        get: arg1 !== false,\n        enumerable: false\n      };\n    }\n    \n    let from = subject;\n    \n    if(arg0 instanceof Model){\n      from = arg0;\n    }\n    else {\n      const fn = METHOD.get(arg0) || arg0;\n      arg1 = ((p, k) => fn.call(p, k, p)) as get.Effect<T>;\n    }\n\n    const source: get.Source<T> = resolve => resolve(from);\n    const getter = arg1 as get.Compute<R, T>;\n\n    let reset: (() => void) | undefined;\n    let isAsync: boolean;\n    let proxy: any;\n\n    function connect(model: Model){\n      reset = createEffect(model, current => {\n        proxy = current;\n\n        if(!(key in state) || STALE.delete(compute))\n          compute(!reset);\n\n        return (didUpdate) => {\n          if(didUpdate){\n            STALE.add(compute);\n            event(subject, key, true);\n          }\n        };\n      }, false)\n    }\n\n    function compute(initial?: boolean){\n      let next: R | undefined;\n\n      try {\n        next = getter.call(proxy, proxy, key);\n      }\n      catch(err){\n        console.warn(`An exception was thrown while ${initial ? \"initializing\" : \"refreshing\"} ${subject}.${key}.`)\n\n        if(initial)\n          throw err;\n\n        console.error(err);\n      }\n\n      update(subject, key, next, !isAsync);\n    }\n\n    return () => {\n      if(!proxy){\n        source(connect);\n        isAsync = true;\n      }\n\n      if(STALE.delete(compute))\n        compute();\n\n      return fetch(subject, key, !proxy) as T;\n    }\n  })\n}\n\nexport { get };","import { addListener, enter } from '../control';\nimport { Model, update } from '../model';\nimport { use } from './use';\n\nconst { defineProperty, defineProperties } = Object;\n\ndeclare namespace ref {\n  type Callback<T> = (argument: T) =>\n    ((next: T | null) => void) | Promise<void> | void | boolean;\n\n  interface Object<T = any> {\n    (next: T | null): void;\n\n    /** Current value held by this reference. */\n    current: T | null;\n\n    /** \n     * Subscribe to changes of this reference.\n     * \n     * @param callback - Callback to invoke with the current value when it changes.\n     * @returns Unsubscribe function to stop listening to changes.\n     */\n    get(callback: (value: T) => void): () => void;\n\n    /** Retrieve current value. */\n    get(): T | null;\n  }\n\n  /** Object with references to all managed values of `T`. */\n\n  /** Object with references to all managed values of `T`. */\n  type Proxy<T extends Model> =\n    & { [P in Model.Field<T>]-?: Object<T[P]> }\n    & { get(): T };\n\n  type CustomProxy<T extends Model, R> =\n    & { [P in Model.Field<T>]-?: R }\n    & { get(): T };\n}\n\n/**\n * Creates an object with references to all managed values.\n * Each property is a function to set value in state when invoked.\n *\n * *Properties are simultaneously a ref-function and ref-object, use as needed.*\n *\n * @param target - Source model from which to reference values.\n */\nfunction ref <T extends Model> (target: T): ref.Proxy<T>;\n\n/**\n * Creates an object with values based on managed values.\n * Each property will invoke mapper function on first access supply\n * the its return value going forward.\n *\n * @param target - Source model from which to reference values.\n * @param mapper - Function producing the placeholder value for any given property.\n */\nfunction ref <O extends Model, R>\n  (target: O, mapper: (key: Model.Field<O>) => R): ref.CustomProxy<O, R>;\n\n/**\n * Creates a ref-compatible property.\n * Will persist value, and updates to this are made part of controller event-stream.\n *\n * *Output is simultaneously a ref-function and ref-object, use as needed.*\n *\n * @param callback - Optional callback to synchronously fire when reference is first set or does update.\n */\nfunction ref <T> (callback?: ref.Callback<T>): ref.Object<T>;\n\n/**\n * Creates a ref-compatible property.\n * Will persist value, and updates to this are made part of controller event-stream.\n *\n * *Output is simultaneously a ref-function and ref-object, use as needed.*\n *\n * @param callback - Optional callback to synchronously fire when reference is first set or does update.\n * @param ignoreNull - Default `true`. If `false`, will still callback with `null`.\n */\nfunction ref <T> (callback: ref.Callback<T | null>, ignoreNull: boolean): ref.Object<T>;\n\nfunction ref<T>(\n  arg?: ref.Callback<T> | Model,\n  arg2?: ((key: string) => any) | boolean){\n\n  return use<T>((key, subject, state) => {\n    let value = {};\n    const method = (key: string) =>\n      (callback?: (value: T) => void) => callback\n        ? addListener(subject, () => callback(state[key]), key)\n        : state[key];\n\n    if(arg === subject)\n      subject.get(() => {\n        for(const key in state)\n          if(typeof arg2 == \"function\")\n            defineProperty(value, key, {\n              configurable: true,\n              get(){\n                const out = arg2(key);\n                defineProperty(value, key, { value: out });\n                return out;\n              }\n            })\n          else {\n            const get = method(key);\n            const set = (value: unknown) => {\n              update(subject, key, value)\n            };\n\n            defineProperties(set, {\n              current: { get, set },\n              get: { value: get }\n            });\n\n            defineProperty(value, key, { value: set });\n          }\n      })\n\n    else if(typeof arg == \"object\")\n      throw new Error(\"ref instruction does not support object which is not 'this'\");\n\n    else {\n      let unset: ((next: T) => void) | undefined;\n\n      const get = method(key);\n      const set = (value?: any) => {\n        if(!update(subject, key, value) || !arg)\n          return;\n\n        if(unset)\n          unset = void unset(value);\n    \n        if(value === null && arg2 !== false)\n          return;\n\n        const exit = enter();\n        const out = arg.call(subject, value);\n        const flush = exit();\n\n        unset = key => {\n          if(typeof out == \"function\")\n            out(key);\n\n          flush();\n        }\n      };\n  \n      state[key] = null;\n      value = defineProperties(set, {\n        current: { get, set },\n        get: { value: get }\n      }) as ref.Object<T>;\n    }\n\n    defineProperty(subject, key, { value });\n  })\n}\n\nexport { ref }","import { addListener, enter } from '../control';\nimport { Model, event, update } from '../model';\nimport { use } from './use';\n\ndeclare namespace set {\n  type Callback<T, S = any> = (this: S, next: T, previous: T) =>\n    ((next: T) => void) | Promise<any> | void | boolean;\n\n  type Factory<T, S = any> = (this: S, key: string) => Promise<T> | T;\n}\n\n/**\n * Set property as `undefined` but required.\n * \n * Property cannot be accessed until it is defined. If accessed while undefined, a hybrid\n * `Promise`/`Error` (aka: [Suspense](https://reactjs.org/docs/concurrent-mode-suspense.html)) will be thrown.\n */\nfunction set <T = any>(): T;\n\n/**\n * Set property with a factory function.\n * \n * **Note** Factory is lazy! It will only run if/when property is accessed.\n * Value will be undefined until factory resolves, which will also dispatch an update for the property.\n */\nfunction set <T> (factory: set.Factory<T> | Promise<T>, required: false): T | undefined;\n\n/**\n * Set property with a factory function.\n *\n * If async, property cannot be accessed until resolves, yeilding a result.\n * If accessed while still processing, React Suspense will be thrown.\n *\n * @param factory - Callback run to derrive property value.\n * @param required - If true run factory immediately on creation, otherwise on access.\n */\nfunction set <T> (factory: set.Factory<T> | Promise<T>, required?: boolean): T;\n\n/**\n * Set property with a factory function.\n *\n * If async, property cannot be accessed until resolves, yeilding a result.\n * If accessed while still processing, React Suspense will be thrown.\n *\n * @param factory - Callback run to derrive property value.\n * @param onUpdate - Callback run when property is finished computing or is set. \n */\nfunction set <T> (factory: set.Factory<T> | Promise<T>, onUpdate?: set.Callback<T>): T;\n\n/**\n * Set a property with empty placeholder and/or update callback.\n * \n * @param value - Starting value for property. If undefined, suspense will be thrown on access, until value is set and accepted by callback.\n * @param onUpdate - Callback run when property is set. If returns false, update is not accepted and property will keep previous value.\n */\nfunction set <T> (value: T | undefined, onUpdate?: set.Callback<T>): T;\n\nfunction set <T> (\n  value?: set.Factory<T> | Promise<T> | T,\n  argument?: set.Callback<any> | boolean){\n\n  return use<T>((key, subject) => {\n    const property: Model.Descriptor = { enumerable: false };\n\n    if(typeof value == \"function\" || value instanceof Promise){\n      function init(){\n        if(typeof value == \"function\")\n          try {\n            value = attempt(value.bind(subject, key));\n          }\n          catch(err){\n            console.warn(`Generating initial value for ${subject}.${key} failed.`);\n            throw err;\n          }\n\n        property.get = argument !== false;\n\n        const set = (value: any) => subject[key] = value;\n\n        if(value instanceof Promise)\n          value.then(set, error => {\n            event(subject, key);\n            property.get = () => { throw error };\n          })\n        else\n          set(value);\n\n        if(argument)\n          return null;\n        \n        return subject[key];\n      }\n\n      if(argument)\n        addListener(subject, init, true);\n      else\n        property.get = init;\n    }\n    else if(value !== undefined)\n      property.value = value;\n\n    if(typeof argument == \"function\"){\n      let unset: ((next: T) => void) | undefined;\n\n      property.set = function(this: any, value: any, previous: any){\n        const exit = enter();\n        const returns = argument.call(this, value, previous);\n        const flush = exit();\n\n        if(returns === false)\n          return false;\n\n        if(typeof unset == \"function\")\n          unset(value);\n\n        unset = (next: T) => {\n          if(typeof returns == \"function\")\n            returns(next);\n\n          flush();\n        }\n      }\n    }\n    else\n      property.set = value => {\n        property.get = undefined;\n        update(subject, key, value);\n      }\n\n    return property;\n  })\n}\n\nfunction attempt(fn: () => any): any {\n  function retry(err: unknown){\n    if(err instanceof Promise)\n      return err.then(compute);\n    else\n      throw err;\n  }\n\n  function compute(): any {\n    try {\n      const output = fn();\n\n      return output instanceof Promise\n        ? output.catch(retry)\n        : output;\n    }\n    catch(err){\n      return retry(err);\n    }\n  }\n\n  return compute();\n}\n\nexport { set }","import { enter } from '../control';\nimport { Context } from '../context';\nimport { Model, update } from '../model';\nimport { use } from './use';\n\nconst APPLY = new WeakMap<Model, (model: Model) => (() => void) | boolean | void>();\n\ndeclare namespace has {\n  type Callback<T = any> = (model: T, recipient: Model) => void | boolean | (() => void);\n}\n\nfunction has <T extends Model> (type: Model.Type<T>, callback?: has.Callback<T>): readonly T[];\nfunction has (callback?: has.Callback): readonly Model[];\n  \nfunction has <T extends Model> (\n  arg1?: Model.Type<T> | has.Callback<Model>,\n  arg2?: has.Callback<T>){\n\n  return use<T[]>((key, subject) => {\n    const applied = new Set<Model>();\n    const reset = () => {\n      update(subject, key, Object.freeze(Array.from(applied)));\n    }\n\n    if(Model.is(arg1))\n      Context.get(subject, ctx => {\n        ctx.has(arg1, model => {\n          let remove: (() => void) | undefined;\n          let disconnect: (() => void) | undefined;\n          let flush: (() => void) | undefined;\n  \n          if(applied.has(model))\n            return;\n          \n          const exit = enter();\n\n          try {\n            const notify = APPLY.get(model);\n\n            if(notify){\n              const after = notify(subject);\n    \n              if(after === false)\n                return;\n    \n              if(typeof after == \"function\")\n                disconnect = after;\n            }\n    \n            if(typeof arg2 == \"function\"){\n              const done = arg2(model, subject);\n    \n              if(done === false)\n                return false;\n\n              if(typeof done == \"function\")\n                remove = done;\n            }\n          }\n          finally {\n            flush = exit();\n          }\n  \n          applied.add(model);\n          reset();\n  \n          const done = () => { \n            flush();\n            ignore();\n  \n            applied.delete(model);\n            reset();\n  \n            if(disconnect)\n              disconnect();\n  \n            if(typeof remove == \"function\")\n              remove();\n\n            remove = undefined;\n          }\n  \n          const ignore = model.set(done, null);\n          \n          return done;\n        })\n      });\n    else {\n      if(APPLY.has(subject))\n        throw new Error(`'has' callback can only be used once per model.`);\n\n      APPLY.set(subject, recipient => {\n        let remove: (() => void) | boolean | void;\n\n        if(arg1){\n          remove = arg1(recipient, subject);\n  \n          if(remove === false)\n            return false;\n        }\n\n        applied.add(recipient);\n        reset();\n\n        return () => {\n          applied.delete(recipient);\n          reset();\n\n          if(typeof remove == \"function\")\n            remove();\n        }\n      });\n    }\n\n    return { value: [] };\n  })\n}\n\nexport { has }"],"mappings":"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","names":["key","event","watch","key","update","res","set","keys","bind","use","get","value","silent","keys","require","key","init","event","key","set","init","key","assign","key","get","set","value","key","init","set","value","key","done"]}
+{"version":3,"sources":["../src/index.ts","../src/control.ts","../src/model.ts","../src/context.ts","../src/instruction/use.ts","../src/instruction/get.ts","../src/instruction/ref.ts","../src/instruction/set.ts","../src/instruction/has.ts"],"sourcesContent":["export { get } from './instruction/get';\nexport { ref } from './instruction/ref';\nexport { set } from './instruction/set';\nexport { use } from './instruction/use';\nexport { has } from './instruction/has';\n\nexport { Model, Model as default, METHOD } from './model';\nexport { createEffect, addListener, event, Observable } from './control';\nexport { Context } from './context';","/**\n * Update callback function.\n * \n * @param key -\n *   - `string` - property which has updated.\n *   - `false` - a normal update has completed.\n *   - `true` - initial event; instance is ready.\n *   - `null` - terminal event; instance is expired.\n * @param source - Instance of Model for which update has occured.\n */\ntype OnUpdate<T extends Observable = any> = \n  (this: T, key: Event, source: T) => (() => void) | null | void;\n\ntype Effect<T extends Observable> = (this: T, proxy: T) =>\n  ((update: boolean | null) => void) | Promise<void> | null | void;\n\ntype Event = number | string | null | boolean | symbol;\n\ntype PromiseLite<T = void> = { then: (callback: () => T) => T };\n\ndeclare namespace Observable {\n  export type Callback = () => void | PromiseLite;\n}\n\ninterface Observable {\n  [Observable](callback: Observable.Callback, required?: boolean): this;\n}\n\nconst Observable = Symbol(\"observe\");\n\n/** Placeholder event determines if model is initialized or not. */\nconst onReady = () => null;\n\nconst LISTENERS = new WeakMap<Observable, Map<OnUpdate, Set<Event> | undefined>>();\n\n/** Events pending for a given object. */\nconst PENDING = new WeakMap<Observable, Set<Event>>();\n\n/** Update register. */\nconst PENDING_KEYS = new WeakMap<Observable, Set<string | number | symbol>>();\n\n/** Central event dispatch. Bunches all updates to occur at same time. */\nconst DISPATCH = new Set<() => void>();\n\nfunction addListener<T extends Observable>(\n  subject: T, callback: OnUpdate<T>, select?: Event | Set<Event>){\n\n  let listeners = LISTENERS.get(subject)!;\n\n  if(!listeners)\n    LISTENERS.set(subject, listeners = new Map([[onReady, undefined]]));\n\n  if(select !== undefined && !(select instanceof Set))\n    select = new Set([select]);\n\n  if(!listeners.has(onReady) && !select)\n    callback.call(subject, true, subject);\n\n  listeners.set(callback, select);\n\n  return () => listeners.delete(callback);\n}\n\nfunction emit(model: Observable, key: Event): void {\n  const listeners = LISTENERS.get(model)!;\n  const notReady = listeners.has(onReady);\n\n  if(key === true && !notReady)\n    return;\n\n  let pending = PENDING.get(model);\n\n  if(pending){\n    pending.add(key);\n    return;\n  }\n\n  PENDING.set(model, pending = new Set(notReady ? [true, key] : [key]));\n\n  for(const key of pending)\n    for(const [callback, filter] of listeners)\n      if(!filter || filter.has(key)){\n        const after = callback.call(model, key, model);\n\n        if(after)\n          enqueue(after);\n\n        else if(after === null)\n          listeners.delete(callback);\n      }\n\n  if(key === null)\n    listeners.clear();\n  \n  PENDING.delete(model);\n}\n\nfunction event(\n  subject: Observable,\n  key?: string | number | symbol | null,\n  silent?: boolean){\n\n  if(key === null)\n    return emit(subject, key);\n\n  if(!key)\n    return emit(subject, true);\n\n  let pending = PENDING_KEYS.get(subject);\n\n  if(!pending){\n    PENDING_KEYS.set(subject, pending = new Set());\n\n    if(!silent)\n      enqueue(() => {\n        emit(subject, false);\n        PENDING_KEYS.delete(subject)\n      })\n  }\n\n  pending.add(key);\n\n  if(!silent)\n    emit(subject, key);\n}\n\nfunction enqueue(eventHandler: (() => void)){\n  if(!DISPATCH.size)\n    setTimeout(() => {\n      DISPATCH.forEach(event => {\n        try {\n          event();\n        }\n        catch(err){\n          console.error(err);\n        }\n      });\n      DISPATCH.clear();\n    }, 0);\n\n  DISPATCH.add(eventHandler);\n}\n\n/**\n * Create a side-effect which will update whenever values accessed change.\n * Callback is called immediately and whenever values are stale.\n * \n * @param target - Instance of Model to observe.\n * @param callback - Function to invoke when values change.\n * @param requireValues - If `true` will throw if accessing a value which is `undefined`.\n */\nfunction createEffect<T extends Observable>(target: T, callback: Effect<Required<T>>, requireValues: true): () => void;\nfunction createEffect<T extends Observable>(target: T, callback: Effect<T>, recursive?: boolean): () => void;\nfunction createEffect<T extends Observable>(target: T, callback: Effect<T>, argument?: boolean){\n  let unset: ((update: boolean | null) => void) | undefined;\n  let reset: (() => void) | null | undefined;\n\n  function invoke() {\n    let stale: boolean | undefined;\n\n    function onUpdate(): void | PromiseLite<void> {\n      if (stale || reset === null)\n        return;\n\n      stale = true;\n\n      if (reset && unset) {\n        unset(true);\n        unset = undefined;\n      }\n\n      enqueue(invoke);\n      return { then: enqueue }\n    }\n\n    const subscriber = target[Observable](onUpdate, argument === true);\n\n    try {\n      const exit = enter(argument === false);\n      const output = callback.call(subscriber, subscriber);\n      const flush = exit();\n\n      reset = output === null ? null : invoke;\n      unset = key => {\n        if(typeof output == \"function\")\n          output(key);\n\n        flush();\n      }\n    }\n    catch(err){\n      if(err instanceof Promise){\n        reset = undefined;\n        err.then(invoke);\n      }\n      else\n        throw err;\n    }\n  }\n\n  function cleanup(){\n    if(unset)\n      unset(false);\n\n    reset = null;\n  };\n\n  if(EffectContext && argument !== false)\n    EffectContext.add(cleanup);\n\n  addListener(target, key => {\n    if(key === true)\n      invoke();\n\n    else if(!reset)\n      return reset;\n\n    if(key === null && unset)\n      unset(null);\n  });\n  \n  return cleanup;\n}\n\nlet EffectContext: Set<() => void> | undefined;\n\nexport function enter(ignore?: boolean){\n  if(ignore)\n    return () => () => {};\n\n  const last = EffectContext;\n  const context = EffectContext = new Set;\n\n  return () => {\n    EffectContext = last;\n    return () => context.forEach(fn => fn());\n  }\n}\n\nexport {\n  addListener,\n  createEffect,\n  event,\n  OnUpdate,\n  PENDING_KEYS,\n  Observable\n}","import { addListener, createEffect, event, Observable, OnUpdate, PENDING_KEYS } from './control';\n\nconst define = Object.defineProperty;\n\n/** Register for all active models via string identifiers (usually unique). */\nconst ID = new WeakMap<Model, string>();\n\n/** Internal state assigned to models. */\nconst STATE = new WeakMap<Model, Record<string | number | symbol, unknown>>();\n\n/** External listeners for any given Model. */\nconst NOTIFY = new WeakMap<Model.Type, Set<OnUpdate>>();\n\n/** Parent-child relationships. */\nconst PARENT = new WeakMap<Model, Model | null>();\n\n/** List of methods defined by a given type. */\nconst METHODS = new WeakMap<Model.Type, Map<string, (value: any) => void>>();\n\n/** Reference bound instance methods to real ones. */\nconst METHOD = new WeakMap<any, any>();\n\ndeclare namespace Model {\n  /** Any type of Model, using own class constructor as its identifier. */\n  type Type<T extends Model = Model> =\n    (abstract new (...args: any[]) => T) & typeof Model;\n\n  /** A Model constructor, but which is not abstract. */\n  type Init<T extends Model = Model> =\n    (new (...args: Model.Args<T>) => T) & Omit<typeof Model, never>;\n\n  /**\n   * Model constructor callback - is called when Model finishes intializing.\n   * Returned function will run when model is destroyed.\n   */\n  type Callback<T extends Model = Model> =\n    (this: T, thisArg: T) => Promise<void> | (() => void) | Assign<T> | void;\n\n  /** Model constructor argument */\n  type Argument<T extends Model = Model> = Assign<T> | Callback<T> | string | void;\n\n  /** Model constructor arguments */\n  type Args<T extends Model = any> = (Argument<T> | Args<T>)[];\n\n  /** Subset of `keyof T` which are not methods or defined by base Model U. **/\n  type Field<T> = Exclude<keyof T, keyof Model>;\n\n  /** Any valid key for model, including but not limited to Field<T>. */\n  type Event<T> = Field<T> | (string & {}) | number | symbol;\n\n  /** Object overlay to override values and methods on a model. */\n  type Assign<T> = {\n    [K in Field<T>]?:\n      T[K] extends (...args: infer A) => infer R \n        ? (this: T, ...args: A) => R\n        : T[K];\n  } & Record<string, unknown>;\n\n  /** Export/Import compatible value for a given property in a Model. */\n  type Export<R> = R extends { get(): infer T } ? T : R;\n\n  /** Value for a property managed by a model. */\n  type Value<T extends Model, K extends Event<T>> =\n    K extends keyof T ? Export<T[K]> : unknown;\n\n  type OnEvent<T extends Model> =\n    (this: T, key: unknown, source: T) => (() => void) | void | null;\n\n  type OnUpdate<T extends Model, K extends Event<T>> =\n    (this: T, key: K, thisArg: K) => void;\n\n  /**\n   * Values from current state of given model.\n   * Differs from `Values` as values here will drill\n   * into \"real\" values held by exotics like ref.Object.\n   */\n  type State<T> = { [P in Field<T>]: Export<T[P]> };\n\n  /** Object comperable to data found in T. */\n  type Values<T> = { [P in Field<T>]?: Export<T[P]> };\n\n  /** Exotic value, where actual value is contained within. */\n  type Ref<T = any> = {\n    (next: T): void;\n    current: T | null;\n  }\n\n  /**\n   * A callback function which is subscribed to parent and updates when accessed properties change.\n   * \n   * @param current - Current state of this model. This is a proxy which detects properties which\n   * where accessed, and thus depended upon to stay current.\n   * \n   * @param update - Set of properties which have changed, and events fired, since last update.\n   * \n   * @returns A callback function which will be called when this effect is stale.\n   */\n  type Effect<T> = (this: T, current: T, update: Set<Event<T>>) =>\n    EffectCallback | Promise<void> | null | void;\n\n  /**\n   * A callback function returned by effect. Will be called when effect is stale.\n   * \n   * @param update - `true` if update is pending, `false` effect has been cancelled, `null` if model is destroyed.\n   */\n  type EffectCallback = ((update: boolean | null) => void);\n\n  /**\n   * Property initializer, will run upon instance creation.\n   * Optional returned callback will run when once upon first access.\n   */\n  type Instruction<T = any, M extends Model = any> =\n    // TODO: Should this allow for numbers/symbol properties?\n    (this: M, key: Extract<Field<M>, string>, thisArg: M, state: State<M>) =>\n      Descriptor<T> | ((source: M) => T) | void;\n\n  type Getter<T> = (source: Model) => T;\n  type Setter<T> = (value: T, previous: T) => boolean | void | (() => T);\n\n  type Descriptor<T = any> = {\n    get?: Getter<T> | boolean;\n    set?: Setter<T> | boolean;\n    enumerable?: boolean;\n    value?: T;\n  }\n}\n\ninterface Model {\n  /**\n   * Loopback to instance of this model. This is useful when in a subscribed context,\n   * to keep write access to `this` after a destructure. You can use it to read variables silently as well.\n   **/\n  is: this;\n}\n\nabstract class Model implements Observable {\n  constructor(...args: Model.Args){\n    prepare(this);\n    define(this, \"is\", { value: this });\n    init(this, args);\n  }\n\n  [Observable](callback: Observable.Callback, required?: boolean){\n    const watch = new Set<Model.Event<this>>();\n    const proxy = Object.create(this);\n    \n    addListener(this, () => void callback(), watch);\n\n    OBSERVER.set(proxy, (key, value) => {\n      if(value === undefined && required)\n        throw new Error(`${this}.${key} is required in this context.`);\n\n      watch.add(key);\n\n      if(value instanceof Object && Observable in value)\n        return value[Observable](callback, required);\n\n      return value;\n    });\n\n    return proxy as this;\n  }\n\n  /**\n   * Pull current values from state. Flattens all models and exotic values recursively.\n   * \n   * @returns Object with all values from this model.\n   **/\n  get(): Model.State<this>;\n\n  /**\n   * Run a function which will run automatically when accessed values change.\n   * \n   * @param effect Function to run, and again whenever accessed values change.\n   *               If effect returns a function, it will be called when a change occurs (syncronously),\n   *               effect is cancelled, or parent model is destroyed.\n   * @returns Function to cancel listener.\n   */\n  get(effect: Model.Effect<this>): () => void;\n\n  /**\n   * Get value of a property.\n   * \n   * @param key - Property to get value of.\n   * @param required - If true, will throw an error if property is not available.\n   * @returns Value of property.\n   */\n  get<T extends Model.Event<this>>(key: T, required?: boolean): Model.Value<this, T>;\n\n  /**\n   * Run a function when a property is updated.\n   * \n   * @param key - Property to watch for updates.\n   * @param callback - Function to call when property is updated.\n   * @returns Function to cancel listener.\n   */\n  get<T extends Model.Event<this>>(key: T, callback: Model.OnUpdate<this, T>): () => void;\n\n  /**\n   * Check if model is expired.\n   * \n   * @param status - `null` to check if model is expired.\n   * @returns `true` if model is expired, `false` otherwise.\n   */\n  get(status: null): boolean;\n\n  /**\n   * Callback when model is to be destroyed.\n   * \n   * @param callback - Function to call when model is destroyed.\n   * @returns Function to cancel listener.\n   */\n  get(status: null, callback: () => void): () => void;\n\n  get(arg1?: Model.Effect<this> | string | null, arg2?: boolean | Model.OnUpdate<this, any>){\n    const self = this.is;\n\n    if(typeof arg1 == \"function\"){\n      let pending = new Set<Model.Event<this>>();\n\n      return createEffect(self, (proxy) => {\n        const cb = arg1.call(proxy, proxy, pending);\n\n        return cb === null ? null : ((update) => {\n          pending = PENDING_KEYS.get(self)!;\n          if(typeof cb == \"function\")\n            cb(update);\n        })\n      });\n    }\n\n    return (\n      arg1 === undefined ? snapshot(self) :\n      typeof arg2 == \"function\" ? addListener(self, arg2, arg1) :\n      arg1 === null ? Object.isFrozen(STATE.get(self)) :\n      fetch(self, arg1, arg2)\n    )\n  }\n\n  /**\n   * Get update in progress.\n   *\n   * @returns Promise which resolves object with updated values, `undefined` if there no update is pending.\n   **/\n  set(): PromiseLike<Model.Event<this>[]> | undefined;\n\n  /**\n   * Update mulitple properties at once. Merges argument with current state.\n   * Properties which are not managed by this model will be ignored.\n   * \n   * @param assign - Object with properties to update.\n   * @param silent - If an update does occur, listeners will not be refreshed automatically.\n   * @returns Promise resolving an array of keys updated, `undefined` (immediately) if a noop.\n   */\n  set(assign?: Model.Assign<this>, silent?: boolean): PromiseLike<Model.Event<this>[]> | undefined;\n\n  /**\n   * Push an update. This will not change the value of associated property.\n   * \n   * Useful where a property value internally has changed, but the object is the same.\n   * For example: An array has pushed a new value, or a nested property is updated.\n   * \n   * You can also use this to dispatch arbitrary events.\n   * Symbols are recommended as non-property events, however you can use any string.\n   * If doing so, be sure to avoid collisions with property names! An easy way to do this is\n   * to prefix an event with \"!\" and/or use dash-case. e.g. `set(\"!event\")` or `set(\"my-event\")`.\n   * \n   * @param key - Property or event to dispatch.\n   * @returns Promise resolves an array of keys updated.\n   */\n  set(key: Model.Event<this>): PromiseLike<Model.Event<this>[]>;\n\n  /**\n   * Set a value for a property. This will update the value and notify listeners.\n   * \n   * **Use with caution!** Key nor value are checked for validity.\n   * \n   * This is meant for assigning values programmatically,\n   * where simple assignment is not practicable.\n   * \n   * For example: `(this as any)[myProperty] = value;`\n   * \n   * @param key - Property to set value for.\n   * @param value - Value to set for property.\n   * @param init - If true, model will begin to manage the property if it is not already.\n   * @returns Promise resolves an array of keys updated.\n   */\n  set(key: Model.Event<this>, value: unknown, init?: boolean): PromiseLike<Model.Event<this>[]>;\n\n  /**\n   * Call a function when update occurs.\n   * \n   * Given function is called for every assignment (which changes value) or explicit `set`.\n   * \n   * To run logic on final value only, callback may return a function. Using the same\n   * function for one or more events will ensure it is called only when events are settled.\n   * \n   * @param callback - Function to call when update occurs.\n   * @returns Function to remove listener. Will return `true` if removed, `false` if inactive already.\n   * \n  */\n  set(callback: Model.OnEvent<this>): () => boolean;\n\n  /**\n   * Call a function when a property is updated.\n   * Unlike `get`, this calsl synchronously and will fire as many times as the property is updated.\n   * \n   * @param callback - Function to call when property is updated.\n   * @param event - Property to watch for updates.\n   */\n  set(callback: Model.OnEvent<this>, event: Model.Event<this> | null): () => boolean;\n\n  /**\n   * Declare an end to updates. This event is final and will freeze state.\n   * This event can be watched for as well, to run cleanup logic and internally will remove all listeners.\n   * \n   * @param status - `null` to end updates.\n   */\n  set(status: null): void;\n\n  set(\n    arg1?: Model.OnEvent<this> | Model.Assign<this> | Model.Event<this> | null,\n    arg2?: unknown,\n    arg3?: boolean){\n\n    const self = this.is;\n\n    if(typeof arg1 == \"function\")\n      return addListener(self, key => {\n        if(arg2 === key || arg2 === undefined && typeof key == \"string\")\n          return arg1.call(self, key, self);\n      })\n      \n    if(arg1 && typeof arg1 == \"object\")\n      assign(self, arg1, arg2 === true);\n    else if(!arg2)\n      event(self, arg1);\n    else if(arg3)\n      manage(self, arg1 as string | number, arg2);\n    else\n      update(self, arg1 as string | number, arg2)\n\n    const pending = PENDING_KEYS.get(this);\n\n    if(pending)\n      return <PromiseLike<Model.Event<this>[]>> {\n        then: (res) => new Promise<any>(res => {\n          const remove = addListener(this, key => {\n            if(key !== true){\n              remove();\n              return res.bind(null, Array.from(pending));\n            }\n          });\n        }).then(res)\n      }\n  }\n\n  /**\n   * Iterate over managed properties in this instance of Model.\n   * Yeilds the key and current value for each property.\n   */\n  [Symbol.iterator](): Iterator<[string, unknown]> {\n    return Object.entries(STATE.get(this.is)!)[Symbol.iterator]();\n  }\n\n  /**\n   * Create and activate a new instance of this model.\n   * \n   * **Important** - Unlike `new this(...)` - this method also activates state.\n   * \n   * @param args - arguments sent to constructor\n   */\n  static new<T extends Model>(this: Model.Init<T>, ...args: Model.Args<T>){\n    const instance = new this(...args);\n    event(instance);\n    return instance;\n  }\n\n  /**\n   * Static equivalent of `x instanceof this`.\n   * Determines if provided class is a subtype of this one.\n   * If so, language server will make available all static\n   * methods and properties of this class.\n   */\n  static is<T extends Model.Type>(this: T, maybe: unknown): maybe is T {\n    return maybe === this || typeof maybe == \"function\" && maybe.prototype instanceof this;\n  }\n\n  /**\n   * Register a callback to run when any instance of this Model is updated. \n   */\n  static on<T extends Model>(this: Model.Type<T>, listener: Model.OnEvent<T>){\n    let notify = NOTIFY.get(this);\n\n    if(!notify)\n      NOTIFY.set(this, notify = new Set);\n\n    notify.add(listener);\n\n    return () => notify.delete(listener);\n  }\n}\n\ndefine(Model.prototype, \"toString\", {\n  value(){\n    return ID.get(this.is);\n  }\n});\n\ndefine(Model, \"toString\", {\n  value(){\n    return this.name;\n  }\n});\n\nfunction assign(subject: Model, data: Model.Assign<Model>, silent?: boolean){\n  const methods = METHODS.get(subject.constructor as Model.Type)!;\n    \n  for(const key in data){\n    const bind = methods.get(key);\n\n    if(bind)\n      bind.call(subject, data[key]);\n    else if(key in subject && key !== \"is\"){\n      const desc = Object.getOwnPropertyDescriptor(subject, key)!;\n      const set = desc && desc.set as (value: any, silent?: boolean) => void;\n\n      set.call(subject, data[key], silent);\n    }\n  }\n}\n\n/** Apply instructions and inherited event listeners. Ensure class metadata is ready. */\nfunction prepare(model: Model){\n  let T = model.constructor as Model.Type;\n\n  if(T === Model)\n    throw new Error(\"Cannot create base Model.\");\n\n  const chain = [] as Model.Type[];\n  let keys = new Map<string, (value: any) => void>();\n\n  ID.set(model, `${T}-${uid()}`);\n\n  while(T.name){\n    for(const cb of NOTIFY.get(T) || [])\n      addListener(model, cb);\n\n    if(T === Model) break;\n    else chain.unshift(T);\n\n    T = Object.getPrototypeOf(T)\n  }\n\n  for(const type of chain){\n    if(METHODS.has(type)){\n      keys = METHODS.get(type)!;\n      continue;\n    }\n\n    METHODS.set(type, keys = new Map(keys));\n\n    for(const [key, { value }] of Object.entries(\n      Object.getOwnPropertyDescriptors(type.prototype)\n    )){\n      if(!value || key == \"constructor\")\n        continue;\n      \n      function bind(this: Model, original?: Function){\n        const { is } = this;\n\n        if(is.hasOwnProperty(key) && !original)\n          return value as Function;\n\n        const fn = original || value;\n        const bound = fn.bind(is);\n        \n        METHOD.set(bound, fn);\n        define(is, key, { value: bound, writable: true });\n        \n        return bound;\n      }\n\n      keys.set(key, bind);\n      define(type.prototype, key, { get: bind, set: bind });\n    }\n  }\n}\n\n/**\n * Apply model arguemnts, run callbacks and observe properties.\n * Accumulate and handle cleanup events.\n **/\nfunction init(model: Model, args: Model.Args){\n  const state = {} as Record<string | number | symbol, unknown>;\n\n  STATE.set(model, state);\n\n  args = args.flat().filter(arg => {\n    if(typeof arg != \"string\")\n      return true;\n\n    ID.set(model, arg);\n  });\n\n  addListener(model, () => {\n    if(!PARENT.has(model))\n      PARENT.set(model, null);\n\n    for(const key in model){\n      const desc = Object.getOwnPropertyDescriptor(model, key)!;\n\n      if(\"value\" in desc)\n        manage(model, key, desc.value, true);\n    }\n\n    for(const arg of args){\n      const use = typeof arg == \"function\"\n        ? arg.call(model, model)\n        : arg as Model.Assign<Model>;\n\n      if(use instanceof Promise)\n        use.catch(err => {\n          console.error(`Async error in constructor for ${model}:`);\n          console.error(err);\n        });\n      else if(typeof use == \"function\")\n        addListener(model, use, null)\n      else if(typeof use == \"object\")\n        assign(model, use, true);\n    }\n\n    addListener(model, () => {\n      for(const [_, value] of model)\n        if(value instanceof Model && PARENT.get(value) === model)\n          value.set(null);\n  \n      Object.freeze(state);\n    }, null);\n  \n    return null;\n  });\n}\n\nfunction manage(target: Model, key: string | number, value: any, silent?: boolean){\n  const state = STATE.get(target)!;\n  \n  function get(this: Model){\n    return watch(this, key, state[key]);\n  }\n\n  function set(value: unknown, silent?: boolean){\n    update(target, key, value, silent);\n    if(value instanceof Model && !PARENT.has(value)){\n      PARENT.set(value, target);\n      event(value);\n    }\n  }\n\n  define(target, key, { set, get });\n  set(value, silent);\n}\n\ntype Proxy<T = any> = (key: string | number, value: T) => T;\n\nconst OBSERVER = new WeakMap<Model, Proxy>();\n\nfunction watch(from: Model, key: string | number, value?: any){\n  const access = OBSERVER.get(from);\n  return access ? access(key, value) : value;\n}\n\nfunction fetch(subject: Model, property: string, required?: boolean){\n  const state = STATE.get(subject)!;\n  \n  if(property in state || required === false){\n    const value = state[property];\n\n    if(value !== undefined || !required)\n      return value;\n  }\n\n  const error = new Error(`${subject}.${property} is not yet available.`);\n  const promise = new Promise<any>((resolve, reject) => {\n    addListener(subject, key => {\n      if(key === property){\n        resolve(state[key]);\n        return null;\n      }\n\n      if(key === null)\n        reject(new Error(`${subject} is destroyed.`));\n    });\n  });\n\n  throw Object.assign(promise, {\n    toString: () => String(error),\n    name: \"Suspense\",\n    message: error.message,\n    stack: error.stack\n  });\n}\n\n/** Currently accumulating export. Stores real values of placeholder properties such as ref() or child models. */\nlet EXPORT: Map<any, any> | undefined;\n\nfunction snapshot<T extends Model>(model: T): Model.State<T> {\n  const values = {} as any;\n  let isNotRecursive;\n\n  if(!EXPORT){\n    isNotRecursive = true;\n    EXPORT = new Map([[model, values]]);\n  }\n\n  for(let [key, value] of model){\n    if(EXPORT.has(value))\n      value = EXPORT.get(value);\n    else if(value && typeof value == \"object\" && \"get\" in value && typeof value.get === \"function\")\n      EXPORT.set(value, value = value.get());\n\n    values[key] = value;\n  }\n\n  if(isNotRecursive)\n    EXPORT = undefined;\n\n  return Object.freeze(values);\n}\n\nfunction update<T>(\n  subject: Model,\n  key: string | number | symbol,\n  value: T,\n  arg?: boolean | Model.Setter<T>){\n\n  const state = STATE.get(subject)!;\n\n  if(Object.isFrozen(state))\n    throw new Error(`Tried to update ${String(key)} but ${subject} is destroyed.`);\n\n  const previous = state[key] as T;\n\n  if(typeof arg == \"function\"){\n    const out = arg.call(subject, value, previous);\n\n    if(out === false)\n      return false;\n\n    if(typeof out == \"function\")\n      value = out();\n  }\n\n  if(value === previous && value !== undefined)\n    return;\n\n  state[key] = value;\n\n  if(arg !== true)\n    event(subject, key);\n\n  return true;\n}\n\n/** Random alphanumberic of length 6; always starts with a letter. */\nfunction uid(){\n  return (0.278 + Math.random() * 0.722).toString(36).substring(2, 8).toUpperCase();\n}\n\nexport {\n  event,\n  fetch,\n  METHOD,\n  Model,\n  PARENT,\n  STATE,\n  uid,\n  update,\n  watch\n}","import { addListener } from './control';\nimport { event, Model, PARENT, uid } from './model';\n\nconst LOOKUP = new WeakMap<Model, Context | ((got: Context) => void)[]>();\nconst KEYS = new Map<symbol | Model.Type, symbol>();\n\nfunction key(T: Model.Type | symbol, upstream?: boolean): symbol {\n  let K = KEYS.get(T);\n\n  if(!K)\n    KEYS.set(T, K = Symbol(\n      typeof T == \"symbol\" ? \"get \" + T.description : String(T)\n    ));\n  \n  return upstream ? key(K) : K;\n}\n\nfunction keys(from: Model.Type, upstream?: boolean){\n  const keys = new Set<symbol>();\n\n  do {\n    keys.add(key(from, upstream));\n  }\n  while((from = Object.getPrototypeOf(from)) !== Model);\n\n  return keys;\n}\n\ndeclare namespace Context {\n  type Multiple<T extends Model> = {\n    [key: string | number]: Model.Init<T> | T;\n  };\n\n  type Accept<T extends Model = Model> = T | Model.Init<T> | Multiple<T>;\n\n  type Expect<T extends Model = Model> = (model: T) => (() => void) | void;\n}\n\ninterface Context {\n  [key: symbol]: Model | Context.Expect | null | undefined;\n}\n\nclass Context {\n  static get<T extends Model>(on: Model, callback: ((got: Context) => void)): void;\n  static get<T extends Model>(on: Model): Context | undefined;\n  static get({ is }: Model, callback?: (got: Context) => void){\n    const waiting = LOOKUP.get(is);\n\n    if(waiting instanceof Context){\n      if(callback)\n        callback(waiting);\n\n      return waiting;\n    }\n\n    if(callback)\n      if(waiting) \n        waiting.push(callback);\n      else \n        LOOKUP.set(is, [callback]);\n  }\n\n  public id!: string;\n\n  protected layer = new Map<string | number, Model | Model.Type>();\n  protected cleanup = new Set<() => void>();\n\n  constructor(inputs?: Context.Accept){\n    if(inputs)\n      this.include(inputs);\n  }\n\n  /** Run callback when a specified type is registered to a **child** context. */\n  public has<T extends Model>(Type: Model.Type<T>, callback: (model: T) => void){\n    Object.defineProperty(this, key(Type, true), { value: callback, configurable: true });\n  }\n\n  /** Find specified type registered to a parent context. Returns undefined if none are found. */\n  public get<T extends Model>(Type: Model.Type<T>, require: true): T;\n  public get<T extends Model>(Type: Model.Type<T>, require?: boolean): T | undefined;\n  public get<T extends Model>(Type: Model.Type<T>, require?: boolean){\n    const result = this[key(Type)];\n\n    if(result === null)\n      throw new Error(`Did find ${Type} in context, but multiple were defined.`);\n\n    if(result)\n      return result as T;\n\n    if(require)\n      throw new Error(`Could not find ${Type} in context.`);\n  }\n\n  public push(inputs?: Context.Accept){\n    const next = Object.create(this) as this;\n\n    this.cleanup = new Set([() => next.pop(), ...this.cleanup]);\n\n    next.layer = new Map();\n    next.cleanup = new Set();\n\n    if(inputs)\n      next.include(inputs);\n\n    return next;\n  }\n\n  public pop(){\n    for(const key of Object.getOwnPropertySymbols(this))\n      delete (this as any)[key];\n\n    this.cleanup.forEach(cb => cb());\n    this.cleanup.clear();\n    this.layer.clear();\n  }\n\n  public include<T extends Model>(\n    inputs: Context.Accept<T>,\n    forEach?: Context.Expect<T>\n  ){\n    const init = new Map<Model, boolean>();\n\n    if(typeof inputs == \"function\" || inputs instanceof Model)\n      inputs = { [forEach ? 0 : this.layer.size]: inputs };\n\n    Object.entries(inputs).forEach(([K, V]: [string, Model | Model.Init<Model>]) => {\n      if(Model.is(V) || V instanceof Model){\n        const exists = this.layer.get(K);\n  \n        if(!exists){\n          const instance = this.add(V);\n  \n          this.layer.set(K, V);\n          init.set(instance, true);\n        }\n        // Context must force-reset because inputs are no longer safe.\n        else if(exists !== V){    \n          this.pop();\n          this.id = uid();\n          this.include(inputs);\n        }\n\n        return;\n      }\n\n      throw new Error(\n        `Context may only include instance or class \\`extends Model\\` but got ${\n          K == '0' || K == V ? V : `${V} (as '${K}')`\n        }.`\n      );\n    })\n\n    for(const [model, explicit] of init){\n      model.set();\n\n      if(explicit && forEach)\n        forEach(model as T);\n\n      for(const [_key, value] of model)\n        if(PARENT.get(value as Model) === model){\n          this.add(value as Model, true);\n          init.set(value as Model, false);\n        }\n    }\n  }\n\n  protected add<T extends Model>(\n    input: T | Model.Init<T>,\n    implicit?: boolean){\n\n    const cleanup = new Set<() => void>();\n    let T: Model.Type<T>;\n    let I: T;\n\n    if(typeof input == \"function\"){\n      T = input;\n      I = new input() as T;\n    }\n    else {\n      T = input.constructor as Model.Type<T>;\n      I = input;\n    }\n\n    keys(T, true).forEach(K => {\n      const expects = this[K] as Context.Expect | undefined;\n  \n      if(!expects)\n        return;\n  \n      addListener(I, event => {\n        if(event === true){\n          const callback = expects(I);\n            \n          if(callback)\n            cleanup.add(callback);\n        }\n\n        return null;\n      })  \n    });\n\n    keys(T).forEach(K => {\n      const value = this.hasOwnProperty(K) ? null : I;\n\n      if(value || this[K] !== I && !implicit)\n        Object.defineProperty(this, K, {\n          configurable: true,\n          value\n        });\n    });\n\n    this.cleanup.add(() => {\n      cleanup.forEach(cb => cb());\n\n      if(I !== input)\n        event(I, null);\n    })\n\n    const waiting = LOOKUP.get(I);\n  \n    if(waiting instanceof Array)\n      waiting.forEach(cb => cb(this));\n\n    LOOKUP.set(I, this);\n\n    return I;\n  }\n}\n\nexport { Context }","import { fetch, Model, PARENT, STATE, uid, update, watch } from '../model';\n\nconst INSTRUCTION = new Map<symbol, Model.Instruction>();\n\nfunction use <T> (instruction: Model.Instruction<T>): T extends void ? unknown : T;\n\nfunction use <T extends Model> (Type: Model.Init<T>, required: false): T | undefined;\n\nfunction use <T extends Model> (Type: Model.Init<T>, ready?: (i: T) => void): T;\n\nfunction use(\n  arg1: Model.Init | Model.Instruction,\n  arg2?: ((i: Model) => void) | boolean){\n\n  if(Model.is(arg1))\n    arg1 = childInstruction(arg1, arg2);\n\n  const token = Symbol(\"instruction-\" + uid());\n  INSTRUCTION.set(token, arg1);\n  return token;\n}\n\nfunction childInstruction(\n  type: Model.Init<Model>,\n  arg2?: ((i: Model) => void) | boolean\n): Model.Instruction<any, any> {\n  return (key, subject) => {\n    function set(next: Model | undefined){\n      if(next ? !(next instanceof type) : arg2 !== false)\n        throw new Error(`${subject}.${key} expected Model of type ${type} but got ${next && next.constructor}.`);\n\n      update(subject, key, next);\n\n      if(next && typeof arg2 == \"function\")\n        arg2(next);\n\n      return false;\n    }\n\n    const value = new type();\n\n    set(value);\n    PARENT.set(value, subject);\n    value.set();\n\n    return { set };\n  }\n}\n\nfunction init(this: Model){\n  const state = STATE.get(this)!;\n\n  for(const key in this){\n    const { value } = Object.getOwnPropertyDescriptor(this, key)!;\n    const instruction = INSTRUCTION.get(value);\n\n    if(!instruction)\n      continue;\n\n    INSTRUCTION.delete(value);\n    delete (this as any)[key];\n\n    const output = instruction.call(this, key, this, state);\n\n    if(!output)\n      continue;\n\n    const desc = typeof output == \"object\" ? output : { get: output };\n\n    if(\"value\" in desc)\n      state[key] = desc.value;\n\n    const model = this;\n\n    Object.defineProperty(model, key, {\n      enumerable: desc.enumerable !== false,\n      get(this: Model){\n        return watch(this, key, \n          typeof desc.get == \"function\"\n            ? desc.get(this)\n            : fetch(model, key, desc.get)\n        );\n      },\n      set(next){\n        if(desc.set === false)\n          throw new Error(`${model}.${key} is read-only.`);\n\n        update(model, key, next, desc.set);\n      }\n    })\n  }\n\n  return null;\n}\n\nModel.on(init);\n\nexport { use }","import { Context } from '../context';\nimport { createEffect } from '../control';\nimport { fetch, METHOD, Model, PARENT, event, update } from '../model';\nimport { use } from './use';\n\ntype Type<T extends Model> = Model.Type<T> & typeof Model;\n\nconst STALE = new WeakSet<() => void>();\n\ndeclare namespace get {\n  type Compute<T, S = any> = (on: S, key: string) => T;\n\n  type Factory<T, S = any> = (this: S, key: string, thisArg: S) => T;\n\n  type Source<T extends Model = Model> = (resolve: (x: T) => void) => void;\n\n  type Effect<T> = (model: T, key: string) => (() => void) | void;\n}\n\n/**\n * Fetches and assigns the controller which spawned this host.\n * When parent assigns an instance via `use()` directive, it\n * will be made available to child upon this request.\n *\n * @param Type - Type of controller compatible with this class. \n * @param expectParent - If true, will throw if Model is created without a parent.\n */\nfunction get <T extends Model> (Type: Model.Type<T>, expectParent?: true): T;\n\n/**\n * Fetches and assigns the controller which spawned this host.\n * When parent assigns an instance via `use()` directive, it\n * will be made available to child upon this request.\n *\n * @param Type - Type of controller compatible with this class. \n * @param required - If false, property may be undefined. Otherwise will throw suspense.\n */\nfunction get <T extends Model> (Type: Model.Type<T>, required?: false): T | undefined;\n\n/**\n * Implement a computed value from a foreign model. Output will be generated by provided function,\n * where the foreign model will be passed to that function.\n * \n * @param source - Type of Model to fetch for computation.\n * @param compute - Compute function. Will update automatically as input values change.\n */\nfunction get <T extends Model> (Type: Model.Type<T>, effect: get.Effect<T>): T;\n\n/**\n * Implement a computed value; output will be generated by provided function.\n *\n * @param source - Source model from which computed value will be a subscriber.\n * @param compute - Compute function. Bound to a subscriber-proxy of source, returns output value. Will update automatically as input values change.\n */\nfunction get <R, T extends Model> (source: T, compute: get.Compute<R, T>): R;\n\n/**\n * Implement a computed value; output is returned by function from provided factory.\n * \n * Factory is bound to owner of property.\n *\n * @param compute - Factory function to generate a getter to subscribe dependancies.\n */\nfunction get <R, T> (compute: get.Factory<R, T>): R;\n \nfunction get<R, T extends Model>(\n  arg0: T | get.Factory<R, T> | Type<T>,\n  arg1?: Function | boolean){\n\n  return use((key, subject, state) => {\n    if(typeof arg0 == \"symbol\")\n      throw new Error(`Attempted to use an instruction result (probably use or get) as computed source for ${subject}.${key}. This is not allowed.`)\n\n    if(Model.is(arg0)){\n      const hasParent = PARENT.get(subject) as T;\n\n      // TODO: notify on discovered context \n      function assign(value: T) {\n        if (typeof arg1 == \"function\")\n          value.get(x => (arg1 as Function)(x, key));\n\n        update(subject, key, value);\n      }\n\n      if(!hasParent && arg1 === true)\n        throw new Error(`${subject} may only exist as a child of type ${arg0}.`);\n      else if(hasParent)\n        if(hasParent instanceof arg0){\n          assign(hasParent);\n          return {}\n        }\n        else if(arg1 === true)\n          throw new Error(`New ${subject} created as child of ${hasParent}, but must be instanceof ${arg0}.`);\n \n      Context.get(subject, (context) => {\n        const model = context.get(arg0);\n\n        if(model)\n          assign(model);\n        else if(arg1 !== false)\n          throw new Error(`Required ${arg0} not found in context for ${subject}.`)\n      });\n\n      return {\n        get: arg1 !== false,\n        enumerable: false\n      };\n    }\n    \n    let from = subject;\n    \n    if(arg0 instanceof Model){\n      from = arg0;\n    }\n    else {\n      const fn = METHOD.get(arg0) || arg0;\n      arg1 = ((p, k) => fn.call(p, k, p)) as get.Effect<T>;\n    }\n\n    const source: get.Source<T> = resolve => resolve(from);\n    const getter = arg1 as get.Compute<R, T>;\n\n    let reset: (() => void) | undefined;\n    let isAsync: boolean;\n    let proxy: any;\n\n    function connect(model: Model){\n      reset = createEffect(model, current => {\n        proxy = current;\n\n        if(!(key in state) || STALE.delete(compute))\n          compute(!reset);\n\n        return (didUpdate) => {\n          if(didUpdate){\n            STALE.add(compute);\n            event(subject, key, true);\n          }\n        };\n      }, false)\n    }\n\n    function compute(initial?: boolean){\n      let next: R | undefined;\n\n      try {\n        next = getter.call(proxy, proxy, key);\n      }\n      catch(err){\n        console.warn(`An exception was thrown while ${initial ? \"initializing\" : \"refreshing\"} ${subject}.${key}.`)\n\n        if(initial)\n          throw err;\n\n        console.error(err);\n      }\n\n      update(subject, key, next, !isAsync);\n    }\n\n    return () => {\n      if(!proxy){\n        source(connect);\n        isAsync = true;\n      }\n\n      if(STALE.delete(compute))\n        compute();\n\n      return fetch(subject, key, !proxy) as T;\n    }\n  })\n}\n\nexport { get };","import { addListener, enter } from '../control';\nimport { Model, update } from '../model';\nimport { use } from './use';\n\nconst { defineProperty, defineProperties } = Object;\n\ndeclare namespace ref {\n  type Callback<T> = (argument: T) =>\n    ((next: T | null) => void) | Promise<void> | void | boolean;\n\n  interface Object<T = any> {\n    (next: T | null): void;\n\n    /** Current value held by this reference. */\n    current: T | null;\n\n    /** \n     * Subscribe to changes of this reference.\n     * \n     * @param callback - Callback to invoke with the current value when it changes.\n     * @returns Unsubscribe function to stop listening to changes.\n     */\n    get(callback: (value: T) => void): () => void;\n\n    /** Retrieve current value. */\n    get(): T | null;\n  }\n\n  /** Object with references to all managed values of `T`. */\n\n  /** Object with references to all managed values of `T`. */\n  type Proxy<T extends Model> =\n    & { [P in Model.Field<T>]-?: Object<T[P]> }\n    & { get(): T };\n\n  type CustomProxy<T extends Model, R> =\n    & { [P in Model.Field<T>]-?: R }\n    & { get(): T };\n}\n\n/**\n * Creates an object with references to all managed values.\n * Each property is a function to set value in state when invoked.\n *\n * *Properties are simultaneously a ref-function and ref-object, use as needed.*\n *\n * @param target - Source model from which to reference values.\n */\nfunction ref <T extends Model> (target: T): ref.Proxy<T>;\n\n/**\n * Creates an object with values based on managed values.\n * Each property will invoke mapper function on first access supply\n * the its return value going forward.\n *\n * @param target - Source model from which to reference values.\n * @param mapper - Function producing the placeholder value for any given property.\n */\nfunction ref <O extends Model, R>\n  (target: O, mapper: (key: Model.Field<O>) => R): ref.CustomProxy<O, R>;\n\n/**\n * Creates a ref-compatible property.\n * Will persist value, and updates to this are made part of controller event-stream.\n *\n * *Output is simultaneously a ref-function and ref-object, use as needed.*\n *\n * @param callback - Optional callback to synchronously fire when reference is first set or does update.\n */\nfunction ref <T> (callback?: ref.Callback<T>): ref.Object<T>;\n\n/**\n * Creates a ref-compatible property.\n * Will persist value, and updates to this are made part of controller event-stream.\n *\n * *Output is simultaneously a ref-function and ref-object, use as needed.*\n *\n * @param callback - Optional callback to synchronously fire when reference is first set or does update.\n * @param ignoreNull - Default `true`. If `false`, will still callback with `null`.\n */\nfunction ref <T> (callback: ref.Callback<T | null>, ignoreNull: boolean): ref.Object<T>;\n\nfunction ref<T>(\n  arg?: ref.Callback<T> | Model,\n  arg2?: ((key: string) => any) | boolean){\n\n  return use<T>((key, subject, state) => {\n    let value = {};\n    const method = (key: string) =>\n      (callback?: (value: T) => void) => callback\n        ? addListener(subject, () => callback(state[key]), key)\n        : state[key];\n\n    if(arg === subject)\n      subject.get(() => {\n        for(const key in state)\n          if(typeof arg2 == \"function\")\n            defineProperty(value, key, {\n              configurable: true,\n              get(){\n                const out = arg2(key);\n                defineProperty(value, key, { value: out });\n                return out;\n              }\n            })\n          else {\n            const get = method(key);\n            const set = (value: unknown) => {\n              update(subject, key, value)\n            };\n\n            defineProperties(set, {\n              current: { get, set },\n              get: { value: get }\n            });\n\n            defineProperty(value, key, { value: set });\n          }\n      })\n\n    else if(typeof arg == \"object\")\n      throw new Error(\"ref instruction does not support object which is not 'this'\");\n\n    else {\n      let unset: ((next: T) => void) | undefined;\n\n      const get = method(key);\n      const set = (value?: any) => {\n        if(!update(subject, key, value) || !arg)\n          return;\n\n        if(unset)\n          unset = void unset(value);\n    \n        if(value === null && arg2 !== false)\n          return;\n\n        const exit = enter();\n        const out = arg.call(subject, value);\n        const flush = exit();\n\n        unset = key => {\n          if(typeof out == \"function\")\n            out(key);\n\n          flush();\n        }\n      };\n  \n      state[key] = null;\n      value = defineProperties(set, {\n        current: { get, set },\n        get: { value: get }\n      }) as ref.Object<T>;\n    }\n\n    defineProperty(subject, key, { value });\n  })\n}\n\nexport { ref }","import { addListener, enter } from '../control';\nimport { Model, event, update } from '../model';\nimport { use } from './use';\n\ndeclare namespace set {\n  type Callback<T, S = any> = (this: S, next: T, previous: T) =>\n    ((next: T) => void) | Promise<any> | void | boolean;\n\n  type Factory<T, S = any> = (this: S, key: string) => Promise<T> | T;\n}\n\n/**\n * Set property as `undefined` but required.\n * \n * Property cannot be accessed until it is defined. If accessed while undefined, a hybrid\n * `Promise`/`Error` (aka: [Suspense](https://reactjs.org/docs/concurrent-mode-suspense.html)) will be thrown.\n */\nfunction set <T = any>(): T;\n\n/**\n * Set property with a factory function.\n * \n * **Note** Factory is lazy! It will only run if/when property is accessed.\n * Value will be undefined until factory resolves, which will also dispatch an update for the property.\n */\nfunction set <T> (factory: set.Factory<T> | Promise<T>, required: false): T | undefined;\n\n/**\n * Set property with a factory function.\n *\n * If async, property cannot be accessed until resolves, yeilding a result.\n * If accessed while still processing, React Suspense will be thrown.\n *\n * @param factory - Callback run to derrive property value.\n * @param required - If true run factory immediately on creation, otherwise on access.\n */\nfunction set <T> (factory: set.Factory<T> | Promise<T>, required?: boolean): T;\n\n/**\n * Set property with a factory function.\n *\n * If async, property cannot be accessed until resolves, yeilding a result.\n * If accessed while still processing, React Suspense will be thrown.\n *\n * @param factory - Callback run to derrive property value.\n * @param onUpdate - Callback run when property is finished computing or is set. \n */\nfunction set <T> (factory: set.Factory<T> | Promise<T>, onUpdate?: set.Callback<T>): T;\n\n/**\n * Set a property with empty placeholder and/or update callback.\n * \n * @param value - Starting value for property. If undefined, suspense will be thrown on access, until value is set and accepted by callback.\n * @param onUpdate - Callback run when property is set. If returns false, update is not accepted and property will keep previous value.\n */\nfunction set <T> (value: T | undefined, onUpdate?: set.Callback<T>): T;\n\nfunction set <T> (\n  value?: set.Factory<T> | Promise<T> | T,\n  argument?: set.Callback<any> | boolean){\n\n  return use<T>((key, subject) => {\n    const property: Model.Descriptor = { enumerable: false };\n\n    if(typeof value == \"function\" || value instanceof Promise){\n      function init(){\n        if(typeof value == \"function\")\n          try {\n            value = attempt(value.bind(subject, key));\n          }\n          catch(err){\n            console.warn(`Generating initial value for ${subject}.${key} failed.`);\n            throw err;\n          }\n\n        property.get = argument !== false;\n\n        const set = (value: any) => subject[key] = value;\n\n        if(value instanceof Promise)\n          value.then(set, error => {\n            event(subject, key);\n            property.get = () => { throw error };\n          })\n        else\n          set(value);\n\n        if(argument)\n          return null;\n        \n        return subject[key];\n      }\n\n      if(argument)\n        addListener(subject, init, true);\n      else\n        property.get = init;\n    }\n    else if(value !== undefined)\n      property.value = value;\n\n    if(typeof argument == \"function\"){\n      let unset: ((next: T) => void) | undefined;\n\n      property.set = function(this: any, value: any, previous: any){\n        const exit = enter();\n        const returns = argument.call(this, value, previous);\n        const flush = exit();\n\n        if(returns === false)\n          return false;\n\n        if(typeof unset == \"function\")\n          unset(value);\n\n        unset = (next: T) => {\n          if(typeof returns == \"function\")\n            returns(next);\n\n          flush();\n        }\n      }\n    }\n    else\n      property.set = value => {\n        property.get = undefined;\n        update(subject, key, value);\n      }\n\n    return property;\n  })\n}\n\nfunction attempt(fn: () => any): any {\n  function retry(err: unknown){\n    if(err instanceof Promise)\n      return err.then(compute);\n    else\n      throw err;\n  }\n\n  function compute(): any {\n    try {\n      const output = fn();\n\n      return output instanceof Promise\n        ? output.catch(retry)\n        : output;\n    }\n    catch(err){\n      return retry(err);\n    }\n  }\n\n  return compute();\n}\n\nexport { set }","import { enter } from '../control';\nimport { Context } from '../context';\nimport { Model, update } from '../model';\nimport { use } from './use';\n\nconst APPLY = new WeakMap<Model, (model: Model) => (() => void) | boolean | void>();\n\ndeclare namespace has {\n  type Callback<T = any> = (model: T, recipient: Model) => void | boolean | (() => void);\n}\n\nfunction has <T extends Model> (type: Model.Type<T>, callback?: has.Callback<T>): readonly T[];\nfunction has (callback?: has.Callback): readonly Model[];\n  \nfunction has <T extends Model> (\n  arg1?: Model.Type<T> | has.Callback<Model>,\n  arg2?: has.Callback<T>){\n\n  return use<T[]>((key, subject) => {\n    const applied = new Set<Model>();\n    const reset = () => {\n      update(subject, key, Object.freeze(Array.from(applied)));\n    }\n\n    if(Model.is(arg1))\n      Context.get(subject, ctx => {\n        ctx.has(arg1, model => {\n          let remove: (() => void) | undefined;\n          let disconnect: (() => void) | undefined;\n          let flush: (() => void) | undefined;\n  \n          if(applied.has(model))\n            return;\n          \n          const exit = enter();\n\n          try {\n            const notify = APPLY.get(model);\n\n            if(notify){\n              const after = notify(subject);\n    \n              if(after === false)\n                return;\n    \n              if(typeof after == \"function\")\n                disconnect = after;\n            }\n    \n            if(typeof arg2 == \"function\"){\n              const done = arg2(model, subject);\n    \n              if(done === false)\n                return false;\n\n              if(typeof done == \"function\")\n                remove = done;\n            }\n          }\n          finally {\n            flush = exit();\n          }\n  \n          applied.add(model);\n          reset();\n  \n          const done = () => { \n            flush();\n            ignore();\n  \n            applied.delete(model);\n            reset();\n  \n            if(disconnect)\n              disconnect();\n  \n            if(typeof remove == \"function\")\n              remove();\n\n            remove = undefined;\n          }\n  \n          const ignore = model.set(done, null);\n          \n          return done;\n        })\n      });\n    else {\n      if(APPLY.has(subject))\n        throw new Error(`'has' callback can only be used once per model.`);\n\n      APPLY.set(subject, recipient => {\n        let remove: (() => void) | boolean | void;\n\n        if(arg1){\n          remove = arg1(recipient, subject);\n  \n          if(remove === false)\n            return false;\n        }\n\n        applied.add(recipient);\n        reset();\n\n        return () => {\n          applied.delete(recipient);\n          reset();\n\n          if(typeof remove == \"function\")\n            remove();\n        }\n      });\n    }\n\n    return { value: [] };\n  })\n}\n\nexport { has }"],"mappings":"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","names":["key","event","watch","key","update","res","set","keys","bind","use","get","value","silent","keys","require","key","init","event","key","set","init","key","assign","key","get","set","value","key","init","set","value","key","done"]}

package/package.json

@@ -31,6 +31,6 @@
     "jest": "^27.5.1",
     "tsup": "^8.0.2"
   },
-  "version": "0.64.0",
-  "gitHead": "fd9b5054d8ee9c7f0f0b9153645442909dc0be1b"
+  "version": "0.64.2",
+  "gitHead": "08fa262e2063decdd104f969e8909b718b09420c"
 }