@travetto/registry 6.0.1 → 7.0.0-rc.1

package/README.md

@@ -20,20 +20,21 @@ Registration, within the framework flows throw two main use cases:
 
 ### Initial Flows
 The primary flow occurs on initialization of the application. At that point, the module will:
-   1. Initialize [RootRegistry](https://github.com/travetto/travetto/tree/main/module/registry/src/service/root.ts#L10) and will automatically register/load all relevant files
+   1. Initialize [Registry](https://github.com/travetto/travetto/tree/main/module/registry/src/service/registry.ts#L9) and will automatically register/load all relevant files
    1. As files are imported, decorators within the files will record various metadata relevant to the respective registries
-   1. When all files are processed, the [RootRegistry](https://github.com/travetto/travetto/tree/main/module/registry/src/service/root.ts#L10) is finished, and it will signal to anything waiting on registered data that its free to use it.
+   1. When all files are processed, the [Registry](https://github.com/travetto/travetto/tree/main/module/registry/src/service/registry.ts#L9) is finished, and it will signal to anything waiting on registered data that its free to use it.
 
 This flow ensures all files are loaded and processed before application starts. A sample registry could like:
 
 **Code: Sample Registry**
 ```typescript
 import { Class } from '@travetto/runtime';
-import { MetadataRegistry } from '@travetto/registry';
+import { ChangeEvent, RegistryAdapter, RegistryIndex, RegistryIndexStore, Registry } from '@travetto/registry';
 
 interface Group {
   class: Class;
   name: string;
+  children: Child[];
 }
 
 interface Child {
@@ -41,41 +42,68 @@ interface Child {
   method: Function;
 }
 
-function isComplete(o: Partial<Group>): o is Group {
-  return !!o;
-}
+/**
+ * The adapter to handle mapping/modeling a specific class
+ */
+class SampleRegistryAdapter implements RegistryAdapter<Group> {
+
+  #class: Class;
+  #config: Group;
+
+  constructor(cls: Class) {
+    this.#class = cls;
+  }
 
-export class SampleRegistry extends MetadataRegistry<Group, Child> {
-  /**
-   * Finalize class after all metadata is collected
-   */
-  onInstallFinalize<T>(cls: Class<T>): Group {
-    const pending: Partial<Group> = this.getOrCreatePending(cls);
-    if (isComplete(pending)) {
-      return pending;
-    } else {
-      throw new Error('Invalid Group');
+  register(...data: Partial<Partial<Group>>[]): Group {
+    for (const d of data) {
+      Object.assign(this.#config, {
+        ...d,
+        children: [
+          ...(this.#config?.children ?? []),
+          ...(d.children ?? [])
+        ]
+      });
     }
+    return this.#config;
+  }
+
+  registerChild(method: Function, name: string): void {
+    this.register({ children: [{ method, name }] });
+  }
+
+  finalize?(parent?: Partial<Group> | undefined): void {
+    // Nothing to do
   }
 
-  /**
-   * Create scaffolding on first encounter of a class
-   */
-  createPending(cls: Class): Partial<Group> {
-    return {
-      class: cls,
-      name: cls.name
-    };
+  get(): Group {
+    return this.#config;
+  }
+}
+
+/**
+ * Basic Index that handles cross-class activity
+ */
+export class SampleRegistryIndex implements RegistryIndex {
+  static #instance = Registry.registerIndex(SampleRegistryIndex);
+
+  static getForRegister(cls: Class, allowFinalized = false): SampleRegistryAdapter {
+    return this.#instance.store.getForRegister(cls, allowFinalized);
+  }
+
+  store = new RegistryIndexStore(SampleRegistryAdapter);
+
+  process(events: ChangeEvent<Class>[]): void {
+    // Nothing to do
   }
 }
 ```
 
-The registry is a [MetadataRegistry](https://github.com/travetto/travetto/tree/main/module/registry/src/service/metadata.ts#L14) that similar to the [Schema](https://github.com/travetto/travetto/tree/main/module/schema#readme "Data type registry for runtime validation, reflection and binding.")'s Schema registry and [Dependency Injection](https://github.com/travetto/travetto/tree/main/module/di#readme "Dependency registration/management and injection support.")'s Dependency registry.
+The registry index is a [RegistryIndex](https://github.com/travetto/travetto/tree/main/module/registry/src/service/types.ts#L36) that similar to the [Schema](https://github.com/travetto/travetto/tree/main/module/schema#readme "Data type registry for runtime validation, reflection and binding.")'s Schema registry and [Dependency Injection](https://github.com/travetto/travetto/tree/main/module/di#readme "Dependency registration/management and injection support.")'s Dependency registry.
 
 ### Live Flow
 At runtime, the registry is designed to listen for changes and to propagate the changes as necessary. In many cases the same file is handled by multiple registries. 
 
-As the [DynamicFileLoader](https://github.com/travetto/travetto/tree/main/module/registry/src/internal/file-loader.ts#L17) notifies that a file has been changed, the [RootRegistry](https://github.com/travetto/travetto/tree/main/module/registry/src/service/root.ts#L10) will pick it up, and process it accordingly.
+As the [DynamicFileLoader](https://github.com/travetto/travetto/tree/main/module/registry/src/internal/file-loader.ts#L17) notifies that a file has been changed, the [Registry](https://github.com/travetto/travetto/tree/main/module/registry/src/service/registry.ts#L9) will pick it up, and process it accordingly.
 
 ## Supporting Metadata
 As mentioned in [Manifest](https://github.com/travetto/travetto/tree/main/module/manifest#readme "Support for project indexing, manifesting, along with file watching")'s readme, the framework produces hashes of methods, classes, and functions, to allow for detecting changes to individual parts of the codebase. During the live flow, various registries will inspect this information to determine if action should be taken.
@@ -116,7 +144,7 @@ As mentioned in [Manifest](https://github.com/travetto/travetto/tree/main/module
           const nextHash = describeFunction(next.get(k)!)?.hash;
           if (prevHash !== nextHash) {
             changes += 1;
-            this.emit({ type: 'changed', curr: next.get(k)!, prev: prev.get(k) });
+            this.emit({ type: 'changed', curr: next.get(k)!, prev: prev.get(k)! });
           }
         }
       }

package/__index__.ts

@@ -1,8 +1,7 @@
-export * from './src/registry.ts';
-export * from './src/service/metadata.ts';
-export * from './src/service/root.ts';
+export * from './src/service/registry.ts';
+export * from './src/service/types.ts';
+export * from './src/service/store.ts';
 export * from './src/proxy.ts';
-export * from './src/registry.ts';
 export * from './src/source/class-source.ts';
 export * from './src/source/method-source.ts';
 export * from './src/types.ts';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/registry",
-  "version": "6.0.1",
+  "version": "7.0.0-rc.1",
   "description": "Patterns and utilities for handling registration of metadata and functionality for run-time use",
   "keywords": [
     "ast-transformations",
@@ -27,11 +27,11 @@
     "directory": "module/registry"
   },
   "dependencies": {
-    "@travetto/runtime": "^6.0.1"
+    "@travetto/runtime": "^7.0.0-rc.1"
   },
   "peerDependencies": {
-    "@travetto/cli": "^6.0.1",
-    "@travetto/transformer": "^6.0.1"
+    "@travetto/cli": "^7.0.0-rc.1",
+    "@travetto/transformer": "^7.0.0-rc.1"
   },
   "peerDependenciesMeta": {
     "@travetto/transformer": {

package/src/service/registry.ts

@@ -0,0 +1,166 @@
+import { EventEmitter } from 'node:events';
+import { AppError, castTo, Class, Util } from '@travetto/runtime';
+
+import { ClassSource } from '../source/class-source';
+import { ChangeEvent } from '../types';
+import { MethodSource } from '../source/method-source';
+import { RegistryIndex, RegistryIndexClass, EXPIRED_CLASS } from './types';
+
+class $Registry {
+
+  #resolved = false;
+  #initialized?: Promise<unknown>;
+  trace = false;
+  #uid = Util.uuid();
+
+  // Lookups
+  #indexes = new Map<RegistryIndexClass, RegistryIndex>();
+  #indexOrder: RegistryIndexClass[] = [];
+
+  // Eventing
+  #classSource = new ClassSource();
+  #methodSource?: MethodSource;
+  #emitter = new EventEmitter<{ event: [ChangeEvent<Class>] }>();
+
+  #removeItems(classes: Class[]): void {
+    for (const cls of classes) {
+      for (const idx of this.#indexOrder) {
+        this.instance(idx).store.remove(cls);
+      }
+      // Tag expired classes
+      Object.assign(cls, { [EXPIRED_CLASS]: true });
+    }
+  }
+
+  #finalizeItems(classes: Class[]): void {
+    for (const idx of this.#indexOrder) {
+      const inst = this.instance(idx);
+      for (const cls of classes) {
+        if (inst.store.has(cls) && !inst.store.finalized(cls)) {
+          if (inst.finalize) {
+            inst.finalize(cls);
+          } else {
+            inst.store.finalize(cls);
+          }
+        }
+      }
+    }
+  }
+
+  finalizeForIndex(indexCls: RegistryIndexClass): void {
+    const inst = this.instance(indexCls);
+    this.#finalizeItems(inst.store.getClasses());
+  }
+
+  process(events: ChangeEvent<Class>[]): void {
+    this.#finalizeItems(events.filter(ev => 'curr' in ev).map(ev => ev.curr));
+
+    for (const indexCls of this.#indexOrder) { // Visit every index, in order
+      const inst = this.instance(indexCls);
+      const matched = events.filter(e => inst.store.has('curr' in e ? e.curr : e.prev!));
+      if (matched.length) {
+        inst.process(matched);
+      }
+    }
+
+    Util.queueMacroTask().then(() => {
+      this.#removeItems(events.filter(ev => 'prev' in ev).map(ev => ev.prev!));
+    });
+
+    for (const e of events) {
+      this.#emitter.emit('event', e);
+    }
+  }
+
+  /**
+   * Run initialization
+   */
+  async #init(): Promise<void> {
+    try {
+      this.#resolved = false;
+
+      if (this.trace) {
+        console.debug('Initializing', { uid: this.#uid });
+      }
+
+      const added = await this.#classSource.init();
+      this.process(added.map(cls => ({ type: 'added', curr: cls })));
+      this.#classSource.on(e => this.process([e]));
+    } finally {
+      this.#resolved = true;
+    }
+  }
+
+  /**
+   * Verify initialized state
+   */
+  verifyInitialized(): void {
+    if (!this.#resolved) {
+      throw new AppError('Registry not initialized, call init() first');
+    }
+  }
+
+  /**
+   * Register a new index
+   */
+  registerIndex<T extends RegistryIndexClass>(indexCls: T): InstanceType<T> {
+    if (!this.#indexes.has(indexCls)) {
+      this.#indexes.set(indexCls, new indexCls());
+      this.#indexOrder.push(indexCls);
+    }
+    return castTo(this.#indexes.get(indexCls));
+  }
+
+  /**
+   * Initialize, with a built-in latch to prevent concurrent initializations
+   */
+  async init(): Promise<unknown> {
+    if (this.trace && this.#initialized) {
+      console.trace('Trying to re-initialize', { uid: this.#uid, initialized: !!this.#initialized });
+    }
+    return this.#initialized ??= this.#init();
+  }
+
+  instance<T extends RegistryIndexClass>(indexCls: T): InstanceType<T> {
+    return castTo(this.#indexes.get(indexCls));
+  }
+
+  /**
+   * Listen for changes
+   */
+  onClassChange(handler: (event: ChangeEvent<Class>) => void, matches?: RegistryIndexClass): void {
+    if (!matches) {
+      this.#emitter.on('event', handler);
+    } else {
+      const inst = this.instance(matches);
+      this.#emitter.on('event', (event) => {
+        if (inst.store.has('curr' in event ? event.curr : event.prev!)) {
+          handler(event);
+        }
+      });
+    }
+  }
+
+  onNonClassChanges(handler: (file: string) => void): void {
+    this.#classSource.onNonClassChanges(handler);
+  }
+
+  onMethodChange(
+    handler: (event: ChangeEvent<[Class, Function]>) => void,
+    matches?: RegistryIndexClass,
+  ): void {
+    const src = this.#methodSource ??= new MethodSource(this.#classSource);
+    if (!matches) {
+      src.on(handler);
+    } else {
+      const inst = this.instance(matches);
+      src.on((event) => {
+        if (inst.store.has('curr' in event ? event.curr[0] : event.prev[0])) {
+          handler(event);
+        }
+      });
+    }
+  }
+}
+
+export const Registry = new $Registry();

package/src/service/store.ts

@@ -0,0 +1,103 @@
+import { Any, AppError, castTo, Class, getParentClass, Runtime } from '@travetto/runtime';
+
+import { EXPIRED_CLASS, RegistrationMethods, RegistryAdapter } from './types';
+
+function ExchangeExpired<R = unknown>() {
+  return function (
+    target: Any,
+    propertyKey: string | symbol,
+    descriptor: TypedPropertyDescriptor<(this: RegistryIndexStore, cls: Class) => R>
+  ): void {
+    if (Runtime.dynamic) {
+      const original = descriptor.value!;
+      descriptor.value = function (this: RegistryIndexStore, cls: Class): R {
+        const resolved = EXPIRED_CLASS in cls ? this.getClassById(cls.Ⲑid) : cls;
+        return original.apply(this, [resolved]);
+      };
+    }
+  };
+}
+
+/**
+ * Base registry index implementation
+ */
+export class RegistryIndexStore<A extends RegistryAdapter<{}> = RegistryAdapter<{}>> {
+
+  // Core data
+  #adapters = new Map<Class, A>();
+  #idToCls = new Map<string, Class>();
+  #adapterCls: new (cls: Class) => A;
+  #finalized = new Map<Class, boolean>();
+
+  constructor(adapterCls: new (cls: Class) => A) {
+    this.#adapterCls = adapterCls;
+    this.getClassById = this.getClassById.bind(this);
+  }
+
+  getClasses(): Class[] {
+    return Array.from(this.#adapters.keys());
+  }
+
+  getClassById(id: string): Class {
+    return this.#idToCls.get(id)!;
+  }
+
+  finalize(cls: Class, parentConfig?: ReturnType<A['get']>): void {
+    if (!parentConfig) {
+      const parentClass = getParentClass(cls);
+      parentConfig = castTo(parentClass && this.has(parentClass) ? this.get(parentClass).get() : undefined);
+    }
+    this.adapter(cls).finalize?.(parentConfig);
+    this.#finalized.set(cls, true);
+  }
+
+  remove(cls: Class): void {
+    this.#adapters.delete(cls);
+    this.#finalized.delete(cls);
+  }
+
+  @ExchangeExpired()
+  has(cls: Class): boolean {
+    return this.#adapters.has(cls);
+  }
+
+  @ExchangeExpired()
+  adapter(cls: Class): A {
+    if (!this.#adapters.has(cls)!) {
+      const adapter = new this.#adapterCls(cls);
+      this.#adapters.set(cls, adapter);
+      this.#idToCls.set(cls.Ⲑid, cls);
+    }
+
+    return castTo(this.#adapters.get(cls));
+  }
+
+  @ExchangeExpired()
+  getForRegister(cls: Class, allowFinalized = false): A {
+    if (this.#finalized.get(cls) && !allowFinalized) {
+      throw new AppError(`Class ${cls.Ⲑid} is already finalized`);
+    }
+    return this.adapter(cls);
+  }
+
+  @ExchangeExpired()
+  get(cls: Class): Omit<A, RegistrationMethods> {
+    if (!this.has(cls)) {
+      throw new AppError(`Class ${cls.Ⲑid} is not registered for ${this.#adapterCls.Ⲑid}`);
+    }
+    return this.adapter(cls);
+  }
+
+  @ExchangeExpired()
+  getOptional(cls: Class): Omit<A, RegistrationMethods> | undefined {
+    if (!this.has(cls)) {
+      return undefined;
+    }
+    return this.adapter(cls);
+  }
+
+  @ExchangeExpired()
+  finalized(cls: Class): boolean {
+    return this.#finalized.has(cls);
+  }
+}

package/src/service/types.ts

@@ -0,0 +1,40 @@
+import { Class } from '@travetto/runtime';
+import { ChangeEvent } from '../types';
+
+export type RegistrationMethods = `register${string}` | `finalize${string}`;
+
+export const EXPIRED_CLASS = Symbol();
+
+/**
+ * Interface for registry adapters to implement
+ */
+export interface RegistryAdapter<C extends {} = {}> {
+  register(...data: Partial<C>[]): C;
+  finalize?(parent?: C): void;
+  get(): C;
+}
+
+export type RegistryIndexClass = {
+  new(): RegistryIndex;
+};
+
+/**
+ * Simple store interface for registry indexes
+ */
+export interface RegistrySimpleStore {
+  has(cls: Class): boolean;
+  finalize(cls: Class): void;
+  finalized(cls: Class): boolean;
+  remove(cls: Class): void;
+  getClasses(): Class[];
+};
+
+/**
+ * Registry index definition
+ * @concrete
+ */
+export interface RegistryIndex {
+  store: RegistrySimpleStore;
+  process(events: ChangeEvent<Class>[]): void;
+  finalize?(cls: Class): void;
+}

package/src/source/class-source.ts

@@ -17,7 +17,11 @@ function isClass(cls: Function): cls is Class {
 export class ClassSource implements ChangeSource<Class> {
 
   #classes = new Map<string, Map<string, Class>>();
-  #emitter = new EventEmitter();
+  #emitter = new EventEmitter<{
+    change: [ChangeEvent<Class>];
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    'unchanged-import': [string];
+  }>();
   #listening: Promise<void> | undefined;
 
   /**
@@ -28,8 +32,9 @@ export class ClassSource implements ChangeSource<Class> {
   /**
    * Flush classes
    */
-  #flush(): void {
-    for (const cls of flushPendingFunctions().filter(isClass)) {
+  #flush(): Class[] {
+    const flushed = flushPendingFunctions().filter(isClass);
+    for (const cls of flushed) {
       const src = Runtime.getSourceFile(cls);
       if (!this.#classes.has(src)) {
         this.#classes.set(src, new Map());
@@ -37,6 +42,7 @@ export class ClassSource implements ChangeSource<Class> {
       this.#classes.get(src)!.set(cls.Ⲑid, cls);
       this.emit({ type: 'added', curr: cls });
     }
+    return flushed;
   }
 
   #removeFile(file: string): void {
@@ -85,7 +91,7 @@ export class ClassSource implements ChangeSource<Class> {
           const nextHash = describeFunction(next.get(k)!)?.hash;
           if (prevHash !== nextHash) {
             changes += 1;
-            this.emit({ type: 'changed', curr: next.get(k)!, prev: prev.get(k) });
+            this.emit({ type: 'changed', curr: next.get(k)!, prev: prev.get(k)! });
           }
         }
       }
@@ -118,7 +124,11 @@ export class ClassSource implements ChangeSource<Class> {
    */
   emit(e: ChangeEvent<Class>): void {
     if (this.trace) {
-      console.debug('Emitting change', { type: e.type, curr: e.curr?.Ⲑid, prev: e.prev?.Ⲑid });
+      console.debug('Emitting change', {
+        type: e.type,
+        curr: (e.type !== 'removing' ? e.curr?.Ⲑid : undefined),
+        prev: (e.type !== 'added' ? e.prev?.Ⲑid : undefined)
+      });
     }
     this.#emitter.emit('change', e);
   }
@@ -126,7 +136,7 @@ export class ClassSource implements ChangeSource<Class> {
   /**
    * Initialize
    */
-  async init(): Promise<void> {
+  async init(): Promise<Class[]> {
     if (Runtime.dynamic && !this.#listening) {
       this.#listening = (async (): Promise<void> => {
         for await (const ev of await DynamicFileLoader.listen()) {
@@ -147,10 +157,12 @@ export class ClassSource implements ChangeSource<Class> {
     for (const entry of RuntimeIndex.find({
       module: (m) => {
         const role = Env.TRV_ROLE.val;
-        return m.roles.includes('std') && (
-          !Runtime.production || m.prod ||
-          ((role === 'doc' || role === 'test') && m.roles.includes(role))
-        );
+        return role !== 'test' && // Skip all modules when in test
+          m.roles.includes('std') &&
+          (
+            !Runtime.production || m.prod ||
+            (role === 'doc' && m.roles.includes(role))
+          );
       },
       folder: f => f === 'src' || f === '$index'
     })) {
@@ -158,7 +170,7 @@ export class ClassSource implements ChangeSource<Class> {
     }
 
     // Flush all load events
-    this.#flush();
+    return this.#flush();
   }
 
   /**
@@ -168,6 +180,13 @@ export class ClassSource implements ChangeSource<Class> {
     this.#emitter.on('change', callback);
   }
 
+  /**
+   * Add callback for change events
+   */
+  off(callback: ChangeHandler<Class>): void {
+    this.#emitter.off('change', callback);
+  }
+
   /**
    * Add callback for when a import is changed, but emits no class changes
    */

package/src/source/method-source.ts

@@ -29,16 +29,16 @@ export class MethodSource implements ChangeSource<[Class, Function]> {
    * On a class being emitted, check methods
    */
   onClassEvent(e: ChangeEvent<Class>): void {
-    const next = describeFunction(e.curr!)?.methods ?? {};
-    const prev = describeFunction(e.prev!)?.methods ?? {};
+    const next = (e.type !== 'removing' ? describeFunction(e.curr!)?.methods : null) ?? {};
+    const prev = (e.type !== 'added' ? describeFunction(e.prev!)?.methods : null) ?? {};
 
     /**
      * Go through each method, comparing hashes.  To see added/removed and changed
      */
     for (const k of Object.keys(next)) {
-      if (!prev[k] || !e.prev) {
+      if ((!prev[k] || !('prev' in e)) && e.type !== 'removing') {
         this.emit({ type: 'added', curr: [e.curr!, e.curr!.prototype[k]] });
-      } else if (next[k].hash !== prev[k].hash && e.curr) {
+      } else if (next[k].hash !== prev[k].hash && e.type === 'changed') {
         // FIXME: Why is e.prev undefined sometimes?
         this.emit({ type: 'changed', curr: [e.curr, e.curr.prototype[k]], prev: [e.prev, e.prev.prototype[k]] });
       } else {
@@ -47,7 +47,7 @@ export class MethodSource implements ChangeSource<[Class, Function]> {
     }
 
     for (const k of Object.keys(prev)) {
-      if (!next[k] && e.prev) {
+      if (!next[k] && e.type !== 'added') {
         this.emit({ type: 'removing', prev: [e.prev, e.prev.prototype[k]] });
       }
     }

package/src/types.ts

@@ -1,11 +1,10 @@
 /**
  * A change event
  */
-export interface ChangeEvent<T> {
-  type: 'changed' | 'added' | 'removing';
-  prev?: T;
-  curr?: T;
-}
+export type ChangeEvent<T> =
+  { type: 'changed', prev: T, curr: T } |
+  { type: 'added', curr: T } |
+  { type: 'removing', prev: T };
 
 /**
  * Change handler

package/src/registry.ts

@@ -1,209 +0,0 @@
-import { EventEmitter } from 'node:events';
-import { Class, Env } from '@travetto/runtime';
-import { ChangeSource, ChangeEvent, ChangeHandler } from './types.ts';
-
-/**
- * Base registry class, designed to listen to changes over time
- */
-export abstract class Registry implements ChangeSource<Class> {
-
-  /**
-   * Has the registry been resolved
-   */
-  #resolved: boolean;
-  /**
-   * Initializing promises
-   */
-  #initialized?: Promise<unknown>;
-  /**
-   * Event emitter, to broadcast event changes
-   */
-  #emitter = new EventEmitter();
-  /**
-   * Dependent registries
-   */
-  #dependents: Registry[] = [];
-  /**
-   * Parent registries
-   */
-  #parents: ChangeSource<Class>[] = [];
-  /**
-   * Unique identifier
-   */
-  #uid: string;
-
-  /**
-   * Are we in a mode that should have enhanced debug info
-   */
-  trace = Env.DEBUG.val?.includes('@travetto/registry');
-
-  /**
-   * Creates a new registry, with it's parents specified
-   */
-  constructor(...parents: ChangeSource<Class>[]) {
-    this.#uid = `${this.constructor.name}_${Date.now()}`;
-    this.#parents = parents;
-
-    if (this.#parents.length) {
-      // Have the child listen to the parents
-      for (const parent of this.#parents) {
-        this.listen(parent);
-        if (parent instanceof Registry) {
-          parent.#dependents.push(this);
-        }
-      }
-    }
-  }
-
-  /**
-   * Run initialization
-   */
-  async #runInit(): Promise<void> {
-    try {
-      this.#resolved = false;
-      if (this.trace) {
-        console.debug('Initializing', { id: this.constructor.Ⲑid, uid: this.#uid });
-      }
-
-      // Handle top level when dealing with non-registry
-      const waitFor = this.#parents.filter(x => !(x instanceof Registry));
-      await Promise.all(waitFor.map(x => x.init()));
-
-      const classes = await this.initialInstall();
-
-      if (classes) {
-        for (const cls of classes) {
-          this.install(cls, { type: 'added', curr: cls });
-        }
-      }
-
-      await Promise.all(this.#dependents.map(x => x.init()));
-    } finally {
-      this.#resolved = true;
-    }
-  }
-
-  get resolved(): boolean {
-    return this.#resolved;
-  }
-
-  /**
-   * Return list of classes for the initial installation
-   */
-  initialInstall(): Class[] {
-    return [];
-  }
-
-  /**
-   * Verify initialized state
-   */
-  verifyInitialized(): void {
-    if (!this.#resolved) {
-      throw new Error(`${this.constructor.name} has not been initialized, you probably need to call RootRegistry.init()`);
-    }
-  }
-
-  /**
-   * Initialize, with a built-in latch to prevent concurrent initializations
-   */
-  async init(): Promise<unknown> {
-    if (this.trace) {
-      console.debug('Trying to initialize', { id: this.constructor.Ⲑid, uid: this.#uid, initialized: !!this.#initialized });
-    }
-
-    if (!this.#initialized) {
-      this.#initialized = this.#runInit();
-    }
-    return this.#initialized;
-  }
-
-  parent<T extends ChangeSource<Class>>(type: Class<T>): T | undefined {
-    return this.#parents.find((dep: unknown): dep is T => dep instanceof type);
-  }
-
-  /**
-   * When an installation event occurs
-   */
-  onInstall?(cls: Class, e: ChangeEvent<Class>): void;
-
-  /**
-   * When an un-installation event occurs
-   */
-  onUninstall?(cls: Class, e: ChangeEvent<Class>): void;
-
-  /**
-   * Uninstall a class or list of classes
-   */
-  uninstall(classes: Class | Class[], e: ChangeEvent<Class>): void {
-    if (!Array.isArray(classes)) {
-      classes = [classes];
-    }
-    for (const cls of classes) {
-      this.onUninstall?.(cls, e);
-    }
-  }
-
-  /**
-   * Install a class or a list of classes
-   */
-  install(classes: Class | Class[], e: ChangeEvent<Class>): void {
-    if (!Array.isArray(classes)) {
-      classes = [classes];
-    }
-    for (const cls of classes) {
-      this.onInstall?.(cls, e);
-    }
-  }
-
-  /**
-   * Listen for events from the parent
-   */
-  onEvent(event: ChangeEvent<Class>): void {
-    if (this.trace) {
-      console.debug('Received', { id: this.constructor.Ⲑid, type: event.type, targetId: (event.curr ?? event.prev)!.Ⲑid });
-    }
-
-    switch (event.type) {
-      case 'removing':
-        this.uninstall(event.prev!, event);
-        break;
-      case 'added':
-        this.install(event.curr!, event);
-        break;
-      case 'changed':
-        this.uninstall(event.prev!, event);
-        this.install(event.curr!, event);
-        break;
-      default:
-        return;
-    }
-  }
-
-  /**
-   * Emit a new event
-   */
-  emit(e: ChangeEvent<Class>): void {
-    this.#emitter.emit('change', e);
-  }
-
-  /**
-   * Register additional listeners
-   */
-  on<T>(callback: ChangeHandler<Class<T>>): void {
-    this.#emitter.on('change', callback);
-  }
-
-  /**
-   * Remove listeners
-   */
-  off<T>(callback: ChangeHandler<Class<T>>): void {
-    this.#emitter.off('change', callback);
-  }
-
-  /**
-   * Connect changes sources
-   */
-  listen(source: ChangeSource<Class>): void {
-    source.on(e => this.onEvent(e));
-  }
-}

package/src/service/metadata.ts

@@ -1,192 +0,0 @@
-/* eslint @typescript-eslint/no-unused-vars: ["error", { "args": "none"} ] */
-import { Class } from '@travetto/runtime';
-
-import { Registry } from '../registry.ts';
-import { ChangeEvent } from '../types.ts';
-
-function id(cls: string | Class): string {
-  return cls && typeof cls !== 'string' ? cls.Ⲑid : cls;
-}
-
-/**
- * Metadata registry
- */
-export abstract class MetadataRegistry<C extends { class: Class }, M = unknown, F = Function> extends Registry {
-
-  static id = id;
-  /**
-   * Classes pending removal
-   */
-  expired = new Map<string, C>();
-  /**
-   * Classes pending creation
-   */
-  pending = new Map<string, Partial<C>>();
-  /**
-   * Fields pending creation
-   */
-  pendingFields = new Map<string, Map<F, Partial<M>>>();
-  /**
-   * Active items
-   */
-  entries = new Map<string, C>();
-
-  /**
-   * Code to call when the installation is finalized
-   */
-  abstract onInstallFinalize<T>(cls: Class<T>): C;
-
-  /**
-   * Code to call when uninstall is finalized
-   */
-  onUninstallFinalize<T>(cls: Class<T>): void {
-
-  }
-
-  /**
-   * Create a pending class.  Items are pending until the registry is activated
-   */
-  abstract createPending(cls: Class): Partial<C>;
-
-  /**
-   * Is class found by id or by Class
-   */
-  has(cls: string | Class): boolean {
-    return this.entries.has(id(cls));
-  }
-
-  /**
-   * Get class by id or by Class
-   */
-  get(cls: string | Class): C {
-    return this.entries.get(id(cls))!;
-  }
-
-  /**
-   * Retrieve the class that is being removed
-   */
-  getExpired(cls: string | Class): C {
-    return this.expired.get(id(cls))!;
-  }
-
-  /**
-   * Is there a class that is expiring
-   */
-  hasExpired(cls: string | Class): boolean {
-    return this.expired.has(id(cls));
-  }
-
-  /**
-   * Is there a pending state for the class
-   */
-  hasPending(cls: string | Class): boolean {
-    return this.pending.has(id(cls));
-  }
-
-  /**
-   * Get list of all classes that have been registered
-   */
-  getClasses(): Class[] {
-    return Array.from(this.entries.values()).map(x => x.class);
-  }
-
-  /**
-   * Trigger initial install, moves pending to finalized (active)
-   */
-  override initialInstall(): Class[] {
-    return Array.from(this.pending.values()).map(x => x.class).filter(x => !!x);
-  }
-
-  /**
-   * Create a pending field
-   */
-  createPendingField(cls: Class, field: F): Partial<M> {
-    return {};
-  }
-
-  /**
-   * Find parent class for a given class object
-   */
-  getParentClass(cls: Class): Class | null {
-    const parent: Class = Object.getPrototypeOf(cls);
-    return parent.name && parent !== Object ? parent : null;
-  }
-
-  /**
-   * Get or create a pending class
-   */
-  getOrCreatePending(cls: Class): Partial<C> {
-    const cid = id(cls);
-    if (!this.pending.has(cid)) {
-      this.pending.set(cid, this.createPending(cls));
-      this.pendingFields.set(cid, new Map());
-    }
-    return this.pending.get(cid)!;
-  }
-
-  /**
-   * Get or create a pending field
-   */
-  getOrCreatePendingField(cls: Class, field: F): Partial<M> {
-    this.getOrCreatePending(cls);
-    const classId = cls.Ⲑid;
-
-    if (!this.pendingFields.get(classId)!.has(field)) {
-      this.pendingFields.get(classId)!.set(field, this.createPendingField(cls, field));
-    }
-    return this.pendingFields.get(classId)!.get(field)!;
-  }
-
-  /**
-   * Register a pending class, with partial config to overlay
-   */
-  register(cls: Class, pConfig: Partial<C> = {}): void {
-    const conf = this.getOrCreatePending(cls);
-    Object.assign(conf, pConfig);
-  }
-
-  /**
-   * Register a pending field, with partial config to overlay
-   */
-  registerField(cls: Class, field: F, pConfig: Partial<M>): void {
-    const conf = this.getOrCreatePendingField(cls, field);
-    Object.assign(conf, pConfig);
-  }
-
-  /**
-   * On an install event, finalize
-   */
-  onInstall(cls: Class, e: ChangeEvent<Class>): void {
-    const classId = cls.Ⲑid;
-    if (this.pending.has(classId) || this.pendingFields.has(classId)) {
-      if (this.trace) {
-        console.debug('Installing', { service: this.constructor.name, id: classId });
-      }
-      const result = this.onInstallFinalize(cls);
-      this.pendingFields.delete(classId);
-      this.pending.delete(classId);
-
-      this.entries.set(classId, result);
-      this.emit(e);
-    }
-  }
-
-  /**
-   * On an uninstall event, remove
-   */
-  onUninstall(cls: Class, e: ChangeEvent<Class>): void {
-    const classId = cls.Ⲑid;
-    if (this.entries.has(classId)) {
-      if (this.trace) {
-        console.debug('Uninstalling', { service: this.constructor.name, id: classId });
-      }
-      this.expired.set(classId, this.entries.get(classId)!);
-      this.entries.delete(classId);
-      this.onUninstallFinalize(cls);
-      if (e.type === 'removing') {
-        this.emit(e);
-      }
-      process.nextTick(() => this.expired.delete(classId));
-    }
-  }
-}

package/src/service/root.ts

@@ -1,32 +0,0 @@
-import { Class } from '@travetto/runtime';
-
-import { Registry } from '../registry.ts';
-import { ClassSource } from '../source/class-source.ts';
-import { ChangeEvent } from '../types.ts';
-
-/**
- * The root registry that controls all registries
- */
-class $RootRegistry extends Registry {
-  constructor() {
-    super(new ClassSource());
-  }
-
-  /**
-   * Send event to all all of the children
-   */
-  override async onEvent(e: ChangeEvent<Class>): Promise<void> {
-    await super.onEvent(e); // Process event, and
-    this.emit(e); // Send to children
-  }
-
-  /**
-   * Registers a listener to be notified when a file changes, but no
-   * classes are modified
-   */
-  onNonClassChanges(handler: (file: string) => void): void {
-    this.parent(ClassSource)!.onNonClassChanges(handler);
-  }
-}
-
-export const RootRegistry = new $RootRegistry();