@orxataguy/tyr 1.0.11-beta.1 → 1.0.11-beta.3

package/bin/loader.mjs

@@ -13,17 +13,68 @@
  */
 
 import { transformSync } from 'esbuild';
-import { readFileSync } from 'fs';
-import { fileURLToPath } from 'url';
+import { existsSync, readFileSync } from 'fs';
+import { fileURLToPath, pathToFileURL } from 'url';
+import { resolve as resolvePath, dirname } from 'path';
 
-const TS_RE = /\.m?[ct]?ts$/;
+const TS_RE       = /\.m?[ct]?ts$/;
+const NO_EXT_RE   = /\/[^./]+$/;          // path segment with no extension at the end
+const EXT_MAP     = { '.js': '.ts', '.mjs': '.mts', '.cjs': '.cts' };
+const BARE_EXTS   = ['.ts', '.mts', '.cts', '.js', '.mjs', '/index.ts', '/index.js'];
+
+/**
+ * resolve() — handle two TypeScript-in-ESM conventions that Node cannot resolve natively:
+ *
+ *  1. Extensionless imports:  './Container'  →  './Container.ts'
+ *  2. JS-extension imports:   './Foo.js'     →  './Foo.ts'  (TypeScript ESM idiom)
+ *
+ * Only relative imports are intercepted; bare specifiers (npm packages) go straight
+ * to the default resolver.
+ */
+export function resolve(specifier, context, next) {
+    if (!specifier.startsWith('.') || !context.parentURL) {
+        return next(specifier, context);
+    }
+
+    const parentDir = dirname(fileURLToPath(context.parentURL));
+    const fullPath  = resolvePath(parentDir, specifier);
+
+    // Case 1: specifier ends with a JS extension — try the equivalent TS extension
+    for (const [jsExt, tsExt] of Object.entries(EXT_MAP)) {
+        if (specifier.endsWith(jsExt)) {
+            const tsPath = fullPath.slice(0, -jsExt.length) + tsExt;
+            if (existsSync(tsPath)) {
+                return { url: pathToFileURL(tsPath).href, shortCircuit: true };
+            }
+        }
+    }
+
+    // Case 2: extensionless — probe TS then JS extensions
+    if (NO_EXT_RE.test(fullPath)) {
+        for (const ext of BARE_EXTS) {
+            const candidate = fullPath + ext;
+            if (existsSync(candidate)) {
+                return { url: pathToFileURL(candidate).href, shortCircuit: true };
+            }
+        }
+    }
+
+    return next(specifier, context);
+}
 
 /**
  * load() — intercept every ESM import whose URL ends in a TypeScript extension.
- * Files inside node_modules are never transformed (they ship as JS already).
+ *
+ * We do NOT exclude node_modules: the tyr package itself ships as .ts source
+ * (bin/tyr.ts, src/core/Kernel.ts, etc.) and those files ARE under node_modules
+ * when installed globally. Node.js 24's built-in strip-types refuses to handle
+ * .ts files under node_modules, so our loader must cover them.
+ *
+ * The TS_RE regex already limits interception to .ts/.mts/.cts files — the
+ * compiled .js files that third-party packages ship will never match it.
  */
 export function load(url, context, next) {
-    const isTs = TS_RE.test(url) && !url.includes('/node_modules/');
+    const isTs = TS_RE.test(url);
     if (!isTs) return next(url, context);
 
     const filePath = fileURLToPath(url);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orxataguy/tyr",
-  "version": "1.0.11-beta.1",
+  "version": "1.0.11-beta.3",
   "type": "module",
   "bin": {
     "tyr": "./bin/tyr.js"

package/src/core/Kernel.ts

@@ -4,15 +4,15 @@ import yaml from 'js-yaml';
 import dotenv from 'dotenv';
 import { fileURLToPath, pathToFileURL } from 'url';
 import { homedir } from 'os';
-import { Container } from './Container';
-
-import gen   from './sys/gen';
-import rem   from './sys/rem';
-import doc   from './sys/doc';
-import ai    from './sys/ai';
-import build from './sys/build';
-import config from './sys/config';
-import help   from './sys/help';
+import { Container } from './Container.ts';
+
+import gen   from './sys/gen.ts';
+import rem   from './sys/rem.ts';
+import doc   from './sys/doc.ts';
+import ai    from './sys/ai.ts';
+import build from './sys/build.ts';
+import config from './sys/config.ts';
+import help   from './sys/help.ts';
 
 import { TyrError } from './TyrError';