@macroforge/vite-plugin 0.1.77 → 0.1.79

package/package.json

@@ -1,7 +1,7 @@
 {
   "dependencies": {
-    "@macroforge/shared": "^0.1.77",
-    "macroforge": "^0.1.77"
+    "@macroforge/shared": "file:../shared",
+    "macroforge": "file:../../crates/macroforge_ts"
   },
   "devDependencies": {
     "@types/node": "^22.0.0"
@@ -22,7 +22,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/macroforge-ts/vite-plugin.git"
+    "url": "git+https://github.com/macroforge-ts/macroforge-ts.git"
   },
   "scripts": {
     "build": "echo 'No build needed'",
@@ -30,5 +30,5 @@
   },
   "type": "module",
   "types": "src/index.d.ts",
-  "version": "0.1.77"
+  "version": "0.1.79"
 }

package/src/index.js

@@ -42,9 +42,11 @@
 import { createRequire } from "node:module";
 import { createHash } from "node:crypto";
 import * as fs from "node:fs";
+import * as os from "node:os";
 import * as path from "node:path";
 import {
   collectExternalDecoratorModules,
+  hasMacroAnnotations,
   loadMacroConfig,
 } from "@macroforge/shared";
 
@@ -346,6 +348,48 @@ export async function macroforge() {
   try {
     const projectRequire = createRequire(process.cwd() + "/");
     rustTransformer = projectRequire("macroforge");
+
+    // Register external macro callbacks for WASM builds.
+    // The WASM build cannot spawn Node subprocesses to resolve external macros,
+    // so we provide JS-side resolve/run callbacks. No-op for NAPI builds.
+    if (rustTransformer.setupExternalMacros) {
+      const req = createRequire(process.cwd() + "/package.json");
+
+      const resolveDecoratorNames = function (packagePath) {
+        const pkg = req(packagePath);
+        const names = [];
+        if (pkg.__macroforgeGetManifest) {
+          names.push(
+            ...(pkg.__macroforgeGetManifest().decorators || []).map(
+              (d) => d.export,
+            ),
+          );
+        }
+        for (const key of Object.keys(pkg)) {
+          if (
+            key.startsWith("__macroforgeGetManifest_") &&
+            typeof pkg[key] === "function"
+          ) {
+            names.push(
+              ...(pkg[key]().decorators || []).map((d) => d.export),
+            );
+          }
+        }
+        if (names.length > 0) return [...new Set(names)];
+        return [];
+      };
+
+      const runMacro = function (ctxJson) {
+        const ctx = JSON.parse(ctxJson);
+        const fnName = `__macroforgeRun${ctx.macro_name}`;
+        const pkg = req(ctx.module_path);
+        const fn_ = pkg?.[fnName] || pkg?.default?.[fnName];
+        if (typeof fn_ === "function") return fn_(ctxJson);
+        throw new Error(`Macro ${fnName} not found in ${ctx.module_path}`);
+      };
+
+      rustTransformer.setupExternalMacros(resolveDecoratorNames, runMacro);
+    }
   } catch (error) {
     console.warn(
       "[@macroforge/vite-plugin] Rust binary not found. Please run `npm run build:rust` first.",
@@ -454,17 +498,84 @@ export async function macroforge() {
    * @returns {string}
    */
   function getMacroforgeVersion() {
+    const req = createRequire(process.cwd() + "/");
     try {
-      const req = createRequire(process.cwd() + "/");
-      const mainPath = req.resolve("macroforge");
-      const pkgDir = path.dirname(mainPath);
-      const pkgJson = JSON.parse(
-        fs.readFileSync(path.join(pkgDir, "package.json"), "utf-8"),
-      );
-      return pkgJson.version;
-    } catch {
-      return "unknown";
+      return JSON.parse(
+        fs.readFileSync(req.resolve("macroforge/package.json"), "utf-8"),
+      ).version;
+    } catch { /* exports map may block ./package.json */ }
+    try {
+      return JSON.parse(
+        fs.readFileSync(
+          path.join(process.cwd(), "node_modules", "macroforge", "package.json"),
+          "utf-8",
+        ),
+      ).version;
+    } catch { /* not in local node_modules */ }
+    return "unknown";
+  }
+
+  /**
+   * Computes a hash over external macro package binaries (`.node`, `.wasm`)
+   * so the cache invalidates when a local macro package is rebuilt.
+   * @returns {string}
+   */
+  function getExternalMacroHash() {
+    const nodeModules = path.join(projectRoot || process.cwd(), "node_modules");
+    if (!fs.existsSync(nodeModules)) return "none";
+
+    // Collect path:size:mtime_seconds parts, sort for deterministic ordering
+    // (readdir order varies across Node/Deno/Rust), then hash.
+    const parts = [];
+
+    const checkPackage = (pkgDir) => {
+      const indexJs = path.join(pkgDir, "index.js");
+      try {
+        const content = fs.readFileSync(indexJs, "utf-8");
+        if (!content.includes("__macroforgeRun")) return;
+      } catch {
+        return;
+      }
+      try {
+        for (const entry of fs.readdirSync(pkgDir)) {
+          const ext = path.extname(entry);
+          if (ext === ".node" || ext === ".wasm" || entry === "index.js") {
+            const full = path.join(pkgDir, entry);
+            try {
+              const stat = fs.statSync(full);
+              parts.push(
+                `${full}:${stat.size}:${Math.floor(stat.mtimeMs / 1000)}`,
+              );
+            } catch { /* expected */ }
+          }
+        }
+      } catch { /* expected */ }
+    };
+
+    try {
+      for (const entry of fs.readdirSync(nodeModules)) {
+        const full = path.join(nodeModules, entry);
+        if (!fs.statSync(full).isDirectory()) continue;
+        if (entry.startsWith("@")) {
+          try {
+            for (const sub of fs.readdirSync(full)) {
+              const subFull = path.join(full, sub);
+              if (fs.statSync(subFull).isDirectory()) checkPackage(subFull);
+            }
+          } catch { /* expected */ }
+        } else if (!entry.startsWith(".")) {
+          checkPackage(full);
+        }
+      }
+    } catch { /* expected */ }
+
+    if (parts.length === 0) return "none";
+    parts.sort();
+    const hasher = createHash("sha256");
+    for (const part of parts) {
+      hasher.update(part);
     }
+    return hasher.digest("hex");
   }
 
   /**
@@ -517,6 +628,17 @@ export async function macroforge() {
         return null;
       }
 
+      const currentExternalHash = getExternalMacroHash();
+      if (
+        manifest.externalMacroHash &&
+        manifest.externalMacroHash !== currentExternalHash
+      ) {
+        console.log(
+          "[@macroforge/vite-plugin] Cache invalidated: external macro binary changed",
+        );
+        return null;
+      }
+
       return manifest;
     } catch {
       return null;
@@ -573,6 +695,7 @@ export async function macroforge() {
         cacheManifest = {
           version: macroforgeVersion,
           configHash: getConfigHash(),
+          externalMacroHash: getExternalMacroHash(),
           entries: {},
         };
       }
@@ -726,42 +849,61 @@ export async function macroforge() {
     },
 
     /**
-     * Pre-scan the project to build a type registry for compile-time type awareness.
+     * Load the type registry from the CLI cache for compile-time type awareness.
      * The registry is passed to every expandSync call so macros can introspect
-     * any type in the project (Zig-style type awareness).
+     * any type in the project.
      */
     buildStart() {
-      if (!rustTransformer || !rustTransformer.scanProjectSync) {
-        return;
+      const localRegistry = path.join(
+        projectRoot,
+        ".macroforge",
+        "type-registry.json",
+      );
+      if (fs.existsSync(localRegistry)) {
+        typeRegistryJson = fs.readFileSync(localRegistry, "utf-8");
+        try {
+          const parsed = JSON.parse(typeRegistryJson);
+          const count = Object.keys(parsed.types ?? parsed).length;
+          console.log(
+            `[@macroforge/vite-plugin] Type registry loaded: ${count} types`,
+          );
+        } catch {
+          // JSON is passed as-is to expandSync, no need to parse here
+        }
+      } else {
+        console.warn(
+          `[@macroforge/vite-plugin] No type registry found at .macroforge/type-registry.json. Run \`macroforge watch\` to generate it.`,
+        );
       }
+    },
 
-      try {
-        const scanStart = performance.now();
-        const scanResult = rustTransformer.scanProjectSync(projectRoot, {
-          exportedOnly: false,
-        });
-        const scanTime = (performance.now() - scanStart).toFixed(0);
+    /**
+     * Resolve `.svelte` imports to `.svelte.ts` when the `.svelte` file
+     * does not exist. Macroforge type files use the `.svelte.ts` extension
+     * (Svelte 5 runes modules) but are imported with just `.svelte`.
+     *
+     * @param {string} source
+     * @param {string | undefined} importer
+     * @param {object} options
+     */
+    async resolveId(source, importer, options) {
+      if (!source.endsWith(".svelte") || !importer) return null;
 
-        typeRegistryJson = scanResult.registryJson;
+      // Let other plugins (SvelteKit, etc.) try to resolve it first
+      const resolved = await this.resolve(source, importer, {
+        ...options,
+        skipSelf: true,
+      });
 
-        console.log(
-          `[@macroforge/vite-plugin] Type scan: ${scanResult.typesFound} types from ${scanResult.filesScanned} files (${scanTime}ms)`,
-        );
+      if (resolved && !resolved.external) return resolved;
 
-        for (const diag of scanResult.diagnostics) {
-          if (diag.level === "error") {
-            console.error(
-              `[@macroforge/vite-plugin] Scan error: ${diag.message}`,
-            );
-          }
-        }
-      } catch (error) {
-        console.warn(
-          `[@macroforge/vite-plugin] Type scan failed, macros will run without type awareness:`,
-          error.message || error,
-        );
-        typeRegistryJson = undefined;
-      }
+      // Fall back: try appending .ts
+      const resolvedTs = await this.resolve(source + ".ts", importer, {
+        ...options,
+        skipSelf: true,
+      });
+
+      return resolvedTs || null;
     },
 
     /**
@@ -789,8 +931,8 @@ export async function macroforge() {
         return null;
       }
 
-      // Quick check: files without @derive can't have macros — skip entirely
-      if (!code.includes("@derive")) {
+      // Quick check: skip files without a real @derive directive
+      if (!hasMacroAnnotations(code)) {
         return null;
       }
 
@@ -801,7 +943,6 @@ export async function macroforge() {
           if (cached) {
             let cachedCode = cached.code;
 
-            // Apply same post-processing as the normal path
             cachedCode = cachedCode.replace(
               /\/\*\*\s*import\s+macro[\s\S]*?\*\/\s*/gi,
               "",
@@ -813,18 +954,6 @@ export async function macroforge() {
               );
             }
 
-            // Generate type definitions from cached expanded code
-            if (generateTypes) {
-              const emitted = emitDeclarationsFromCode(
-                cachedCode,
-                id,
-                projectRoot,
-              );
-              if (emitted) {
-                writeTypeDefinitions(id, emitted);
-              }
-            }
-
             return {
               code: cachedCode,
               map: null,