@mmapp/react-compiler 0.1.0-alpha.15 → 0.1.0-alpha.17

package/dist/chunk-NTB7OEX2.mjs

@@ -1,2918 +0,0 @@
-import {
-  babelPlugin,
-  init_ts_to_expression,
-  transpileBlock,
-  ts_to_expression_exports
-} from "./chunk-OPJKP747.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 !== "sync");
-    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) {
-    if (t.isTryStatement(stmt) && containsAwait(stmt.block)) {
-      if (current.length > 0) {
-        segments.push({ index: index++, kind: "sync", statements: current });
-        current = [];
-      }
-      const trySegs = splitAtAwaits(stmt.block.body);
-      const catchStmts = stmt.handler?.body.body ?? [];
-      const catchParam = stmt.handler?.param && t.isIdentifier(stmt.handler.param) ? stmt.handler.param.name : "error";
-      segments.push({
-        index: index++,
-        kind: "try_catch",
-        statements: [stmt],
-        trySegments: trySegs,
-        catchStatements: catchStmts,
-        catchParam
-      });
-      continue;
-    }
-    if (t.isForOfStatement(stmt) && containsAwait(stmt.body)) {
-      if (current.length > 0) {
-        segments.push({ index: index++, kind: "sync", statements: current });
-        current = [];
-      }
-      const loopBody = t.isBlockStatement(stmt.body) ? stmt.body.body : [stmt.body];
-      const loopBinding = t.isVariableDeclaration(stmt.left) && t.isIdentifier(stmt.left.declarations[0]?.id) ? stmt.left.declarations[0].id.name : "item";
-      segments.push({
-        index: index++,
-        kind: "loop",
-        statements: [stmt],
-        loopBinding,
-        loopIterable: stmt.right,
-        loopBodySegments: splitAtAwaits(loopBody)
-      });
-      continue;
-    }
-    const promiseInfo = extractPromiseAllOrRace(stmt);
-    if (promiseInfo) {
-      if (current.length > 0) {
-        segments.push({ index: index++, kind: "sync", statements: current });
-        current = [];
-      }
-      segments.push({
-        index: index++,
-        kind: promiseInfo.type === "all" ? "parallel" : "race",
-        statements: [stmt],
-        parallelCallees: promiseInfo.callees,
-        resultBinding: promiseInfo.binding
-      });
-      continue;
-    }
-    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 containsAwait(node) {
-  if (t.isAwaitExpression(node)) return true;
-  if (t.isBlockStatement(node)) {
-    return node.body.some((s) => containsAwait(s));
-  }
-  if (t.isExpressionStatement(node)) {
-    return containsAwait(node.expression);
-  }
-  if (t.isVariableDeclaration(node)) {
-    return node.declarations.some((d) => d.init ? containsAwait(d.init) : false);
-  }
-  if (t.isReturnStatement(node) && node.argument) {
-    return containsAwait(node.argument);
-  }
-  if (t.isCallExpression(node)) {
-    return node.arguments.some((a) => t.isNode(a) && containsAwait(a));
-  }
-  if (t.isForOfStatement(node)) {
-    return containsAwait(node.body);
-  }
-  if (t.isForStatement(node)) {
-    return containsAwait(node.body);
-  }
-  if (t.isIfStatement(node)) {
-    return containsAwait(node.consequent) || (node.alternate ? containsAwait(node.alternate) : false);
-  }
-  if (t.isTryStatement(node)) {
-    return containsAwait(node.block) || (node.handler ? containsAwait(node.handler.body) : false);
-  }
-  if (t.isArrayExpression(node)) {
-    return node.elements.some((e) => e && !t.isSpreadElement(e) && containsAwait(e));
-  }
-  return false;
-}
-function extractPromiseAllOrRace(stmt) {
-  let awaitExpr = null;
-  let binding;
-  if (t.isVariableDeclaration(stmt)) {
-    const decl = stmt.declarations[0];
-    if (decl?.init && t.isAwaitExpression(decl.init)) {
-      awaitExpr = decl.init;
-      binding = t.isIdentifier(decl.id) ? decl.id.name : t.isArrayPattern(decl.id) ? "__destructured__" : void 0;
-    }
-  } else if (t.isExpressionStatement(stmt) && t.isAwaitExpression(stmt.expression)) {
-    awaitExpr = stmt.expression;
-  }
-  if (!awaitExpr) return null;
-  const arg = awaitExpr.argument;
-  if (!t.isCallExpression(arg)) return null;
-  if (!t.isMemberExpression(arg.callee)) return null;
-  if (!t.isIdentifier(arg.callee.object) || arg.callee.object.name !== "Promise") return null;
-  if (!t.isIdentifier(arg.callee.property)) return null;
-  const method = arg.callee.property.name;
-  if (method !== "all" && method !== "race") return null;
-  const firstArg = arg.arguments[0];
-  if (!t.isArrayExpression(firstArg)) return null;
-  const callees = [];
-  for (const elem of firstArg.elements) {
-    if (!elem || t.isSpreadElement(elem)) continue;
-    if (t.isCallExpression(elem)) {
-      callees.push({
-        callee: getCalleeName(elem.callee),
-        args: elem.arguments
-      });
-    }
-  }
-  if (callees.length === 0) return null;
-  if (binding === "__destructured__" && t.isVariableDeclaration(stmt)) {
-    const decl = stmt.declarations[0];
-    if (t.isArrayPattern(decl.id)) {
-      for (let i = 0; i < decl.id.elements.length && i < callees.length; i++) {
-        const elem = decl.id.elements[i];
-        if (t.isIdentifier(elem)) {
-          callees[i].binding = elem.name;
-        }
-      }
-    }
-  }
-  return { type: method, callees, binding };
-}
-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;
-    }
-    if (seg.kind === "try_catch" && seg.trySegments) {
-      if (pendingSyncStmts.length > 0) {
-        const block = t.blockStatement(pendingSyncStmts);
-        const transpiled = transpileBlock(block, { allMutable: true, derivedVarMap: buildDerivedVarMap(awaitBindings), parameterMap });
-        if (!transpiled.pure) bodyIsPure = false;
-        const preState = uniqueState("pre_try", usedStateNames);
-        states.push({ name: preState, type: "REGULAR", on_enter: [], during: [], on_exit: [] });
-        transitions.push({
-          name: transitionCount === 0 ? "execute" : `on_${getStateSuffix(prevState)}_complete`,
-          from: [prevState],
-          to: preState,
-          actions: [{ id: `pre_try_${transitionCount}`, type: "eval", mode: "auto", config: { expression: transpiled.expression } }]
-        });
-        prevState = preState;
-        transitionCount++;
-        pendingSyncStmts = [];
-      }
-      const tryResult = generateMultiStateIR(seg.trySegments, _warnings, parameterMap);
-      if (!tryResult.bodyIsPure) bodyIsPure = false;
-      const successState = uniqueState("try_success", usedStateNames);
-      const errorState = uniqueState("try_error", usedStateNames);
-      states.push({ name: errorState, type: "REGULAR", on_enter: [], during: [], on_exit: [] });
-      states.push({ name: successState, type: "REGULAR", on_enter: [], during: [], on_exit: [] });
-      for (const s of tryResult.states) {
-        if (s.name === "ready" || s.name === "done") continue;
-        states.push(s);
-      }
-      for (const tr of tryResult.transitions) {
-        const remappedFrom = tr.from.map((f) => f === "ready" ? prevState : f);
-        const remappedTo = tr.to === "done" ? successState : tr.to;
-        transitions.push({ ...tr, from: remappedFrom, to: remappedTo });
-        if (tr.actions.some((a) => a.type === "call_workflow")) {
-          const awaitState = tr.to === successState ? successState : tr.to;
-          if (awaitState !== successState) {
-            transitions.push({
-              name: `on_${getStateSuffix(awaitState)}_error`,
-              from: [awaitState],
-              to: errorState,
-              actions: [],
-              conditions: [{ expression: "action_error != null", type: "expression" }]
-            });
-          }
-        }
-      }
-      if (tryResult.transitions.length > 0 && transitionCount === 0) {
-        transitions[transitions.length - tryResult.transitions.length].name = "execute";
-      }
-      if (seg.catchStatements && seg.catchStatements.length > 0) {
-        const catchBlock = t.blockStatement(seg.catchStatements);
-        const catchBindings = new Map(awaitBindings);
-        if (seg.catchParam) {
-          catchBindings.set(seg.catchParam, "action_error");
-        }
-        const catchTranspiled = transpileBlock(catchBlock, {
-          allMutable: true,
-          derivedVarMap: buildDerivedVarMap(catchBindings),
-          parameterMap
-        });
-        if (!catchTranspiled.pure) bodyIsPure = false;
-        const postCatch = uniqueState("post_catch", usedStateNames);
-        states.push({ name: postCatch, type: "REGULAR", on_enter: [], during: [], on_exit: [] });
-        transitions.push({
-          name: `catch_${transitionCount}`,
-          from: [errorState],
-          to: postCatch,
-          actions: [{ id: `catch_eval_${transitionCount}`, type: "eval", mode: "auto", config: { expression: catchTranspiled.expression } }]
-        });
-        prevState = postCatch;
-        transitions.push({
-          name: `try_success_${transitionCount}`,
-          from: [successState],
-          to: postCatch,
-          actions: []
-        });
-      } else {
-        prevState = successState;
-      }
-      transitionCount++;
-      continue;
-    }
-    if ((seg.kind === "parallel" || seg.kind === "race") && seg.parallelCallees) {
-      if (pendingSyncStmts.length > 0) {
-        const block = t.blockStatement(pendingSyncStmts);
-        const transpiled = transpileBlock(block, { allMutable: true, derivedVarMap: buildDerivedVarMap(awaitBindings), parameterMap });
-        if (!transpiled.pure) bodyIsPure = false;
-        pendingSyncStmts = [];
-      }
-      const groupId = `p${transitionCount}`;
-      const dispatchKind = seg.kind === "parallel" ? "parallel" : "race";
-      const stateName2 = uniqueState(`awaiting_${dispatchKind}_${transitionCount}`, usedStateNames);
-      states.push({ name: stateName2, type: "REGULAR", on_enter: [], during: [], on_exit: [] });
-      const actions2 = [];
-      for (let ci = 0; ci < seg.parallelCallees.length; ci++) {
-        const callee = seg.parallelCallees[ci];
-        const slug = toSnakeCase(callee.callee);
-        actions2.push({
-          id: `call_${slug}_${ci}`,
-          type: "call_workflow",
-          mode: "auto",
-          config: {
-            definition_slug: callee.callee,
-            result_key: slug,
-            [`${dispatchKind}_group`]: groupId
-          }
-        });
-        if (callee.binding) {
-          awaitBindings.set(callee.binding, `action_results.${slug}`);
-        }
-      }
-      const transName2 = transitionCount === 0 ? "execute" : `on_${getStateSuffix(prevState)}_complete`;
-      transitions.push({ name: transName2, from: [prevState], to: stateName2, actions: actions2 });
-      prevState = stateName2;
-      transitionCount++;
-      continue;
-    }
-    if (seg.kind === "loop" && seg.loopBodySegments) {
-      if (pendingSyncStmts.length > 0) {
-        const block = t.blockStatement(pendingSyncStmts);
-        const transpiled = transpileBlock(block, { allMutable: true, derivedVarMap: buildDerivedVarMap(awaitBindings), parameterMap });
-        if (!transpiled.pure) bodyIsPure = false;
-        pendingSyncStmts = [];
-      }
-      const loopState = uniqueState(`loop_${toSnakeCase(seg.loopBinding ?? "item")}`, usedStateNames);
-      const postLoop = uniqueState("post_loop", usedStateNames);
-      states.push({ name: loopState, type: "REGULAR", on_enter: [], during: [], on_exit: [] });
-      states.push({ name: postLoop, type: "REGULAR", on_enter: [], during: [], on_exit: [] });
-      const initTransName = transitionCount === 0 ? "execute" : `on_${getStateSuffix(prevState)}_complete`;
-      transitions.push({
-        name: initTransName,
-        from: [prevState],
-        to: loopState,
-        actions: [{
-          id: `loop_init_${transitionCount}`,
-          type: "eval",
-          mode: "auto",
-          config: { expression: `let __loop_idx = 0; let __loop_items = ${seg.loopIterable ? toSnakeCase(seg.loopBinding ?? "items") : "[]"}` }
-        }]
-      });
-      const awaitSegs = seg.loopBodySegments.filter((s) => s.kind === "await");
-      if (awaitSegs.length > 0) {
-        const firstAwait = awaitSegs[0];
-        const slug = toSnakeCase(firstAwait.awaitTarget ?? "action");
-        transitions.push({
-          name: `loop_body_${transitionCount}`,
-          from: [loopState],
-          to: loopState,
-          actions: [{
-            id: `loop_call_${slug}`,
-            type: "call_workflow",
-            mode: "auto",
-            config: {
-              definition_slug: firstAwait.awaitTarget,
-              result_key: slug,
-              loop_iteration: true
-            }
-          }],
-          conditions: [{ expression: "__loop_idx < length(__loop_items)", type: "expression" }]
-        });
-      }
-      transitions.push({
-        name: `loop_done_${transitionCount}`,
-        from: [loopState],
-        to: postLoop,
-        actions: [],
-        conditions: [{ expression: "__loop_idx >= length(__loop_items)", type: "expression" }]
-      });
-      prevState = postLoop;
-      transitionCount++;
-      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 uniqueState(base, used) {
-  if (!used.has(base)) {
-    used.add(base);
-    return base;
-  }
-  let suffix = 2;
-  while (used.has(`${base}_${suffix}`)) suffix++;
-  const name = `${base}_${suffix}`;
-  used.add(name);
-  return name;
-}
-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 configSchemaBlock = extractObjectBlock(source, "configSchema");
-  if (configSchemaBlock) {
-    const configSchema = {};
-    const modelSlugMatch = configSchemaBlock.match(/modelSlug:\s*['"]([^'"]+)['"]/);
-    if (modelSlugMatch) configSchema.modelSlug = modelSlugMatch[1];
-    const defaultsBlock = extractObjectBlock(configSchemaBlock, "defaults");
-    if (defaultsBlock) {
-      const defaults = {};
-      const kvRegex = /(\w+):\s*(?:'([^']*)'|"([^"]*)"|(\d+(?:\.\d+)?)|(\btrue\b|\bfalse\b))/g;
-      let kv;
-      while ((kv = kvRegex.exec(defaultsBlock)) !== 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 depBlocks = extractNestedObjects(depsBlock);
-    for (const block of depBlocks) {
-      const slugMatch = block.match(/slug:\s*['"]([^'"]+)['"]/);
-      if (!slugMatch) continue;
-      const entry = { slug: slugMatch[1] };
-      const verMatch = block.match(/version:\s*['"]([^'"]+)['"]/);
-      if (verMatch) entry.version = verMatch[1];
-      const reqMatch = block.match(/required:\s*(true|false)/);
-      if (reqMatch) entry.required = reqMatch[1] === "true";
-      const prefixMatch = block.match(/prefix:\s*['"]([^'"]+)['"]/);
-      if (prefixMatch) entry.routeConfig = { prefix: prefixMatch[1] };
-      const configBlock = extractObjectBlock(block, "config");
-      if (configBlock) {
-        const config = {};
-        const kvRegex = /(\w+):\s*(?:'([^']*)'|"([^"]*)"|(\d+(?:\.\d+)?)|(\btrue\b|\bfalse\b))/g;
-        let kv;
-        while ((kv = kvRegex.exec(configBlock)) !== null) {
-          const key = kv[1];
-          const val = kv[2] ?? kv[3] ?? (kv[4] !== void 0 ? Number(kv[4]) : kv[5] === "true");
-          config[key] = val;
-        }
-        if (Object.keys(config).length > 0) entry.config = config;
-      }
-      dependencies.push(entry);
-    }
-    if (dependencies.length > 0) manifest.dependencies = dependencies;
-  }
-  const hasRichFields = manifest.routes || manifest.actions || manifest.contributions || manifest.capabilities || manifest.dependencies || manifest.configSchema;
-  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 ? "" : "?";
-      const desc = field.description;
-      if (desc) {
-        lines.push(`  /** ${desc} */`);
-      }
-      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
-};