@travetto/runtime 8.0.0-alpha.1 → 8.0.0-alpha.10

package/README.md

@@ -70,7 +70,7 @@ class $Runtime {
   /** Import from a given path */
   async importFrom<T = unknown>(location?: string): Promise<T>;
   /** Get an install command for a given npm module */
-  getInstallCommand(pkg: string, production = false): string;
+  getInstallCommand(pkg: string, production?: boolean): string;
 }
 ```
 
@@ -284,7 +284,7 @@ tpl`{{age:20}} {{name: 'bob'}}</>;
 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.
 
 ## JSON Utilities
-The [JSONUtil](https://github.com/travetto/travetto/tree/main/module/runtime/src/json.ts#L31) 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#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:
    *  `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)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/runtime",
-  "version": "8.0.0-alpha.1",
+  "version": "8.0.0-alpha.10",
   "type": "module",
   "description": "Runtime for travetto applications.",
   "keywords": [
@@ -26,13 +26,13 @@
     "directory": "module/runtime"
   },
   "dependencies": {
-    "@travetto/manifest": "^8.0.0-alpha.1",
-    "@types/debug": "^4.1.12",
+    "@travetto/manifest": "^8.0.0-alpha.4",
+    "@types/debug": "^4.1.13",
     "debug": "^4.4.3",
-    "temporal-polyfill-lite": "^0.2.3"
+    "temporal-polyfill-lite": "^0.3.3"
   },
   "peerDependencies": {
-    "@travetto/transformer": "^8.0.0-alpha.1"
+    "@travetto/transformer": "^8.0.0-alpha.5"
   },
   "peerDependenciesMeta": {
     "@travetto/transformer": {

package/src/context.ts

@@ -6,7 +6,7 @@ import { type ManifestIndex, type ManifestContext, ManifestModuleUtil } from '@t
 import { Env } from './env.ts';
 import { RuntimeIndex } from './manifest-index.ts';
 import { describeFunction } from './function.ts';
-import type { Role } from './trv';
+import type { Role } from './trv.ts';
 import { JSONUtil } from './json.ts';
 
 /** Constrained version of {@type ManifestContext} */
@@ -111,7 +111,7 @@ class $Runtime {
   /** Import from a given path */
   async importFrom<T = unknown>(location?: string): Promise<T> {
     const file = path.resolve(this.#idx.mainModule.sourcePath, location!);
-    if (await fs.stat(file).catch(() => false)) {
+    if (await fs.stat(file, { throwIfNoEntry: false })) {
       location = this.#idx.getFromSource(file)?.import;
     }
 
@@ -138,7 +138,13 @@ class $Runtime {
   }
 
   /** Get an install command for a given npm module */
-  getInstallCommand(pkg: string, production = false): string {
+  getInstallCommand(pkg: string, production?: boolean): string {
+    if (production === undefined) {
+      const module = RuntimeIndex.getModule(pkg);
+      if (module !== undefined) {
+        production = module.production;
+      }
+    }
     switch (this.workspace.manager) {
       case 'npm': return `npm install ${production ? '' : '--save-dev '}${pkg}`;
       case 'yarn': return `yarn add ${production ? '' : '--dev '}${pkg}`;

package/src/env.ts

@@ -90,7 +90,7 @@ export class EnvProp<T> {
   }
 }
 
-type AllType = {
+type EnvDataCombinedType = {
   [K in keyof EnvData]: Pick<EnvProp<EnvData[K]>, 'key' | 'export' | 'value' | 'set' | 'clear' | 'isSet' |
     (EnvData[K] extends unknown[] ? 'list' | 'add' : never) |
     (Extract<EnvData[K], object> extends never ? never : 'object') |
@@ -99,7 +99,7 @@ type AllType = {
   >
 };
 
-function delegate<T extends object>(base: T): AllType & T {
+function delegate<T extends object>(base: T): EnvDataCombinedType & T {
   return new Proxy(castTo(base), {
     get(target, property): unknown {
       return typeof property !== 'string' ? undefined :

package/src/file-loader.ts

@@ -30,7 +30,7 @@ export class FileLoader {
   async resolve(relativePath: string): Promise<string> {
     for (const sub of this.searchPaths) {
       const resolved = path.join(sub, relativePath);
-      if (await fs.stat(resolved).catch(() => false)) {
+      if (await fs.stat(resolved, { throwIfNoEntry: false })) {
         return resolved;
       }
     }
@@ -41,7 +41,7 @@ export class FileLoader {
    * Read a file as utf8 text, after resolving the path
    * @param relativePath The path to read
    */
-  async readText(relativePath: string): Promise<string> {
+  async readUTF8(relativePath: string): Promise<string> {
     const file = await this.resolve(relativePath);
     return fs.readFile(file, 'utf8');
   }

package/src/global.d.ts

@@ -1,6 +1,11 @@
 import './types';
 
 declare const write: unique symbol;
+
+declare global {
+  var devProcessWarningExclusions: ((message: string, category: string) => boolean)[] | undefined;
+}
+
 declare global {
   // https://github.com/microsoft/TypeScript/issues/59012
   interface WritableStreamDefaultWriter<W = any> {
@@ -64,4 +69,11 @@ declare module 'stream/web' {
    * @concrete node:stream/web#ReadableStream
    */
   interface ReadableStream { }
+}
+
+// Remove once node 26 types are released
+declare module 'node:fs' {
+  interface StatOptions {
+    throwIfNoEntry?: boolean;
+  }
 }

package/src/json.ts

@@ -1,16 +1,18 @@
+import { AssertionError } from 'node:assert';
+
 import type { BinaryArray } from './binary.ts';
 import { CodecUtil } from './codec.ts';
 import { RuntimeError, type RuntimeErrorOptions } from './error.ts';
-import { castTo } from './types.ts';
+import { castTo, type Any } from './types.ts';
+
+const VALID_JSON_ERROR_TYPES = ['runtime', 'plain', 'assert'] as const;
+const VALID_JSON_ERROR_TYPE_SET = new Set<unknown>(VALID_JSON_ERROR_TYPES);
 
 type JSONTransformer = (this: unknown, key: string, value: unknown) => unknown;
 type JSONOutputConfig = { indent?: number, replacer?: JSONTransformer };
 type JSONInputConfig = { reviver?: JSONTransformer };
 type JSONCloneConfig = JSONOutputConfig & JSONInputConfig;
-type ErrorShape<T extends string, V> = { $trv: T, message: string, stack?: string } & V;
-type JSONError =
-  ErrorShape<'runtime', RuntimeErrorOptions<Record<string, unknown>>> |
-  ErrorShape<'plain', { name: string }>;
+type JSONError = { $trv: (typeof VALID_JSON_ERROR_TYPES)[number], name?: string } & Partial<RuntimeErrorOptions<Record<string, unknown>>>;
 
 Object.defineProperty(BigInt.prototype, 'toJSON', {
   value() { return `${this}n`; },
@@ -47,53 +49,46 @@ export class JSONUtil {
 
 
   static isJSONError(value: unknown): value is JSONError {
-    return typeof value === 'object' && value !== null && '$trv' in value && (
-      value.$trv === 'runtime' || value.$trv === 'plain'
-    );
+    return typeof value === 'object' && value !== null && '$trv' in value && VALID_JSON_ERROR_TYPE_SET.has(value.$trv);
   }
 
   /** Convert from JSON object */
-  static jsonErrorToError(error: JSONError): Error | RuntimeError {
-    switch (error.$trv) {
-      case 'runtime': {
-        const { $trv: _, ...rest } = error;
-        const result = new RuntimeError(error.message, castTo<RuntimeErrorOptions<Record<string, unknown>>>(rest));
-        result.stack = error.stack;
-        return result;
-      }
-      case 'plain': {
-        const result = new Error(error.message);
-        result.name = error.name;
-        result.stack = error.stack ?? result.stack;
-        return result;
-      }
+  static jsonErrorToError(error: JSONError): Error {
+    const { $trv, message, stack, name, ...rest } = error;
+    let response: Error;
+    switch ($trv) {
+      case 'runtime': response = new RuntimeError(message!, castTo<Any>(rest)); break;
+      case 'assert': response = new AssertionError({ message, ...rest }); break;
+      case 'plain': response = new Error(message!); break;
     }
+    response.stack = stack;
+    if (name) { response.name = name; }
+    return response;
   }
 
   /**
    * Serializes an error to a basic object
    */
-  static errorToJSONError(error: RuntimeError | Error, includeStack?: boolean): JSONError | undefined {
+  static errorToJSONError(error: Error, includeStack?: boolean): JSONError | undefined {
     includeStack ??= JSONUtil.includeStackTraces;
-    if (error instanceof RuntimeError) {
-      return {
-        $trv: 'runtime',
-        message: error.message,
+    let $trv: JSONError['$trv'];
+    switch (true) {
+      case error instanceof RuntimeError: $trv = 'runtime'; break;
+      case error instanceof AssertionError: $trv = 'assert'; break;
+      default: $trv = 'plain'; break;
+    }
+    return {
+      $trv,
+      message: error.message,
+      ...(error.cause ? { cause: `${error.cause}` } : undefined),
+      ...(includeStack ? { stack: error.stack } : undefined),
+      ...(error instanceof RuntimeError ? {
         category: error.category,
-        ...(error.cause ? { cause: `${error.cause}` } : undefined),
         type: error.type,
         at: error.at,
         ...(error.details ? { details: error.details } : undefined!),
-        ...(includeStack ? { stack: error.stack } : undefined)
-      };
-    } else {
-      return {
-        $trv: 'plain',
-        message: error.message,
-        name: error.name,
-        ...(includeStack ? { stack: error.stack } : undefined)
-      };
-    }
+      } : {})
+    };
   }
 
   /** UTF8 string to JSON */

package/src/trv.d.ts

@@ -2,7 +2,7 @@ import { type ManifestModuleRole } from '@travetto/manifest';
 import { type TimeSpan } from './time.ts';
 type Role = Exclude<ManifestModuleRole, 'compile'>;
 
-declare module "@travetto/runtime" {
+declare module '@travetto/runtime' {
   interface EnvData {
     /** 
      * The node environment we are running in

package/src/watch.ts

@@ -91,8 +91,13 @@ export class WatchUtil {
       error: (...args: unknown[]): void => console.error(...args),
     });
 
-    return this.runWithRetry(async ({ signal }) => {
-      await client.waitForState(['compile-end', 'watch-start'], undefined, signal);
+    // pre-check
+    if (!await client.isWatching()) { // If we get here, without a watch
+      throw new RuntimeError('Compile Server is not running');
+    }
+
+    void this.runWithRetry(async ({ signal }) => {
+      await client.waitForState(['watch-start'], undefined, signal);
 
       if (!await client.isWatching()) { // If we get here, without a watch
         return 'error';

package/support/patch.js

@@ -0,0 +1,47 @@
+import 'temporal-polyfill-lite/global';
+import fs from 'node:fs/promises';
+
+if (process.env.NODE_ENV !== 'production') {
+  process.setSourceMapsEnabled(true); // Ensure source map during compilation/development
+  process.env.NODE_OPTIONS = `${process.env.NODE_OPTIONS ?? ''} --enable-source-maps`; // Ensure it passes to children
+  Error.stackTraceLimit = 50;
+
+  const ogEmitWarning = process.emitWarning;
+  const exclusions = global.devProcessWarningExclusions = [];
+  process.emitWarning = (message, category, ...other) => {
+    if (exclusions.length === 0 || !exclusions.some(filter => filter(message, category))) {
+      return ogEmitWarning(message, category, ...other);
+    }
+  };
+}
+
+const isError = Error.isError.bind(Error);
+Object.defineProperty(Error, 'isError', {
+  value: (input) => isError(input) || (input instanceof Error)
+});
+
+// polyfills
+
+const [majorVersion, minorVersion] = process.version.replace(/^v/, '').split('.').map(text => parseInt(text, 10));
+
+Map.prototype.getOrInsert ??= function (key, value) {
+  return (this.has(key) || this.set(key, value), this.get(key));
+};
+
+Map.prototype.getOrInsertComputed ??= function (key, compute) {
+  return (this.has(key) || this.set(key, compute()), this.get(key));
+};
+
+// Allow for the throwIfNoEntry if on a version of node that is less than 25.7
+if (majorVersion < 25 || (majorVersion === 25 && minorVersion < 7)) {
+  const og = fs.stat;
+  Object.defineProperty(fs, 'stat', {
+    value: (...args) => {
+      const out = og.call(fs, ...args);
+      if (typeof args[1] === 'object' && args[1].throwIfNoEntry === false) {
+        return out.catch(() => { });
+      }
+      return out;
+    }
+  });
+}

package/support/polyfill.js

@@ -1,9 +0,0 @@
-import 'temporal-polyfill-lite/global';
-
-Map.prototype.getOrInsert ??= function(key, value) {
-  return (this.has(key) || this.set(key, value), this.get(key));
-};
-
-Map.prototype.getOrInsertComputed ??= function(key, compute) {
-  return (this.has(key) || this.set(key, compute()), this.get(key));
-};