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

package/dist/chunk-UDDTWG5J.mjs

@@ -0,0 +1,734 @@
+import {
+  mindmatrixReact
+} from "./chunk-BZEXUPDH.mjs";
+import {
+  build
+} from "./chunk-VLTKQDJ3.mjs";
+
+// src/cli/local-server.ts
+import * as http from "http";
+import { randomUUID } from "crypto";
+var MemoryStore = class {
+  constructor() {
+    this.definitions = /* @__PURE__ */ new Map();
+    this.instances = /* @__PURE__ */ new Map();
+    this.slugIndex = /* @__PURE__ */ new Map();
+  }
+  // slug → id
+  // ── Definitions ──────────────────────────────────────────────────────
+  createDefinition(input) {
+    if (this.slugIndex.has(input.slug)) {
+      const existing = this.definitions.get(this.slugIndex.get(input.slug));
+      if (existing) return existing;
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const def = {
+      id: input.id ?? randomUUID(),
+      slug: input.slug,
+      name: input.name,
+      version: input.version ?? "1.0.0",
+      description: input.description ?? null,
+      category: input.category ?? "workflow",
+      fields: input.fields ?? [],
+      states: input.states ?? [],
+      transitions: input.transitions ?? [],
+      roles: input.roles ?? [],
+      experience: input.experience ?? null,
+      metadata: input.metadata ?? {},
+      child_definitions: input.child_definitions ?? [],
+      is_immutable: input.is_immutable ?? false,
+      tags: input.tags ?? [],
+      inline_tags: input.inline_tags ?? [],
+      created_at: now,
+      updated_at: now
+    };
+    this.definitions.set(def.id, def);
+    this.slugIndex.set(def.slug, def.id);
+    return def;
+  }
+  getDefinition(idOrSlug) {
+    const byId = this.definitions.get(idOrSlug);
+    if (byId) return byId;
+    const id = this.slugIndex.get(idOrSlug);
+    if (id) return this.definitions.get(id);
+    return void 0;
+  }
+  listDefinitions(opts) {
+    let items = Array.from(this.definitions.values());
+    if (opts?.category) {
+      items = items.filter((d) => d.category === opts.category);
+    }
+    const total = items.length;
+    const offset = opts?.offset ?? 0;
+    const limit = opts?.limit ?? 50;
+    items = items.slice(offset, offset + limit);
+    return { items, total };
+  }
+  patchDefinition(id, patch) {
+    const def = this.definitions.get(id);
+    if (!def) return void 0;
+    Object.assign(def, patch, { updated_at: (/* @__PURE__ */ new Date()).toISOString() });
+    return def;
+  }
+  deleteDefinition(id) {
+    const def = this.definitions.get(id);
+    if (!def) return false;
+    this.slugIndex.delete(def.slug);
+    this.definitions.delete(id);
+    return true;
+  }
+  // ── Instances ────────────────────────────────────────────────────────
+  createInstance(input) {
+    const def = this.getDefinition(input.definition_id) ?? this.getDefinition(input.definition_slug);
+    if (!def) return null;
+    const initialState = def.states.find((s) => s.type === "START" || s.type === "initial");
+    const stateName = initialState?.name ?? "initial";
+    const stateData = {};
+    for (const field of def.fields) {
+      if (field.default_value !== void 0) {
+        stateData[field.name] = field.default_value;
+      }
+    }
+    Object.assign(stateData, input.state_data ?? {});
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const inst = {
+      id: randomUUID(),
+      definition_id: def.id,
+      definition_slug: def.slug,
+      current_state: stateName,
+      state_data: stateData,
+      execution_lock_version: 0,
+      event_log: [{
+        event_type: "transition",
+        message: `Instance created in state '${stateName}'`,
+        timestamp: now
+      }],
+      created_at: now,
+      updated_at: now
+    };
+    this.instances.set(inst.id, inst);
+    return inst;
+  }
+  getInstance(id) {
+    return this.instances.get(id);
+  }
+  listInstances(opts) {
+    let items = Array.from(this.instances.values());
+    if (opts?.definition_id) {
+      items = items.filter((i) => i.definition_id === opts.definition_id);
+    }
+    const total = items.length;
+    const offset = opts?.offset ?? 0;
+    const limit = opts?.limit ?? 50;
+    items = items.slice(offset, offset + limit);
+    return { items, total };
+  }
+  // ── Execute Action (Transition) ──────────────────────────────────────
+  executeAction(input) {
+    const def = this.getDefinition(input.definition_id);
+    if (!def) return { success: false, error: "Definition not found" };
+    let inst;
+    if (input.instance_id) {
+      const existing = this.instances.get(input.instance_id);
+      if (!existing) return { success: false, error: "Instance not found" };
+      inst = existing;
+    } else {
+      const created = this.createInstance({
+        definition_id: def.id,
+        definition_slug: def.slug,
+        state_data: input.payload
+      });
+      if (!created) return { success: false, error: "Failed to create instance" };
+      inst = created;
+    }
+    if (input.payload && input.instance_id) {
+      Object.assign(inst.state_data, input.payload);
+    }
+    const transition = def.transitions.find((t) => t.name === input.action_name && t.from.includes(inst.current_state));
+    if (!transition) {
+      return {
+        success: false,
+        instance_id: inst.id,
+        from_state: inst.current_state,
+        to_state: null,
+        state_data: inst.state_data,
+        error: `No transition '${input.action_name}' from state '${inst.current_state}'`
+      };
+    }
+    const fromState = inst.current_state;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const events = [];
+    let lastEvalResult = null;
+    events.push({ event_type: "transition", message: `Transition '${transition.name}' started: ${fromState} \u2192 ${transition.to}`, timestamp: now });
+    for (const action of transition.actions ?? []) {
+      try {
+        if (action.type === "set_field") {
+          const field = action.config?.field;
+          if (action.config?.expression) {
+            const expr = action.config.expression;
+            const result = this.evaluateSimpleExpression(expr, inst.state_data);
+            inst.state_data[field] = result;
+          } else if (action.config?.value !== void 0) {
+            inst.state_data[field] = action.config.value;
+          }
+          events.push({ event_type: "action_executed", message: `transition action 'set_field' succeeded`, timestamp: now });
+        } else if (action.type === "eval") {
+          const expr = action.config?.expression;
+          lastEvalResult = this.evaluateSimpleExpression(expr, inst.state_data);
+          events.push({ event_type: "action_executed", message: `transition action 'eval' succeeded`, timestamp: now });
+        } else {
+          events.push({ event_type: "action_executed", message: `transition action '${action.type}' succeeded (no-op in local mode)`, timestamp: now });
+        }
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        events.push({ event_type: "action_failed", message: `transition action '${action.type}' failed: ${msg}`, timestamp: now });
+        return {
+          success: false,
+          instance_id: inst.id,
+          from_state: fromState,
+          to_state: null,
+          state_data: inst.state_data,
+          event_log: events,
+          error: `transition action failed: ${msg}`
+        };
+      }
+    }
+    inst.current_state = transition.to;
+    inst.execution_lock_version++;
+    inst.updated_at = now;
+    events.push({ event_type: "transition", message: `State changed: ${fromState} \u2192 ${transition.to}`, timestamp: now });
+    inst.event_log.push(...events);
+    return {
+      success: true,
+      instance_id: inst.id,
+      from_state: fromState,
+      to_state: transition.to,
+      state_data: inst.state_data,
+      result: lastEvalResult,
+      event_log: events
+    };
+  }
+  /**
+   * Minimal expression evaluator for local dev mode.
+   * Handles: field references, arithmetic, string literals, simple comparisons.
+   * Does NOT handle: while loops, if/else, function calls, multi-statement blocks.
+   * For full evaluation, use mm-napi when available.
+   */
+  evaluateSimpleExpression(expr, context) {
+    if (context[expr] !== void 0) return context[expr];
+    const arithMatch = expr.match(/^(\w+)\s*([+\-*/])\s*(\d+(?:\.\d+)?)$/);
+    if (arithMatch) {
+      const [, field, op, numStr] = arithMatch;
+      const left = Number(context[field] ?? 0);
+      const right = Number(numStr);
+      switch (op) {
+        case "+":
+          return left + right;
+        case "-":
+          return left - right;
+        case "*":
+          return left * right;
+        case "/":
+          return right !== 0 ? left / right : 0;
+      }
+    }
+    if (/^\d+(\.\d+)?$/.test(expr.trim())) {
+      return Number(expr.trim());
+    }
+    const strMatch = expr.match(/^["'](.*)["']$/);
+    if (strMatch) return strMatch[1];
+    try {
+      const keys = Object.keys(context);
+      const values = Object.values(context);
+      const fn = new Function(...keys, `"use strict"; return (${expr});`);
+      return fn(...values);
+    } catch {
+      return null;
+    }
+  }
+};
+async function startLocalServer(options = {}) {
+  const { port = 4200, noAuth = true } = options;
+  const store = new MemoryStore();
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  function json(res, status, body) {
+    const data = JSON.stringify(body);
+    res.writeHead(status, {
+      "Content-Type": "application/json",
+      "Access-Control-Allow-Origin": "*",
+      "Access-Control-Allow-Methods": "GET, POST, PATCH, PUT, DELETE, OPTIONS",
+      "Access-Control-Allow-Headers": "Content-Type, Authorization",
+      "Content-Length": Buffer.byteLength(data)
+    });
+    res.end(data);
+  }
+  function readBody(req) {
+    return new Promise((resolve, reject) => {
+      const chunks = [];
+      req.on("data", (chunk) => chunks.push(chunk));
+      req.on("end", () => resolve(Buffer.concat(chunks).toString()));
+      req.on("error", reject);
+    });
+  }
+  function parseQuery(url) {
+    const idx = url.indexOf("?");
+    if (idx === -1) return {};
+    const params = {};
+    const qs = url.slice(idx + 1);
+    for (const pair of qs.split("&")) {
+      const [k, v] = pair.split("=");
+      if (k) params[decodeURIComponent(k)] = decodeURIComponent(v ?? "");
+    }
+    return params;
+  }
+  const server = http.createServer(async (req, res) => {
+    const method = req.method?.toUpperCase() ?? "GET";
+    const rawUrl = req.url ?? "/";
+    const queryStart = rawUrl.indexOf("?");
+    const path = queryStart >= 0 ? rawUrl.slice(0, queryStart) : rawUrl;
+    const query = parseQuery(rawUrl);
+    if (method === "OPTIONS") {
+      res.writeHead(204, {
+        "Access-Control-Allow-Origin": "*",
+        "Access-Control-Allow-Methods": "GET, POST, PATCH, PUT, DELETE, OPTIONS",
+        "Access-Control-Allow-Headers": "Content-Type, Authorization",
+        "Access-Control-Max-Age": "86400"
+      });
+      res.end();
+      return;
+    }
+    try {
+      if (path === "/health" && method === "GET") {
+        return json(res, 200, {
+          status: "ok",
+          service: "mm-local-dev",
+          mode: "in-memory",
+          started_at: startedAt,
+          definitions: store.definitions.size,
+          instances: store.instances.size
+        });
+      }
+      if (path === "/api/v1/auth/login" && (method === "POST" || method === "GET")) {
+        return json(res, 200, {
+          token: "dev-token-local",
+          user: {
+            id: "dev-user-001",
+            email: "dev@localhost",
+            role: "admin",
+            name: "Local Developer"
+          }
+        });
+      }
+      if (path === "/api/v1/workflow/definitions" && method === "GET") {
+        const result = store.listDefinitions({
+          category: query.category,
+          limit: query.limit ? parseInt(query.limit, 10) : void 0,
+          offset: query.offset ? parseInt(query.offset, 10) : void 0
+        });
+        if (query.slug) {
+          const def = store.getDefinition(query.slug);
+          return json(res, 200, { items: def ? [def] : [], total: def ? 1 : 0 });
+        }
+        return json(res, 200, result);
+      }
+      const defMatch = path.match(/^\/api\/v1\/workflow\/definitions\/([^/]+)$/);
+      if (defMatch && method === "GET") {
+        const def = store.getDefinition(defMatch[1]);
+        if (!def) return json(res, 404, { error: "Not found" });
+        return json(res, 200, def);
+      }
+      if (path === "/api/v1/workflow/definitions" && method === "POST") {
+        const body = JSON.parse(await readBody(req));
+        const def = store.createDefinition(body);
+        return json(res, 201, def);
+      }
+      if (defMatch && method === "PATCH") {
+        const body = JSON.parse(await readBody(req));
+        const updated = store.patchDefinition(defMatch[1], body);
+        if (!updated) return json(res, 404, { error: "Not found" });
+        return json(res, 200, updated);
+      }
+      if (defMatch && method === "DELETE") {
+        const deleted = store.deleteDefinition(defMatch[1]);
+        if (!deleted) return json(res, 404, { error: "Not found" });
+        return json(res, 204, null);
+      }
+      if (path === "/api/v1/workflow/instances" && method === "GET") {
+        const result = store.listInstances({
+          definition_id: query.definition_id,
+          limit: query.limit ? parseInt(query.limit, 10) : void 0,
+          offset: query.offset ? parseInt(query.offset, 10) : void 0
+        });
+        return json(res, 200, result);
+      }
+      if (path === "/api/v1/workflow/instances" && method === "POST") {
+        const body = JSON.parse(await readBody(req));
+        const inst = store.createInstance(body);
+        if (!inst) return json(res, 404, { error: "Definition not found" });
+        return json(res, 201, inst);
+      }
+      const instMatch = path.match(/^\/api\/v1\/workflow\/instances\/([^/]+)$/);
+      if (instMatch && method === "GET") {
+        const inst = store.getInstance(instMatch[1]);
+        if (!inst) return json(res, 404, { error: "Not found" });
+        return json(res, 200, inst);
+      }
+      if (path === "/api/v1/workflow/execute-action" && method === "POST") {
+        const body = JSON.parse(await readBody(req));
+        const result = store.executeAction(body);
+        return json(res, 200, result);
+      }
+      const dataMatch = path.match(/^\/api\/v1\/data\/([^/]+)$/);
+      if (dataMatch && method === "GET") {
+        const def = store.getDefinition(dataMatch[1]);
+        if (!def) return json(res, 404, { error: "Not found" });
+        const instances = store.listInstances({ definition_id: def.id });
+        return json(res, 200, instances);
+      }
+      if (path.startsWith("/api/v1/")) {
+        return json(res, 501, { error: "Not implemented in local dev mode", path, method });
+      }
+      return json(res, 404, { error: "Not found", path });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.error(`[mm-local] ${method} ${path} \u2014 Error: ${message}`);
+      return json(res, 500, { error: message });
+    }
+  });
+  return new Promise((resolve, reject) => {
+    server.on("error", (err) => {
+      if (err.code === "EADDRINUSE") {
+        reject(new Error(`Port ${port} is already in use. Is another server running?`));
+      } else {
+        reject(err);
+      }
+    });
+    server.listen(port, () => {
+      console.log(`[mm-local] Local API server running at http://localhost:${port}`);
+      console.log(`[mm-local] Mode: in-memory (data lost on restart)`);
+      console.log(`[mm-local] Auth: disabled (all requests accepted)`);
+      resolve({
+        server,
+        port,
+        store,
+        async close() {
+          return new Promise((res) => {
+            server.close(() => {
+              console.log("[mm-local] Local API server stopped");
+              res();
+            });
+          });
+        }
+      });
+    });
+  });
+}
+
+// src/dev-server.ts
+var currentErrors = null;
+function escapeHtml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function renderErrorOverlay(errors) {
+  const cards = errors.map((err) => {
+    const loc = err.line ? `${err.file}:${err.line}${err.column ? ":" + err.column : ""}` : err.file;
+    const snippet = err.snippet ? `<pre style="background:#1a1a2e;color:#e0e0e0;padding:12px 16px;border-radius:6px;overflow-x:auto;margin-top:8px;font-size:13px;line-height:1.5">${escapeHtml(err.snippet)}</pre>` : "";
+    return `<div style="background:#2d1b1b;border:1px solid #5c2020;border-radius:8px;padding:16px 20px;margin-bottom:12px">
+      <div style="color:#ff6b6b;font-family:monospace;font-size:13px;margin-bottom:6px">${escapeHtml(loc)}</div>
+      <div style="color:#ffa0a0;font-size:15px;font-weight:500">${escapeHtml(err.message)}</div>${snippet}</div>`;
+  }).join("\n");
+  return `<!DOCTYPE html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
+<title>Compile Error - MindMatrix Dev</title>
+<style>*{box-sizing:border-box;margin:0;padding:0}body{background:#1a1a2e;color:#e0e0e0;font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,sans-serif;padding:40px 20px;min-height:100vh}</style></head>
+<body><div style="max-width:800px;margin:0 auto">
+<div style="display:flex;align-items:center;gap:12px;margin-bottom:24px">
+<div style="background:#5c2020;color:#ff6b6b;font-size:14px;font-weight:600;padding:4px 10px;border-radius:4px">COMPILE ERROR</div>
+<div style="color:#888;font-size:13px">${errors.length} error${errors.length !== 1 ? "s" : ""}</div></div>
+${cards}
+<div style="color:#666;font-size:12px;margin-top:24px;text-align:center">Fix the error and save -- the page will reload automatically.</div></div>
+<script>const ws=new WebSocket('ws://'+location.host+'/__mm_dev');ws.onmessage=e=>{const m=JSON.parse(e.data);if(m.type==='workflow:compiled'||m.type==='workflow:rebuild')location.reload()};ws.onclose=()=>setTimeout(()=>location.reload(),2000)</script>
+</body></html>`;
+}
+function errorOverlayMiddleware() {
+  return (req, res, next) => {
+    if (!currentErrors || !req.url) return next();
+    const url = req.url;
+    if (url.startsWith("/api") || url.startsWith("/health") || url.startsWith("/ws") || url.startsWith("/__mm_dev") || url.startsWith("/@") || url.startsWith("/node_modules")) return next();
+    const accept = req.headers?.accept ?? "";
+    if (!accept.includes("text/html")) return next();
+    res.writeHead(500, { "Content-Type": "text/html; charset=utf-8" });
+    res.end(renderErrorOverlay(currentErrors));
+  };
+}
+async function resolveDevToken(apiUrl, explicit) {
+  if (explicit) return explicit;
+  try {
+    const { resolveToken } = await import("./auth-3UK75242.mjs");
+    const s = resolveToken(apiUrl);
+    if (s) return s;
+  } catch {
+  }
+  try {
+    const resp = await fetch(`${apiUrl}/auth/login`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ email: "admin@mindmatrix.com", password: "Admin123!" })
+    });
+    if (resp.ok) {
+      const data = await resp.json();
+      const token = data.token ?? data.access_token;
+      if (token) {
+        try {
+          const { saveCredentials } = await import("./auth-3UK75242.mjs");
+          saveCredentials(apiUrl, token);
+        } catch {
+        }
+        return token;
+      }
+    }
+  } catch {
+  }
+  return process.env.MINDMATRIX_TOKEN;
+}
+async function checkBackendHealth(apiUrl) {
+  try {
+    const base = apiUrl.replace(/\/api\/v1\/?$/, "");
+    const resp = await fetch(`${base}/health`, { signal: AbortSignal.timeout(5e3) });
+    if (resp.ok) {
+      const d = await resp.json();
+      return { ok: true, version: d.version, db: d.database };
+    }
+    return { ok: resp.status < 500 };
+  } catch {
+    return { ok: false };
+  }
+}
+async function initialBuildDeploy(src, outDir, mode, apiUrl, token) {
+  console.log("[mm-dev] Compiling project...");
+  const buildResult = await build({ src, outDir, mode, skipTypeCheck: true });
+  if (buildResult.errors > 0) {
+    currentErrors = buildResult.errorDetails.map((e) => ({ file: e.file, message: e.message, line: e.line }));
+    console.error(`[mm-dev] Build failed with ${buildResult.errors} error(s) -- error overlay active`);
+    return { buildResult, deployed: false, slug: void 0 };
+  }
+  currentErrors = null;
+  if (buildResult.compiled === 0) return { buildResult, deployed: false, slug: void 0 };
+  console.log(`[mm-dev] Compiled ${buildResult.compiled} definition(s)`);
+  try {
+    const { deploy } = await import("./deploy-YAJGW6II.mjs");
+    const result = await deploy({ apiUrl, token, dir: outDir });
+    const total = result.created.length + result.updated.length + result.versioned.length;
+    if (total > 0) console.log(`[mm-dev] Deployed: ${result.created.length} created, ${result.updated.length} updated`);
+    return { buildResult, deployed: true, slug: buildResult.definitions?.[0]?.slug };
+  } catch (e) {
+    console.warn(`[mm-dev] Deploy failed: ${e instanceof Error ? e.message : e}`);
+    return { buildResult, deployed: false, slug: void 0 };
+  }
+}
+function printBanner(o) {
+  const l = "-".repeat(58);
+  console.log(`
+  ${l}
+  MindMatrix Dev Server
+  ${l}
+`);
+  console.log(`  Preview:    http://localhost:${o.port}`);
+  console.log(`  API Proxy:  /api/* -> ${o.apiUrl}`);
+  console.log(`  WebSocket:  ws://localhost:${o.port}/__mm_dev`);
+  console.log(`  Watching:   ${o.src} (${o.include.join(", ")})
+`);
+  console.log(`  Backend:    ${o.health.ok ? "connected" : "unreachable"}${o.health.version ? ` (v${o.health.version})` : ""}`);
+  if (o.health.db) console.log(`  Database:   ${o.health.db}`);
+  console.log(`  Auth:       ${o.token ? "authenticated" : "no token"}`);
+  if (o.compiled > 0) {
+    console.log(`  Blueprint:  ${o.slug ?? "unknown"} (${o.compiled} defs)`);
+    console.log(`  Deploy:     ${o.deployed ? "synced" : "pending"}`);
+  }
+  if (o.errors > 0) console.log(`  Errors:     ${o.errors} compile error(s) -- overlay active`);
+  console.log(`
+  ${l}
+`);
+}
+function broadcast(clients, data) {
+  const msg = JSON.stringify(data);
+  for (const c of clients) {
+    try {
+      if (c.readyState === 1) c.send(msg);
+    } catch {
+      clients.delete(c);
+    }
+  }
+}
+async function createDevServer(options = {}) {
+  const {
+    port = 5199,
+    src = "src/workflows",
+    mode = "infer",
+    include = ["**/*.workflow.tsx"],
+    outDir = "dist/workflows",
+    seed = false,
+    apiUrl: rawApiUrl = "auto",
+    authToken: explicitToken,
+    ws: enableWs = true,
+    open = false
+  } = options;
+  const clients = /* @__PURE__ */ new Set();
+  let localServer = null;
+  let apiUrl;
+  let isLocalMode = false;
+  if (rawApiUrl === "local") {
+    localServer = await startLocalServer({ port: 4200 });
+    apiUrl = "http://localhost:4200/api/v1";
+    isLocalMode = true;
+  } else if (rawApiUrl === "auto") {
+    const defaultRemote = "https://dev.mindmatrix.club/api/v1";
+    const remoteHealth = await checkBackendHealth(defaultRemote);
+    if (remoteHealth.ok) {
+      apiUrl = defaultRemote;
+    } else {
+      const localHealth = await checkBackendHealth("http://localhost:4200/api/v1");
+      if (localHealth.ok) {
+        apiUrl = "http://localhost:4200/api/v1";
+      } else {
+        console.log("[mm-dev] No backend detected \u2014 starting local in-memory API server...");
+        localServer = await startLocalServer({ port: 4200 });
+        apiUrl = "http://localhost:4200/api/v1";
+        isLocalMode = true;
+      }
+    }
+  } else {
+    apiUrl = rawApiUrl;
+  }
+  const token = isLocalMode ? "dev-token-local" : await resolveDevToken(apiUrl, explicitToken);
+  const health = isLocalMode ? { ok: true, version: "local", db: "in-memory" } : await checkBackendHealth(apiUrl);
+  let initialSlug, initialCompiled = 0, initialDeployed = false, initialErrors = 0;
+  if (token && health.ok) {
+    const r = await initialBuildDeploy(src, outDir, mode, apiUrl, token);
+    initialCompiled = r.buildResult.compiled;
+    initialDeployed = r.deployed;
+    initialSlug = r.slug;
+    initialErrors = r.buildResult.errors;
+  }
+  if (seed && token && initialDeployed) {
+    try {
+      const { seedInstances } = await import("./seed-KOGEPGOJ.mjs");
+      console.log("[mm-dev] Seeding sample instances...");
+      const sr = await seedInstances({ apiUrl, token, dir: outDir });
+      console.log(`[mm-dev] Seeded ${sr.created} instance(s) across ${sr.definitions} definition(s)`);
+    } catch (e) {
+      console.warn(`[mm-dev] Seed failed: ${e instanceof Error ? e.message : e}`);
+    }
+  }
+  const pluginOpts = { mode, include, outDir, seedOnCompile: seed, apiUrl, authToken: token };
+  const proxyTarget = apiUrl.replace(/\/api\/v1\/?$/, "") || apiUrl;
+  let deployInFlight = false;
+  const compileDeployPlugin = {
+    name: "mindmatrix-dev-compile-deploy",
+    enforce: "post",
+    async handleHotUpdate(ctx) {
+      const isWf = include.some((p) => new RegExp(p.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "<<G>>").replace(/\*/g, "[^/]*").replace(/<<G>>/g, ".*").replace(/\?/g, ".")).test(ctx.file));
+      if (!isWf) return;
+      const fn = ctx.file.split("/").pop() ?? ctx.file;
+      console.log(`[mm-dev] Recompiling ${fn}...`);
+      const br = await build({ src, outDir, mode, skipTypeCheck: true });
+      if (br.errors > 0) {
+        currentErrors = br.errorDetails.map((e) => ({ file: e.file, message: e.message, line: e.line }));
+        broadcast(clients, { type: "workflow:error", errors: br.errors, timestamp: ctx.timestamp });
+        return;
+      }
+      currentErrors = null;
+      if (token && !deployInFlight) {
+        deployInFlight = true;
+        try {
+          const { deploy: d } = await import("./deploy-YAJGW6II.mjs");
+          await d({ apiUrl, token, dir: outDir });
+        } catch {
+        } finally {
+          deployInFlight = false;
+        }
+      }
+      broadcast(clients, { type: "workflow:compiled", file: ctx.file, compiled: br.compiled, timestamp: ctx.timestamp });
+    }
+  };
+  const viteConfig = {
+    root: process.cwd(),
+    server: {
+      port,
+      open,
+      host: true,
+      proxy: {
+        "/api": { target: proxyTarget, changeOrigin: true, secure: true, ws: true },
+        "/health": { target: proxyTarget, changeOrigin: true, secure: true },
+        "/ws": { target: proxyTarget.replace(/^http/, "ws"), changeOrigin: true, ws: true }
+      }
+    },
+    plugins: [
+      mindmatrixReact(pluginOpts),
+      compileDeployPlugin,
+      { name: "mindmatrix-error-overlay", configureServer(server) {
+        server.middlewares.use(errorOverlayMiddleware());
+      } }
+    ],
+    logLevel: "warn"
+  };
+  const { createServer: createServer2 } = await import("vite");
+  const vite = await createServer2(viteConfig);
+  await vite.listen();
+  const resolvedPort = vite.config.server.port ?? port;
+  if (enableWs && vite.httpServer) {
+    try {
+      const wsM = await Function('return import("ws")')();
+      const WSS = wsM.WebSocketServer ?? wsM.default?.WebSocketServer;
+      if (WSS) {
+        const wss = new WSS({ server: vite.httpServer, path: "/__mm_dev" });
+        wss.on("connection", (s) => {
+          clients.add(s);
+          s.on("close", () => clients.delete(s));
+          s.send(JSON.stringify({ type: "mm:connected", version: "0.1.0", capabilities: ["compile", "deploy", "proxy", "notify", "error-overlay"] }));
+        });
+      }
+    } catch {
+    }
+  }
+  printBanner({ port: resolvedPort, apiUrl: isLocalMode ? `${apiUrl} (local in-memory)` : apiUrl, src, include, health, token: !!token, compiled: initialCompiled, deployed: initialDeployed, slug: initialSlug, errors: initialErrors });
+  return {
+    vite,
+    port: resolvedPort,
+    clients,
+    async rebuild() {
+      const r = await build({ src, outDir, mode });
+      if (r.errors > 0) {
+        currentErrors = r.errorDetails.map((e) => ({ file: e.file, message: e.message, line: e.line }));
+      } else {
+        currentErrors = null;
+        if (token) {
+          try {
+            const { deploy: d } = await import("./deploy-YAJGW6II.mjs");
+            await d({ apiUrl, token, dir: outDir });
+          } catch {
+          }
+        }
+      }
+      broadcast(clients, { type: "workflow:rebuild", compiled: r.compiled, errors: r.errors, timestamp: Date.now() });
+      return r;
+    },
+    async close() {
+      for (const c of clients) {
+        try {
+          c.close();
+        } catch {
+        }
+      }
+      clients.clear();
+      currentErrors = null;
+      await vite.close();
+      if (localServer) {
+        await localServer.close();
+      }
+    }
+  };
+}
+
+export {
+  createDevServer
+};