macroforge 0.1.78 → 0.1.80

package/js/cli/tsc-wrapper.js

@@ -0,0 +1,198 @@
+/**
+ * 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 declarativeRegistryPath =
+  process.env.MACROFORGE_DECLARATIVE_REGISTRY_PATH;
+let declarativeRegistryJson = void 0;
+if (declarativeRegistryPath) {
+  try {
+    declarativeRegistryJson = fs.readFileSync(declarativeRegistryPath, "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;
+if (declarativeRegistryJson) {
+  tscExpandOpts.declarativeRegistryJson = declarativeRegistryJson;
+}
+const host = ts.createCompilerHost(options);
+const origGetSourceFile = host.getSourceFile.bind(host);
+// Text-level fast path: skip files that don't contain any macro markers.
+// Matches:
+//   - `@derive` (derive macros)
+//   - `macroforge/rules` (declarative-macro-defining files that
+//     `import { macroRules } from "macroforge/rules"`)
+//   - `import macro` inside a JSDoc comment (declarative-macro-consuming
+//     files that use `/** import macro { $name } from "./file" */`)
+function hasMacroMarkers(sourceText) {
+  if (!sourceText) return false;
+  if (sourceText.includes("@derive")) return true;
+  if (sourceText.includes("macroforge/rules")) return true;
+  if (sourceText.includes("import macro")) return true;
+  return false;
+}
+host.getSourceFile = (fileName, languageVersion, ...rest) => {
+  try {
+    if (
+      (fileName.endsWith(".ts") || fileName.endsWith(".tsx")) &&
+      !fileName.endsWith(".d.ts")
+    ) {
+      const sourceText = ts.sys.readFile(fileName);
+      if (hasMacroMarkers(sourceText)) {
+        const result = plugin.processFile(fileName, sourceText, tscExpandOpts);
+        const text = result.code || sourceText;
+        return ts.createSourceFile(fileName, text, languageVersion, true);
+      }
+    }
+  } catch (e) {
+    if (process.env.MACROFORGE_DEBUG_WRAPPER) {
+      console.error(
+        `[macroforge tsc wrapper] expand failed for ${fileName}:`,
+        e,
+      );
+    }
+  }
+  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/rules/index.d.ts

@@ -0,0 +1,94 @@
+/**
+ * # Macroforge Rules Module
+ *
+ * Declarative pattern-matching macros for TypeScript. Define macros with
+ * `` const $name = macroRules`...` ``, invoke them as `$name(args)`, and the
+ * macroforge build pass rewrites call sites at compile time.
+ *
+ * Example:
+ *
+ * ```typescript
+ * import { macroRules } from "macroforge/rules";
+ *
+ * const $vec = macroRules`
+ *   () => []
+ *
+ *   ($($x:Expr),+ $(,)?) => {
+ *     const __v = [];
+ *     $( __v.push($x); )+
+ *     __v
+ *   }
+ * `;
+ *
+ * const empty = $vec();
+ * const xs = $vec(1, 2, 3);
+ * ```
+ *
+ * ## Runtime behavior
+ *
+ * `macroRules` is a sentinel tag function. It throws at runtime if the
+ * macroforge build pass is not installed — if you see the runtime error,
+ * your build toolchain is not running macroforge on this file.
+ *
+ * @module macroforge/rules
+ */
+/**
+ * A macro invocation — a function that takes any arguments and may produce
+ * any value. The exact return type depends on the macro body; for accurate
+ * types, the macroforge build pass is responsible for erasing the macro
+ * definition and inlining the expansion at each call site. Only this
+ * placeholder shape is visible to the TypeScript type checker.
+ */
+export type MacroInvocation = (...args: any[]) => any;
+/**
+ * The macro definition tag function.
+ *
+ * At build time, `` const $name = macroRules`...` `` is recognized by
+ * macroforge, the template body is parsed as a macro definition, and the
+ * declaration is erased from the output. Call sites of `$name(...)` are
+ * rewritten in place with the matching arm's body.
+ *
+ * The return type is a generic callable, so TypeScript lets users invoke
+ * `$name(...)` without complaint. At runtime (if the build pass did not
+ * run) the tag itself throws — any caller would already have seen the
+ * compile-time rewrite.
+ */
+export declare function macroRules(_strings: TemplateStringsArray, ..._values: unknown[]): MacroInvocation;
+/**
+ * Configuration for a macro's reverse-monomorphization behavior.
+ *
+ * Currently a type-only declaration — the object form
+ * `macroRules({ expand, runtime, call, mode })` is part of the reverse-mono
+ * follow-up and is not yet wired through the build pass. The type is
+ * exported now so consumer code can start using the shape.
+ */
+export interface MacroConfig {
+    /**
+     * Controls how the macro emits in dev vs. prod builds.
+     *
+     * - `"auto"` (default): dev expands inline, prod shares runtime when safe.
+     * - `"expand-only"`: always expand inline at every call site.
+     * - `"share-only"`: always emit calls to a shared runtime helper.
+     * - `"share-anyway"`: share even past the megamorphism threshold.
+     */
+    readonly mode?: "auto" | "expand-only" | "share-only" | "share-anyway";
+    /**
+     * The expand-form macro template (used for dev + `expand-only` + type-check).
+     */
+    readonly expand?: unknown;
+    /**
+     * The shared runtime body, emitted once per module when the macro
+     * is in a sharing mode.
+     */
+    readonly runtime?: string;
+    /**
+     * The call-form template that replaces call sites when the macro
+     * is in a sharing mode.
+     */
+    readonly call?: unknown;
+    /**
+     * Above this count of distinct types calling the shared runtime,
+     * the megamorphism analyzer emits a warning. Default: 4.
+     */
+    readonly megamorphismThreshold?: number;
+}

package/js/rules/index.mjs

@@ -0,0 +1,9 @@
+// js/rules/index.ts
+function macroRules(_strings, ..._values) {
+  throw new Error(
+    "macroforge/rules: macros are compile-time only \u2014 they should have been erased by the macroforge build pass. If you're seeing this at runtime, the macroforge plugin is not installed or not running on this file."
+  );
+}
+export {
+  macroRules
+};

package/js/rules/index.ts

@@ -0,0 +1,109 @@
+/**
+ * # Macroforge Rules Module
+ *
+ * Declarative pattern-matching macros for TypeScript. Define macros with
+ * `` const $name = macroRules`...` ``, invoke them as `$name(args)`, and the
+ * macroforge build pass rewrites call sites at compile time.
+ *
+ * Example:
+ *
+ * ```typescript
+ * import { macroRules } from "macroforge/rules";
+ *
+ * const $vec = macroRules`
+ *   () => []
+ *
+ *   ($($x:Expr),+ $(,)?) => {
+ *     const __v = [];
+ *     $( __v.push($x); )+
+ *     __v
+ *   }
+ * `;
+ *
+ * const empty = $vec();
+ * const xs = $vec(1, 2, 3);
+ * ```
+ *
+ * ## Runtime behavior
+ *
+ * `macroRules` is a sentinel tag function. It throws at runtime if the
+ * macroforge build pass is not installed — if you see the runtime error,
+ * your build toolchain is not running macroforge on this file.
+ *
+ * @module macroforge/rules
+ */
+
+/**
+ * A macro invocation — a function that takes any arguments and may produce
+ * any value. The exact return type depends on the macro body; for accurate
+ * types, the macroforge build pass is responsible for erasing the macro
+ * definition and inlining the expansion at each call site. Only this
+ * placeholder shape is visible to the TypeScript type checker.
+ */
+export type MacroInvocation = (...args: any[]) => any;
+
+/**
+ * The macro definition tag function.
+ *
+ * At build time, `` const $name = macroRules`...` `` is recognized by
+ * macroforge, the template body is parsed as a macro definition, and the
+ * declaration is erased from the output. Call sites of `$name(...)` are
+ * rewritten in place with the matching arm's body.
+ *
+ * The return type is a generic callable, so TypeScript lets users invoke
+ * `$name(...)` without complaint. At runtime (if the build pass did not
+ * run) the tag itself throws — any caller would already have seen the
+ * compile-time rewrite.
+ */
+export function macroRules(
+  _strings: TemplateStringsArray,
+  ..._values: unknown[]
+): MacroInvocation {
+  throw new Error(
+    "macroforge/rules: macros are compile-time only — they should have been erased by the macroforge build pass. " +
+      "If you're seeing this at runtime, the macroforge plugin is not installed or not running on this file.",
+  );
+}
+
+/**
+ * Configuration for a macro's reverse-monomorphization behavior.
+ *
+ * Currently a type-only declaration — the object form
+ * `macroRules({ expand, runtime, call, mode })` is part of the reverse-mono
+ * follow-up and is not yet wired through the build pass. The type is
+ * exported now so consumer code can start using the shape.
+ */
+export interface MacroConfig {
+  /**
+   * Controls how the macro emits in dev vs. prod builds.
+   *
+   * - `"auto"` (default): dev expands inline, prod shares runtime when safe.
+   * - `"expand-only"`: always expand inline at every call site.
+   * - `"share-only"`: always emit calls to a shared runtime helper.
+   * - `"share-anyway"`: share even past the megamorphism threshold.
+   */
+  readonly mode?: "auto" | "expand-only" | "share-only" | "share-anyway";
+
+  /**
+   * The expand-form macro template (used for dev + `expand-only` + type-check).
+   */
+  readonly expand?: unknown;
+
+  /**
+   * The shared runtime body, emitted once per module when the macro
+   * is in a sharing mode.
+   */
+  readonly runtime?: string;
+
+  /**
+   * The call-form template that replaces call sites when the macro
+   * is in a sharing mode.
+   */
+  readonly call?: unknown;
+
+  /**
+   * Above this count of distinct types calling the shared runtime,
+   * the megamorphism analyzer emits a warning. Default: 4.
+   */
+  readonly megamorphismThreshold?: number;
+}

package/package.json

@@ -1,92 +1,79 @@
 {
-  "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": ">= 24"
-  },
-  "exports": {
-    ".": {
-      "default": "./index.js",
-      "require": "./index.js",
-      "types": "./index.d.ts"
+    "author": "macroforge contributors",
+    "bugs": {
+        "url": "https://github.com/macroforge-ts/macroforge-ts/issues"
     },
-    "./reexports": {
-      "default": "./js/reexports/index.mjs",
-      "import": "./js/reexports/index.mjs",
-      "types": "./js/reexports/index.d.ts"
+    "description": "TypeScript macro expansion engine powered by Rust, Oxc, and WebAssembly",
+    "exports": {
+        ".": {
+            "require": "./pkg/macroforge_ts.js",
+            "types": "./pkg/macroforge_ts.d.ts",
+            "default": "./pkg/macroforge_ts.js"
+        },
+        "./buildtime": {
+            "import": "./js/buildtime/index.mjs",
+            "types": "./js/buildtime/index.d.ts",
+            "default": "./js/buildtime/index.mjs"
+        },
+        "./reexports": {
+            "import": "./js/reexports/index.mjs",
+            "types": "./js/reexports/index.d.ts",
+            "default": "./js/reexports/index.mjs"
+        },
+        "./reexports/effect": {
+            "import": "./js/reexports/effect.mjs",
+            "types": "./js/reexports/effect.d.ts",
+            "default": "./js/reexports/effect.mjs"
+        },
+        "./rules": {
+            "import": "./js/rules/index.mjs",
+            "types": "./js/rules/index.d.ts",
+            "default": "./js/rules/index.mjs"
+        },
+        "./serde": {
+            "import": "./js/serde/index.mjs",
+            "types": "./js/serde/index.d.ts",
+            "default": "./js/serde/index.mjs"
+        },
+        "./traits": {
+            "import": "./js/traits/index.mjs",
+            "types": "./js/traits/index.d.ts",
+            "default": "./js/traits/index.mjs"
+        }
     },
-    "./reexports/effect": {
-      "default": "./js/reexports/effect.mjs",
-      "import": "./js/reexports/effect.mjs",
-      "types": "./js/reexports/effect.d.ts"
+    "files": [
+        "js",
+        "pkg"
+    ],
+    "homepage": "https://github.com/macroforge-ts/macroforge-ts#readme",
+    "keywords": [
+        "typescript",
+        "macros",
+        "derive",
+        "codegen",
+        "oxc",
+        "wasm",
+        "webassembly"
+    ],
+    "license": "MIT",
+    "main": "./pkg/macroforge_ts.js",
+    "name": "macroforge",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/macroforge-ts/macroforge-ts.git"
     },
-    "./serde": {
-      "default": "./js/serde/index.mjs",
-      "import": "./js/serde/index.mjs",
-      "types": "./js/serde/index.d.ts"
+    "scripts": {
+        "build": "deno task build:wasm",
+        "build:buildtime": "deno run -A npm:esbuild js/buildtime/index.ts --bundle --outfile=js/buildtime/index.mjs --format=esm && deno run -A npm:typescript/tsc js/buildtime/index.ts --declaration --emitDeclarationOnly --outDir js/buildtime --lib ES2024 --skipLibCheck",
+        "build:js": "deno task build:serde && deno task build:traits && deno task build:rules && deno task build:buildtime",
+        "build:rules": "deno run -A npm:esbuild js/rules/index.ts --bundle --outfile=js/rules/index.mjs --format=esm && deno run -A npm:typescript/tsc js/rules/index.ts --declaration --emitDeclarationOnly --outDir js/rules --lib ES2024 --skipLibCheck",
+        "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",
+        "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"
     },
-    "./traits": {
-      "default": "./js/traits/index.mjs",
-      "import": "./js/traits/index.mjs",
-      "types": "./js/traits/index.d.ts"
-    }
-  },
-  "files": [
-    "index.d.ts",
-    "index.js",
-    "js"
-  ],
-  "homepage": "https://github.com/macroforge-ts/core#readme",
-  "keywords": [
-    "typescript",
-    "macros",
-    "derive",
-    "codegen",
-    "swc"
-  ],
-  "license": "MIT",
-  "main": "index.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.78",
-    "@macroforge/bin-darwin-x64": "0.1.78",
-    "@macroforge/bin-linux-arm64-gnu": "0.1.78",
-    "@macroforge/bin-linux-x64-gnu": "0.1.78",
-    "@macroforge/bin-win32-arm64-msvc": "0.1.78",
-    "@macroforge/bin-win32-x64-msvc": "0.1.78"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/macroforge-ts/core.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: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",
-    "cleanbuild": "deno task clean && deno task build"
-  },
-  "type": "commonjs",
-  "types": "index.d.ts",
-  "version": "0.1.78"
+    "type": "commonjs",
+    "types": "./pkg/macroforge_ts.d.ts",
+    "version": "0.1.80"
 }