@h-rig/core 0.0.6-alpha.81 → 0.0.6-alpha.83

package/dist/src/load-config.js

@@ -1,6 +1,6 @@
 // @bun
 // packages/core/src/load-config.ts
-import { existsSync, mkdtempSync, readFileSync, rmSync } from "fs";
+import { existsSync, mkdtempSync, readFileSync, readdirSync, rmSync } from "fs";
 import { tmpdir } from "os";
 import { dirname, join } from "path";
 import { fileURLToPath, pathToFileURL } from "url";
@@ -38,6 +38,118 @@ function isModuleResolutionError(error) {
 function runningFromCompiledBinary() {
   return import.meta.url.includes("$bunfs");
 }
+function packageNameAndSubpath(specifier) {
+  if (specifier.startsWith(".") || specifier.startsWith("/") || /^[a-zA-Z]+:/.test(specifier))
+    return null;
+  const parts = specifier.split("/");
+  const packageName = specifier.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0];
+  if (!packageName)
+    return null;
+  const rest = parts.slice(specifier.startsWith("@") ? 2 : 1).join("/");
+  return { packageName, subpath: rest ? `./${rest}` : "." };
+}
+function exportTargetFromEntry(entry) {
+  if (typeof entry === "string")
+    return entry;
+  if (entry && typeof entry === "object" && !Array.isArray(entry)) {
+    const conditions = entry;
+    for (const key of ["bun", "import", "default", "require"]) {
+      if (typeof conditions[key] === "string")
+        return conditions[key];
+    }
+  }
+  return null;
+}
+function patternExportTarget(record, subpath) {
+  for (const [pattern, entry] of Object.entries(record)) {
+    if (!pattern.includes("*"))
+      continue;
+    const [prefix = "", suffix = ""] = pattern.split("*");
+    if (!subpath.startsWith(prefix) || !subpath.endsWith(suffix))
+      continue;
+    const replacement = subpath.slice(prefix.length, subpath.length - suffix.length);
+    const target = exportTargetFromEntry(entry);
+    if (target)
+      return target.replace("*", replacement);
+  }
+  return null;
+}
+function exportTargetFromPackageJson(pkg, subpath) {
+  const exportsField = pkg.exports;
+  const target = (() => {
+    if (typeof exportsField === "string" && subpath === ".")
+      return exportsField;
+    if (!exportsField || typeof exportsField !== "object" || Array.isArray(exportsField))
+      return null;
+    const record = exportsField;
+    return exportTargetFromEntry(record[subpath] ?? (subpath === "." ? record["."] : undefined)) ?? patternExportTarget(record, subpath);
+  })();
+  if (target)
+    return target;
+  return subpath === "." && typeof pkg.module === "string" ? pkg.module : subpath === "." && typeof pkg.main === "string" ? pkg.main : null;
+}
+function resolvePackageDirFromBunStore(packageName, nodeModulesDir) {
+  const storeDir = join(nodeModulesDir, ".bun");
+  if (!existsSync(storeDir))
+    return null;
+  const encoded = packageName.replace("/", "+");
+  try {
+    for (const entry of readdirSync(storeDir).sort()) {
+      if (!entry.startsWith(`${encoded}@`))
+        continue;
+      const candidate = join(storeDir, entry, "node_modules", packageName);
+      if (existsSync(join(candidate, "package.json")))
+        return candidate;
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+function resolvePackageExportFromDir(packageDir, subpath) {
+  const packageJsonPath = join(packageDir, "package.json");
+  if (!existsSync(packageJsonPath))
+    return null;
+  try {
+    const pkg = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+    const target = exportTargetFromPackageJson(pkg, subpath);
+    if (target) {
+      const resolved = join(packageDir, target);
+      if (existsSync(resolved))
+        return resolved;
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+function resolveBarePackageExport(specifier, parentDir) {
+  const parsed = packageNameAndSubpath(specifier);
+  if (!parsed)
+    return null;
+  const packageNames = parsed.packageName.startsWith("@rig/") ? [parsed.packageName, parsed.packageName.replace(/^@rig\//, "@h-rig/")] : [parsed.packageName];
+  let current = parentDir;
+  while (true) {
+    const nodeModulesDir = join(current, "node_modules");
+    for (const packageName of packageNames) {
+      const directPackageDir = join(nodeModulesDir, packageName);
+      const resolvedDirect = resolvePackageExportFromDir(directPackageDir, parsed.subpath);
+      if (resolvedDirect)
+        return resolvedDirect;
+      const bunStorePackageDir = resolvePackageDirFromBunStore(packageName, nodeModulesDir);
+      if (bunStorePackageDir) {
+        const resolvedFromStore = resolvePackageExportFromDir(bunStorePackageDir, parsed.subpath);
+        if (resolvedFromStore)
+          return resolvedFromStore;
+      }
+    }
+    const next = dirname(current);
+    if (next === current)
+      break;
+    current = next;
+  }
+  return null;
+}
 var runtimeBundleQueue = Promise.resolve();
 function enqueueRuntimeBundle(operation) {
   const next = runtimeBundleQueue.then(operation, operation);
@@ -67,16 +179,20 @@ async function importConfigViaRuntimeBundleUnserialized(configPath) {
     setup(build) {
       build.onResolve({ filter: /^@rig\// }, (args) => {
         const candidates = [
-          [args.path, configDir],
           [args.path, hostDir],
-          [args.path.replace(/^@rig\//, "@h-rig/"), hostDir]
+          [args.path.replace(/^@rig\//, "@h-rig/"), hostDir],
+          [args.path, configDir]
         ];
         for (const [specifier, parent] of candidates) {
           try {
-            const resolved = bun.resolveSync?.(specifier, parent);
+            const resolved = bun.resolveSync?.(specifier, parent) ?? resolveBarePackageExport(specifier, parent);
             if (resolved)
               return { path: resolved };
-          } catch {}
+          } catch {
+            const resolved = resolveBarePackageExport(specifier, parent);
+            if (resolved)
+              return { path: resolved };
+          }
         }
         return;
       });
@@ -85,10 +201,13 @@ async function importConfigViaRuntimeBundleUnserialized(configPath) {
           return;
         const parent = args.importer ? dirname(args.importer) : configDir;
         try {
-          const resolved = bun.resolveSync?.(args.path, parent);
+          const resolved = bun.resolveSync?.(args.path, parent) ?? resolveBarePackageExport(args.path, parent);
           if (resolved)
             return { path: resolved };
         } catch {
+          const resolved = resolveBarePackageExport(args.path, parent);
+          if (resolved)
+            return { path: resolved };
           return { path: args.path, namespace: UNRESOLVED_NAMESPACE };
         }
         return;
@@ -132,6 +251,11 @@ async function loadConfig(cwd) {
         if (runningFromCompiledBinary()) {
           return importConfigViaRuntimeBundleUnserialized(p);
         }
+        const source = readFileSync(p, "utf8");
+        const importsRigHostPackages = /(?:import\s+[^;]*?from\s*|import\s*\()\s*["']@rig\//.test(source);
+        if (importsRigHostPackages) {
+          return importConfigViaRuntimeBundleUnserialized(p);
+        }
         try {
           return await import(pathToFileURL(p).href);
         } catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@h-rig/core",
-  "version": "0.0.6-alpha.81",
+  "version": "0.0.6-alpha.83",
   "type": "module",
   "description": "Rig package",
   "license": "UNLICENSED",
@@ -37,7 +37,7 @@
   "module": "./dist/src/index.js",
   "types": "./dist/src/index.d.ts",
   "dependencies": {
-    "@rig/contracts": "npm:@h-rig/contracts@0.0.6-alpha.81",
+    "@rig/contracts": "npm:@h-rig/contracts@0.0.6-alpha.83",
     "effect": "4.0.0-beta.78"
   }
 }