@mmapp/react-compiler 0.1.0-alpha.1 → 0.1.0-alpha.4

package/dist/chunk-4OPI5L7G.mjs

@@ -0,0 +1,2593 @@
+import {
+  babelPlugin,
+  init_ts_to_expression,
+  transpileBlock,
+  ts_to_expression_exports
+} from "./chunk-FYT47UBU.mjs";
+import {
+  __toCommonJS
+} from "./chunk-CIESM3BP.mjs";
+
+// src/project-compiler.ts
+import { transformSync as transformSync3 } from "@babel/core";
+
+// src/babel/extractors/router-extractor.ts
+function pathToStateName(routePath) {
+  if (!routePath || routePath === "" || routePath === "/") return "HOME";
+  return routePath.split("/").filter(Boolean).map((segment) => {
+    if (segment.startsWith("[") && segment.endsWith("]")) {
+      return segment.slice(1, -1);
+    }
+    return segment;
+  }).join("_").replace(/([a-z])([A-Z])/g, "$1_$2").toUpperCase().replace(/-/g, "_");
+}
+function pathToUrlPattern(relativePath, pageFileName = "page.tsx") {
+  let routePath = relativePath.replace(new RegExp(`/?${pageFileName.replace(".", "\\.")}$`), "");
+  routePath = routePath.replace(/\[([^\]]+)\]/g, ":$1");
+  return "/" + routePath;
+}
+function extractParams(relativePath) {
+  const params = [];
+  const paramRegex = /\[([^\]]+)\]/g;
+  let match;
+  while ((match = paramRegex.exec(relativePath)) !== null) {
+    params.push(match[1]);
+  }
+  return params;
+}
+function extractRouterWorkflow(pages, options = {}) {
+  const {
+    slug = "app-router",
+    pageFileName = "page.tsx",
+    layoutFileName = "layout.tsx"
+  } = options;
+  const pageFiles = pages.filter((p) => !p.isLayout && p.relativePath.endsWith(pageFileName));
+  const layoutFiles = pages.filter((p) => p.isLayout || p.relativePath.endsWith(layoutFileName));
+  const routeStates = [];
+  const stateMap = /* @__PURE__ */ new Map();
+  for (const page of pageFiles) {
+    const routePath = page.relativePath.replace(new RegExp(`/?${pageFileName.replace(".", "\\.")}$`), "");
+    const stateName = pathToStateName(routePath);
+    const urlPattern = pathToUrlPattern(page.relativePath, pageFileName);
+    const params = extractParams(page.relativePath);
+    const layoutBoundary = findLayoutBoundary(page.relativePath, layoutFiles);
+    const routeState = {
+      name: stateName,
+      path: urlPattern,
+      params,
+      layoutBoundary,
+      sourceFile: page.relativePath,
+      type: stateName === "HOME" ? "START" : "REGULAR"
+    };
+    routeStates.push(routeState);
+    stateMap.set(stateName, routeState);
+  }
+  if (!stateMap.has("HOME") && routeStates.length > 0) {
+    routeStates[0].type = "START";
+  }
+  const states = routeStates.map((rs) => ({
+    name: rs.name,
+    type: rs.type,
+    description: `Route: ${rs.path}`,
+    on_enter: [],
+    during: [],
+    on_exit: []
+  }));
+  const transitions = [];
+  let transitionId = 0;
+  for (const page of pageFiles) {
+    if (!page.navigationTargets) continue;
+    const fromPath = page.relativePath.replace(new RegExp(`/?${pageFileName.replace(".", "\\.")}$`), "");
+    const fromState = pathToStateName(fromPath);
+    for (const target of page.navigationTargets) {
+      const targetPath = target.replace(/^\//, "").replace(/\/page\.(tsx|ts|jsx|js)$/, "");
+      const toState = pathToStateName(targetPath);
+      if (stateMap.has(toState) || toState === fromState) continue;
+      const transitionName = `navigate_to_${toState.toLowerCase()}`;
+      transitions.push({
+        name: transitionName,
+        from: [fromState],
+        to: toState,
+        actions: [],
+        conditions: []
+      });
+      transitionId++;
+    }
+  }
+  if (routeStates.length > 1) {
+    for (const rs of routeStates) {
+      if (rs.type !== "START") {
+        transitions.push({
+          name: `navigate_home_from_${rs.name.toLowerCase()}`,
+          from: [rs.name],
+          to: "HOME",
+          actions: [],
+          conditions: []
+        });
+      }
+    }
+  }
+  const fields = [];
+  const seenParams = /* @__PURE__ */ new Set();
+  for (const rs of routeStates) {
+    for (const param of rs.params) {
+      if (seenParams.has(param)) continue;
+      seenParams.add(param);
+      fields.push({
+        name: param,
+        type: "text",
+        required: false,
+        default_value: ""
+      });
+    }
+  }
+  const routeMetadata = routeStates.map((rs) => ({
+    state: rs.name,
+    path: rs.path,
+    params: rs.params,
+    layoutBoundary: rs.layoutBoundary,
+    sourceFile: rs.sourceFile
+  }));
+  return {
+    slug,
+    name: "Router",
+    version: "1.0.0",
+    description: "Auto-derived router workflow from file-based routing",
+    category: "router",
+    fields,
+    states,
+    transitions,
+    roles: [],
+    tags: [{ tag_name: "auto-derived" }, { tag_name: "router" }],
+    metadata: {
+      runtime: "local",
+      routes: routeMetadata,
+      layoutBoundaries: layoutFiles.map((l) => l.relativePath)
+    }
+  };
+}
+function findLayoutBoundary(pageRelativePath, layoutFiles) {
+  const layoutPaths = layoutFiles.map((l) => l.relativePath);
+  const parts = pageRelativePath.split("/");
+  for (let i = parts.length - 1; i >= 0; i--) {
+    const dir = parts.slice(0, i).join("/");
+    const layoutPath = dir ? `${dir}/layout.tsx` : "layout.tsx";
+    if (layoutPaths.includes(layoutPath)) {
+      return layoutPath;
+    }
+  }
+  return void 0;
+}
+
+// src/model-compiler.ts
+import { transformSync } from "@babel/core";
+function extractInterfaceName(source) {
+  const match = source.match(/export\s+interface\s+(\w+)/);
+  return match ? match[1] : "Unknown";
+}
+function extractWorkflowAnnotation(source) {
+  const result = {};
+  const workflowMatch = source.match(/@workflow\s+(.+)/);
+  if (workflowMatch) {
+    const attrs = workflowMatch[1];
+    const slugM = attrs.match(/slug="([^"]+)"/);
+    if (slugM) result.slug = slugM[1];
+    const versionM = attrs.match(/version="([^"]+)"/);
+    if (versionM) result.version = versionM[1];
+    const categoryM = attrs.match(/category="([^"]+)"/);
+    if (categoryM) result.category = categoryM[1];
+  }
+  const descMatch = source.match(/@description\s+(.+)/);
+  if (descMatch) result.description = descMatch[1].trim();
+  return result;
+}
+function extractFieldOptionsRaw(source) {
+  const result = {};
+  const match = source.match(/export\s+const\s+fieldOptions\s*=\s*\{([\s\S]*?)\};/);
+  if (!match) return result;
+  const body = match[1];
+  const fieldRegex = /(\w+)\s*:\s*\{([^}]*)\}/g;
+  let fieldMatch;
+  while ((fieldMatch = fieldRegex.exec(body)) !== null) {
+    const fieldName = fieldMatch[1];
+    const optionsBody = fieldMatch[2];
+    const opts = {};
+    const kvRegex = /(\w+)\s*:\s*(?:'([^']*)'|"([^"]*)"|\[([^\]]*)\]|(\d+(?:\.\d+)?)|(\w+))/g;
+    let kvMatch;
+    while ((kvMatch = kvRegex.exec(optionsBody)) !== null) {
+      const key = kvMatch[1];
+      const strVal = kvMatch[2] ?? kvMatch[3];
+      const arrVal = kvMatch[4];
+      const numVal = kvMatch[5];
+      const identVal = kvMatch[6];
+      if (strVal !== void 0) {
+        opts[key] = strVal;
+      } else if (arrVal !== void 0) {
+        opts[key] = arrVal.split(",").map((s) => s.trim().replace(/['"]/g, "")).filter(Boolean);
+      } else if (numVal !== void 0) {
+        opts[key] = Number(numVal);
+      } else if (identVal !== void 0) {
+        if (identVal === "true") opts[key] = true;
+        else if (identVal === "false") opts[key] = false;
+        else opts[key] = identVal;
+      }
+    }
+    result[fieldName] = opts;
+  }
+  return result;
+}
+function compileModel(filename, source, options = {}) {
+  const mode = options.mode || "infer";
+  const interfaceName = extractInterfaceName(source);
+  const annotation = extractWorkflowAnnotation(source);
+  const rawFieldOptions = extractFieldOptionsRaw(source);
+  const parserPlugins = filename.endsWith(".tsx") ? ["typescript", "jsx"] : ["typescript"];
+  const babelResult = transformSync(source, {
+    filename,
+    plugins: [[babelPlugin, { mode }]],
+    parserOpts: { plugins: parserPlugins, attachComment: true }
+  });
+  const ir = babelResult?.metadata?.mindmatrixIR ?? createEmptyModelIR(interfaceName);
+  ir.category = options.categoryOverride || annotation.category || "data";
+  if (options.slugOverride) {
+    ir.slug = options.slugOverride;
+  }
+  if (ir.states.length === 0) {
+    ir.states.push({
+      name: "draft",
+      type: "START",
+      on_enter: [],
+      during: [],
+      on_exit: []
+    });
+  }
+  const hasStart = ir.states.some((s) => s.type === "START");
+  if (!hasStart && ir.states.length > 0) {
+    ir.states[0].type = "START";
+  }
+  if (!ir.metadata) ir.metadata = {};
+  const meta = ir.metadata;
+  meta.sourceInterface = interfaceName;
+  meta.fieldOptions = rawFieldOptions;
+  meta.provenance = {
+    frontend: "react-compiler",
+    source: "model",
+    compiler_version: "2.0.0"
+  };
+  return {
+    ir,
+    interfaceName,
+    fieldNames: ir.fields.map((f) => f.name),
+    transitionNames: ir.transitions.map((t2) => t2.name),
+    stateNames: ir.states.map((s) => s.name),
+    hasFieldOptions: Object.keys(rawFieldOptions).length > 0,
+    fieldOptions: rawFieldOptions
+  };
+}
+function compileModels(files, options = {}) {
+  const results = /* @__PURE__ */ new Map();
+  for (const [filename, source] of Object.entries(files)) {
+    try {
+      const compiled = compileModel(filename, source, options);
+      results.set(filename, compiled);
+    } catch (_err) {
+      const iface = extractInterfaceName(source);
+      results.set(filename, {
+        ir: createEmptyModelIR(iface),
+        interfaceName: iface,
+        fieldNames: [],
+        transitionNames: [],
+        stateNames: ["draft"],
+        hasFieldOptions: false,
+        fieldOptions: {}
+      });
+    }
+  }
+  return results;
+}
+function createEmptyModelIR(interfaceName) {
+  const slug = interfaceName.replace(/([A-Z])/g, "-$1").toLowerCase().replace(/^-/, "");
+  return {
+    slug,
+    name: interfaceName,
+    version: "1.0.0",
+    description: "Data model: " + interfaceName,
+    category: "data",
+    fields: [],
+    states: [{
+      name: "draft",
+      type: "START",
+      on_enter: [],
+      during: [],
+      on_exit: []
+    }],
+    transitions: [],
+    roles: [],
+    tags: [{ tag_name: "data" }, { tag_name: "model" }],
+    metadata: {
+      sourceInterface: interfaceName,
+      provenance: {
+        frontend: "react-compiler",
+        source: "model",
+        compiler_version: "2.0.0"
+      }
+    }
+  };
+}
+
+// src/route-extractor.ts
+function filePathToUrlPattern(filePath, rootDir) {
+  let route = filePath;
+  const rootPrefix = rootDir + "/";
+  if (route.startsWith(rootPrefix)) {
+    route = route.slice(rootPrefix.length);
+  }
+  route = route.replace(/\.(tsx?|jsx?)$/, "");
+  route = route.replace(/\/(page|index)$/, "");
+  if (route === "page" || route === "index" || route === "") {
+    return "/";
+  }
+  route = route.replace(/\[([^\]]+)\]/g, ":$1");
+  return "/" + route;
+}
+function urlToStateName(urlPath) {
+  if (urlPath === "/") return "HOME";
+  return urlPath.split("/").filter(Boolean).map((segment) => segment.replace(/^:/, "")).join("_").replace(/([a-z])([A-Z])/g, "$1_$2").replace(/-/g, "_").toUpperCase();
+}
+function extractRouteParams(filePath) {
+  const params = [];
+  const regex = /\[([^\]]+)\]/g;
+  let match;
+  while ((match = regex.exec(filePath)) !== null) {
+    params.push(match[1]);
+  }
+  return params;
+}
+function routeDepth(urlPath) {
+  if (urlPath === "/") return 0;
+  return urlPath.split("/").filter(Boolean).length;
+}
+function isPageFile(filename, pageFileName) {
+  if (filename.endsWith("/" + pageFileName)) return true;
+  return /\.(tsx|ts|jsx|js)$/.test(filename) && !filename.endsWith(".test.ts") && !filename.endsWith(".test.tsx") && !filename.includes("layout");
+}
+function isLayoutFile(filename, layoutFileName) {
+  return filename.endsWith("/" + layoutFileName) || filename.endsWith(layoutFileName);
+}
+function extractRoutes(files, options = {}) {
+  const rootDir = options.rootDir || "app";
+  const pageFileName = options.pageFileName || "page.tsx";
+  const layoutFileName = options.layoutFileName || "layout.tsx";
+  const slugPrefix = options.slugPrefix || "app";
+  const layouts = [];
+  for (const filename of Object.keys(files)) {
+    if (isLayoutFile(filename, layoutFileName)) {
+      const dir = filename.replace(/\/[^/]+$/, "");
+      layouts.push({
+        sourceFile: filename,
+        directory: dir,
+        depth: dir.split("/").filter(Boolean).length
+      });
+    }
+  }
+  layouts.sort((a, b) => a.depth - b.depth);
+  const routes = [];
+  const allParams = /* @__PURE__ */ new Set();
+  for (const filename of Object.keys(files)) {
+    if (isLayoutFile(filename, layoutFileName)) continue;
+    if (!filename.startsWith(rootDir + "/") && !filename.startsWith(rootDir)) continue;
+    if (!isPageFile(filename, pageFileName)) continue;
+    const urlPath = filePathToUrlPattern(filename, rootDir);
+    const stateName = urlToStateName(urlPath);
+    const params = extractRouteParams(filename);
+    const depth = routeDepth(urlPath);
+    const fileDir = filename.replace(/\/[^/]+$/, "");
+    let layoutBoundary;
+    for (let i = layouts.length - 1; i >= 0; i--) {
+      if (fileDir.startsWith(layouts[i].directory)) {
+        layoutBoundary = layouts[i].sourceFile;
+        break;
+      }
+    }
+    for (const p of params) allParams.add(p);
+    routes.push({
+      path: urlPath,
+      stateName,
+      sourceFile: filename,
+      params,
+      layoutBoundary,
+      depth
+    });
+  }
+  routes.sort((a, b) => a.path.localeCompare(b.path));
+  const routerIR = buildRouterIR(routes, layouts, Array.from(allParams), slugPrefix);
+  return {
+    routes,
+    layouts,
+    routerIR,
+    allParams: Array.from(allParams)
+  };
+}
+function buildRouterIR(routes, layouts, allParams, slugPrefix) {
+  const states = routes.map((route) => ({
+    name: route.stateName,
+    type: route.path === "/" ? "START" : "REGULAR",
+    description: "Route: " + route.path,
+    on_enter: [],
+    during: [],
+    on_exit: []
+  }));
+  if (states.length > 0 && !states.some((s) => s.type === "START")) {
+    states[0].type = "START";
+  }
+  const transitions = [];
+  for (const from of routes) {
+    for (const to of routes) {
+      if (from.stateName === to.stateName) continue;
+      transitions.push({
+        name: "nav_" + from.stateName.toLowerCase() + "_to_" + to.stateName.toLowerCase(),
+        from: [from.stateName],
+        to: to.stateName,
+        actions: [],
+        conditions: []
+      });
+    }
+  }
+  const fields = allParams.map((param) => ({
+    name: param,
+    type: "text",
+    label: param.replace(/([A-Z])/g, " $1").replace(/^./, (c) => c.toUpperCase()),
+    required: false,
+    default_value: ""
+  }));
+  fields.push({
+    name: "current_route",
+    type: "text",
+    label: "Current Route",
+    required: false,
+    default_value: "/"
+  });
+  return {
+    slug: slugPrefix + "-router",
+    name: "Router",
+    version: "1.0.0",
+    description: "Auto-generated router from app/ directory structure",
+    category: "router",
+    fields,
+    states,
+    transitions,
+    roles: [],
+    tags: [{ tag_name: "auto-derived" }, { tag_name: "router" }],
+    metadata: {
+      runtime: "local",
+      routes: routes.map((r) => ({
+        state: r.stateName,
+        path: r.path,
+        params: r.params,
+        layoutBoundary: r.layoutBoundary,
+        sourceFile: r.sourceFile
+      })),
+      layoutBoundaries: layouts.map((l) => l.sourceFile),
+      provenance: {
+        frontend: "react-compiler",
+        source: "route-extractor",
+        compiler_version: "2.0.0"
+      }
+    }
+  };
+}
+
+// src/action-compiler.ts
+import { transformSync as transformSync2 } from "@babel/core";
+function extractActionGroup(filename) {
+  const base = filename.split("/").pop() || filename;
+  return base.replace(/\.server\.(ts|tsx|js|jsx)$/, "");
+}
+function generateEndpoint(blueprintSlug, group, actionName, apiBasePath) {
+  return apiBasePath + "/" + blueprintSlug + "/" + group + "/" + actionName;
+}
+function generateActionId(group, actionName) {
+  return group + ":" + actionName;
+}
+function extractFunctionBodies(source) {
+  const result = /* @__PURE__ */ new Map();
+  const funcHeaderRegex = /export\s+(async\s+)?function\s+(\w+)\s*\(/g;
+  let headerMatch;
+  while ((headerMatch = funcHeaderRegex.exec(source)) !== null) {
+    const funcName = headerMatch[2];
+    const startIdx = headerMatch.index;
+    let braceStart = source.indexOf("{", headerMatch.index + headerMatch[0].length);
+    if (braceStart === -1) continue;
+    const signatureSlice = source.slice(headerMatch.index + headerMatch[0].length, braceStart);
+    const returnTypeMatch = signatureSlice.match(/\)\s*:\s*([^{]+)/);
+    const returnType = returnTypeMatch ? returnTypeMatch[1].trim() : void 0;
+    let depth = 0;
+    let endIdx = braceStart;
+    for (let i = braceStart; i < source.length; i++) {
+      if (source[i] === "{") depth++;
+      else if (source[i] === "}") {
+        depth--;
+        if (depth === 0) {
+          endIdx = i + 1;
+          break;
+        }
+      }
+    }
+    const fullText = source.slice(startIdx, endIdx);
+    result.set(funcName, { body: fullText, returnType });
+  }
+  return result;
+}
+function extractActionsViaRegex(source) {
+  const actions = [];
+  const funcRegex = /(?:\/\*\*([\s\S]*?)\*\/\s*)?export\s+(async\s+)?function\s+(\w+)\s*\(([^)]*)\)/g;
+  let match;
+  while ((match = funcRegex.exec(source)) !== null) {
+    const jsdoc = match[1];
+    const isAsync = !!match[2];
+    const name = match[3];
+    const paramsStr = match[4];
+    const params = paramsStr.split(",").map((p) => p.trim().split(":")[0].trim().split("?")[0].trim()).filter(Boolean);
+    let description;
+    if (jsdoc) {
+      const lines = jsdoc.split("\n");
+      for (const line of lines) {
+        const trimmed = line.replace(/^\s*\*\s?/, "").trim();
+        if (trimmed && !trimmed.startsWith("@")) {
+          description = trimmed;
+          break;
+        }
+      }
+    }
+    actions.push({ name, async: isAsync, params, description });
+  }
+  const arrowRegex = /export\s+const\s+(\w+)\s*=\s*(async\s+)?\([^)]*\)/g;
+  while ((match = arrowRegex.exec(source)) !== null) {
+    const name = match[1];
+    const isAsync = !!match[2];
+    const arrowParamMatch = source.slice(match.index).match(/\(([^)]*)\)/);
+    const params = arrowParamMatch ? arrowParamMatch[1].split(",").map((p) => p.trim().split(":")[0].trim()).filter(Boolean) : [];
+    actions.push({ name, async: isAsync, params });
+  }
+  return actions;
+}
+function compileActions(files, options = {}) {
+  const mode = options.mode || "infer";
+  const blueprintSlug = options.blueprintSlug || "app";
+  const apiBasePath = options.apiBasePath || "/api/v1/actions";
+  const allActions = [];
+  const byFile = /* @__PURE__ */ new Map();
+  const byGroup = /* @__PURE__ */ new Map();
+  const errors = [];
+  for (const [filename, source] of Object.entries(files)) {
+    const group = extractActionGroup(filename);
+    const fileActions = [];
+    const bodies = extractFunctionBodies(source);
+    try {
+      const parserPlugins = filename.endsWith(".tsx") ? ["typescript", "jsx"] : ["typescript"];
+      const babelResult = transformSync2(source, {
+        filename,
+        plugins: [[babelPlugin, { mode }]],
+        parserOpts: { plugins: parserPlugins, attachComment: true }
+      });
+      const ir = babelResult?.metadata?.mindmatrixIR ?? null;
+      const meta = ir?.metadata;
+      const babelActions = meta?.serverActions;
+      if (babelActions && babelActions.length > 0) {
+        for (const action of babelActions) {
+          const bodyInfo = bodies.get(action.name);
+          const reg = {
+            name: action.name,
+            sourceFile: filename,
+            async: action.async,
+            params: action.params,
+            contextType: action.contextType,
+            description: action.description,
+            body: bodyInfo?.body,
+            returnType: bodyInfo?.returnType,
+            endpoint: generateEndpoint(blueprintSlug, group, action.name, apiBasePath),
+            group,
+            actionId: generateActionId(group, action.name)
+          };
+          fileActions.push(reg);
+        }
+      } else {
+        const regexActions = extractActionsViaRegex(source);
+        for (const action of regexActions) {
+          const bodyInfo = bodies.get(action.name);
+          const reg = {
+            name: action.name,
+            sourceFile: filename,
+            async: action.async,
+            params: action.params,
+            description: action.description,
+            body: bodyInfo?.body,
+            returnType: bodyInfo?.returnType,
+            endpoint: generateEndpoint(blueprintSlug, group, action.name, apiBasePath),
+            group,
+            actionId: generateActionId(group, action.name)
+          };
+          fileActions.push(reg);
+        }
+      }
+    } catch (err) {
+      errors.push({ file: filename, message: err.message });
+      const regexActions = extractActionsViaRegex(source);
+      for (const action of regexActions) {
+        const bodyInfo = bodies.get(action.name);
+        const reg = {
+          name: action.name,
+          sourceFile: filename,
+          async: action.async,
+          params: action.params,
+          description: action.description,
+          body: bodyInfo?.body,
+          returnType: bodyInfo?.returnType,
+          endpoint: generateEndpoint(blueprintSlug, group, action.name, apiBasePath),
+          group,
+          actionId: generateActionId(group, action.name)
+        };
+        fileActions.push(reg);
+      }
+    }
+    byFile.set(filename, fileActions);
+    if (!byGroup.has(group)) byGroup.set(group, []);
+    byGroup.get(group).push(...fileActions);
+    allActions.push(...fileActions);
+  }
+  return { actions: allActions, byFile, byGroup, errors };
+}
+function resolveActionReferences(actionNames, registrations) {
+  const result = /* @__PURE__ */ new Map();
+  const byName = new Map(registrations.map((r) => [r.name, r]));
+  for (const name of actionNames) {
+    if (byName.has(name)) {
+      result.set(name, byName.get(name));
+      continue;
+    }
+    const colonIdx = name.indexOf(":");
+    if (colonIdx > 0) {
+      const actionName = name.slice(colonIdx + 1);
+      if (byName.has(actionName)) {
+        result.set(name, byName.get(actionName));
+        continue;
+      }
+    }
+    result.set(name, null);
+  }
+  return result;
+}
+
+// src/babel/extractors/action-extractor.ts
+init_ts_to_expression();
+import { parse } from "@babel/parser";
+import * as t from "@babel/types";
+function extractAction(source, filename) {
+  let ast;
+  try {
+    ast = parse(source, {
+      sourceType: "module",
+      plugins: ["typescript"],
+      strictMode: false
+    });
+  } catch {
+    return null;
+  }
+  const result = findDefaultExportedFunction(ast);
+  if (!result) return null;
+  const { name, params, body, returnTypeAnnotation, isAsync } = result;
+  const slug = toKebabCase(name);
+  const warnings = [];
+  const fields = params.map((p) => paramToField(p));
+  const parameterMap = /* @__PURE__ */ new Map();
+  for (const p of params) {
+    const snakeName = toSnakeCase(p.name);
+    if (snakeName !== p.name) {
+      parameterMap.set(p.name, snakeName);
+    }
+  }
+  const humanName = name.replace(/([A-Z])/g, " $1").replace(/^./, (s) => s.toUpperCase()).trim();
+  const metadata = {
+    source_file: filename,
+    source_function: name,
+    provenance: {
+      frontend: "react-compiler",
+      source: "action-extractor",
+      compiler_version: "2.0.0"
+    }
+  };
+  if (returnTypeAnnotation) {
+    metadata.return_type = returnTypeAnnotation;
+  }
+  if (isAsync) {
+    const segments = splitAtAwaits(body.body);
+    const hasAwaits = segments.some((s) => s.kind === "await");
+    if (hasAwaits) {
+      const rewritten = rewriteAwaitReferences(segments);
+      const { states: states2, transitions: transitions2, bodyIsPure } = generateMultiStateIR(rewritten, warnings, parameterMap);
+      if (!bodyIsPure) {
+        warnings.push(`Async action '${name}' body contains untranslatable JS \u2014 wrapped in $expr() markers`);
+      }
+      const ir2 = {
+        slug,
+        name: humanName,
+        version: "0.1.0",
+        category: "action",
+        fields,
+        states: states2,
+        transitions: transitions2,
+        roles: [],
+        metadata: { ...metadata, async: true }
+      };
+      return { ir: ir2, bodyIsPure, warnings };
+    }
+  }
+  const transpileResult = transpileBlock(body, { allMutable: true, parameterMap });
+  const bodyExpr = transpileResult.expression;
+  if (!transpileResult.pure) {
+    warnings.push(`Action '${name}' body contains untranslatable JS \u2014 wrapped in $expr() markers`);
+  }
+  const states = [
+    {
+      name: "ready",
+      type: "START",
+      on_enter: [],
+      during: [],
+      on_exit: []
+    },
+    {
+      name: "done",
+      type: "END",
+      on_enter: [],
+      during: [],
+      on_exit: []
+    }
+  ];
+  const transitions = [
+    {
+      name: "execute",
+      from: ["ready"],
+      to: "done",
+      actions: [
+        {
+          id: "body",
+          type: "eval",
+          mode: "auto",
+          config: {
+            expression: bodyExpr
+          }
+        }
+      ]
+    }
+  ];
+  const ir = {
+    slug,
+    name: humanName,
+    version: "0.1.0",
+    category: "action",
+    fields,
+    states,
+    transitions,
+    roles: [],
+    metadata
+  };
+  return { ir, bodyIsPure: transpileResult.pure, warnings };
+}
+function findDefaultExportedFunction(ast) {
+  const topLevelVars = /* @__PURE__ */ new Map();
+  for (const node of ast.program.body) {
+    if (t.isVariableDeclaration(node)) {
+      for (const decl of node.declarations) {
+        if (t.isIdentifier(decl.id) && decl.init) {
+          if (t.isArrowFunctionExpression(decl.init) || t.isFunctionExpression(decl.init)) {
+            topLevelVars.set(decl.id.name, decl.init);
+          }
+        }
+      }
+    }
+  }
+  for (const node of ast.program.body) {
+    if (t.isExportDefaultDeclaration(node)) {
+      const decl = node.declaration;
+      if (t.isFunctionDeclaration(decl) && decl.body) {
+        const name = decl.id?.name ?? inferNameFromFile(decl) ?? "action";
+        return extractFromFunction(name, decl.params, decl.body, decl.returnType, decl.async);
+      }
+      if (t.isArrowFunctionExpression(decl) || t.isFunctionExpression(decl)) {
+        const name = t.isFunctionExpression(decl) && decl.id ? decl.id.name : "action";
+        const body = ensureBlock(decl.body);
+        if (!body) return null;
+        return extractFromFunction(name, decl.params, body, decl.returnType, decl.async);
+      }
+      if (t.isIdentifier(decl)) {
+        const fn = topLevelVars.get(decl.name);
+        if (fn) {
+          const body = ensureBlock(fn.body);
+          if (!body) return null;
+          return extractFromFunction(decl.name, fn.params, body, fn.returnType, fn.async);
+        }
+      }
+    }
+  }
+  return null;
+}
+function extractFromFunction(name, params, body, returnType, isAsync = false) {
+  const extracted = params.map((p) => extractParam(p));
+  const returnTypeAnnotation = returnType && t.isTSTypeAnnotation(returnType) ? serializeTSType(returnType.typeAnnotation) : void 0;
+  return { name, params: extracted, body, returnTypeAnnotation, isAsync };
+}
+function ensureBlock(body) {
+  if (t.isBlockStatement(body)) return body;
+  const ret = t.returnStatement(body);
+  return t.blockStatement([ret]);
+}
+function inferNameFromFile(_node) {
+  return null;
+}
+function extractParam(param) {
+  if (t.isIdentifier(param)) {
+    return {
+      name: param.name,
+      typeAnnotation: param.typeAnnotation ? param.typeAnnotation.typeAnnotation : null,
+      optional: param.optional ?? false
+    };
+  }
+  if (t.isAssignmentPattern(param)) {
+    const inner = param.left;
+    if (t.isIdentifier(inner)) {
+      return {
+        name: inner.name,
+        typeAnnotation: inner.typeAnnotation ? inner.typeAnnotation.typeAnnotation : null,
+        optional: true,
+        defaultValue: param.right
+      };
+    }
+  }
+  if (t.isRestElement(param)) {
+    const arg = param.argument;
+    return {
+      name: t.isIdentifier(arg) ? arg.name : "rest",
+      typeAnnotation: null,
+      optional: true
+    };
+  }
+  return { name: "params", typeAnnotation: null, optional: false };
+}
+function paramToField(param) {
+  const fieldType = param.typeAnnotation ? tsTypeToFieldType(param.typeAnnotation) : "text";
+  const field = {
+    name: toSnakeCase(param.name),
+    type: fieldType,
+    required: !param.optional
+  };
+  if (param.defaultValue !== void 0) {
+    field.default_value = extractLiteralDefault(param.defaultValue);
+  }
+  return field;
+}
+function extractLiteralDefault(expr) {
+  if (!expr) return void 0;
+  if (t.isStringLiteral(expr)) return expr.value;
+  if (t.isNumericLiteral(expr)) return expr.value;
+  if (t.isBooleanLiteral(expr)) return expr.value;
+  if (t.isNullLiteral(expr)) return null;
+  if (t.isArrayExpression(expr) && expr.elements.length === 0) return [];
+  if (t.isObjectExpression(expr) && expr.properties.length === 0) return {};
+  return void 0;
+}
+function tsTypeToFieldType(tsType) {
+  if (t.isTSStringKeyword(tsType)) return "text";
+  if (t.isTSNumberKeyword(tsType)) return "number";
+  if (t.isTSBooleanKeyword(tsType)) return "boolean";
+  if (t.isTSObjectKeyword(tsType)) return "json";
+  if (t.isTSAnyKeyword(tsType) || t.isTSUnknownKeyword(tsType)) return "json";
+  if (t.isTSArrayType(tsType)) return "json";
+  if (t.isTSUnionType(tsType)) {
+    const nonNullable = tsType.types.filter(
+      (t2) => !t.isTSNullKeyword(t2) && !t.isTSUndefinedKeyword(t2)
+    );
+    if (nonNullable.length === 1) {
+      return tsTypeToFieldType(nonNullable[0]);
+    }
+    if (nonNullable.every((t2) => t.isTSLiteralType(t2) && t.isStringLiteral(t2.literal))) {
+      return "select";
+    }
+    return "text";
+  }
+  if (t.isTSTypeReference(tsType) && t.isIdentifier(tsType.typeName)) {
+    const name = tsType.typeName.name;
+    if (name === "Date") return "datetime";
+    if (name === "string") return "text";
+    if (name === "number") return "number";
+    if (name === "boolean") return "boolean";
+  }
+  return "text";
+}
+function serializeTSType(tsType) {
+  if (t.isTSStringKeyword(tsType)) return "string";
+  if (t.isTSNumberKeyword(tsType)) return "number";
+  if (t.isTSBooleanKeyword(tsType)) return "boolean";
+  if (t.isTSVoidKeyword(tsType)) return "void";
+  if (t.isTSAnyKeyword(tsType)) return "any";
+  if (t.isTSTypeReference(tsType) && t.isIdentifier(tsType.typeName)) {
+    return tsType.typeName.name;
+  }
+  if (t.isTSArrayType(tsType)) return `${serializeTSType(tsType.elementType)}[]`;
+  if (t.isTSPromiseType(tsType)) {
+    return `Promise<${tsType.typeParameter ? serializeTSType(tsType.typeParameter.params[0]) : "unknown"}>`;
+  }
+  return "unknown";
+}
+function splitAtAwaits(body) {
+  const segments = [];
+  let current = [];
+  let index = 0;
+  for (const stmt of body) {
+    const awaitInfo = extractAwait(stmt);
+    if (!awaitInfo) {
+      current.push(stmt);
+      continue;
+    }
+    if (current.length > 0) {
+      segments.push({ index: index++, kind: "sync", statements: current });
+      current = [];
+    }
+    segments.push({
+      index: index++,
+      kind: "await",
+      statements: [stmt],
+      awaitTarget: awaitInfo.callee,
+      awaitArgs: awaitInfo.args,
+      resultBinding: awaitInfo.binding
+    });
+  }
+  if (current.length > 0) {
+    segments.push({ index: index++, kind: "sync", statements: current });
+  }
+  return segments;
+}
+function extractAwait(stmt) {
+  if (t.isVariableDeclaration(stmt)) {
+    const decl = stmt.declarations[0];
+    if (decl?.init && t.isAwaitExpression(decl.init)) {
+      const arg = decl.init.argument;
+      if (t.isCallExpression(arg)) {
+        return {
+          callee: getCalleeName(arg.callee),
+          args: arg.arguments,
+          binding: t.isIdentifier(decl.id) ? decl.id.name : void 0
+        };
+      }
+    }
+  }
+  if (t.isExpressionStatement(stmt) && t.isAwaitExpression(stmt.expression)) {
+    const arg = stmt.expression.argument;
+    if (t.isCallExpression(arg)) {
+      return {
+        callee: getCalleeName(arg.callee),
+        args: arg.arguments,
+        binding: void 0
+      };
+    }
+  }
+  if (t.isReturnStatement(stmt) && stmt.argument && t.isAwaitExpression(stmt.argument)) {
+    const arg = stmt.argument.argument;
+    if (t.isCallExpression(arg)) {
+      return {
+        callee: getCalleeName(arg.callee),
+        args: arg.arguments,
+        binding: void 0
+      };
+    }
+  }
+  return null;
+}
+function getCalleeName(callee) {
+  if (t.isIdentifier(callee)) return callee.name;
+  if (t.isMemberExpression(callee) && t.isIdentifier(callee.object) && t.isIdentifier(callee.property)) {
+    return `${callee.object.name}_${callee.property.name}`;
+  }
+  return "unknown_action";
+}
+function rewriteAwaitReferences(segments) {
+  const bindings = /* @__PURE__ */ new Map();
+  const slugCounts = /* @__PURE__ */ new Map();
+  return segments.map((seg) => {
+    if (seg.kind === "await" && seg.resultBinding) {
+      const slug = toSnakeCase(seg.awaitTarget ?? "unknown");
+      const count = (slugCounts.get(slug) ?? 0) + 1;
+      slugCounts.set(slug, count);
+      const key = count > 1 ? `${slug}_${count}` : slug;
+      bindings.set(seg.resultBinding, `action_results.${key}`);
+    }
+    if (seg.kind === "sync" && bindings.size > 0) {
+      return {
+        ...seg,
+        statements: seg.statements.map(
+          (stmt) => rewriteIdentifiersInStatement(stmt, bindings)
+        )
+      };
+    }
+    return seg;
+  });
+}
+function rewriteIdentifiersInStatement(stmt, _bindings) {
+  return stmt;
+}
+function generateMultiStateIR(segments, _warnings, parameterMap) {
+  const states = [];
+  const transitions = [];
+  let bodyIsPure = true;
+  const awaitBindings = /* @__PURE__ */ new Map();
+  const slugCounts = /* @__PURE__ */ new Map();
+  for (const seg of segments) {
+    if (seg.kind === "await" && seg.resultBinding) {
+      const slug = toSnakeCase(seg.awaitTarget ?? "unknown");
+      const count = (slugCounts.get(slug) ?? 0) + 1;
+      slugCounts.set(slug, count);
+      const key = count > 1 ? `${slug}_${count}` : slug;
+      awaitBindings.set(seg.resultBinding, `action_results.${key}`);
+    }
+  }
+  states.push({ name: "ready", type: "START", on_enter: [], during: [], on_exit: [] });
+  const usedStateNames = /* @__PURE__ */ new Set();
+  let prevState = "ready";
+  let transitionCount = 0;
+  let pendingSyncStmts = [];
+  for (const seg of segments) {
+    if (seg.kind === "sync") {
+      pendingSyncStmts.push(...seg.statements);
+      continue;
+    }
+    const targetSlug = toSnakeCase(seg.awaitTarget ?? "unknown");
+    let stateName = `awaiting_${targetSlug}`;
+    if (usedStateNames.has(stateName)) {
+      let suffix = 2;
+      while (usedStateNames.has(`${stateName}_${suffix}`)) suffix++;
+      stateName = `${stateName}_${suffix}`;
+    }
+    usedStateNames.add(stateName);
+    states.push({ name: stateName, type: "REGULAR", on_enter: [], during: [], on_exit: [] });
+    const actions = [];
+    if (pendingSyncStmts.length > 0) {
+      const block = t.blockStatement(pendingSyncStmts);
+      const transpiled = transpileBlock(block, {
+        allMutable: true,
+        derivedVarMap: buildDerivedVarMap(awaitBindings),
+        parameterMap
+      });
+      if (!transpiled.pure) bodyIsPure = false;
+      actions.push({
+        id: `pre_${transitionCount}`,
+        type: "eval",
+        mode: "auto",
+        config: { expression: transpiled.expression }
+      });
+      pendingSyncStmts = [];
+    }
+    const callConfig = {
+      definition_slug: seg.awaitTarget,
+      result_key: targetSlug
+    };
+    if (seg.awaitArgs && seg.awaitArgs.length > 0) {
+      const params = {};
+      for (let i = 0; i < seg.awaitArgs.length; i++) {
+        const arg = seg.awaitArgs[i];
+        if (t.isObjectExpression(arg)) {
+          for (const prop of arg.properties) {
+            if (t.isObjectProperty(prop) && t.isIdentifier(prop.key)) {
+              const { expression: valExpr } = transpileArgExpression(prop.value, awaitBindings);
+              params[prop.key.name] = valExpr;
+            }
+          }
+        } else {
+          const { expression: valExpr } = transpileArgExpression(arg, awaitBindings);
+          params[`arg${i}`] = valExpr;
+        }
+      }
+      if (Object.keys(params).length > 0) {
+        callConfig.params = params;
+      }
+    }
+    actions.push({
+      id: `call_${targetSlug}`,
+      type: "call_workflow",
+      mode: "auto",
+      config: callConfig
+    });
+    const transName = transitionCount === 0 ? "execute" : `on_${getStateSuffix(prevState)}_complete`;
+    transitions.push({
+      name: transName,
+      from: [prevState],
+      to: stateName,
+      actions
+    });
+    prevState = stateName;
+    transitionCount++;
+  }
+  states.push({ name: "done", type: "END", on_enter: [], during: [], on_exit: [] });
+  const finalActions = [];
+  if (pendingSyncStmts.length > 0) {
+    const block = t.blockStatement(pendingSyncStmts);
+    const transpiled = transpileBlock(block, {
+      allMutable: true,
+      derivedVarMap: buildDerivedVarMap(awaitBindings),
+      parameterMap
+    });
+    if (!transpiled.pure) bodyIsPure = false;
+    finalActions.push({
+      id: "post_final",
+      type: "eval",
+      mode: "auto",
+      config: { expression: transpiled.expression }
+    });
+  }
+  const finalTransName = transitionCount === 0 ? "execute" : `on_${getStateSuffix(prevState)}_complete`;
+  transitions.push({
+    name: finalTransName,
+    from: [prevState],
+    to: "done",
+    actions: finalActions
+  });
+  return { states, transitions, bodyIsPure };
+}
+function getStateSuffix(stateName) {
+  return stateName.replace(/^awaiting_/, "");
+}
+function transpileArgExpression(expr, bindings) {
+  if (t.isIdentifier(expr)) {
+    const replacement = bindings.get(expr.name);
+    if (replacement) return { expression: replacement };
+    return { expression: `state_data.${toSnakeCase(expr.name)}` };
+  }
+  if (t.isMemberExpression(expr) && t.isIdentifier(expr.object)) {
+    const replacement = bindings.get(expr.object.name);
+    if (replacement && t.isIdentifier(expr.property)) {
+      return { expression: `${replacement}.${expr.property.name}` };
+    }
+  }
+  if (t.isStringLiteral(expr)) return { expression: `'${expr.value}'` };
+  if (t.isNumericLiteral(expr)) return { expression: String(expr.value) };
+  if (t.isBooleanLiteral(expr)) return { expression: String(expr.value) };
+  const { transpile } = (init_ts_to_expression(), __toCommonJS(ts_to_expression_exports));
+  return { expression: transpile(expr, { derivedVarMap: buildDerivedVarMap(bindings) }) };
+}
+function buildDerivedVarMap(bindings) {
+  const map = /* @__PURE__ */ new Map();
+  for (const [varName, path] of bindings) {
+    map.set(varName, t.identifier(path));
+  }
+  return map;
+}
+function toKebabCase(name) {
+  return name.replace(/([A-Z])/g, "-$1").toLowerCase().replace(/^-/, "");
+}
+function toSnakeCase(name) {
+  return name.replace(/([A-Z])/g, "_$1").toLowerCase().replace(/^_/, "");
+}
+
+// src/incremental-compiler.ts
+function hashContent(content) {
+  let hash = 5381;
+  for (let i = 0; i < content.length; i++) {
+    hash = (hash << 5) + hash + content.charCodeAt(i);
+    hash |= 0;
+  }
+  return (hash >>> 0).toString(36);
+}
+function extractImports(source) {
+  const imports = [];
+  const regex = /import\s+.*?from\s+['"](\.[^'"]+)['"]/g;
+  let match;
+  while ((match = regex.exec(source)) !== null) {
+    imports.push(match[1]);
+  }
+  return imports;
+}
+function resolveImport(fromFile, importPath, availableFiles) {
+  const parts = fromFile.split("/");
+  parts.pop();
+  const dir = parts.join("/");
+  const segments = (dir ? dir + "/" + importPath : importPath).split("/");
+  const resolved = [];
+  for (const seg of segments) {
+    if (seg === ".") continue;
+    if (seg === "..") {
+      resolved.pop();
+      continue;
+    }
+    resolved.push(seg);
+  }
+  const basePath = resolved.join("/");
+  const extensions = ["", ".ts", ".tsx", ".js", ".jsx"];
+  for (const ext of extensions) {
+    const candidate = basePath + ext;
+    if (availableFiles.includes(candidate)) {
+      return candidate;
+    }
+  }
+  for (const ext of [".ts", ".tsx", ".js", ".jsx"]) {
+    const candidate = basePath + "/index" + ext;
+    if (availableFiles.includes(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function buildDependencyGraph(files) {
+  const availableFiles = Object.keys(files);
+  const edges = [];
+  const dependents = /* @__PURE__ */ new Map();
+  const dependencies = /* @__PURE__ */ new Map();
+  for (const filename of availableFiles) {
+    dependents.set(filename, /* @__PURE__ */ new Set());
+    dependencies.set(filename, /* @__PURE__ */ new Set());
+  }
+  for (const [filename, source] of Object.entries(files)) {
+    const imports = extractImports(source);
+    for (const imp of imports) {
+      const resolved = resolveImport(filename, imp, availableFiles);
+      if (resolved && resolved !== filename) {
+        edges.push({ from: filename, to: resolved });
+        dependencies.get(filename).add(resolved);
+        if (!dependents.has(resolved)) dependents.set(resolved, /* @__PURE__ */ new Set());
+        dependents.get(resolved).add(filename);
+      }
+    }
+  }
+  return { edges, dependents, dependencies };
+}
+function computeTransitiveDirtySet(directlyChanged, dependents) {
+  const dirty = new Set(directlyChanged);
+  const queue = [...directlyChanged];
+  while (queue.length > 0) {
+    const file = queue.shift();
+    const deps = dependents.get(file);
+    if (!deps) continue;
+    for (const dep of deps) {
+      if (!dirty.has(dep)) {
+        dirty.add(dep);
+        queue.push(dep);
+      }
+    }
+  }
+  return dirty;
+}
+function topologicalSort(files, dependencies) {
+  const inDegree = /* @__PURE__ */ new Map();
+  const dependentMap = /* @__PURE__ */ new Map();
+  for (const f of files) {
+    inDegree.set(f, 0);
+    dependentMap.set(f, /* @__PURE__ */ new Set());
+  }
+  for (const f of files) {
+    const deps = dependencies.get(f);
+    if (!deps) continue;
+    for (const dep of deps) {
+      if (files.includes(dep)) {
+        inDegree.set(f, (inDegree.get(f) || 0) + 1);
+        if (!dependentMap.has(dep)) dependentMap.set(dep, /* @__PURE__ */ new Set());
+        dependentMap.get(dep).add(f);
+      }
+    }
+  }
+  const queue = [];
+  for (const [f, degree] of inDegree) {
+    if (degree === 0) queue.push(f);
+  }
+  const order = [];
+  while (queue.length > 0) {
+    const f = queue.shift();
+    order.push(f);
+    for (const dependent of dependentMap.get(f) || []) {
+      const newDegree = (inDegree.get(dependent) || 1) - 1;
+      inDegree.set(dependent, newDegree);
+      if (newDegree === 0) queue.push(dependent);
+    }
+  }
+  for (const f of files) {
+    if (!order.includes(f)) {
+      order.push(f);
+    }
+  }
+  return order;
+}
+var IncrementalCache = class {
+  constructor() {
+    this.hashes = /* @__PURE__ */ new Map();
+    this.results = /* @__PURE__ */ new Map();
+    this.lastStats = {
+      totalCached: 0,
+      lastRecompiled: 0,
+      lastCacheHits: 0,
+      lastCompileMs: 0,
+      avgPerFileMs: 0,
+      cacheHitRate: 0
+    };
+  }
+  /**
+   * Determines which files are dirty given current file contents.
+   */
+  detectDirtyFiles(files, dependents) {
+    const currentFiles = new Set(Object.keys(files));
+    const contentChanged = [];
+    const removed = [];
+    const added = [];
+    for (const [filename, source] of Object.entries(files)) {
+      const hash = hashContent(source);
+      const cached = this.hashes.get(filename);
+      if (!cached) {
+        added.push(filename);
+      } else if (cached.hash !== hash) {
+        contentChanged.push(filename);
+      }
+    }
+    for (const cached of this.hashes.keys()) {
+      if (!currentFiles.has(cached)) {
+        removed.push(cached);
+      }
+    }
+    const directlyDirty = /* @__PURE__ */ new Set([...contentChanged, ...added]);
+    let dependencyDirty = [];
+    if (dependents && directlyDirty.size > 0) {
+      const allDirty = computeTransitiveDirtySet(directlyDirty, dependents);
+      dependencyDirty = [...allDirty].filter((f) => !directlyDirty.has(f));
+    }
+    return { contentChanged, dependencyDirty, removed, added };
+  }
+  /**
+   * Updates the cache with a compilation result.
+   */
+  set(filename, source, result) {
+    this.hashes.set(filename, {
+      hash: hashContent(source),
+      compiledAt: Date.now(),
+      size: source.length
+    });
+    this.results.set(filename, result);
+  }
+  /**
+   * Gets a cached result.
+   */
+  get(filename) {
+    return this.results.get(filename);
+  }
+  /**
+   * Checks if a file is in cache and not dirty.
+   */
+  has(filename) {
+    return this.results.has(filename);
+  }
+  /**
+   * Removes a file from cache.
+   */
+  delete(filename) {
+    this.hashes.delete(filename);
+    this.results.delete(filename);
+  }
+  /**
+   * Clears all cached data.
+   */
+  clear() {
+    this.hashes.clear();
+    this.results.clear();
+  }
+  /**
+   * Updates stats after a compilation run.
+   */
+  updateStats(recompiled, cacheHits, compileMs) {
+    const total = recompiled + cacheHits;
+    this.lastStats = {
+      totalCached: this.results.size,
+      lastRecompiled: recompiled,
+      lastCacheHits: cacheHits,
+      lastCompileMs: compileMs,
+      avgPerFileMs: recompiled > 0 ? compileMs / recompiled : 0,
+      cacheHitRate: total > 0 ? cacheHits / total : 0
+    };
+  }
+  /**
+   * Gets compilation statistics.
+   */
+  getStats() {
+    return { ...this.lastStats };
+  }
+  /**
+   * Gets all cached filenames.
+   */
+  getCachedFiles() {
+    return [...this.results.keys()];
+  }
+  /**
+   * Gets all cached results.
+   */
+  getAllResults() {
+    return new Map(this.results);
+  }
+};
+
+// src/project-compiler.ts
+function parseConfig(source) {
+  const config = {};
+  const slugMatch = source.match(/slug:\s*['"]([^'"]+)['"]/);
+  if (slugMatch) config.slug = slugMatch[1];
+  const nameMatch = source.match(/name:\s*['"]([^'"]+)['"]/);
+  if (nameMatch) config.name = nameMatch[1];
+  const versionMatch = source.match(/version:\s*['"]([^'"]+)['"]/);
+  if (versionMatch) config.version = versionMatch[1];
+  const descMatch = source.match(/description:\s*['"]([^'"]+)['"]/);
+  if (descMatch) config.description = descMatch[1];
+  const categoryArrayMatch = source.match(/category:\s*\[([^\]]+)\]/);
+  if (categoryArrayMatch) {
+    const items = categoryArrayMatch[1].match(/['"]([^'"]+)['"]/g);
+    if (items) {
+      config.category = items.map((s) => s.replace(/['"]/g, ""));
+    }
+  } else {
+    const categoryMatch = source.match(/category:\s*['"]([^'"]+)['"]/);
+    if (categoryMatch) config.category = categoryMatch[1];
+  }
+  const modeMatch = source.match(/mode:\s*['"]([^'"]+)['"]/);
+  if (modeMatch && (modeMatch[1] === "strict" || modeMatch[1] === "infer")) {
+    config.mode = modeMatch[1];
+  }
+  return config;
+}
+function parseModuleManifest(source) {
+  if (!source.includes("defineBlueprint") && !source.includes("defineModule")) return null;
+  const manifest = {};
+  const stringFields = ["slug", "name", "version", "description", "author", "license", "icon"];
+  for (const field of stringFields) {
+    const match = source.match(new RegExp(`${field}:\\s*['"]([^'"]+)['"]`));
+    if (match) manifest[field] = match[1];
+  }
+  const catArrayMatch = source.match(/category:\s*\[([^\]]+)\]/);
+  if (catArrayMatch) {
+    const items = catArrayMatch[1].match(/['"]([^'"]+)['"]/g);
+    if (items) {
+      manifest.category = items.map((s) => s.replace(/['"]/g, ""));
+    }
+  } else {
+    const catMatch = source.match(/category:\s*['"]([^'"]+)['"]/);
+    if (catMatch) manifest.category = catMatch[1];
+  }
+  const tagsMatch = source.match(/tags:\s*\[([^\]]*)\]/);
+  if (tagsMatch) {
+    manifest.tags = tagsMatch[1].split(",").map((s) => s.trim().replace(/^['"]|['"]$/g, "")).filter(Boolean);
+  }
+  const modelsMatch = source.match(/models:\s*\[([^\]]*)\]/);
+  if (modelsMatch) {
+    manifest.models = modelsMatch[1].split(",").map((s) => s.trim().replace(/^['"]|['"]$/g, "")).filter(Boolean);
+  }
+  const capsMatch = source.match(/capabilities:\s*\[([^\]]*)\]/);
+  if (capsMatch) {
+    manifest.capabilities = capsMatch[1].split(",").map((s) => s.trim().replace(/^['"]|['"]$/g, "")).filter(Boolean);
+  }
+  const routesBlock = extractArrayBlock(source, "routes");
+  if (routesBlock) {
+    const routes = [];
+    const routeRegex = /\{\s*path:\s*['"]([^'"]+)['"][^}]*\}/g;
+    let rm;
+    while ((rm = routeRegex.exec(routesBlock)) !== null) {
+      const entry = { path: rm[1] };
+      const labelMatch = rm[0].match(/label:\s*['"]([^'"]+)['"]/);
+      if (labelMatch) entry.label = labelMatch[1];
+      const groupMatch = rm[0].match(/group:\s*['"]([^'"]+)['"]/);
+      if (groupMatch) entry.group = groupMatch[1];
+      const iconMatch = rm[0].match(/icon:\s*['"]([^'"]+)['"]/);
+      if (iconMatch) entry.icon = iconMatch[1];
+      routes.push(entry);
+    }
+    if (routes.length > 0) manifest.routes = routes;
+  }
+  const actionsBlock = extractArrayBlock(source, "actions");
+  if (actionsBlock) {
+    const actions = [];
+    const actionRegex = /\{\s*id:\s*['"]([^'"]+)['"][^}]*\}/g;
+    let am;
+    while ((am = actionRegex.exec(actionsBlock)) !== null) {
+      const entry = { id: am[1] };
+      const descMatch = am[0].match(/description:\s*['"]([^'"]+)['"]/);
+      if (descMatch) entry.description = descMatch[1];
+      actions.push(entry);
+    }
+    if (actions.length > 0) manifest.actions = actions;
+  }
+  const contribsBlock = extractArrayBlock(source, "contributions");
+  if (contribsBlock) {
+    const contributions = [];
+    const contribRegex = /\{\s*slot:\s*['"]([^'"]+)['"][^}]*\}/g;
+    let cm;
+    while ((cm = contribRegex.exec(contribsBlock)) !== null) {
+      const entry = { slot: cm[1], view: "" };
+      const viewMatch = cm[0].match(/view:\s*['"]([^'"]+)['"]/);
+      if (viewMatch) entry.view = viewMatch[1];
+      const prioMatch = cm[0].match(/priority:\s*(\d+)/);
+      if (prioMatch) entry.priority = parseInt(prioMatch[1], 10);
+      contributions.push(entry);
+    }
+    if (contributions.length > 0) manifest.contributions = contributions;
+  }
+  const configSchemaMatch = source.match(/configSchema:\s*\{([^}]*(?:\{[^}]*\}[^}]*)*)\}/);
+  if (configSchemaMatch) {
+    const configSchema = {};
+    const modelSlugMatch = configSchemaMatch[1].match(/modelSlug:\s*['"]([^'"]+)['"]/);
+    if (modelSlugMatch) configSchema.modelSlug = modelSlugMatch[1];
+    const defaultsMatch = configSchemaMatch[1].match(/defaults:\s*\{([^}]*)\}/);
+    if (defaultsMatch) {
+      const defaults = {};
+      const kvRegex = /(\w+):\s*(?:'([^']*)'|"([^"]*)"|(\d+(?:\.\d+)?)|(\btrue\b|\bfalse\b))/g;
+      let kv;
+      while ((kv = kvRegex.exec(defaultsMatch[1])) !== null) {
+        const key = kv[1];
+        const val = kv[2] ?? kv[3] ?? (kv[4] !== void 0 ? Number(kv[4]) : kv[5] === "true");
+        defaults[key] = val;
+      }
+      configSchema.defaults = defaults;
+    }
+    manifest.configSchema = configSchema;
+  }
+  const depsBlock = extractArrayBlock(source, "dependencies");
+  if (depsBlock) {
+    const dependencies = [];
+    const depRegex = /\{\s*slug:\s*['"]([^'"]+)['"][^}]*\}/g;
+    let dm;
+    while ((dm = depRegex.exec(depsBlock)) !== null) {
+      const entry = { slug: dm[1] };
+      const verMatch = dm[0].match(/version:\s*['"]([^'"]+)['"]/);
+      if (verMatch) entry.version = verMatch[1];
+      const reqMatch = dm[0].match(/required:\s*(true|false)/);
+      if (reqMatch) entry.required = reqMatch[1] === "true";
+      const prefixMatch = dm[0].match(/prefix:\s*['"]([^'"]+)['"]/);
+      if (prefixMatch) entry.routeConfig = { prefix: prefixMatch[1] };
+      dependencies.push(entry);
+    }
+    if (dependencies.length > 0) manifest.dependencies = dependencies;
+  }
+  const hasRichFields = manifest.routes || manifest.actions || manifest.contributions || manifest.capabilities || manifest.dependencies;
+  return hasRichFields ? manifest : null;
+}
+function parseDependencyRouteConfigs(files) {
+  const result = /* @__PURE__ */ new Map();
+  let configSource;
+  for (const [filename, source] of Object.entries(files)) {
+    if (isConfigFile(filename)) {
+      configSource = source;
+      break;
+    }
+  }
+  if (!configSource) return result;
+  const depsBlock = extractArrayBlock(configSource, "dependencies");
+  if (!depsBlock) return result;
+  const depObjects = extractNestedObjects(depsBlock);
+  for (const depSrc of depObjects) {
+    const slugMatch = depSrc.match(/slug:\s*['"]([^'"]+)['"]/);
+    if (!slugMatch) continue;
+    const slug = slugMatch[1];
+    const rcBlock = extractObjectBlock(depSrc, "routeConfig");
+    if (!rcBlock) continue;
+    const entry = {};
+    const prefixMatch = rcBlock.match(/prefix:\s*['"]([^'"]+)['"]/);
+    if (prefixMatch) entry.prefix = prefixMatch[1];
+    const routesBlock = extractObjectBlock(rcBlock, "routes");
+    if (routesBlock) {
+      const overrides = {};
+      const overrideRegex = /['"]([^'"]+)['"]\s*:\s*(?:['"]([^'"]+)['"]|(false))/g;
+      let om;
+      while ((om = overrideRegex.exec(routesBlock)) !== null) {
+        overrides[om[1]] = om[3] === "false" ? false : om[2];
+      }
+      if (Object.keys(overrides).length > 0) entry.routes = overrides;
+    }
+    result.set(slug, entry);
+  }
+  return result;
+}
+function extractNestedObjects(source) {
+  const objects = [];
+  let depth = 0;
+  let start = -1;
+  for (let i = 0; i < source.length; i++) {
+    if (source[i] === "{") {
+      if (depth === 0) start = i;
+      depth++;
+    } else if (source[i] === "}") {
+      depth--;
+      if (depth === 0 && start >= 0) {
+        objects.push(source.slice(start, i + 1));
+        start = -1;
+      }
+    }
+  }
+  return objects;
+}
+function extractObjectBlock(source, fieldName) {
+  const pattern = new RegExp(`${fieldName}:\\s*\\{`);
+  const match = pattern.exec(source);
+  if (!match) return null;
+  let depth = 1;
+  const startIdx = match.index + match[0].length;
+  for (let i = startIdx; i < source.length; i++) {
+    if (source[i] === "{") depth++;
+    else if (source[i] === "}") {
+      depth--;
+      if (depth === 0) return source.slice(startIdx, i);
+    }
+  }
+  return null;
+}
+function extractArrayBlock(source, fieldName) {
+  const startPattern = new RegExp(`${fieldName}:\\s*\\[`);
+  const match = startPattern.exec(source);
+  if (!match) return null;
+  let depth = 1;
+  const startIdx = match.index + match[0].length;
+  for (let i = startIdx; i < source.length; i++) {
+    if (source[i] === "[") depth++;
+    else if (source[i] === "]") {
+      depth--;
+      if (depth === 0) return source.slice(startIdx, i);
+    }
+  }
+  return null;
+}
+function isWorkflowFile(filename) {
+  return /\.workflow\.(tsx?|jsx?)$/.test(filename);
+}
+function isModelFile(filename) {
+  return /models\/.*\.(ts|tsx)$/.test(filename) && !filename.endsWith(".test.ts");
+}
+function isServerActionFile(filename) {
+  return /\.server\.(ts|tsx)$/.test(filename);
+}
+function isActionFile(filename) {
+  return /^actions\/.*\.(ts|tsx)$/.test(filename) && !filename.endsWith(".server.ts") && !filename.endsWith(".test.ts") && !filename.endsWith(".test.tsx");
+}
+function isComponentFile(filename) {
+  return /components\/.*\.(tsx?|jsx?)$/.test(filename) && !filename.endsWith(".test.ts") && !filename.endsWith(".test.tsx");
+}
+function isPageFile2(filename) {
+  return (/pages\/.*\.(tsx?|jsx?)$/.test(filename) || /app\/.*\.(tsx?|jsx?)$/.test(filename)) && !filename.endsWith(".test.ts") && !filename.endsWith(".test.tsx") && !filename.includes("layout");
+}
+function isAppDirFile(filename) {
+  return /^app\//.test(filename);
+}
+function isConfigFile(filename) {
+  return /mm\.config\.(ts|tsx|js)$/.test(filename);
+}
+function isModuleManifestFile(filename) {
+  return /mm\.module\.(ts|tsx|js)$/.test(filename);
+}
+function isCompilableFile(filename) {
+  return isWorkflowFile(filename) || isModelFile(filename) || isServerActionFile(filename) || isActionFile(filename) || isPageFile2(filename) || isComponentFile(filename);
+}
+function compileFile(filename, source, mode) {
+  const errors = [];
+  try {
+    const parserPlugins = filename.endsWith(".tsx") || filename.endsWith(".jsx") ? ["typescript", "jsx"] : ["typescript"];
+    const result = transformSync3(source, {
+      filename,
+      plugins: [[babelPlugin, { mode }]],
+      parserOpts: { plugins: parserPlugins, attachComment: true }
+    });
+    const ir = result?.metadata?.mindmatrixIR ?? null;
+    if (ir?.metadata) {
+      const meta = ir.metadata;
+      const fileErrors = meta.errors;
+      const fileWarnings = meta.warnings;
+      if (fileErrors) {
+        for (const e of fileErrors) {
+          errors.push({
+            file: filename,
+            message: e.message,
+            line: e.line,
+            column: e.column,
+            endLine: e.line,
+            endColumn: e.column !== void 0 ? e.column + 10 : void 0,
+            severity: "error"
+          });
+        }
+      }
+      if (fileWarnings) {
+        for (const w of fileWarnings) {
+          errors.push({
+            file: filename,
+            message: w.message,
+            line: w.line,
+            column: w.column,
+            endLine: w.line,
+            endColumn: w.column !== void 0 ? w.column + 10 : void 0,
+            severity: "warning"
+          });
+        }
+      }
+    }
+    return { ir, errors };
+  } catch (err) {
+    const errMsg = err.message;
+    const locMatch = errMsg.match(/\((\d+):(\d+)\)/);
+    const line = locMatch ? parseInt(locMatch[1], 10) : void 0;
+    const column = locMatch ? parseInt(locMatch[2], 10) : void 0;
+    errors.push({
+      file: filename,
+      message: "Compilation failed: " + errMsg,
+      line,
+      column,
+      endLine: line,
+      endColumn: column !== void 0 ? column + 1 : void 0,
+      severity: "error"
+    });
+    return { ir: null, errors };
+  }
+}
+function deduplicateActions(actions) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const action of actions) {
+    const key = JSON.stringify(action);
+    if (!seen.has(key)) {
+      seen.add(key);
+      result.push(action);
+    }
+  }
+  return result;
+}
+function mergeIRs(irs, config) {
+  if (irs.length === 0) {
+    return createEmptyIR(config);
+  }
+  if (irs.length === 1) {
+    return applyConfig(irs[0], config);
+  }
+  const fieldMap = /* @__PURE__ */ new Map();
+  for (const ir of irs) {
+    for (const field of ir.fields) {
+      if (!fieldMap.has(field.name)) {
+        fieldMap.set(field.name, field);
+      } else {
+        const existing = fieldMap.get(field.name);
+        if (field.required && !existing.required) {
+          existing.required = true;
+        }
+        if (field.default_value != null && field.default_value !== "" && field.default_value !== 0 && field.default_value !== false) {
+          if (existing.default_value == null || existing.default_value === "" || existing.default_value === 0 || existing.default_value === false) {
+            existing.default_value = field.default_value;
+          }
+        }
+      }
+    }
+  }
+  const stateMap = /* @__PURE__ */ new Map();
+  for (const ir of irs) {
+    for (const state of ir.states) {
+      if (stateMap.has(state.name)) {
+        const existing = stateMap.get(state.name);
+        existing.on_enter = deduplicateActions([...existing.on_enter, ...state.on_enter]);
+        existing.on_exit = deduplicateActions([...existing.on_exit, ...state.on_exit]);
+        existing.during = deduplicateActions([...existing.during, ...state.during]);
+        if (state.on_event) {
+          existing.on_event = [...existing.on_event || [], ...state.on_event];
+        }
+      } else {
+        stateMap.set(state.name, { ...state });
+      }
+    }
+  }
+  const transitionMap = /* @__PURE__ */ new Map();
+  for (const ir of irs) {
+    for (const transition of ir.transitions) {
+      if (!transitionMap.has(transition.name)) {
+        transitionMap.set(transition.name, transition);
+      }
+    }
+  }
+  const events = [];
+  for (const ir of irs) {
+    if (ir.on_event) {
+      events.push(...ir.on_event);
+    }
+  }
+  const viewTrees = [];
+  for (const ir of irs) {
+    const views = ir.views;
+    if (views?.default) {
+      viewTrees.push(views.default);
+    }
+  }
+  const extensions = {};
+  for (const ir of irs) {
+    if (ir.extensions) {
+      for (const [key, islands] of Object.entries(ir.extensions)) {
+        if (!extensions[key]) extensions[key] = [];
+        extensions[key].push(...islands);
+      }
+    }
+  }
+  const metadata = {};
+  for (const ir of irs) {
+    if (ir.metadata) {
+      for (const [key, value] of Object.entries(ir.metadata)) {
+        if (key === "errors" || key === "warnings") continue;
+        metadata[key] = value;
+      }
+    }
+  }
+  const roleMap = /* @__PURE__ */ new Map();
+  for (const ir of irs) {
+    for (const role of ir.roles) {
+      if (!roleMap.has(role.name)) {
+        roleMap.set(role.name, role);
+      }
+    }
+  }
+  const base = irs[0];
+  const merged = {
+    slug: base.slug,
+    name: base.name,
+    version: base.version,
+    description: base.description,
+    category: base.category,
+    fields: Array.from(fieldMap.values()),
+    states: Array.from(stateMap.values()),
+    transitions: Array.from(transitionMap.values()),
+    roles: Array.from(roleMap.values()),
+    tags: base.tags,
+    metadata
+  };
+  if (events.length > 0) {
+    merged.on_event = events;
+  }
+  if (Object.keys(extensions).length > 0) {
+    merged.extensions = extensions;
+  }
+  if (viewTrees.length === 1) {
+    merged.views = { default: viewTrees[0] };
+  } else if (viewTrees.length > 1) {
+    const rootView = {
+      id: "project-root",
+      component: "Stack",
+      children: viewTrees
+    };
+    merged.views = { default: rootView };
+  }
+  return applyConfig(merged, config);
+}
+function applyConfig(ir, config) {
+  if (config.slug) ir.slug = config.slug;
+  if (config.name) ir.name = config.name;
+  if (config.version) ir.version = config.version;
+  if (config.description !== void 0) ir.description = config.description;
+  if (config.category) ir.category = config.category;
+  if (!ir.metadata) ir.metadata = {};
+  ir.metadata.stable_id = "def-" + ir.slug;
+  ir.metadata.provenance = {
+    frontend: "react-compiler",
+    source: "project",
+    compiler_version: "2.0.0"
+  };
+  return ir;
+}
+function createEmptyIR(config) {
+  return {
+    slug: config.slug || "project",
+    name: config.name || "Project",
+    version: config.version || "0.1.0",
+    description: config.description,
+    category: config.category || "workflow",
+    fields: [],
+    states: [{
+      name: "draft",
+      type: "START",
+      on_enter: [],
+      during: [],
+      on_exit: []
+    }],
+    transitions: [],
+    roles: [],
+    tags: [],
+    metadata: {
+      stable_id: "def-" + (config.slug || "project"),
+      provenance: {
+        frontend: "react-compiler",
+        source: "project",
+        compiler_version: "2.0.0"
+      }
+    }
+  };
+}
+function resolveImportLinks(files, compilableFiles) {
+  const links = [];
+  for (const filename of compilableFiles) {
+    const source = files[filename];
+    const importRegex = /import\s+(?:type\s+)?(?:\{([^}]+)\}|(\w+))\s+from\s+['"](\.[^'"]+)['"]/g;
+    let match;
+    while ((match = importRegex.exec(source)) !== null) {
+      const namedImports = match[1];
+      const defaultImport = match[2];
+      const importPath = match[3];
+      const resolved = resolveImport(filename, importPath, Object.keys(files));
+      if (!resolved || resolved === filename) continue;
+      let linkType = "unknown";
+      if (isModelFile(resolved)) {
+        linkType = "data-source";
+      } else if (isServerActionFile(resolved)) {
+        linkType = "action";
+      } else if (/components\//.test(resolved)) {
+        linkType = "component";
+      }
+      const symbols = [];
+      if (namedImports) {
+        symbols.push(...namedImports.split(",").map((s) => s.trim().split(" as ")[0].trim()).filter(Boolean));
+      }
+      if (defaultImport) {
+        symbols.push(defaultImport);
+      }
+      links.push({
+        fromFile: filename,
+        toFile: resolved,
+        linkType,
+        symbols
+      });
+    }
+  }
+  return links;
+}
+function resolveCompilationOrder(files, compilableFiles) {
+  const { dependencies } = buildDependencyGraph(files);
+  return topologicalSort(compilableFiles, dependencies);
+}
+function extractComponentProps(source) {
+  const match = source.match(/function\s+\w+\s*\(\s*\{([^}]+)\}/);
+  if (!match) return [];
+  return match[1].split(",").map((p) => p.trim().split(/[\s=:]/)[0].replace(/^\.{3}/, "").trim()).filter(Boolean);
+}
+function generateModuleTypeStubs(childDefinitions, modelResults) {
+  const stubs = {};
+  for (const child of childDefinitions) {
+    if (!child.slug) continue;
+    const category = child.category;
+    const isModel = category === "data" || Array.isArray(category) && category.includes("model") || Array.isArray(category) && category.includes("data");
+    if (!isModel || !child.fields || child.fields.length === 0) continue;
+    const interfaceName = slugToInterfaceName(child.slug) + "Fields";
+    const lines = [
+      `// Auto-generated type stub for model: ${child.slug}`,
+      `// Do not edit \u2014 regenerated on each build.`,
+      ``,
+      `export interface ${interfaceName} {`
+    ];
+    for (const field of child.fields) {
+      const tsType = irFieldTypeToTs(field.type || "string");
+      const optional = field.required ? "" : "?";
+      if (field.description) {
+        lines.push(`  /** ${field.description} */`);
+      }
+      lines.push(`  ${field.name}${optional}: ${tsType};`);
+    }
+    lines.push(`}`);
+    lines.push(``);
+    lines.push(`export declare const ${slugToCamelCase(child.slug)}Slug: '${child.slug}';`);
+    lines.push(``);
+    stubs[`types/modules/${child.slug}.d.ts`] = lines.join("\n");
+  }
+  return stubs;
+}
+function slugToInterfaceName(slug) {
+  return slug.split("-").map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join("");
+}
+function slugToCamelCase(slug) {
+  const parts = slug.split("-");
+  return parts[0] + parts.slice(1).map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join("");
+}
+function irFieldTypeToTs(type) {
+  switch (type) {
+    case "string":
+    case "text":
+    case "email":
+    case "url":
+    case "phone":
+    case "slug":
+    case "color":
+    case "password":
+      return "string";
+    case "number":
+    case "integer":
+    case "float":
+    case "currency":
+    case "percent":
+      return "number";
+    case "boolean":
+    case "toggle":
+      return "boolean";
+    case "date":
+    case "datetime":
+    case "timestamp":
+      return "string";
+    case "json":
+    case "object":
+      return "Record<string, unknown>";
+    case "array":
+      return "unknown[]";
+    case "enum":
+      return "string";
+    case "file":
+    case "image":
+      return "string";
+    default:
+      return "unknown";
+  }
+}
+function buildComposedResult(files, fileIRs, config, errors, warnings, options = {}) {
+  const usePhase2 = options.usePhase2Modules !== false;
+  const workflowIRs = [];
+  const modelIRs = [];
+  const actionDefinitionIRs = [];
+  const serverActionEntries = [];
+  let modelResults;
+  let actionResult;
+  let routeResult;
+  const componentDefinitions = {};
+  for (const [filename, ir] of Object.entries(fileIRs)) {
+    if (isWorkflowFile(filename)) {
+      workflowIRs.push(ir);
+    } else if (isModelFile(filename)) {
+      if (!ir.category || ir.category === "workflow") {
+        ir.category = "data";
+      }
+      modelIRs.push(ir);
+    } else if (isServerActionFile(filename)) {
+      const meta = ir.metadata;
+      const actions = meta?.serverActions;
+      if (actions) {
+        for (const action of actions) {
+          serverActionEntries.push({
+            name: action.name,
+            sourceFile: filename,
+            async: action.async,
+            params: action.params,
+            description: action.description
+          });
+        }
+      }
+    } else if (isComponentFile(filename)) {
+      const views = ir.views;
+      const experience = views?.default ?? ir.experience;
+      if (experience) {
+        const baseName = filename.split("/").pop()?.replace(/\.(tsx?|jsx?)$/, "") || "Component";
+        const source = files[filename];
+        const props = source ? extractComponentProps(source) : [];
+        componentDefinitions[baseName] = { experience, props };
+      }
+    }
+  }
+  for (const [filename, source] of Object.entries(files)) {
+    if (isActionFile(filename)) {
+      const result = extractAction(source, filename);
+      if (result) {
+        actionDefinitionIRs.push(result.ir);
+        for (const w of result.warnings) {
+          warnings.push({ file: filename, message: w, severity: "warning" });
+        }
+      }
+    }
+  }
+  if (usePhase2) {
+    const modelFiles = {};
+    for (const [filename, source] of Object.entries(files)) {
+      if (isModelFile(filename)) {
+        modelFiles[filename] = source;
+      }
+    }
+    if (Object.keys(modelFiles).length > 0) {
+      modelResults = compileModels(modelFiles, { mode: options.mode || "infer" });
+      modelIRs.length = 0;
+      for (const [, result] of modelResults) {
+        modelIRs.push(result.ir);
+      }
+    }
+    const actionFiles = {};
+    for (const [filename, source] of Object.entries(files)) {
+      if (isServerActionFile(filename)) {
+        actionFiles[filename] = source;
+      }
+    }
+    if (Object.keys(actionFiles).length > 0) {
+      actionResult = compileActions(actionFiles, {
+        mode: options.mode || "infer",
+        blueprintSlug: config.slug || "app"
+      });
+      serverActionEntries.length = 0;
+      for (const reg of actionResult.actions) {
+        serverActionEntries.push({
+          name: reg.name,
+          sourceFile: reg.sourceFile,
+          async: reg.async,
+          params: reg.params,
+          description: reg.description,
+          body: reg.body,
+          returnType: reg.returnType
+        });
+      }
+    }
+    const appFiles = {};
+    for (const [filename, source] of Object.entries(files)) {
+      if (isAppDirFile(filename) || isPageFile2(filename)) {
+        appFiles[filename] = source;
+      }
+    }
+    if (Object.keys(appFiles).length > 0) {
+      routeResult = extractRoutes(appFiles, {
+        slugPrefix: config.slug || "app"
+      });
+    }
+  }
+  const childDefinitions = [
+    ...workflowIRs,
+    ...modelIRs,
+    ...actionDefinitionIRs
+  ];
+  let routeTable = [];
+  if (routeResult) {
+    routeTable = routeResult.routes.map((r) => ({
+      path: r.path,
+      stateName: r.stateName,
+      sourceFile: r.sourceFile,
+      params: r.params
+    }));
+    childDefinitions.push(routeResult.routerIR);
+  } else {
+    const pageFiles = [];
+    for (const filename of Object.keys(files)) {
+      if (isPageFile2(filename)) {
+        pageFiles.push({
+          relativePath: filename,
+          absolutePath: filename
+        });
+        const routePath = filename.replace(/^pages\//, "").replace(/^app\//, "").replace(/\.(tsx?|jsx?)$/, "").replace(/\/index$/, "").replace(/\/page$/, "");
+        const stateName = pathToStateName(routePath);
+        const urlPattern = pathToUrlPattern(filename, filename.split("/").pop() || "page.tsx");
+        const params = extractParams(filename);
+        routeTable.push({
+          path: urlPattern,
+          stateName,
+          sourceFile: filename,
+          params
+        });
+      }
+    }
+    if (pageFiles.length > 0) {
+      const routerWorkflow = extractRouterWorkflow(pageFiles, {
+        slug: config.slug ? config.slug + "-router" : "app-router",
+        pageFileName: pageFiles[0]?.relativePath.split("/").pop() || "page.tsx"
+      });
+      childDefinitions.push(routerWorkflow);
+    }
+  }
+  if (options.resolvedModules && options.resolvedModules.length > 0) {
+    const depConfigs = parseDependencyRouteConfigs(files);
+    for (const mod of options.resolvedModules) {
+      const depConfig = depConfigs.get(mod.slug);
+      const prefix = depConfig?.prefix ?? `/${mod.slug.replace(/^mod-/, "")}`;
+      const routeOverrides = depConfig?.routes;
+      for (const modRoute of mod.routeTable) {
+        if (routeOverrides) {
+          const override = routeOverrides[modRoute.path];
+          if (override === false) continue;
+          if (typeof override === "string") {
+            const existingPaths2 = new Set(routeTable.map((r) => r.path));
+            if (!existingPaths2.has(override)) {
+              routeTable.push({
+                path: override,
+                stateName: `MOD_${mod.slug.replace(/-/g, "_").toUpperCase()}_${modRoute.stateName}`,
+                sourceFile: modRoute.sourceFile,
+                params: modRoute.params,
+                moduleSlug: mod.slug
+              });
+            }
+            continue;
+          }
+        }
+        const prefixedPath = prefix + (modRoute.path === "/" ? "" : modRoute.path);
+        const existingPaths = new Set(routeTable.map((r) => r.path));
+        if (!existingPaths.has(prefixedPath)) {
+          routeTable.push({
+            path: prefixedPath,
+            stateName: `MOD_${mod.slug.replace(/-/g, "_").toUpperCase()}_${modRoute.stateName}`,
+            sourceFile: modRoute.sourceFile,
+            params: modRoute.params,
+            moduleSlug: mod.slug
+          });
+        }
+      }
+    }
+  }
+  if (options.resolvedModules && options.resolvedModules.length > 0) {
+    for (const mod of options.resolvedModules) {
+      if (mod.serverActions && mod.serverActions.length > 0) {
+        for (const action of mod.serverActions) {
+          const namespacedName = `${mod.slug}:${action.name}`;
+          if (!serverActionEntries.some((a) => a.name === namespacedName)) {
+            serverActionEntries.push({
+              ...action,
+              name: namespacedName,
+              sourceFile: `${mod.slug}/${action.sourceFile}`
+            });
+          }
+        }
+      }
+    }
+  }
+  const allIRs = Object.values(fileIRs);
+  const parentIR = mergeIRs(allIRs, config);
+  if (!parentIR.metadata) parentIR.metadata = {};
+  const parentMeta = parentIR.metadata;
+  parentMeta.childSlugs = childDefinitions.map((c) => c.slug);
+  parentMeta.serverActions = serverActionEntries;
+  if (routeTable.length > 0) {
+    parentMeta.routeTable = routeTable;
+  }
+  parentMeta.composition = {
+    workflowCount: workflowIRs.length,
+    modelCount: modelIRs.length,
+    actionCount: actionDefinitionIRs.length,
+    serverActionCount: serverActionEntries.length,
+    routeCount: routeTable.length,
+    componentCount: Object.keys(componentDefinitions).length,
+    totalFiles: Object.keys(files).length
+  };
+  if (Object.keys(componentDefinitions).length > 0) {
+    parentMeta.componentDefinitions = componentDefinitions;
+  }
+  if (actionResult) {
+    parentMeta.actionEndpoints = actionResult.actions.map((a) => ({
+      actionId: a.actionId,
+      endpoint: a.endpoint,
+      group: a.group
+    }));
+  }
+  for (const [filename, source] of Object.entries(files)) {
+    if (isConfigFile(filename) || isModuleManifestFile(filename)) {
+      const manifest2 = parseModuleManifest(source);
+      if (manifest2) {
+        parentMeta.module_manifest = manifest2;
+      }
+      break;
+    }
+  }
+  const manifest = parentMeta.module_manifest;
+  if (manifest?.dependencies) {
+    parentMeta.module_dependencies = manifest.dependencies;
+  }
+  if (manifest?.contributions) {
+    parentMeta.slot_contributions = manifest.contributions;
+  }
+  if (manifest?.configSchema) {
+    parentMeta.configSchema = manifest.configSchema;
+  }
+  if (manifest?.dependencies) {
+    const depConfigs = {};
+    for (const dep of manifest.dependencies) {
+      if (dep.config) {
+        depConfigs[dep.slug] = dep.config;
+      }
+    }
+    if (Object.keys(depConfigs).length > 0) {
+      parentMeta.module_configs = depConfigs;
+    }
+  }
+  const compilableFiles = Object.keys(files).filter(isCompilableFile);
+  const importLinks = resolveImportLinks(files, compilableFiles);
+  const pageExperiences = {};
+  for (const [filename, ir] of Object.entries(fileIRs)) {
+    if (isPageFile2(filename)) {
+      const views = ir.views;
+      if (views?.default) {
+        pageExperiences[filename] = views.default;
+      }
+    }
+  }
+  const parentViews = parentIR.views;
+  if (Object.keys(pageExperiences).length > 0) {
+    const pageEntries = Object.entries(pageExperiences);
+    const routeNodes = pageEntries.map(([pagePath, pageTree], i) => {
+      const routePath = "/" + pagePath.replace(/^app\//, "").replace(/\.(tsx?|jsx?)$/, "").replace(/\/index$/, "").replace(/\/page$/, "");
+      return {
+        id: `route-${i}`,
+        component: "Route",
+        config: { path: routePath },
+        children: [pageTree]
+      };
+    });
+    const navLinks = pageEntries.map(([pagePath], i) => {
+      const routePath = "/" + pagePath.replace(/^app\//, "").replace(/\.(tsx?|jsx?)$/, "").replace(/\/index$/, "").replace(/\/page$/, "");
+      const segments = routePath.split("/").filter(Boolean);
+      const label = segments[segments.length - 1]?.replace(/-/g, " ").replace(/\b\w/g, (c) => c.toUpperCase()) || "Home";
+      return {
+        id: `nav-link-${i}`,
+        component: "NavLink",
+        config: { to: routePath, label }
+      };
+    });
+    routeNodes.unshift({
+      id: "route-index",
+      component: "Route",
+      config: { path: "/", exact: true },
+      children: [pageEntries[0][1]]
+    });
+    const moduleRoutes = routeTable.filter((r) => r.moduleSlug);
+    for (let mi = 0; mi < moduleRoutes.length; mi++) {
+      const mr = moduleRoutes[mi];
+      routeNodes.push({
+        id: `mod-route-${mi}`,
+        component: "Route",
+        config: { path: mr.path },
+        children: [{
+          id: `mod-route-${mi}-placeholder`,
+          component: "ModuleView",
+          config: { moduleSlug: mr.moduleSlug, sourceFile: mr.sourceFile, path: mr.path }
+        }]
+      });
+      const segments = mr.path.split("/").filter(Boolean);
+      const label = segments[segments.length - 1]?.replace(/-/g, " ").replace(/\b\w/g, (c) => c.toUpperCase()) || mr.moduleSlug;
+      navLinks.push({
+        id: `mod-nav-${mi}`,
+        component: "NavLink",
+        config: { to: mr.path, label, moduleSlug: mr.moduleSlug }
+      });
+    }
+    const composedExperience = {
+      id: "blueprint-root",
+      component: "Stack",
+      className: "h-full flex flex-col",
+      children: [
+        // Nav bar (always visible, not inside Router so it always renders)
+        {
+          id: "nav-bar",
+          component: "Row",
+          config: { gap: 1 },
+          className: "px-4 py-2 border-b border-border bg-background/95 backdrop-blur-sm sticky top-0 z-10 flex-wrap",
+          children: navLinks
+        },
+        // Router with page routes
+        {
+          id: "page-router",
+          component: "Router",
+          className: "flex-1 min-h-0 overflow-y-auto",
+          children: routeNodes.map((r) => ({
+            ...r,
+            children: r.children?.map((child) => ({
+              ...child,
+              id: child.id || r.id + "-content",
+              component: child.component || "Stack",
+              config: { ...child.config, gap: 4, padding: 4 }
+            }))
+          }))
+        }
+      ]
+    };
+    parentIR.experience = composedExperience;
+    const slug = config.slug || parentIR.slug || "blueprint";
+    parentMeta.blueprint_manifest = {
+      routes: [
+        { path: `${slug}/*`, node: slug, label: config.name || parentIR.name || slug }
+      ],
+      config: {
+        full_bleed: true
+      }
+    };
+  } else if (parentViews?.default) {
+    parentIR.experience = parentViews.default;
+  }
+  for (const childDef of childDefinitions) {
+    for (const [filename, ir] of Object.entries(fileIRs)) {
+      if (ir.slug === childDef.slug || isWorkflowFile(filename) && ir.slug === childDef.slug) {
+        const views = ir.views;
+        if (views?.default) {
+          childDef.experience = views.default;
+        }
+        break;
+      }
+    }
+  }
+  const typeStubs = generateModuleTypeStubs(childDefinitions, modelResults);
+  return {
+    ir: parentIR,
+    childDefinitions,
+    fileIRs,
+    routeTable,
+    serverActions: serverActionEntries,
+    errors,
+    warnings,
+    pageExperiences,
+    componentDefinitions,
+    importLinks,
+    modelResults,
+    actionResult,
+    routeResult,
+    typeStubs
+  };
+}
+function compileProject(files, options = {}) {
+  const allErrors = [];
+  const allWarnings = [];
+  const fileIRs = {};
+  let config = {};
+  for (const [filename, source] of Object.entries(files)) {
+    if (isConfigFile(filename)) {
+      config = parseConfig(source);
+      break;
+    }
+  }
+  const mode = config.mode || options.mode || "infer";
+  const compilableFiles = Object.keys(files).filter(isCompilableFile);
+  const orderedFiles = resolveCompilationOrder(files, compilableFiles);
+  for (const filename of orderedFiles) {
+    const source = files[filename];
+    const { ir, errors } = compileFile(filename, source, mode);
+    for (const e of errors) {
+      if (e.severity === "error") allErrors.push(e);
+      else allWarnings.push(e);
+    }
+    if (ir) {
+      fileIRs[filename] = ir;
+    }
+  }
+  return buildComposedResult(files, fileIRs, config, allErrors, allWarnings, {
+    usePhase2Modules: options.usePhase2Modules,
+    mode,
+    resolvedModules: options.resolvedModules
+  });
+}
+var IncrementalProjectCompiler = class {
+  constructor() {
+    this.lastConfig = {};
+    this.cache = new IncrementalCache();
+  }
+  /**
+   * Compile a project incrementally — only recompiles changed files.
+   */
+  compile(files, options = {}) {
+    const startTime = Date.now();
+    const { dependents } = buildDependencyGraph(files);
+    const dirtySet = this.cache.detectDirtyFiles(files, dependents);
+    const allDirty = /* @__PURE__ */ new Set([
+      ...dirtySet.contentChanged,
+      ...dirtySet.dependencyDirty,
+      ...dirtySet.added
+    ]);
+    for (const removed of dirtySet.removed) {
+      this.cache.delete(removed);
+    }
+    if (allDirty.size === 0 && this.cache.getCachedFiles().length > 0) {
+      this.cache.updateStats(0, this.cache.getCachedFiles().length, Date.now() - startTime);
+      return this.rebuildFromCache(files, options);
+    }
+    for (const [filename, source] of Object.entries(files)) {
+      if (isConfigFile(filename)) {
+        if (allDirty.has(filename)) {
+          this.lastConfig = parseConfig(source);
+        }
+        break;
+      }
+    }
+    const mode = this.lastConfig.mode || options.mode || "infer";
+    const compilableFiles = Object.keys(files).filter(isCompilableFile);
+    let recompiled = 0;
+    let cacheHits = 0;
+    for (const filename of compilableFiles) {
+      if (allDirty.has(filename) || !this.cache.has(filename)) {
+        const { ir, errors } = compileFile(filename, files[filename], mode);
+        if (ir) {
+          this.cache.set(filename, files[filename], { ir, errors });
+        } else {
+          this.cache.delete(filename);
+        }
+        recompiled++;
+      } else {
+        cacheHits++;
+      }
+    }
+    for (const cached of this.cache.getCachedFiles()) {
+      if (!compilableFiles.includes(cached)) {
+        this.cache.delete(cached);
+      }
+    }
+    const fileIRs = {};
+    const allErrors = [];
+    const allWarnings = [];
+    for (const cached of this.cache.getCachedFiles()) {
+      const entry = this.cache.get(cached);
+      if (entry) {
+        fileIRs[cached] = entry.ir;
+        for (const e of entry.errors) {
+          if (e.severity === "error") allErrors.push(e);
+          else allWarnings.push(e);
+        }
+      }
+    }
+    this.cache.updateStats(recompiled, cacheHits, Date.now() - startTime);
+    return buildComposedResult(files, fileIRs, this.lastConfig, allErrors, allWarnings, {
+      usePhase2Modules: options.usePhase2Modules,
+      mode,
+      resolvedModules: options.resolvedModules
+    });
+  }
+  /**
+   * Rebuild result from cache without recompiling anything.
+   */
+  rebuildFromCache(files, options) {
+    let config = this.lastConfig;
+    if (!config.slug) {
+      for (const [filename, source] of Object.entries(files)) {
+        if (isConfigFile(filename)) {
+          config = parseConfig(source);
+          this.lastConfig = config;
+          break;
+        }
+      }
+    }
+    const fileIRs = {};
+    const allErrors = [];
+    const allWarnings = [];
+    for (const cached of this.cache.getCachedFiles()) {
+      const entry = this.cache.get(cached);
+      if (entry) {
+        fileIRs[cached] = entry.ir;
+        for (const e of entry.errors) {
+          if (e.severity === "error") allErrors.push(e);
+          else allWarnings.push(e);
+        }
+      }
+    }
+    const mode = this.lastConfig.mode || options.mode || "infer";
+    return buildComposedResult(files, fileIRs, config, allErrors, allWarnings, {
+      usePhase2Modules: options.usePhase2Modules,
+      mode,
+      resolvedModules: options.resolvedModules
+    });
+  }
+  /** Invalidate a specific file's cache. */
+  invalidate(filename) {
+    this.cache.delete(filename);
+  }
+  /** Invalidate all caches. */
+  invalidateAll() {
+    this.cache.clear();
+    this.lastConfig = {};
+  }
+  /** Check if a file would need recompilation given its current source. */
+  isDirty(filename, source) {
+    hashContent(source);
+    const cached = this.cache.get(filename);
+    return !cached;
+  }
+  /** Get list of files currently in cache. */
+  getCachedFiles() {
+    return this.cache.getCachedFiles();
+  }
+  /** Get compilation statistics. */
+  getStats() {
+    const stats = this.cache.getStats();
+    return {
+      cachedFiles: stats.totalCached,
+      totalHashes: stats.totalCached,
+      ...stats
+    };
+  }
+};
+
+export {
+  compileModel,
+  compileModels,
+  extractRoutes,
+  compileActions,
+  resolveActionReferences,
+  hashContent,
+  extractImports,
+  resolveImport,
+  buildDependencyGraph,
+  computeTransitiveDirtySet,
+  topologicalSort,
+  IncrementalCache,
+  compileProject,
+  IncrementalProjectCompiler
+};