@travetto/runtime 8.0.0-alpha.9 → 8.0.0

package/README.md

@@ -13,7 +13,7 @@ npm install @travetto/runtime
 yarn add @travetto/runtime
 ```
 
-Runtime is the foundation of all [Travetto](https://travetto.dev) applications.  It is intended to be a minimal application set, as well as support for commonly shared functionality. It has support for the following key areas:
+Runtime is the foundation of all [Travetto](https://travetto.dev) applications. It is intended to be a minimal application set, as well as support for commonly shared functionality. It has support for the following key areas:
    *  Runtime Context
    *  Environment Support
    *  Standard Error Support
@@ -29,7 +29,7 @@ Runtime is the foundation of all [Travetto](https://travetto.dev) applications.
    *  Path behavior
 
 ## Runtime Context
-While running any code within the framework, there are common patterns/goals for interacting with the underlying code repository.  These include:
+While running any code within the framework, there are common patterns/goals for interacting with the underlying code repository. These include:
    *  Determining attributes of the running environment (e.g., name, debug information, production flags)
    *  Resolving paths within the workspace (e.g. standard, tooling, resourcing, modules)
 
@@ -75,10 +75,10 @@ class $Runtime {
 ```
 
 ### Class and Function Metadata
-For the framework to work properly, metadata needs to be collected about files, classes and functions to uniquely identify them, with support for detecting changes during live reloads.  To achieve this, every `class` is decorated with metadata, including methods, line numbers, and ultimately a unique id stored at `Ⲑid`.
+For the framework to work properly, metadata needs to be collected about files, classes and functions to uniquely identify them, with support for detecting changes during live reloads. To achieve this, every `class` is decorated with metadata, including methods, line numbers, and ultimately a unique id stored at `Ⲑid`.
 
 ## Environment Support
-The functionality we support for testing and retrieving environment information for known environment variables. They can be accessed directly on the [Env](https://github.com/travetto/travetto/tree/main/module/runtime/src/env.ts#L114) object, and will return a scoped [EnvProp](https://github.com/travetto/travetto/tree/main/module/runtime/src/env.ts#L8), that is compatible with the property definition.  E.g. only showing boolean related fields when the underlying flag supports `true` or `false`
+The functionality we support for testing and retrieving environment information for known environment variables. They can be accessed directly on the [Env](https://github.com/travetto/travetto/tree/main/module/runtime/src/env.ts#L134) object, and will return a scoped [EnvProp](https://github.com/travetto/travetto/tree/main/module/runtime/src/env.ts#L8), that is compatible with the property definition. E.g. only showing boolean related fields when the underlying flag supports `true` or `false`
 
 **Code: Base Known Environment Flags**
 ```typescript
@@ -138,7 +138,9 @@ For a given [EnvProp](https://github.com/travetto/travetto/tree/main/module/runt
 ```typescript
 export class EnvProp<T> {
   readonly key: string;
-  constructor(key: string) { this.key = key; }
+  constructor(key: string);
+  /** Set value according to type */
+  set(value: T | undefined | null): void;
   /** Remove value */
   clear(): void;
   /** Export value */
@@ -165,9 +167,9 @@ 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 [RuntimeError](https://github.com/travetto/travetto/tree/main/module/runtime/src/error.ts#L17) (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 support for creating Web Applications") 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 [RuntimeError](https://github.com/travetto/travetto/tree/main/module/runtime/src/error.ts#L10) (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 support for creating Web Applications") module and HTTP status codes). 
 
-The [RuntimeError](https://github.com/travetto/travetto/tree/main/module/runtime/src/error.ts#L17) takes in a message, and an optional payload and / or error classification. The currently supported error classifications are:
+The [RuntimeError](https://github.com/travetto/travetto/tree/main/module/runtime/src/error.ts#L10) takes in a message, and an optional payload and / or error classification. The currently supported error classifications are:
    *  `general` - General purpose errors
    *  `system` - Synonym for `general`
    *  `data` - Data format, content, etc are incorrect. Generally correlated to bad input.
@@ -190,7 +192,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#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). 
+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#L44). This module, hooks into the [ConsoleManager](https://github.com/travetto/travetto/tree/main/module/runtime/src/console.ts#L44) and receives all logging events from all files compiled by the [Travetto](https://travetto.dev). 
 
 A sample of the instrumentation would be:
 
@@ -227,7 +229,7 @@ export function work() {
 ```
 
 #### Filtering Debug
-The `debug` messages can be filtered using the patterns from the [debug](https://www.npmjs.com/package/debug).  You can specify wild cards to only `DEBUG` specific modules, folders or files.  You can specify multiple, and you can also add negations to exclude specific packages.
+The `debug` messages can be filtered using the patterns from the [debug](https://www.npmjs.com/package/debug). You can specify wild cards to only `DEBUG` specific modules, folders or files. You can specify multiple, and you can also add negations to exclude specific packages.
 
 **Terminal: Sample environment flags**
 ```bash
@@ -251,9 +253,9 @@ $ DEBUG=express:*,@travetto/web npx trv run web
 ## Resource Access
 The primary access patterns for resources, is to directly request a file, and to resolve that file either via file-system look up or leveraging the [Manifest](https://github.com/travetto/travetto/tree/main/module/manifest#readme "Support for project indexing, manifesting, along with file watching")'s data for what resources were found at manifesting time.
 
-The [FileLoader](https://github.com/travetto/travetto/tree/main/module/runtime/src/file-loader.ts#L11) allows for accessing information about the resources, and subsequently reading the file as text/binary or to access the resource as a `Readable` stream.  If a file is not found, it will throw an [RuntimeError](https://github.com/travetto/travetto/tree/main/module/runtime/src/error.ts#L17) with a category of 'notfound'.  
+The [FileLoader](https://github.com/travetto/travetto/tree/main/module/runtime/src/file-loader.ts#L11) allows for accessing information about the resources, and subsequently reading the file as text/binary or to access the resource as a `Readable` stream. If a file is not found, it will throw an [RuntimeError](https://github.com/travetto/travetto/tree/main/module/runtime/src/error.ts#L10) with a category of 'notfound'. 
 
-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.
+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#L134)'s `TRV_RESOURCES` information on where to attempt to find a requested resource.
 
 ## Encoding and Decoding Utilities
 The [CodecUtil](https://github.com/travetto/travetto/tree/main/module/runtime/src/codec.ts#L15) class provides a variety of static methods for encoding and decoding data. When working with JSON data, it also provide security checks to prevent prototype pollution. The utility supports the following formats:
@@ -265,12 +267,12 @@ The [CodecUtil](https://github.com/travetto/travetto/tree/main/module/runtime/sr
    *  New Line Delimited UTF8
 
 ## Common Utilities
-Common utilities used throughout the framework. Currently [Util](https://github.com/travetto/travetto/tree/main/module/runtime/src/util.ts#L14) includes:
+Common utilities used throughout the framework. Currently [Util](https://github.com/travetto/travetto/tree/main/module/runtime/src/util.ts#L16) 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 '!'.
+   *  `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.
-   *  `resolvablePromise()` produces a `Promise` instance with the `resolve` and `reject` methods attached to the instance.  This is extremely useful for integrating promises into async iterations, or any other situation in which the promise creation and the execution flow don't always match up.
-   *  `bufferedFileWrite(file:string, content: string)` will write the file, using a temporary buffer file to ensure that the entire file is written before being moved to the final location.  This helps minimize file watch noise when writing files.
+   *  `resolvablePromise()` produces a `Promise` instance with the `resolve` and `reject` methods attached to the instance. This is extremely useful for integrating promises into async iterations, or any other situation in which the promise creation and the execution flow don't always match up.
+   *  `bufferedFileWrite(file:string, content: string)` will write the file, using a temporary buffer file to ensure that the entire file is written before being moved to the final location. This helps minimize file watch noise when writing files.
 
 **Code: Sample makeTemplate Usage**
 ```typescript
@@ -281,10 +283,10 @@ tpl`{{age:20}} {{name: 'bob'}}</>;
 ```
 
 ## Binary Utilities
-The [BinaryUtil](https://github.com/travetto/travetto/tree/main/module/runtime/src/binary.ts#L59) class provides a unified interface for working with binary data across different formats, especially bridging the gap between Node.js specific types (`Buffer`, `Stream`) and Web Standard types (`Blob`, `ArrayBuffer`). The framework leverages this to allow for seamless handling of binary data, regardless of the source.
+The [BinaryUtil](https://github.com/travetto/travetto/tree/main/module/runtime/src/binary.ts#L68) class provides a unified interface for working with binary data across different formats, especially bridging the gap between Node.js specific types (`Buffer`, `Stream`) and Web Standard types (`Blob`, `ArrayBuffer`). The framework leverages this to allow for seamless handling of binary data, regardless of the source.
 
 ## JSON Utilities
-The [JSONUtil](https://github.com/travetto/travetto/tree/main/module/runtime/src/json.ts#L33) class provides a comprehensive set of utilities for working with JSON data, including serialization, deserialization, encoding, and deep cloning capabilities. The utility handles special types like `Date`, `BigInt`, and `Error` objects seamlessly. Key features include:
+The [JSONUtil](https://github.com/travetto/travetto/tree/main/module/runtime/src/json.ts#L39) class provides a comprehensive set of utilities for working with JSON data, including serialization, deserialization, encoding, and deep cloning capabilities. The utility handles special types like `Date`, `BigInt`, and `Error` objects seamlessly. Key features include:
    *  `fromUTF8(input, config?)` - Parse JSON from a UTF-8 string
    *  `toUTF8(value, config?)` - Serialize a value to JSON string
    *  `toUTF8Pretty(value)` - Serialize with pretty formatting (2-space indent)
@@ -299,7 +301,7 @@ The [JSONUtil](https://github.com/travetto/travetto/tree/main/module/runtime/src
 The `TRANSMIT_REVIVER` automatically restores `Date` objects and `BigInt` values during deserialization, making it ideal for transmitting complex data structures across network boundaries.
 
 ## Time Utilities
-[TimeUtil](https://github.com/travetto/travetto/tree/main/module/runtime/src/time.ts#L21) contains general helper methods, created to assist with time-based inputs via environment variables, command line interfaces, and other string-heavy based input.
+[TimeUtil](https://github.com/travetto/travetto/tree/main/module/runtime/src/time.ts#L37) contains general helper methods, created to assist with time-based inputs via environment variables, command line interfaces, and other string-heavy based input.
 
 **Code: Time Utilities**
 ```typescript
@@ -324,13 +326,14 @@ export class TimeUtil {
 ```
 
 ## Process Execution
-[ExecUtil](https://github.com/travetto/travetto/tree/main/module/runtime/src/exec.ts#L41) exposes `getResult` as a means to wrap [child_process](https://nodejs.org/api/child_process.html)'s process object.  This wrapper allows for a promise-based resolution of the subprocess with the ability to capture the stderr/stdout.
+[ExecUtil](https://github.com/travetto/travetto/tree/main/module/runtime/src/exec.ts#L41) exposes `getResult` as a means to wrap [child_process](https://nodejs.org/api/child_process.html)'s process object. This wrapper allows for a promise-based resolution of the subprocess with the ability to capture the stderr/stdout.
 
 A simple example would be:
 
 **Code: Running a directory listing via ls**
 ```typescript
 import { spawn } from 'node:child_process';
+
 import { ExecUtil } from '@travetto/runtime';
 
 export async function executeListing() {
@@ -357,4 +360,4 @@ export function registerShutdownHandler() {
 ```
 
 ## Path Behavior
-To ensure consistency in path usage throughout the framework, imports pointing at `node:path` and `path` are rewritten at compile time.  These imports are pointing towards [Manifest](https://github.com/travetto/travetto/tree/main/module/manifest#readme "Support for project indexing, manifesting, along with file watching")'s `path`  implementation.  This allows for seamless import/usage patterns with the reliability needed for cross platform support.
+To ensure consistency in path usage throughout the framework, imports pointing at `node:path` and `path` are rewritten at compile time. These imports are pointing towards [Manifest](https://github.com/travetto/travetto/tree/main/module/manifest#readme "Support for project indexing, manifesting, along with file watching")'s `path` implementation. This allows for seamless import/usage patterns with the reliability needed for cross platform support.

package/__index__.ts

@@ -1,14 +1,15 @@
-import type { } from './src/global.d.ts';
-import type { } from './src/trv.d.ts';
+import type {} from './src/global.d.ts';
+import type {} from './src/trv.d.ts';
+
 export * from './src/binary.ts';
 export * from './src/binary-metadata.ts';
+export * from './src/codec.ts';
 export * from './src/console.ts';
 export * from './src/context.ts';
 export * from './src/debug.ts';
+export * from './src/env.ts';
 export * from './src/error.ts';
 export * from './src/exec.ts';
-export * from './src/codec.ts';
-export * from './src/env.ts';
 export * from './src/file-loader.ts';
 export * from './src/function.ts';
 export * from './src/json.ts';
@@ -18,5 +19,5 @@ 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';
+export * from './src/watch.ts';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@travetto/runtime",
-  "version": "8.0.0-alpha.9",
-  "type": "module",
+  "version": "8.0.0",
+  "private": false,
   "description": "Runtime for travetto applications.",
   "keywords": [
     "console-manager",
@@ -12,38 +12,41 @@
   "homepage": "https://travetto.io",
   "license": "MIT",
   "author": {
-    "email": "travetto.framework@gmail.com",
-    "name": "Travetto Framework"
+    "name": "Travetto Framework",
+    "email": "travetto.framework@gmail.com"
+  },
+  "repository": {
+    "url": "git+https://github.com/travetto/travetto.git",
+    "directory": "module/runtime"
   },
   "files": [
     "__index__.ts",
     "src",
     "support"
   ],
+  "type": "module",
   "main": "__index__.ts",
-  "repository": {
-    "url": "git+https://github.com/travetto/travetto.git",
-    "directory": "module/runtime"
+  "publishConfig": {
+    "access": "public"
   },
   "dependencies": {
-    "@travetto/manifest": "^8.0.0-alpha.4",
+    "@travetto/manifest": "^8.0.0",
     "@types/debug": "^4.1.13",
-    "debug": "^4.4.3",
-    "temporal-polyfill-lite": "^0.3.2"
+    "debug": "^4.4.3"
   },
   "peerDependencies": {
-    "@travetto/transformer": "^8.0.0-alpha.4"
+    "@travetto/transformer": "^8.0.0",
+    "temporal-polyfill-lite": "^0.4.0"
   },
   "peerDependenciesMeta": {
     "@travetto/transformer": {
       "optional": true
+    },
+    "temporal-polyfill-lite": {
+      "optional": true
     }
   },
   "travetto": {
     "displayName": "Runtime"
-  },
-  "private": false,
-  "publishConfig": {
-    "access": "public"
   }
 }

package/src/binary-metadata.ts

@@ -1,16 +1,16 @@
 import crypto from 'node:crypto';
+import { createReadStream, ReadStream } from 'node:fs';
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import { createReadStream, ReadStream } from 'node:fs';
 
-import { BinaryUtil, type BinaryArray, type BinaryContainer, type BinaryStream, type BinaryType } from './binary.ts';
-import { RuntimeError } from './error.ts';
+import { type BinaryArray, type BinaryContainer, type BinaryStream, type BinaryType, BinaryUtil } from './binary.ts';
 import { CodecUtil } from './codec.ts';
+import { RuntimeError } from './error.ts';
 
-type BlobInput = BinaryType | (() => (BinaryType | Promise<BinaryType>));
+type BlobInput = BinaryType | (() => BinaryType | Promise<BinaryType>);
 
 /** Range of bytes, inclusive */
-export type ByteRange = { start: number, end?: number };
+export type ByteRange = { start: number; end?: number };
 
 export interface BinaryMetadata {
   /** Size of binary data */
@@ -45,7 +45,7 @@ export class BinaryMetadataUtil {
   /** Set metadata for a binary type  */
   static write(input: BinaryType, metadata: BinaryMetadata): BinaryMetadata {
     const withMeta: BinaryType & { [BinaryMetaSymbol]?: BinaryMetadata } = input;
-    return withMeta[BinaryMetaSymbol] = metadata;
+    return (withMeta[BinaryMetaSymbol] = metadata);
   }
 
   /** Read metadata for a binary type, if available  */
@@ -75,15 +75,13 @@ export class BinaryMetadataUtil {
       hash.update(BinaryUtil.binaryArrayToUint8Array(input));
       return hash.digest(outputEncoding).substring(0, length);
     } else {
-      return BinaryUtil.pipeline(input, hash).then(() =>
-        hash.digest(outputEncoding).substring(0, length)
-      );
+      return BinaryUtil.pipeline(input, hash).then(() => hash.digest(outputEncoding).substring(0, length));
     }
   }
 
   /** Compute the length of the binary data to be returned */
   static readLength(metadata: BinaryMetadata): number | undefined {
-    return metadata.range ? (metadata.range.end - metadata.range.start + 1) : metadata.size;
+    return metadata.range ? metadata.range.end - metadata.range.start + 1 : metadata.size;
   }
 
   /** Compute metadata for a given binary input */
@@ -119,13 +117,25 @@ export class BinaryMetadataUtil {
    * Rewrite a blob to support metadata, and provide a dynamic input source
    */
   static defineBlob<T extends Blob>(target: T, input: BlobInput, metadata: BinaryMetadata = {}): typeof target {
-    const inputFn = async (): Promise<BinaryType> => typeof input === 'function' ? await input() : input;
+    const inputFn = async (): Promise<BinaryType> => (typeof input === 'function' ? await input() : input);
     this.write(target, metadata);
 
     Object.defineProperties(target, {
-      size: { get() { return BinaryMetadataUtil.readLength(metadata); } },
-      type: { get() { return metadata.contentType; } },
-      name: { get() { return metadata.filename; } },
+      size: {
+        get() {
+          return BinaryMetadataUtil.readLength(metadata);
+        }
+      },
+      type: {
+        get() {
+          return metadata.contentType;
+        }
+      },
+      name: {
+        get() {
+          return metadata.filename;
+        }
+      },
       arrayBuffer: { value: () => inputFn().then(BinaryUtil.toArrayBuffer) },
       stream: { value: () => BinaryUtil.toReadableStream(BinaryUtil.toSynchronous(input)) },
       bytes: { value: () => inputFn().then(BinaryUtil.toBuffer) },
@@ -133,11 +143,15 @@ export class BinaryMetadataUtil {
       slice: {
         value: (start?: number, end?: number, _contentType?: string) => {
           const result = target instanceof File ? new File([], '') : new Blob([]);
-          return BinaryMetadataUtil.defineBlob(result,
-            () => inputFn().then(BinaryUtil.toBinaryArray).then(data => BinaryUtil.sliceByteArray(data, start, end)),
+          return BinaryMetadataUtil.defineBlob(
+            result,
+            () =>
+              inputFn()
+                .then(BinaryUtil.toBinaryArray)
+                .then(data => BinaryUtil.sliceByteArray(data, start, end)),
             {
               ...metadata,
-              range: { start: start ?? 0, end: end ?? metadata.size! - 1 },
+              range: { start: start ?? 0, end: end ?? metadata.size! - 1 }
             }
           );
         }
@@ -163,7 +177,7 @@ export class BinaryMetadataUtil {
     const size = metadata.size;
 
     // End is inclusive
-    const [start, end] = [range.start, Math.min(range.end ?? (size - 1), size - 1)];
+    const [start, end] = [range.start, Math.min(range.end ?? size - 1, size - 1)];
 
     if (Number.isNaN(start) || Number.isNaN(end) || !Number.isFinite(start) || start >= size || start < 0 || start > end) {
       throw new RuntimeError('Invalid position, out of range', { category: 'data', details: { start, end, size } });
@@ -171,4 +185,4 @@ export class BinaryMetadataUtil {
 
     return { start, end };
   }
-}
+}

package/src/binary.ts

@@ -1,8 +1,8 @@
 import { PassThrough, Readable, type Writable } from 'node:stream';
+import consumers from 'node:stream/consumers';
 import { pipeline } from 'node:stream/promises';
 import { ReadableStream } from 'node:stream/web';
-import consumers from 'node:stream/consumers';
-import { isArrayBuffer, isPromise, isTypedArray, isUint16Array, isUint32Array, isUint8Array, isUint8ClampedArray } from 'node:util/types';
+import { isArrayBuffer, isPromise, isTypedArray, isUint8Array, isUint8ClampedArray, isUint16Array, isUint32Array } from 'node:util/types';
 
 import { castTo, hasFunction, toConcrete } from './types.ts';
 
@@ -28,8 +28,16 @@ export type BinaryContainer = Blob | File;
 export type BinaryType = BinaryArray | BinaryStream | BinaryContainer;
 
 const BINARY_CONSTRUCTOR_SET = new Set<unknown>([
-  Readable, Buffer, Blob, ReadableStream, ArrayBuffer, Uint8Array,
-  Uint16Array, Uint32Array, Uint8ClampedArray, File
+  Readable,
+  Buffer,
+  Blob,
+  ReadableStream,
+  ArrayBuffer,
+  Uint8Array,
+  Uint16Array,
+  Uint32Array,
+  Uint8ClampedArray,
+  File
 ]);
 
 let BINARY_REFS: Set<unknown> | undefined;
@@ -40,7 +48,7 @@ const isBinaryTypeReference = (value: unknown): boolean =>
     toConcrete<BinaryType>(),
     toConcrete<BinaryStream>(),
     toConcrete<BinaryArray>(),
-    toConcrete<BinaryContainer>(),
+    toConcrete<BinaryContainer>()
   ])).has(value);
 
 const isReadable = hasFunction<Readable>('pipe');
@@ -51,13 +59,13 @@ const isBinaryArray = (value: unknown): value is BinaryArray =>
   isUint8Array(value) || isArrayBuffer(value) || isUint16Array(value) || isUint32Array(value) || isUint8ClampedArray(value);
 const isBinaryStream = (value: unknown): value is BinaryStream => isReadable(value) || isReadableStream(value) || isAsyncIterable(value);
 const isBinaryContainer = (value: unknown): value is BinaryContainer => value instanceof Blob;
-const isBinaryType = (value: unknown): value is BinaryType => !!value && (isBinaryArray(value) || isBinaryStream(value) || isBinaryContainer(value));
+const isBinaryType = (value: unknown): value is BinaryType =>
+  !!value && (isBinaryArray(value) || isBinaryStream(value) || isBinaryContainer(value));
 
 /**
  * Common functions for dealing with binary data/streams
  */
 export class BinaryUtil {
-
   /** Is the input a byte array */
   static isBinaryArray = isBinaryArray;
   /** Is the input a byte stream */
@@ -180,8 +188,8 @@ export class BinaryUtil {
   /**
    * Convert an inbound binary type or factory into a synchronous binary type
    */
-  static toSynchronous(input: BinaryType | (() => (BinaryType | Promise<BinaryType>))): BinaryType {
-    const value = (typeof input === 'function') ? input() : input;
+  static toSynchronous(input: BinaryType | (() => BinaryType | Promise<BinaryType>)): BinaryType {
+    const value = typeof input === 'function' ? input() : input;
     if (isPromise(value)) {
       const stream = new PassThrough();
       value.then(result => BinaryUtil.pipeline(result, stream)).catch(error => stream.destroy(error));
@@ -190,4 +198,4 @@ export class BinaryUtil {
       return value;
     }
   }
-}
+}

package/src/codec.ts

@@ -1,8 +1,8 @@
 import { createInterface } from 'node:readline/promises';
 
-import { BinaryUtil, type BinaryArray, type BinaryType } from './binary.ts';
+import { type BinaryArray, type BinaryType, BinaryUtil } from './binary.ts';
 import { RuntimeError } from './error.ts';
-import { castTo, type Any } from './types.ts';
+import { type Any, castTo } from './types.ts';
 
 type TextInput = string | BinaryArray;
 
@@ -13,7 +13,6 @@ const UTF8_ENCODER = new TextEncoder();
  * Utilities for encoding and decoding common formats
  */
 export class CodecUtil {
-
   /** Generate buffer from hex string  */
   static fromHexString(value: string): BinaryArray {
     try {
@@ -85,7 +84,10 @@ export class CodecUtil {
   /** Consume lines  */
   static async readLines(stream: BinaryType, handler: (input: string) => unknown | Promise<unknown>): Promise<void> {
     for await (const item of createInterface(BinaryUtil.toReadable(stream))) {
-      await handler(item);
+      const result = await handler(item);
+      if (result === false) {
+        break;
+      }
     }
   }
 
@@ -99,7 +101,23 @@ export class CodecUtil {
     if (!encoding) {
       return this.readUtf8Chunk(chunk);
     }
-    return BinaryUtil.isBinaryArray(chunk) ? chunk :
-      Buffer.from(typeof chunk === 'string' ? chunk : `${chunk}`, castTo(encoding ?? 'utf8'));
+    return BinaryUtil.isBinaryArray(chunk)
+      ? chunk
+      : Buffer.from(typeof chunk === 'string' ? chunk : `${chunk}`, castTo(encoding ?? 'utf8'));
+  }
+
+  static readFirstLine(data: string): string;
+  static readFirstLine(data: string | undefined, defaultValue: string): string;
+  static readFirstLine(data: string | undefined, defaultValue: string = ''): string {
+    if (typeof data === 'undefined') {
+      return defaultValue;
+    } else {
+      const end = data.indexOf('\n');
+      if (end === -1) {
+        return data.trim();
+      } else {
+        return data.substring(0, end).trim();
+      }
+    }
   }
-}
+}

package/src/console.ts

@@ -1,4 +1,5 @@
 import util from 'node:util';
+
 import debug from 'debug';
 
 import { RuntimeIndex } from './manifest-index.ts';
@@ -21,7 +22,7 @@ export interface ConsoleEvent {
   scope?: string;
   /** Arguments passed to the console call*/
   args: unknown[];
-};
+}
 
 /**
  * @concrete
@@ -41,7 +42,6 @@ const DEBUG_HANDLE = { formatArgs: debug.formatArgs, log: debug.log };
  * @alias ConsoleManager
  */
 class $ConsoleManager implements ConsoleListener {
-
   /**
    * The current listener
    */
@@ -84,10 +84,15 @@ class $ConsoleManager implements ConsoleListener {
         args.unshift(this.namespace);
         args.push(debug.humanize(this.diff));
       };
-      debug.log = (modulePath, ...args: string[]): void => this.log({
-        level: 'debug', module: '@npm:debug', modulePath,
-        args: [util.format(...args)], line: 0, timestamp: new Date()
-      });
+      debug.log = (modulePath, ...args: string[]): void =>
+        this.log({
+          level: 'debug',
+          module: '@npm:debug',
+          modulePath,
+          args: [util.format(...args)],
+          line: 0,
+          timestamp: new Date()
+        });
     } else {
       debug.formatArgs = DEBUG_HANDLE.formatArgs;
       debug.log = DEBUG_HANDLE.log;
@@ -118,10 +123,9 @@ class $ConsoleManager implements ConsoleListener {
       modulePath: event.modulePath ?? event.import?.[1]
     };
 
-    if (this.#filters[result.level] && !this.#filters[result.level]!(result)) {
-      return; // Do nothing
-    } else {
-      return this.#listener.log(result);
+    const filter = this.#filters[result.level];
+    if (!filter || filter(result)) {
+      this.#listener.log(result);
     }
   }
 
@@ -140,5 +144,9 @@ class $ConsoleManager implements ConsoleListener {
   }
 }
 
-export const ConsoleManager = new $ConsoleManager({ log(event): void { console![event.level](...event.args); } });
-export const log = ConsoleManager.log.bind(ConsoleManager);
+export const ConsoleManager = new $ConsoleManager({
+  log(event): void {
+    console![event.level](...event.args);
+  }
+});
+export const log = ConsoleManager.log.bind(ConsoleManager);

package/src/context.ts

@@ -1,17 +1,16 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 
-import { type ManifestIndex, type ManifestContext, ManifestModuleUtil } from '@travetto/manifest';
+import { type ManifestContext, type ManifestIndex, ManifestModuleUtil } from '@travetto/manifest';
 
 import { Env } from './env.ts';
-import { RuntimeIndex } from './manifest-index.ts';
 import { describeFunction } from './function.ts';
-import type { Role } from './trv';
 import { JSONUtil } from './json.ts';
+import { RuntimeIndex } from './manifest-index.ts';
+import type { Role } from './trv.ts';
 
 /** Constrained version of {@type ManifestContext} */
 class $Runtime {
-
   #idx: ManifestIndex;
   #resourceOverrides?: Record<string, string>;
 
@@ -23,14 +22,13 @@ class $Runtime {
   get #moduleAliases(): Record<string, string> {
     return {
       '@': this.#idx.mainModule.sourcePath,
-      '@@': this.#idx.manifest.workspace.path,
+      '@@': this.#idx.manifest.workspace.path
     };
   }
 
   /** The role we are running as */
   get role(): Role {
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    return Env.TRV_ROLE.value as Role ?? 'std';
+    return (Env.TRV_ROLE.value as Role) ?? 'std';
   }
 
   /** Are we in production mode */
@@ -45,7 +43,7 @@ class $Runtime {
 
   /** Get debug value */
   get debug(): false | string {
-    return Env.DEBUG.isFalse ? false : (Env.DEBUG.value || false);
+    return Env.DEBUG.isFalse ? false : Env.DEBUG.value || false;
   }
 
   /** Manifest main */
@@ -80,7 +78,7 @@ class $Runtime {
 
   /** Produce a workspace path for tooling, with '@' being replaced by node_module/name folder */
   toolPath(...parts: string[]): string {
-    parts = parts.flatMap(part => part === '@' ? ['node_modules', this.#idx.manifest.main.name] : [part]);
+    parts = parts.flatMap(part => (part === '@' ? ['node_modules', this.#idx.manifest.main.name] : [part]));
     return path.resolve(this.workspace.path, this.#idx.manifest.build.toolFolder, ...parts);
   }
 
@@ -95,12 +93,14 @@ class $Runtime {
 
   /** Resolve resource paths */
   resourcePaths(paths: string[] = []): string[] {
-    return [...new Set([...paths, ...Env.TRV_RESOURCES.list ?? [], '@#resources', '@@#resources'].map(module => this.modulePath(module)))];
+    return [
+      ...new Set([...paths, ...(Env.TRV_RESOURCES.list ?? []), '@#resources', '@@#resources'].map(module => this.modulePath(module)))
+    ];
   }
 
   /** Get source for function */
   getSourceFile(handle: Function): string {
-    return this.#idx.getFromImport(this.getImport(handle))?.sourceFile!;
+    return this.#idx.getFromImport(this.getImport(handle))?.sourceFile ?? undefined!;
   }
 
   /** Get import for function */
@@ -146,11 +146,14 @@ class $Runtime {
       }
     }
     switch (this.workspace.manager) {
-      case 'npm': return `npm install ${production ? '' : '--save-dev '}${pkg}`;
-      case 'yarn': return `yarn add ${production ? '' : '--dev '}${pkg}`;
-      case 'pnpm': return `pnpm add ${production ? '' : '--dev '}${pkg}`;
+      case 'npm':
+        return `npm install ${production ? '' : '--save-dev '}${pkg}`;
+      case 'yarn':
+        return `yarn add ${production ? '' : '--dev '}${pkg}`;
+      case 'pnpm':
+        return `pnpm add ${production ? '' : '--dev '}${pkg}`;
     }
   }
 }
 
-export const Runtime = new $Runtime(RuntimeIndex, Env.TRV_RESOURCE_OVERRIDES.object);
+export const Runtime = new $Runtime(RuntimeIndex, Env.TRV_RESOURCE_OVERRIDES.object);