@travetto/runtime 6.0.0-rc.1 → 6.0.0-rc.2

package/README.md

@@ -57,7 +57,7 @@ class $Runtime {
   /** Produce a workspace path for tooling, with '@' being replaced by node_module/name folder */
   toolPath(...rel: string[]): string;
   /** Resolve single module path */
-  modulePath(modulePath: string): string;
+  modulePath(modulePath: string, overrides?: Record<string, string>): string;
   /** Resolve resource paths */
   resourcePaths(paths: string[] = []): string[];
   /** Get source for function */
@@ -125,7 +125,7 @@ interface EnvData {
     /**
      * trvc log level
      */
-    TRV_BUILD: 'none' | 'info' | 'debug' | 'error' | 'warn',
+    TRV_BUILD: 'none' | 'info' | 'debug' | 'error' | 'warn';
     /**
      * Should break on first line of a method when using the @DebugBreak decorator
      * @default false
@@ -168,7 +168,7 @@ export class EnvProp<T> {
 ```
 
 ## Standard Error Support
-While the framework is 100 % compatible with standard `Error` instances, there are cases in which additional functionality is desired. Within the framework we use [AppError](https://github.com/travetto/travetto/tree/main/module/runtime/src/error.ts#L26) (or its derivatives) to represent framework errors. This class is available for use in your own projects. Some of the additional benefits of using this class is enhanced error reporting, as well as better integration with other modules (e.g. the [RESTful API](https://github.com/travetto/travetto/tree/main/module/rest#readme "Declarative api for RESTful APIs with support for the dependency injection module.") module and HTTP status codes). 
+While the framework is 100 % compatible with standard `Error` instances, there are cases in which additional functionality is desired. Within the framework we use [AppError](https://github.com/travetto/travetto/tree/main/module/runtime/src/error.ts#L26) (or its derivatives) to represent framework errors. This class is available for use in your own projects. Some of the additional benefits of using this class is enhanced error reporting, as well as better integration with other modules (e.g. the [Web API](https://github.com/travetto/travetto/tree/main/module/web#readme "Declarative api for Web Applications with support for the dependency injection.") module and HTTP status codes). 
 
 The [AppError](https://github.com/travetto/travetto/tree/main/module/runtime/src/error.ts#L26) takes in a message, and an optional payload and / or error classification. The currently supported error classifications are:
    *  `general` - General purpose errors
@@ -193,7 +193,7 @@ The supported operations are:
 **Note**: All other console methods are excluded, specifically `trace`, `inspect`, `dir`, `time`/`timeEnd`
 
 ### How Logging is Instrumented
-All of the logging instrumentation occurs at transpilation time.  All `console.*` methods are replaced with a call to a globally defined variable that delegates to the [ConsoleManager](https://github.com/travetto/travetto/tree/main/module/runtime/src/console.ts#L35).  This module, hooks into the [ConsoleManager](https://github.com/travetto/travetto/tree/main/module/runtime/src/console.ts#L35) and receives all logging events from all files compiled by the [Travetto](https://travetto.dev). 
+All of the logging instrumentation occurs at transpilation time.  All `console.*` methods are replaced with a call to a globally defined variable that delegates to the [ConsoleManager](https://github.com/travetto/travetto/tree/main/module/runtime/src/console.ts#L43).  This module, hooks into the [ConsoleManager](https://github.com/travetto/travetto/tree/main/module/runtime/src/console.ts#L43) and receives all logging events from all files compiled by the [Travetto](https://travetto.dev). 
 
 A sample of the instrumentation would be:
 
@@ -242,7 +242,7 @@ The `debug` messages can be filtered using the patterns from the [debug](https:/
 # Debug
 $ DEBUG=-@travetto/model npx trv run app
 $ DEBUG=-@travetto/registry npx trv run app
-$ DEBUG=@travetto/rest npx trv run app
+$ DEBUG=@travetto/web npx trv run app
 $ DEBUG=@travetto/*,-@travetto/model npx trv run app
 ```
 
@@ -252,7 +252,7 @@ Additionally, the logging framework will merge [debug](https://www.npmjs.com/pac
 ```bash
 
 # Debug
-$ DEBUG=express:*,@travetto/rest npx trv run rest
+$ DEBUG=express:*,@travetto/web npx trv run web
 ```
 
 ## Resource Access
@@ -263,7 +263,7 @@ The [FileLoader](https://github.com/travetto/travetto/tree/main/module/runtime/s
 The [FileLoader](https://github.com/travetto/travetto/tree/main/module/runtime/src/file-loader.ts#L11) also supports tying itself to [Env](https://github.com/travetto/travetto/tree/main/module/runtime/src/env.ts#L114)'s `TRV_RESOURCES` information on where to attempt to find a requested resource.
 
 ## Common Utilities
-Common utilities used throughout the framework. Currently [Util](https://github.com/travetto/travetto/tree/main/module/runtime/src/util.ts#L17) includes:
+Common utilities used throughout the framework. Currently [Util](https://github.com/travetto/travetto/tree/main/module/runtime/src/util.ts#L12) includes:
    *  `uuid(len: number)` generates a simple uuid for use within the application.
    *  `allowDenyMatcher(rules[])` builds a matching function that leverages the rules as an allow/deny list, where order of the rules matters.  Negative rules are prefixed by '!'.
    *  `hash(text: string, size?: number)` produces a full sha512 hash.

package/__index__.ts

@@ -1,19 +1,19 @@
-import type { } from './src/global';
-import type { } from './src/trv';
-export * from './src/binary';
-export * from './src/console';
-export * from './src/context';
-export * from './src/debug';
-export * from './src/error';
-export * from './src/exec';
-export * from './src/env';
-export * from './src/file-loader';
-export * from './src/function';
-export * from './src/manifest-index';
-export * from './src/queue';
-export * from './src/resources';
-export * from './src/shutdown';
-export * from './src/time';
-export * from './src/types';
-export * from './src/watch';
-export * from './src/util';
+import type { } from './src/global.d.ts';
+import type { } from './src/trv.d.ts';
+export * from './src/binary.ts';
+export * from './src/console.ts';
+export * from './src/context.ts';
+export * from './src/debug.ts';
+export * from './src/error.ts';
+export * from './src/exec.ts';
+export * from './src/env.ts';
+export * from './src/file-loader.ts';
+export * from './src/function.ts';
+export * from './src/manifest-index.ts';
+export * from './src/queue.ts';
+export * from './src/resources.ts';
+export * from './src/shutdown.ts';
+export * from './src/time.ts';
+export * from './src/types.ts';
+export * from './src/watch.ts';
+export * from './src/util.ts';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/runtime",
-  "version": "6.0.0-rc.1",
+  "version": "6.0.0-rc.2",
   "description": "Runtime for travetto applications.",
   "keywords": [
     "console-manager",
@@ -25,12 +25,12 @@
     "directory": "module/runtime"
   },
   "dependencies": {
-    "@travetto/manifest": "^6.0.0-rc.1",
+    "@travetto/manifest": "^6.0.0-rc.2",
     "@types/debug": "^4.1.12",
     "debug": "^4.4.0"
   },
   "peerDependencies": {
-    "@travetto/transformer": "^6.0.0-rc.1"
+    "@travetto/transformer": "^6.0.0-rc.3"
   },
   "peerDependenciesMeta": {
     "@travetto/transformer": {

package/src/binary.ts

@@ -2,21 +2,38 @@ import path from 'node:path';
 import os from 'node:os';
 import crypto from 'node:crypto';
 import fs from 'node:fs/promises';
-import { PassThrough, Readable, Transform } from 'node:stream';
+import { PassThrough, Readable } from 'node:stream';
 import { pipeline } from 'node:stream/promises';
 import { ReadableStream } from 'node:stream/web';
-import { text as toText, arrayBuffer as toBuffer } from 'node:stream/consumers';
+import { text as toText, arrayBuffer as toArrayBuffer } from 'node:stream/consumers';
+import { isArrayBuffer } from 'node:util/types';
 
-import { BinaryInput, BlobMeta } from './types';
-import { AppError } from './error';
-import { Util } from './util';
+import { BinaryInput, BlobMeta, hasFunction } from './types.ts';
+import { Util } from './util.ts';
 
-const BlobMetaSymbol = Symbol.for('@travetto/runtime:blob-meta');
+const BlobMetaSymbol = Symbol();
 
 /**
  * Common functions for dealing with binary data/streams
  */
 export class BinaryUtil {
+  /** Is Array Buffer */
+  static isArrayBuffer = isArrayBuffer;
+  /** Is Readable */
+  static isReadable = hasFunction<Readable>('pipe');
+  /** Is ReadableStream */
+  static isReadableStream = hasFunction<ReadableStream>('pipeTo');
+  /** Is Async Iterable */
+  static isAsyncIterable = (v: unknown): v is AsyncIterable<unknown> =>
+    !!v && (typeof v === 'object' || typeof v === 'function') && Symbol.asyncIterator in v;
+
+  /**
+   * Is src a binary type
+   */
+  static isBinaryType(src: unknown): boolean {
+    return src instanceof Blob || Buffer.isBuffer(src) || this.isReadable(src) ||
+      this.isArrayBuffer(src) || this.isReadableStream(src) || this.isAsyncIterable(src);
+  }
 
   /**
    * Generate a proper sha512 hash from a src value
@@ -26,8 +43,8 @@ export class BinaryUtil {
   static hash(src: string, len: number = -1): string {
     const hash = crypto.createHash('sha512');
     hash.update(src);
-    const ret = hash.digest('hex');
-    return len > 0 ? ret.substring(0, len) : ret;
+    const digest = hash.digest('hex');
+    return len > 0 ? digest.substring(0, len) : digest;
   }
 
   /**
@@ -83,9 +100,9 @@ export class BinaryUtil {
     return Object.defineProperties(out, {
       size: { value: size },
       stream: { value: () => ReadableStream.from(go()) },
-      arrayBuffer: { value: () => toBuffer(go()) },
+      arrayBuffer: { value: () => toArrayBuffer(go()) },
       text: { value: () => toText(go()) },
-      bytes: { value: () => toBuffer(go()).then(v => new Uint8Array(v)) },
+      bytes: { value: () => toArrayBuffer(go()).then(v => new Uint8Array(v)) },
       [BlobMetaSymbol]: { value: metadata }
     });
   }
@@ -98,24 +115,6 @@ export class BinaryUtil {
     return withMeta[BlobMetaSymbol];
   }
 
-  /**
-   * Write limiter
-   * @returns
-   */
-  static limitWrite(maxSize: number): Transform {
-    let read = 0;
-    return new Transform({
-      transform(chunk, encoding, callback): void {
-        read += (Buffer.isBuffer(chunk) || typeof chunk === 'string') ? chunk.length : (chunk instanceof Uint8Array ? chunk.byteLength : 0);
-        if (read > maxSize) {
-          callback(new AppError('File size exceeded', { category: 'data', details: { read, size: maxSize } }));
-        } else {
-          callback(null, chunk);
-        }
-      },
-    });
-  }
-
   /**
    * Get a hashed location/path for a blob
    */

package/src/console.ts

@@ -1,9 +1,12 @@
 import util from 'node:util';
 import debug from 'debug';
 
-import { RuntimeIndex } from './manifest-index';
+import { RuntimeIndex } from './manifest-index.ts';
 
-export type ConsoleEvent = {
+/**
+ * @concrete
+ */
+export interface ConsoleEvent {
   /** Time of event */
   timestamp: Date;
   /** The level of the console event */
@@ -20,6 +23,9 @@ export type ConsoleEvent = {
   args: unknown[];
 };
 
+/**
+ * @concrete
+ */
 export interface ConsoleListener {
   log(ev: ConsoleEvent): void;
 }
@@ -31,6 +37,8 @@ const DEBUG_OG = { formatArgs: debug.formatArgs, log: debug.log };
  *
  * The transpiler will replace all console.* calls in the typescript files for the framework and those provided by the user.
  * Any console.log statements elsewhere will not be affected.
+ *
+ * @alias ConsoleManager
  */
 class $ConsoleManager implements ConsoleListener {
 

package/src/context.ts

@@ -1,13 +1,12 @@
-import { existsSync } from 'node:fs';
 import fs from 'node:fs/promises';
 import path from 'node:path';
 
 import { type ManifestIndex, type ManifestContext, ManifestModuleUtil } from '@travetto/manifest';
 
-import { Env } from './env';
-import { RuntimeIndex } from './manifest-index';
-import { describeFunction } from './function';
-import { castTo } from './types';
+import { Env } from './env.ts';
+import { RuntimeIndex } from './manifest-index.ts';
+import { describeFunction } from './function.ts';
+import { castTo } from './types.ts';
 
 /** Constrained version of {@type ManifestContext} */
 class $Runtime {
@@ -85,8 +84,9 @@ class $Runtime {
   }
 
   /** Resolve single module path */
-  modulePath(modulePath: string): string {
-    const [base, sub] = (this.#resourceOverrides?.[modulePath] ?? modulePath)
+  modulePath(modulePath: string, overrides?: Record<string, string>): string {
+    const combined = { ...this.#resourceOverrides, ...overrides };
+    const [base, sub] = (combined[modulePath] ?? modulePath)
       .replace(/^([^#]*)(#|$)/g, (_, v, r) => `${this.#moduleAliases[v] ?? v}${r}`)
       .split('#');
     return path.resolve(this.#idx.getModule(base)?.sourcePath ?? base, sub ?? '.');
@@ -110,7 +110,7 @@ class $Runtime {
   /** Import from a given path */
   async importFrom<T = unknown>(imp?: string): Promise<T> {
     const file = path.resolve(this.#idx.mainModule.sourcePath, imp!);
-    if (existsSync(file)) {
+    if (await fs.stat(file).catch(() => false)) {
       imp = this.#idx.getFromSource(file)?.import;
     }
 
@@ -121,7 +121,7 @@ class $Runtime {
       return fs.readFile(imp, 'utf8').then(JSON.parse);
     }
 
-    if (!/[.][cm]?[tj]sx?$/.test(imp)) {
+    if (!ManifestModuleUtil.SOURCE_EXT_RE.test(imp)) {
       if (imp.startsWith('@')) {
         if (/[/].*?[/]/.test(imp)) {
           imp = `${imp}.ts`;

package/src/debug.ts

@@ -1,5 +1,5 @@
-import { Env } from './env';
-import { ClassInstance } from './types';
+import { Env } from './env.ts';
+import { ClassInstance } from './types.ts';
 
 /**
  * The `@DebugBreak` indicates that a function inserts an optional debugger keyword to stop on entry

package/src/env.ts

@@ -1,4 +1,4 @@
-import { castKey, castTo } from './types';
+import { castKey, castTo } from './types.ts';
 
 const IS_TRUE = /^(true|yes|on|1)$/i;
 const IS_FALSE = /^(false|no|off|0)$/i;

package/src/error.ts

@@ -1,4 +1,4 @@
-import { castTo } from './types';
+import { castTo } from './types.ts';
 
 export type ErrorCategory =
   'general' |

package/src/exec.ts

@@ -2,11 +2,11 @@ import { ChildProcess } from 'node:child_process';
 import { Readable } from 'node:stream';
 import { createInterface } from 'node:readline/promises';
 
-import { castTo } from './types';
+import { castTo } from './types.ts';
 
 const MINUTE = (1000 * 60);
 
-const RESULT = Symbol.for('@travetto/runtime:exec-result');
+const ResultSymbol = Symbol();
 
 interface ExecutionBaseResult {
   /**
@@ -49,14 +49,18 @@ export class ExecUtil {
    * @param run The factory to produce the next running process
    * @param maxRetriesPerMinute The number of times to allow a retry within a minute
    */
-  static async withRestart(run: () => ChildProcess, maxRetriesPerMinute?: number): Promise<ExecutionResult> {
+  static async withRestart(
+    run: () => ChildProcess,
+    maxRetriesPerMinute?: number,
+    killSignal: 'SIGINT' | 'SIGTERM' = 'SIGINT'
+  ): Promise<ExecutionResult> {
     const maxRetries = maxRetriesPerMinute ?? 5;
     const restarts: number[] = [];
 
     for (; ;) {
       const proc = run();
 
-      const toKill = (): void => { proc.kill('SIGKILL'); };
+      const toKill = (): void => { proc.kill(killSignal); };
       const toMessage = (v: unknown): void => { proc.send?.(v!); };
 
       // Proxy kill requests
@@ -95,12 +99,12 @@ export class ExecUtil {
   static getResult(proc: ChildProcess, options: { catch?: boolean, binary?: false }): Promise<ExecutionResult<string>>;
   static getResult(proc: ChildProcess, options: { catch?: boolean, binary: true }): Promise<ExecutionResult<Buffer>>;
   static getResult<T extends string | Buffer>(proc: ChildProcess, options: { catch?: boolean, binary?: boolean } = {}): Promise<ExecutionResult<T>> {
-    const _proc: ChildProcess & { [RESULT]?: Promise<ExecutionResult> } = proc;
-    const res = _proc[RESULT] ??= new Promise<ExecutionResult>(resolve => {
+    const _proc: ChildProcess & { [ResultSymbol]?: Promise<ExecutionResult> } = proc;
+    const result = _proc[ResultSymbol] ??= new Promise<ExecutionResult>(resolve => {
       const stdout: Buffer[] = [];
       const stderr: Buffer[] = [];
       let done = false;
-      const finish = (result: ExecutionBaseResult): void => {
+      const finish = (finalResult: ExecutionBaseResult): void => {
         if (done) {
           return;
         }
@@ -114,7 +118,7 @@ export class ExecUtil {
         const final = {
           stdout: options.binary ? buffers.stdout : buffers.stdout.toString('utf8'),
           stderr: options.binary ? buffers.stderr : buffers.stderr.toString('utf8'),
-          ...result
+          ...finalResult
         };
 
         resolve(!final.valid ?
@@ -123,8 +127,8 @@ export class ExecUtil {
         );
       };
 
-      proc.stdout?.on('data', (d: string | Buffer) => stdout.push(Buffer.from(d)));
-      proc.stderr?.on('data', (d: string | Buffer) => stderr.push(Buffer.from(d)));
+      proc.stdout?.on('data', (d: string | Buffer) => stdout.push(Buffer.isBuffer(d) ? d : Buffer.from(d)));
+      proc.stderr?.on('data', (d: string | Buffer) => stderr.push(Buffer.isBuffer(d) ? d : Buffer.from(d)));
 
       proc.on('error', (err: Error) =>
         finish({ code: 1, message: err.message, valid: false }));
@@ -137,7 +141,7 @@ export class ExecUtil {
       }
     });
 
-    return castTo(options.catch ? res : res.then(v => {
+    return castTo(options.catch ? result : result.then(v => {
       if (v.valid) {
         return v;
       } else {

package/src/file-loader.ts

@@ -3,7 +3,7 @@ import { Readable } from 'node:stream';
 import fs from 'node:fs/promises';
 import path from 'node:path';
 
-import { AppError } from './error';
+import { AppError } from './error.ts';
 
 /**
  * File loader that will search for files across the provided search paths
@@ -56,4 +56,12 @@ export class FileLoader {
     const file = await this.resolve(relativePath);
     return createReadStream(file, { encoding: binary ? undefined : 'utf8' });
   }
+
+  /**
+   * Read a file as a File object
+   * @param relativePath The path to read
+   */
+  async readFile(relativePath: string): Promise<File> {
+    return new File([await this.read(relativePath, true)], path.basename(relativePath));
+  }
 }

package/src/function.ts

@@ -1,3 +1,5 @@
+import { ManifestModuleUtil } from '@travetto/manifest';
+
 export type FunctionMetadataTag = { hash: number, lines: [start: number, end: number, bodyStart?: number] };
 export type FunctionMetadata = FunctionMetadataTag & {
   id: string;
@@ -9,7 +11,7 @@ export type FunctionMetadata = FunctionMetadataTag & {
   abstract?: boolean;
 };
 
-const MetadataSymbol = Symbol.for('@travetto/runtime:function-metadata');
+const MetadataSymbol = Symbol();
 
 const pending = new Set<Function>([]);
 
@@ -27,7 +29,7 @@ export function registerFunction(
   fn: Function, [pkg, pth]: [string, string], tag: FunctionMetadataTag,
   methods?: Record<string, FunctionMetadataTag>, abstract?: boolean,
 ): void {
-  const modulePath = pth.replace(/[.][cm]?[tj]sx?$/, '');
+  const modulePath = ManifestModuleUtil.withoutSourceExtension(pth);
 
   const metadata: FunctionMetadata = {
     id: (fn.name ? `${pkg}:${modulePath}#${fn.name}` : `${pkg}:${modulePath}`),

package/src/global.d.ts

@@ -11,4 +11,28 @@ declare global {
     /* Exposed for use within framework, only applies to framework managed classes */
     readonly Ⲑid: string;
   }
+
+  /**
+   * @concrete node:buffer#Blob
+   */
+  interface Blob { }
+
+  /**
+   * @concrete node:buffer#File
+   */
+  interface File { }
+
+  namespace NodeJS {
+    /**
+     * @concrete node:stream#Readable
+     */
+    interface ReadableStream { }
+  }
+}
+
+declare module 'stream' {
+  /**
+   * @concrete node:stream#Readable
+   */
+  interface Readable { }
 }

package/src/queue.ts

@@ -1,5 +1,3 @@
-import { Util } from './util';
-
 /**
  * An asynchronous queue
  */
@@ -7,7 +5,7 @@ export class AsyncQueue<X> implements AsyncIterator<X>, AsyncIterable<X> {
 
   #queue: X[] = [];
   #done = false;
-  #ready = Util.resolvablePromise();
+  #ready = Promise.withResolvers<void>();
 
   /**
    * Initial set of items
@@ -31,7 +29,7 @@ export class AsyncQueue<X> implements AsyncIterator<X>, AsyncIterable<X> {
   async next(): Promise<IteratorResult<X>> {
     while (!this.#done && !this.#queue.length) {
       await this.#ready.promise;
-      this.#ready = Util.resolvablePromise();
+      this.#ready = Promise.withResolvers<void>();
     }
     return { value: (this.#queue.length ? this.#queue.shift() : undefined)!, done: this.#done };
   }

package/src/resources.ts

@@ -1,6 +1,6 @@
-import { Runtime } from './context';
-import { Env } from './env';
-import { FileLoader } from './file-loader';
+import { Runtime } from './context.ts';
+import { Env } from './env.ts';
+import { FileLoader } from './file-loader.ts';
 
 /**
  * Environment aware file loader

package/src/shutdown.ts

@@ -1,6 +1,6 @@
-import { Env } from './env';
-import { Util } from './util';
-import { TimeUtil } from './time';
+import { Env } from './env.ts';
+import { Util } from './util.ts';
+import { TimeUtil } from './time.ts';
 
 /**
  * Shutdown manager, allowing for listening for graceful shutdowns
@@ -8,14 +8,14 @@ import { TimeUtil } from './time';
 export class ShutdownManager {
 
   static #registered = false;
-  static #handlers: { name?: string, handler: () => Promise<void> }[] = [];
+  static #handlers: { name?: string, handler: () => (void | Promise<void>) }[] = [];
 
   /**
    * On Shutdown requested
    * @param name name to log for
    * @param handler synchronous or asynchronous handler
    */
-  static onGracefulShutdown(handler: () => Promise<void>, name?: string | { constructor: Function }): () => void {
+  static onGracefulShutdown(handler: () => (void | Promise<void>), name?: string | { constructor: Function }): () => void {
     if (!this.#registered) {
       this.#registered = true;
       const done = (): void => { this.gracefulShutdown(0); };
@@ -34,6 +34,8 @@ export class ShutdownManager {
    * Wait for graceful shutdown to run and complete
    */
   static async gracefulShutdown(code: number | string | undefined = process.exitCode): Promise<void> {
+    await Util.queueMacroTask(); // Force the event loop to wait one cycle
+
     if (code !== undefined) {
       process.exitCode = code;
     }
@@ -42,13 +44,15 @@ export class ShutdownManager {
       console.debug('Graceful shutdown: started');
 
       const items = this.#handlers.splice(0, this.#handlers.length);
-      const handlers = Promise.all(items.map(({ name, handler }) => {
+      const handlers = Promise.all(items.map(async ({ name, handler }) => {
         if (name) {
           console.debug('Stopping', { name });
         }
-        return handler().catch(err => {
+        try {
+          return await handler();
+        } catch (err) {
           console.error('Error shutting down', { name, err });
-        });
+        }
       }));
 
       await Promise.race([

package/src/trv.d.ts

@@ -1,5 +1,5 @@
 import { type ManifestModuleRole } from '@travetto/manifest';
-import { type TimeSpan } from './time';
+import { type TimeSpan } from './time.ts';
 type Role = Exclude<ManifestModuleRole, 'std' | 'compile'>;
 
 declare module "@travetto/runtime" {
@@ -51,7 +51,7 @@ declare module "@travetto/runtime" {
     /**
      * trvc log level
      */
-    TRV_BUILD: 'none' | 'info' | 'debug' | 'error' | 'warn',
+    TRV_BUILD: 'none' | 'info' | 'debug' | 'error' | 'warn';
     /**
      * Should break on first line of a method when using the @DebugBreak decorator
      * @default false

package/src/types.ts

@@ -49,6 +49,10 @@ export const hasFunction = <T>(key: keyof T) => (o: unknown): o is T =>
 
 export const hasToJSON = hasFunction<{ toJSON(): object }>('toJSON');
 
+export function toConcrete<T extends unknown>(): Class<T> {
+  return arguments[0];
+}
+
 /**
  * Range of bytes, inclusive
  */

package/src/util.ts

@@ -1,13 +1,8 @@
 import crypto from 'node:crypto';
 import timers from 'node:timers/promises';
 
-import { castTo } from './types';
-
-type PromiseWithResolvers<T> = {
-  resolve: (v: T) => void;
-  reject: (err?: unknown) => void;
-  promise: Promise<T>;
-};
+import { castTo, hasToJSON } from './types.ts';
+import { AppError } from './error.ts';
 
 type MapFn<T, U> = (val: T, i: number) => U | Promise<U>;
 
@@ -56,15 +51,6 @@ export class Util {
     return bytes.toString('hex').substring(0, len);
   }
 
-  /**
-   * Produce a promise that is externally resolvable
-   */
-  static resolvablePromise<T = void>(): PromiseWithResolvers<T> {
-    let ops: Pick<PromiseWithResolvers<T>, 'reject' | 'resolve'>;
-    const prom = new Promise<T>((resolve, reject) => ops = { resolve, reject });
-    return { ...ops!, promise: prom };
-  }
-
   /**
    * Map an async iterable with various mapping functions
    */
@@ -164,4 +150,49 @@ export class Util {
 
     return JSON.parse(decoded, undefined);
   }
+
+  /**
+   * Serialize to JSON
+   */
+  static serializeToJSON<T>(out: T): string {
+    return JSON.stringify(out, function (k, v) {
+      const ov = this[k];
+      if (ov && ov instanceof Error) {
+        return {
+          $: true,
+          ...hasToJSON(ov) ? ov.toJSON() : ov,
+          name: ov.name,
+          message: ov.message,
+          stack: ov.stack,
+        };
+      } else if (typeof v === 'bigint') {
+        return `${v.toString()}$n`;
+      } else {
+        return v;
+      }
+    });
+  }
+
+  /**
+   * Deserialize from JSON
+   */
+  static deserializeFromJson<T = unknown>(input: string): T {
+    return JSON.parse(input, function (k, v) {
+      if (v && typeof v === 'object' && '$' in v) {
+        const err = AppError.fromJSON(v) ?? new Error();
+        if (!(err instanceof AppError)) {
+          const { $: _, ...rest } = v;
+          Object.assign(err, rest);
+        }
+        err.message = v.message;
+        err.stack = v.stack;
+        err.name = v.name;
+        return err;
+      } else if (typeof v === 'string' && /^\d+[$]n$/.test(v)) {
+        return BigInt(v.split('$')[0]);
+      } else {
+        return v;
+      }
+    });
+  }
 }

package/src/watch.ts

@@ -1,13 +1,13 @@
-import { RuntimeIndex } from './manifest-index';
-import { ExecUtil } from './exec';
-import { ShutdownManager } from './shutdown';
-import { Util } from './util';
+import { RuntimeIndex } from './manifest-index.ts';
+import { ExecUtil } from './exec.ts';
+import { ShutdownManager } from './shutdown.ts';
+import { Util } from './util.ts';
 
 export type WatchEvent = { file: string, action: 'create' | 'update' | 'delete', output: string, module: string, time: number };
 
 export async function* watchCompiler(cfg?: { restartOnExit?: boolean, signal?: AbortSignal }): AsyncIterable<WatchEvent> {
   // Load at runtime
-  const { CompilerClient } = await import('@travetto/compiler/support/server/client');
+  const { CompilerClient } = await import('@travetto/compiler/support/server/client.ts');
 
   const client = new CompilerClient(RuntimeIndex.manifest, {
     warn(message, ...args): void { console.error('warn', message, ...args); },

package/support/transformer/metadata.ts

@@ -0,0 +1,104 @@
+import * as ts from 'typescript';
+
+import { FunctionMetadataTag } from '@travetto/runtime';
+import { CoreUtil, Import, SystemUtil, TransformerState } from '@travetto/transformer';
+
+const RegisterImportSymbol = Symbol();
+
+interface MetadataInfo {
+  [RegisterImportSymbol]?: Import;
+}
+
+/**
+ * Utils for registering function/class metadata at compile time
+ */
+export class MetadataRegistrationUtil {
+
+  static REGISTER_IMPORT = '@travetto/runtime/src/function.ts';
+  static REGISTER_FN = 'registerFunction';
+
+  static isValid({ importName: imp }: TransformerState): boolean {
+    return imp !== this.REGISTER_IMPORT;
+  }
+
+  static tag(state: TransformerState, node: ts.Node): FunctionMetadataTag {
+    const text = node.getText();
+    const hash = SystemUtil.naiveHash(text);
+    try {
+      const range = CoreUtil.getRangeOf(state.source, node) ?? [0, 0];
+      if (ts.isMethodDeclaration(node) || ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node)) {
+        const bodyStart = CoreUtil.getRangeOf(state.source, node?.body?.statements[0])?.[0];
+        if (bodyStart) {
+          range.push(bodyStart);
+        }
+      }
+      return { hash, lines: range };
+    } catch {
+      return { hash, lines: [0, 0] };
+    }
+  }
+
+  /**
+   * Register metadata on a function
+   */
+  static registerFunction(state: TransformerState & MetadataInfo,
+    node: ts.FunctionDeclaration | ts.FunctionExpression,
+    src?: ts.FunctionDeclaration | ts.FunctionExpression | ts.InterfaceDeclaration | ts.TypeAliasDeclaration
+  ): void {
+    // If we have a class like function
+    state[RegisterImportSymbol] ??= state.importFile(this.REGISTER_IMPORT);
+
+    const tag = this.tag(state, src ?? node);
+    const meta = state.factory.createCallExpression(
+      state.createAccess(state[RegisterImportSymbol].ident, this.REGISTER_FN),
+      [],
+      [
+        state.createIdentifier(node.name!.text),
+        state.getModuleIdentifier(),
+        state.fromLiteral(tag),
+      ]
+    );
+    state.addStatements([state.factory.createExpressionStatement(meta)]);
+  }
+
+  /**
+   * Register metadata on a class
+   */
+  static registerClass(
+    state: TransformerState & MetadataInfo, node: ts.ClassDeclaration,
+    cls: FunctionMetadataTag, methods?: Record<string, FunctionMetadataTag>
+  ): ts.ClassDeclaration {
+
+    state[RegisterImportSymbol] ??= state.importFile(this.REGISTER_IMPORT);
+
+    const name = node.name?.escapedText.toString() ?? '';
+
+    const meta = state.factory.createCallExpression(
+      state.createAccess(state[RegisterImportSymbol].ident, this.REGISTER_FN),
+      [],
+      [
+        state.createIdentifier(name),
+        state.getModuleIdentifier(),
+        state.fromLiteral(cls),
+        state.extendObjectLiteral(methods ?? {}),
+        state.fromLiteral(CoreUtil.isAbstract(node)),
+      ]
+    );
+
+    return state.factory.updateClassDeclaration(
+      node,
+      node.modifiers,
+      node.name,
+      node.typeParameters,
+      node.heritageClauses,
+      [
+        state.factory.createClassStaticBlockDeclaration(
+          state.factory.createBlock([
+            state.factory.createExpressionStatement(meta)
+          ])
+        ),
+        ...node.members
+      ]
+    );
+  }
+}

package/support/transformer.concrete-type.ts

@@ -0,0 +1,87 @@
+import ts from 'typescript';
+
+import { TransformerState, OnInterface, OnCall, OnTypeAlias } from '@travetto/transformer';
+
+import { MetadataRegistrationUtil } from './transformer/metadata.ts';
+
+const SRC = '@travetto/runtime/src/types.ts';
+
+/**
+ * Providing support for concrete types
+ */
+export class ConcreteTransformer {
+
+  static #isConcreteSimple(node: ts.InterfaceDeclaration | ts.TypeAliasDeclaration): boolean {
+    return /^\s*[*]\s+@concrete\s*$/gm.test(node.getFullText());
+  }
+
+  static #createConcreteFunction(state: TransformerState, name: string | ts.Identifier): ts.FunctionDeclaration {
+    const final = typeof name === 'string' ? name : name.getText();
+
+    const dec = state.factory.createFunctionDeclaration(
+      // eslint-disable-next-line no-bitwise
+      state.factory.createModifiersFromModifierFlags(ts.ModifierFlags.Export | ts.ModifierFlags.Const),
+      undefined, `${final}$Concrete`, [], [], undefined,
+      state.factory.createBlock([])
+    );
+
+    state.addStatements([
+      dec,
+      state.factory.createExpressionStatement(
+        state.factory.createCallExpression(
+          state.createAccess('Object', 'defineProperty'),
+          undefined,
+          [
+            dec.name!,
+            state.fromLiteral('name'),
+            state.fromLiteral({ value: final })
+          ]
+        )
+      )
+    ]);
+
+    return dec;
+  }
+
+  /**
+   * Handle concrete interface
+   */
+  @OnInterface()
+  static onInterface(state: TransformerState, node: ts.InterfaceDeclaration): typeof node {
+    if (this.#isConcreteSimple(node)) {
+      const func = this.#createConcreteFunction(state, node.name);
+      MetadataRegistrationUtil.registerFunction(state, func, node);
+    }
+    return node;
+  }
+
+  /**
+   * Handle type alias
+   */
+  @OnTypeAlias()
+  static onTypeAlias(state: TransformerState, node: ts.TypeAliasDeclaration): typeof node {
+    if (this.#isConcreteSimple(node)) {
+      const func = this.#createConcreteFunction(state, node.name);
+      MetadataRegistrationUtil.registerFunction(state, func, node);
+    }
+    return node;
+  }
+
+  @OnCall()
+  static onToConcreteCall(state: TransformerState, node: ts.CallExpression): typeof node {
+    if (ts.isIdentifier(node.expression) && node.expression.text === 'toConcrete' && node.typeArguments?.length && node.arguments.length === 0) {
+      const type = state.resolveType(node.expression);
+      if ('importName' in type && type.importName === SRC) {
+        const [target] = node.typeArguments;
+        return state.factory.updateCallExpression(
+          node,
+          node.expression,
+          node.typeArguments,
+          [state.getConcreteType(target)]
+        );
+      }
+    }
+
+    return node;
+  }
+}

package/support/transformer.console-log.ts

@@ -2,7 +2,7 @@ import ts from 'typescript';
 
 import { TransformerState, OnCall, LiteralUtil, OnClass, AfterClass, OnMethod, AfterMethod, AfterFunction, OnFunction } from '@travetto/transformer';
 
-const CONSOLE_IMPORT = '@travetto/runtime/src/console';
+const CONSOLE_IMPORT = '@travetto/runtime/src/console.ts';
 
 type CustomState = TransformerState & {
   scope: { type: 'method' | 'class' | 'function', name: string }[];

package/support/transformer.debug-method.ts

@@ -2,7 +2,7 @@ import ts from 'typescript';
 
 import { TransformerState, OnMethod, CoreUtil } from '@travetto/transformer';
 
-const DebugSymbol = Symbol.for('@travetto/runtime:debug');
+const DebugSymbol = Symbol();
 
 /**
  * Debug transformation state
@@ -19,7 +19,7 @@ export class DebugEntryTransformer {
   @OnMethod('DebugBreak')
   static debugOnEntry(state: TransformerState & DebugState, node: ts.MethodDeclaration): ts.MethodDeclaration {
     if (!state[DebugSymbol]) {
-      const imp = state.importFile('@travetto/runtime/src/debug').ident;
+      const imp = state.importFile('@travetto/runtime/src/debug.ts').ident;
       state[DebugSymbol] = CoreUtil.createAccess(state.factory, imp, 'tryDebugger');
     }
 

package/support/transformer.dynamic-import.ts

@@ -1,19 +1,12 @@
 import ts from 'typescript';
 
-import { LiteralUtil, OnCall, TransformerState } from '@travetto/transformer';
+import { OnCall, TransformerState } from '@travetto/transformer';
 
 /**
  * Dynamic Import Transformer
  */
 export class DynamicImportTransformer {
 
-  static #rewriteModuleSpecifier(state: TransformerState, spec: ts.LiteralExpression | ts.Expression | undefined): ts.Expression | undefined {
-    if (spec && ts.isStringLiteral(spec) && state.isUntypedImport(spec)) {
-      return LiteralUtil.fromLiteral(state.factory, `${spec.text.replace(/['"]/g, '')}.js`);
-    }
-    return spec;
-  }
-
   @OnCall()
   static onLogCall(state: TransformerState, node: ts.CallExpression): typeof node | ts.Identifier {
     if (
@@ -22,7 +15,7 @@ export class DynamicImportTransformer {
       node.arguments.length &&
       ts.isLiteralExpression(node.arguments[0])
     ) {
-      const lit = this.#rewriteModuleSpecifier(state, node.arguments[0])!;
+      const lit = state.normalizeModuleSpecifier(node.arguments[0])!;
       if (lit !== node.arguments[0]) {
         return state.factory.updateCallExpression(node, node.expression, node.typeArguments, [lit, ...node.arguments.slice(1)]);
       }

package/support/transformer.function-metadata.ts

@@ -1,24 +1,16 @@
 import ts from 'typescript';
 
-import { TransformerState, OnMethod, OnClass, AfterClass, CoreUtil, SystemUtil, Import, OnFunction } from '@travetto/transformer';
+import { TransformerState, OnMethod, OnClass, AfterClass, CoreUtil, OnFunction } from '@travetto/transformer';
 
-import type { FunctionMetadataTag } from '../src/function';
+import type { FunctionMetadataTag } from '../src/function.ts';
+import { MetadataRegistrationUtil } from './transformer/metadata.ts';
 
-const RUNTIME_MOD = '@travetto/runtime';
-const RUNTIME_MOD_SRC = `${RUNTIME_MOD}/src`;
-const REGISTER_IMPORT = `${RUNTIME_MOD_SRC}/function`;
-
-const methods = Symbol.for(`${RUNTIME_MOD}:methods`);
-const cls = Symbol.for(`${RUNTIME_MOD}:class`);
-const fn = Symbol.for(`${RUNTIME_MOD}:function`);
-const registerImport = Symbol.for(`${RUNTIME_MOD}:registerImport`);
-const registerFn = 'registerFunction';
+const MethodsSymbol = Symbol();
+const ClassSymbol = Symbol();
 
 interface MetadataInfo {
-  [registerImport]?: Import;
-  [methods]?: Record<string, FunctionMetadataTag>;
-  [cls]?: FunctionMetadataTag;
-  [fn]?: number;
+  [MethodsSymbol]?: Record<string, FunctionMetadataTag>;
+  [ClassSymbol]?: FunctionMetadataTag;
 }
 
 /**
@@ -26,35 +18,17 @@ interface MetadataInfo {
  */
 export class RegisterTransformer {
 
-  static #tag(state: TransformerState, node: ts.Node): FunctionMetadataTag {
-    const hash = SystemUtil.naiveHash(node.getText());
-    try {
-      const range = CoreUtil.getRangeOf(state.source, node) ?? [0, 0];
-      if (ts.isMethodDeclaration(node) || ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node)) {
-        const bodyStart = CoreUtil.getRangeOf(state.source, node?.body?.statements[0])?.[0];
-        if (bodyStart) {
-          range.push(bodyStart);
-        }
-      }
-      return { hash, lines: range };
-    } catch {
-      return { hash, lines: [0, 0] };
-    }
-  }
-
-  static #valid({ importName: imp }: TransformerState): boolean {
-    return !imp.startsWith(REGISTER_IMPORT);
-  }
-
   /**
    * Hash each class
    */
   @OnClass()
   static collectClassMetadata(state: TransformerState & MetadataInfo, node: ts.ClassDeclaration): ts.ClassDeclaration {
-    if (!this.#valid(state)) {
+    if (!MetadataRegistrationUtil.isValid(state)) {
       return node; // Exclude self
     }
-    state[cls] = this.#tag(state, node);
+
+    state[ClassSymbol] = MetadataRegistrationUtil.tag(state, node);
+    state[MethodsSymbol] = {};
     return node;
   }
 
@@ -63,9 +37,8 @@ export class RegisterTransformer {
    */
   @OnMethod()
   static collectMethodMetadata(state: TransformerState & MetadataInfo, node: ts.MethodDeclaration): ts.MethodDeclaration {
-    if (state[cls] && ts.isIdentifier(node.name) && !CoreUtil.isAbstract(node) && ts.isClassDeclaration(node.parent)) {
-      state[methods] ??= {};
-      state[methods]![node.name.escapedText.toString()] = this.#tag(state, node);
+    if (state[ClassSymbol] && ts.isIdentifier(node.name) && !CoreUtil.isAbstract(node) && ts.isClassDeclaration(node.parent)) {
+      state[MethodsSymbol]![node.name.escapedText.toString()] = MetadataRegistrationUtil.tag(state, node);
     }
     return node;
   }
@@ -75,69 +48,26 @@ export class RegisterTransformer {
    */
   @AfterClass()
   static registerClassMetadata(state: TransformerState & MetadataInfo, node: ts.ClassDeclaration): ts.ClassDeclaration {
-    if (!state[cls]) {
+    if (!state[ClassSymbol]) {
       return node;
     }
 
-    state[registerImport] ??= state.importFile(REGISTER_IMPORT);
-
-    const name = node.name?.escapedText.toString() ?? '';
-
-    const meta = state.factory.createCallExpression(
-      state.createAccess(state[registerImport].ident, registerFn),
-      [],
-      [
-        state.createIdentifier(name),
-        state.getModuleIdentifier(),
-        state.fromLiteral(state[cls]),
-        state.extendObjectLiteral(state[methods] || {}),
-        state.fromLiteral(CoreUtil.isAbstract(node)),
-      ]
-    );
-
-    state[methods] = {};
-    delete state[cls];
-
-    return state.factory.updateClassDeclaration(
-      node,
-      node.modifiers,
-      node.name,
-      node.typeParameters,
-      node.heritageClauses,
-      [
-        state.factory.createClassStaticBlockDeclaration(
-          state.factory.createBlock([
-            state.factory.createExpressionStatement(meta)
-          ])
-        ),
-        ...node.members
-      ]
-    );
+    const { [MethodsSymbol]: m, [ClassSymbol]: c } = state;
+    delete state[ClassSymbol];
+    return MetadataRegistrationUtil.registerClass(state, node, c!, m);
   }
 
   /**
-   * Give proper functions a file name
+   * Register proper functions
    */
   @OnFunction()
   static registerFunctionMetadata(state: TransformerState & MetadataInfo, node: ts.FunctionDeclaration | ts.FunctionExpression): typeof node {
-    if (!this.#valid(state)) {
+    if (!MetadataRegistrationUtil.isValid(state) || !ts.isFunctionDeclaration(node)) {
       return node;
     }
 
-    if (ts.isFunctionDeclaration(node) && node.name && node.parent && ts.isSourceFile(node.parent)) {
-      // If we have a class like function
-      state[registerImport] ??= state.importFile(REGISTER_IMPORT);
-      const tag = this.#tag(state, node);
-      const meta = state.factory.createCallExpression(
-        state.createAccess(state[registerImport].ident, registerFn),
-        [],
-        [
-          state.createIdentifier(node.name),
-          state.getModuleIdentifier(),
-          state.fromLiteral(tag),
-        ]
-      );
-      state.addStatements([state.factory.createExpressionStatement(meta)]);
+    if (node.name && node.parent && ts.isSourceFile(node.parent)) {
+      MetadataRegistrationUtil.registerFunction(state, node);
     }
     return node;
   }

package/support/transformer.rewrite-path-import.ts

@@ -3,7 +3,7 @@ import ts from 'typescript';
 import { TransformerState, OnFile } from '@travetto/transformer';
 
 const PATH_REGEX = /^['"](node:)?path['"]$/;
-const PATH_TARGET = '@travetto/manifest/src/path';
+const PATH_IMPORT = '@travetto/manifest/src/path.ts';
 
 /**
  * Rewriting path imports to use manifest's path
@@ -22,7 +22,7 @@ export class PathImportTransformer {
         stmt,
         stmt.modifiers,
         stmt.importClause,
-        state.factory.createStringLiteral(PATH_TARGET),
+        state.factory.createStringLiteral(PATH_IMPORT),
         stmt.attributes
       );
       return state.factory.updateSourceFile(node, node.statements.map(x =>

package/support/transformer.type-helpers.ts

@@ -1,25 +0,0 @@
-import ts from 'typescript';
-
-import { TransformerState, OnCall } from '@travetto/transformer';
-
-const SRC = '@travetto/runtime/src/types.ts';
-
-/**
- * Allows for removal of type helpers at compile time
- */
-export class TypeHelpersTransformer {
-  @OnCall()
-  static onTypeHelper(state: TransformerState, node: ts.CallExpression): ts.Node {
-    if (
-      ts.isIdentifier(node.expression) &&
-      node.arguments.length === 1 &&
-      /as(Class|Constructable|Full)|cast(To|Key)/.test(node.expression.escapedText.toString())
-    ) {
-      const type = state.resolveType(node.expression);
-      if (type.key === 'unknown' && 'importName' in type && type.importName === SRC) {
-        // return node.arguments[0];
-      }
-    }
-    return node;
-  }
-}