worker: shared async context

[myfreeer]

The async context should be shared pre PipelineExecutor, and can be obtained from instances of PipelineExecutor.
The async context should be shared between main thread and worker threads, and should not affect existing message channels.
Keys and values should be stored in the main thread, and copied to workers when requested.

import type {AsyncResult} from './life-cycle/types';

export interface SharedAsyncLock<T> {
  currentValue?: T;
  unlock(content?: LoadingValue<T>): Promise<void>;
}

export type ContextKey = string | number;
export type ContextKeyMatcher = (key: ContextKey) => boolean;
export type Loader<T> = () => AsyncResult<T>;
export type LoadingValue<T> = AsyncResult<T> | Loader<T>;

export interface SharedAsyncContext {
  put<T>(key: ContextKey, value: AsyncResult<T>): Promise<T | void>;
  putIfAbsent<T>(key: ContextKey, value: LoadingValue<T>): Promise<boolean>;
  putIfPreset<T>(key: ContextKey, value: LoadingValue<T>): Promise<boolean>;
  contains<T>(key: ContextKey, value?: AsyncResult<T>): boolean;
  clear(): Promise<boolean>;
  get<T>(key: ContextKey): Promise<T | void>;
  getOrLock<T>(key: ContextKey): Promise<T | SharedAsyncLock<T>>;
  lock<T>(key: ContextKey): Promise<SharedAsyncLock<T>>;
  getOrLoad<T>(key: ContextKey, defaultValue: LoadingValue<T>): Promise<T>;
  getOrLoadOnMainThread<T>(key: ContextKey, loaderKey: ContextKey): Promise<T>;
  remove<T>(key: ContextKey): Promise<T | void>;
  remove<T>(key: ContextKey, expectedValue: AsyncResult<T>): Promise<T | void>;
  isLockObject<T>(obj: T | SharedAsyncLock<T>): obj is SharedAsyncLock<T>;
  isOnMainThread(): this is MainThreadSharedAsyncContext;
  call<T>(name: string, ...args: unknown[]): Promise<T>;
}

export interface MainThreadSharedAsyncContext extends SharedAsyncContext {
  registerLoader<T>(key: ContextKey | ContextKeyMatcher, loader: Loader<T>): boolean;
  deregisterLoader<T>(key: ContextKey | ContextKeyMatcher): Loader<T> | void;
  deregisterLoader<T>(loader: Loader<T>): Loader<T> | void;

  registerFunction<T>(name: string, fn: (...args: unknown[]) => T | Promise<T>): boolean;
  deregisterFunction<T>(name: string, fn?: (...args: unknown[]) => T | Promise<T>): boolean;
}