macroforge 0.1.77 → 0.1.79

package/js/cli/svelte-check-wrapper.js

@@ -0,0 +1,157 @@
+/**
+ * Svelte-check wrapper — spawned by the CLI's `run_svelte_check_wrapper`.
+ *
+ * Patches `ts.sys.readFile` to expand macros before svelte-check sees the files.
+ * Since svelte-check uses TypeScript as a peer dependency and Node.js caches
+ * modules, the patched `ts.sys.readFile` is shared with svelte-check's internal
+ * TypeScript language service.
+ *
+ * Arguments:
+ *   argv[2..] — forwarded to svelte-check CLI
+ *
+ * Environment:
+ *   MACROFORGE_TYPE_REGISTRY_PATH — path to pre-built type registry JSON
+ */
+const { createRequire } = require("module");
+const fs = require("fs");
+const path = require("path");
+const cwdRequire = createRequire(process.cwd() + "/package.json");
+let ts;
+let macros;
+try {
+  ts = cwdRequire("typescript");
+} catch {
+  console.error(
+    "[macroforge] error: typescript is not installed in this project",
+  );
+  process.exit(1);
+}
+try {
+  macros = cwdRequire("macroforge");
+} catch {
+  console.error(
+    "[macroforge] error: macroforge is not installed in this project",
+  );
+  process.exit(1);
+}
+if (macros.setupExternalMacros) {
+  let resolveDecoratorNames = function (packagePath) {
+      const candidates = [packagePath];
+      for (const id of candidates) {
+        try {
+          const pkg = req(id);
+          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)];
+        } catch {}
+      }
+      return [];
+    },
+    runMacro = function (ctxJson) {
+      const ctx = JSON.parse(ctxJson);
+      const fnName = `__macroforgeRun${ctx.macro_name}`;
+      const candidates = [ctx.module_path];
+      for (const id of candidates) {
+        try {
+          const pkg = req(id);
+          const fn_ = pkg?.[fnName] || pkg?.default?.[fnName];
+          if (typeof fn_ === "function") return fn_(ctxJson);
+        } catch {}
+      }
+      throw new Error(`Macro ${fnName} not found in ${ctx.module_path}`);
+    };
+  var resolveDecoratorNames2 = resolveDecoratorNames,
+    runMacro2 = runMacro;
+  const req = createRequire(process.cwd() + "/package.json");
+  macros.setupExternalMacros(resolveDecoratorNames, runMacro);
+}
+const CONFIG_FILES = [
+  "macroforge.config.ts",
+  "macroforge.config.mts",
+  "macroforge.config.js",
+  "macroforge.config.mjs",
+  "macroforge.config.cjs",
+];
+let macroConfigPath = null;
+let currentDir = process.cwd();
+while (true) {
+  for (const filename of CONFIG_FILES) {
+    const candidate = path.join(currentDir, filename);
+    if (fs.existsSync(candidate)) {
+      macroConfigPath = candidate;
+      break;
+    }
+  }
+  if (macroConfigPath) break;
+  if (fs.existsSync(path.join(currentDir, "package.json"))) break;
+  const parent = path.dirname(currentDir);
+  if (parent === currentDir) break;
+  currentDir = parent;
+}
+if (macroConfigPath) {
+  try {
+    const configContent = fs.readFileSync(macroConfigPath, "utf8");
+    macros.loadConfig(configContent, macroConfigPath);
+  } catch {}
+}
+const typeRegistryPath = process.env.MACROFORGE_TYPE_REGISTRY_PATH;
+let typeRegistryJson = void 0;
+if (typeRegistryPath) {
+  try {
+    typeRegistryJson = fs.readFileSync(typeRegistryPath, "utf8");
+  } catch {}
+}
+const plugin = new macros.NativePlugin();
+const expandOpts = {};
+if (macroConfigPath) expandOpts.configPath = macroConfigPath;
+if (typeRegistryJson) expandOpts.typeRegistryJson = typeRegistryJson;
+const tsSys = ts.sys;
+const origReadFile = tsSys.readFile.bind(tsSys);
+tsSys.readFile = (filePath, encoding) => {
+  const content = origReadFile(filePath, encoding);
+  if (content == null) return content;
+  try {
+    if (
+      (filePath.endsWith(".ts") || filePath.endsWith(".tsx")) &&
+      !filePath.endsWith(".d.ts") &&
+      content.includes("@derive")
+    ) {
+      const result = plugin.processFile(filePath, content, expandOpts);
+      return result.code || content;
+    }
+  } catch {}
+  return content;
+};
+const args = ["svelte-check"];
+for (let i = 2; i < process.argv.length; i++) {
+  args.push(process.argv[i]);
+}
+process.argv = [process.argv[0], ...args];
+try {
+  cwdRequire("svelte-check");
+} catch (e) {
+  if (e.code === "MODULE_NOT_FOUND") {
+    console.error(
+      "[macroforge] error: svelte-check is not installed in this project",
+    );
+    console.error(
+      "[macroforge] install it with: npm install --save-dev svelte-check",
+    );
+    process.exit(1);
+  }
+  throw e;
+}

package/js/cli/tsc-wrapper.js

@@ -0,0 +1,166 @@
+/**
+ * TSC wrapper — spawned by the CLI's `run_tsc_wrapper`.
+ *
+ * Wraps `tsc --noEmit` with macro expansion baked into file reads.
+ * Files containing `@derive` are expanded before being passed to the
+ * TypeScript compiler.
+ *
+ * Arguments:
+ *   argv[2] — tsconfig path (default: "tsconfig.json")
+ *
+ * Environment:
+ *   MACROFORGE_TYPE_REGISTRY_PATH — path to pre-built type registry JSON
+ */
+const { createRequire } = require("module");
+const fs = require("fs");
+const path = require("path");
+const cwdRequire = createRequire(process.cwd() + "/package.json");
+const ts = cwdRequire("typescript");
+const macros = cwdRequire("macroforge");
+if (macros.setupExternalMacros) {
+  let resolveDecoratorNames = function (packagePath) {
+      const candidates = [packagePath];
+      for (const id of candidates) {
+        try {
+          const pkg = req(id);
+          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)];
+        } catch {}
+      }
+      return [];
+    },
+    runMacro = function (ctxJson) {
+      const ctx = JSON.parse(ctxJson);
+      const fnName = `__macroforgeRun${ctx.macro_name}`;
+      const candidates = [ctx.module_path];
+      for (const id of candidates) {
+        try {
+          const pkg = req(id);
+          const fn_ = pkg?.[fnName] || pkg?.default?.[fnName];
+          if (typeof fn_ === "function") return fn_(ctxJson);
+        } catch {}
+      }
+      throw new Error(`Macro ${fnName} not found in ${ctx.module_path}`);
+    };
+  var resolveDecoratorNames2 = resolveDecoratorNames,
+    runMacro2 = runMacro;
+  const req = createRequire(process.cwd() + "/package.json");
+  macros.setupExternalMacros(resolveDecoratorNames, runMacro);
+}
+const projectArg = process.argv[2] || "tsconfig.json";
+const configPath = ts.findConfigFile(
+  process.cwd(),
+  ts.sys.fileExists,
+  projectArg,
+);
+if (!configPath) {
+  console.error(`[macroforge] tsconfig not found: ${projectArg}`);
+  process.exit(1);
+}
+const CONFIG_FILES = [
+  "macroforge.config.ts",
+  "macroforge.config.mts",
+  "macroforge.config.js",
+  "macroforge.config.mjs",
+  "macroforge.config.cjs",
+];
+let macroConfigPath = null;
+let currentDir = process.cwd();
+while (true) {
+  for (const filename of CONFIG_FILES) {
+    const candidate = path.join(currentDir, filename);
+    if (fs.existsSync(candidate)) {
+      macroConfigPath = candidate;
+      break;
+    }
+  }
+  if (macroConfigPath) break;
+  if (fs.existsSync(path.join(currentDir, "package.json"))) break;
+  const parent = path.dirname(currentDir);
+  if (parent === currentDir) break;
+  currentDir = parent;
+}
+if (macroConfigPath) {
+  try {
+    const configContent = fs.readFileSync(macroConfigPath, "utf8");
+    macros.loadConfig(configContent, macroConfigPath);
+  } catch {}
+}
+const typeRegistryPath = process.env.MACROFORGE_TYPE_REGISTRY_PATH;
+let typeRegistryJson = void 0;
+if (typeRegistryPath) {
+  try {
+    typeRegistryJson = fs.readFileSync(typeRegistryPath, "utf8");
+  } catch {}
+}
+const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
+if (configFile.error) {
+  console.error(
+    ts.formatDiagnostic(configFile.error, {
+      getCanonicalFileName: (f) => f,
+      getCurrentDirectory: ts.sys.getCurrentDirectory,
+      getNewLine: () => ts.sys.newLine,
+    }),
+  );
+  process.exit(1);
+}
+const parsed = ts.parseJsonConfigFileContent(
+  configFile.config,
+  ts.sys,
+  path.dirname(configPath),
+);
+const options = { ...parsed.options, noEmit: true };
+const formatHost = {
+  getCanonicalFileName: (f) => f,
+  getCurrentDirectory: ts.sys.getCurrentDirectory,
+  getNewLine: () => ts.sys.newLine,
+};
+const plugin = new macros.NativePlugin();
+const tscExpandOpts = {};
+if (macroConfigPath) tscExpandOpts.configPath = macroConfigPath;
+if (typeRegistryJson) tscExpandOpts.typeRegistryJson = typeRegistryJson;
+const host = ts.createCompilerHost(options);
+const origGetSourceFile = host.getSourceFile.bind(host);
+host.getSourceFile = (fileName, languageVersion, ...rest) => {
+  try {
+    if (
+      (fileName.endsWith(".ts") || fileName.endsWith(".tsx")) &&
+      !fileName.endsWith(".d.ts")
+    ) {
+      const sourceText = ts.sys.readFile(fileName);
+      if (sourceText && sourceText.includes("@derive")) {
+        const result = plugin.processFile(fileName, sourceText, tscExpandOpts);
+        const text = result.code || sourceText;
+        return ts.createSourceFile(fileName, text, languageVersion, true);
+      }
+    }
+  } catch {}
+  return origGetSourceFile(fileName, languageVersion, ...rest);
+};
+const program = ts.createProgram(parsed.fileNames, options, host);
+const diagnostics = ts.getPreEmitDiagnostics(program);
+if (diagnostics.length) {
+  diagnostics.forEach((d) => {
+    const msg = ts.formatDiagnostic(d, formatHost);
+    console.error(msg.trimEnd());
+  });
+}
+const hasError = diagnostics.some(
+  (d) => d.category === ts.DiagnosticCategory.Error,
+);
+process.exit(hasError ? 1 : 0);

package/js/serde/index.d.ts

@@ -155,9 +155,22 @@ export interface DeserializeContext {
      * Call this after `applyPatches()` if immutable objects are desired.
      */
     freezeAll(): void;
+    /**
+     * Pushes a field name onto the scope stack.
+     * Nested deserializers call this before processing so that any errors
+     * they push are automatically prefixed with the full path.
+     * @param name - The field name to push (e.g., "colors")
+     */
+    pushScope(name: string): void;
+    /**
+     * Pops the last field name from the scope stack.
+     * Must be called after the nested deserializer returns.
+     */
+    popScope(): void;
     /**
      * Pushes validation errors onto the context.
      * Called by `deserializeWithContext` instead of throwing.
+     * Errors are automatically prefixed with the current scope stack.
      * @param errors - Array of field validation errors to accumulate
      */
     pushErrors(errors: FieldError[]): void;

package/js/serde/index.mjs

@@ -22,6 +22,7 @@ var DeserializeContext;
     const patches = [];
     const toFreeze = [];
     const errors = [];
+    const scopes = [];
     return {
       register: (id, instance) => {
         registry.set(id, instance);
@@ -59,9 +60,17 @@ var DeserializeContext;
           Object.freeze(obj);
         }
       },
+      pushScope: (name) => {
+        scopes.push(name);
+      },
+      popScope: () => {
+        scopes.pop();
+      },
       pushErrors: (errs) => {
+        const prefix = scopes.length > 0 ? scopes.join(".") : "";
         for (const e of errs) {
-          errors.push(e);
+          const field = e.field === "_root" ? prefix || "_root" : prefix ? prefix + "." + e.field : e.field;
+          errors.push({ field, message: e.message });
         }
       },
       getErrors: () => errors

package/js/serde/index.ts

@@ -185,9 +185,24 @@ export interface DeserializeContext {
    */
   freezeAll(): void;
 
+  /**
+   * Pushes a field name onto the scope stack.
+   * Nested deserializers call this before processing so that any errors
+   * they push are automatically prefixed with the full path.
+   * @param name - The field name to push (e.g., "colors")
+   */
+  pushScope(name: string): void;
+
+  /**
+   * Pops the last field name from the scope stack.
+   * Must be called after the nested deserializer returns.
+   */
+  popScope(): void;
+
   /**
    * Pushes validation errors onto the context.
    * Called by `deserializeWithContext` instead of throwing.
+   * Errors are automatically prefixed with the current scope stack.
    * @param errors - Array of field validation errors to accumulate
    */
   pushErrors(errors: FieldError[]): void;
@@ -236,6 +251,7 @@ export namespace DeserializeContext {
     > = [];
     const toFreeze: object[] = [];
     const errors: FieldError[] = [];
+    const scopes: string[] = [];
 
     return {
       register: (id, instance) => {
@@ -281,9 +297,21 @@ export namespace DeserializeContext {
         }
       },
 
+      pushScope: (name) => {
+        scopes.push(name);
+      },
+
+      popScope: () => {
+        scopes.pop();
+      },
+
       pushErrors: (errs) => {
+        const prefix = scopes.length > 0 ? scopes.join(".") : "";
         for (const e of errs) {
-          errors.push(e);
+          const field = e.field === "_root"
+            ? (prefix || "_root")
+            : (prefix ? prefix + "." + e.field : e.field);
+          errors.push({ field, message: e.message });
         }
       },
 

package/package.json

@@ -1,92 +1,67 @@
 {
   "author": "macroforge contributors",
   "bugs": {
-    "url": "https://github.com/macroforge-ts/core/issues"
-  },
-  "dependencies": {
-    "@napi-rs/cli": "^3.5.1"
-  },
-  "description": "TypeScript macro expansion engine powered by Rust and SWC",
-  "engines": {
-    "node": ">= 18"
+    "url": "https://github.com/macroforge-ts/macroforge-ts/issues"
   },
+  "description": "TypeScript macro expansion engine powered by Rust, Oxc, and WebAssembly",
   "exports": {
     ".": {
-      "default": "./index.js",
-      "require": "./index.js",
-      "types": "./index.d.ts"
+      "types": "./pkg/macroforge_ts.d.ts",
+      "require": "./pkg/macroforge_ts.js",
+      "default": "./pkg/macroforge_ts.js"
     },
     "./reexports": {
-      "default": "./js/reexports/index.mjs",
+      "types": "./js/reexports/index.d.ts",
       "import": "./js/reexports/index.mjs",
-      "types": "./js/reexports/index.d.ts"
+      "default": "./js/reexports/index.mjs"
     },
     "./reexports/effect": {
-      "default": "./js/reexports/effect.mjs",
+      "types": "./js/reexports/effect.d.ts",
       "import": "./js/reexports/effect.mjs",
-      "types": "./js/reexports/effect.d.ts"
+      "default": "./js/reexports/effect.mjs"
     },
     "./serde": {
-      "default": "./js/serde/index.mjs",
+      "types": "./js/serde/index.d.ts",
       "import": "./js/serde/index.mjs",
-      "types": "./js/serde/index.d.ts"
+      "default": "./js/serde/index.mjs"
     },
     "./traits": {
-      "default": "./js/traits/index.mjs",
+      "types": "./js/traits/index.d.ts",
       "import": "./js/traits/index.mjs",
-      "types": "./js/traits/index.d.ts"
+      "default": "./js/traits/index.mjs"
     }
   },
   "files": [
-    "index.d.ts",
-    "index.js",
-    "js"
+    "js",
+    "pkg"
   ],
-  "homepage": "https://github.com/macroforge-ts/core#readme",
+  "homepage": "https://github.com/macroforge-ts/macroforge-ts#readme",
   "keywords": [
     "typescript",
     "macros",
     "derive",
     "codegen",
-    "swc"
+    "oxc",
+    "wasm",
+    "webassembly"
   ],
   "license": "MIT",
-  "main": "index.js",
+  "main": "./pkg/macroforge_ts.js",
   "name": "macroforge",
-  "napi": {
-    "binaryName": "macroforge",
-    "packageName": "@macroforge/bin",
-    "targets": [
-      "x86_64-apple-darwin",
-      "aarch64-apple-darwin",
-      "x86_64-unknown-linux-gnu",
-      "aarch64-unknown-linux-gnu",
-      "x86_64-pc-windows-msvc",
-      "aarch64-pc-windows-msvc"
-    ]
-  },
-  "optionalDependencies": {
-    "@macroforge/bin-darwin-arm64": "0.1.77",
-    "@macroforge/bin-darwin-x64": "0.1.77",
-    "@macroforge/bin-linux-arm64-gnu": "0.1.77",
-    "@macroforge/bin-linux-x64-gnu": "0.1.77",
-    "@macroforge/bin-win32-arm64-msvc": "0.1.77",
-    "@macroforge/bin-win32-x64-msvc": "0.1.77"
-  },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/macroforge-ts/core.git"
+    "url": "git+https://github.com/macroforge-ts/macroforge-ts.git"
   },
   "scripts": {
-    "artifacts": "napi artifacts --npm-dir npm",
-    "build": "deno install --node-modules-dir && deno task build:js && deno run -A npm:@napi-rs/cli/napi build --platform --release && cargo install --path . --force",
+    "build": "deno task build:wasm",
     "build:js": "deno task build:serde && deno task build:traits",
     "build:serde": "deno run -A npm:esbuild js/serde/index.ts --bundle --outfile=js/serde/index.mjs --format=esm && deno run -A npm:typescript/tsc js/serde/index.ts --declaration --emitDeclarationOnly --outDir js/serde --lib ES2024 --skipLibCheck",
     "build:traits": "deno run -A npm:esbuild js/traits/index.ts --bundle --outfile=js/traits/index.mjs --format=esm && deno run -A npm:typescript/tsc js/traits/index.ts --declaration --emitDeclarationOnly --outDir js/traits --lib ES2024 --skipLibCheck",
-    "clean": "rm -f macroforge.*.node || true; rm -f pkg/*.node || true; rm -rf node_modules",
+    "build:wasm": "deno install --node-modules-dir && deno task build:js && cargo build --release --target wasm32-unknown-unknown && deno run -A ../../tooling/scripts/bench.mjs --wasm-bindgen target/wasm32-unknown-unknown/release/macroforge_ts.wasm pkg",
+    "clean": "rm -rf pkg node_modules",
     "cleanbuild": "deno task clean && deno task build"
   },
   "type": "commonjs",
-  "types": "index.d.ts",
-  "version": "0.1.77"
+  "types": "./pkg/macroforge_ts.d.ts",
+  "version": "0.1.79"
 }

package/pkg/macroforge_ts.d.ts

@@ -0,0 +1,97 @@
+/* tslint:disable */
+/* eslint-disable */
+
+export function Derive(): void;
+
+export class NativeMapper {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    expandedToOriginal(pos: number): number | undefined;
+    generatedBy(pos: number): string | undefined;
+    isEmpty(): boolean;
+    isInGenerated(pos: number): boolean;
+    mapSpanToExpanded(start: number, length: number): any;
+    mapSpanToOriginal(start: number, length: number): any;
+    originalToExpanded(pos: number): number;
+}
+
+export class NativePlugin {
+    free(): void;
+    [Symbol.dispose](): void;
+    expandSync(code: string, filepath: string, options: any): any;
+    getMapper(filepath: string): NativeMapper | undefined;
+    log(_message: string): void;
+    mapDiagnostics(filepath: string, diags: any): any;
+    constructor();
+    processFile(filepath: string, code: string, options: any): any;
+    transformSync(code: string, filepath: string): any;
+}
+
+export class NativePositionMapper {
+    free(): void;
+    [Symbol.dispose](): void;
+    mapToExpanded(_line: number, _column: number): any;
+    mapToOriginal(_line: number, _column: number): any;
+    constructor(_mapping: any);
+}
+
+export function __macroforgeDebugDescriptors(): any;
+
+export function __macroforgeDebugGetModules(): any;
+
+export function __macroforgeDebugLookup(module: string, name: string): string;
+
+export function __macroforgeGetMacroNames(): any;
+
+export function __macroforgeGetManifest(): any;
+
+export function __macroforgeIsMacroPackage(): boolean;
+
+export function __macroforgeRunClone(context_json: string): string;
+
+export function __macroforgeRunDebug(context_json: string): string;
+
+export function __macroforgeRunDefault(context_json: string): string;
+
+export function __macroforgeRunDeserialize(context_json: string): string;
+
+export function __macroforgeRunHash(context_json: string): string;
+
+export function __macroforgeRunOrd(context_json: string): string;
+
+export function __macroforgeRunPartialEq(context_json: string): string;
+
+export function __macroforgeRunPartialOrd(context_json: string): string;
+
+export function __macroforgeRunSerialize(context_json: string): string;
+
+export function checkSyntax(code: string, filepath: string): any;
+
+export function clearConfigCache(): void;
+
+export function expandSync(code: string, filepath: string, options: any): any;
+
+export function loadConfig(content: string, filepath: string): any;
+
+export function parseImportSources(code: string, filepath: string): any;
+
+export function scanProjectSync(root_dir: string, options: any): any;
+
+/**
+ * Register JS callbacks for resolving and running external (user-defined) macros.
+ *
+ * Required for WASM builds. The native (NAPI) build resolves external macros
+ * by spawning a Node subprocess, but WASM cannot spawn processes. Instead, the
+ * host JS environment must provide two callbacks:
+ *
+ * resolve: Given a package path, return an array of decorator names exported by that package.
+ *
+ * run: Given a JSON-serialized MacroContextIR, execute the external macro and return a JSON-serialized MacroResult.
+ *
+ * Must be called before expandSync if the source uses import macro comments.
+ * Does not exist on NAPI builds, so guard the call.
+ */
+export function setupExternalMacros(resolve: Function, run: Function): void;
+
+export function transformSync(code: string, filepath: string): any;