@ultrst-armada/krnl 1.0.0 → 1.0.2

package/packages/cli/dist/bin/krnl.js

@@ -1,1864 +1,23 @@
 #!/usr/bin/env node
 import {
   KrnlPackageReconciler,
-  KrnlValidatorEngine,
   generateMagneticDeclarations,
   runGenerate,
   runValidate
-} from "../chunk-F5EHXE2O.js";
-import "../chunk-RJNYUXZD.js";
-import "../chunk-BOXWWXQG.js";
-import "../chunk-OHVMVRBP.js";
-import "../chunk-EG7T2IAD.js";
-import "../chunk-SRTOPJ5W.js";
-import "../chunk-6NIKAMUZ.js";
-import "../chunk-P2PCLEKX.js";
-import "../chunk-FDNCADFE.js";
-import "../chunk-PJQIUOX2.js";
-import "../chunk-GDLRMDAN.js";
-import "../chunk-I74QIQOD.js";
-import "../chunk-ZAAV3JXQ.js";
-import "../chunk-5JDK35TG.js";
-import "../chunk-Q45257P6.js";
-import "../chunk-3TRM6CYL.js";
-import "../chunk-XIRFOO3H.js";
-import "../chunk-JTLSTO25.js";
-import "../chunk-JULBBJ27.js";
-import "../chunk-X5LOIFM7.js";
+} from "../chunk-ESTKOQ7T.js";
 
 // src/bin/krnl.ts
-import * as path10 from "path";
-import * as fs11 from "fs";
-
-// ../studio/src/server/AstMutationEngine.ts
-import { Project as Project2 } from "ts-morph";
-
-// ../studio/src/server/ast/AstMetadataExtractor.ts
-import * as fs from "fs";
-var AstMetadataExtractor = class {
-  project;
-  constructor(project) {
-    this.project = project;
-  }
-  extractInputsAndOutputs(atomPath) {
-    const inputs = [];
-    const outputs = [];
-    if (!fs.existsSync(atomPath)) return { inputs, outputs };
-    try {
-      const sourceFile = this.project.getSourceFile(atomPath) || this.project.addSourceFileAtPath(atomPath);
-      const inputInterface = sourceFile.getInterface((i) => i.getName().endsWith("Input") || i.getName().includes("Inputs"));
-      if (inputInterface) {
-        for (const prop of inputInterface.getProperties()) {
-          inputs.push({ name: prop.getName(), type: prop.getType().getText() });
-        }
-      }
-      const outputInterface = sourceFile.getInterface((i) => i.getName().endsWith("Output") || i.getName().includes("Outputs"));
-      if (outputInterface) {
-        for (const prop of outputInterface.getProperties()) {
-          outputs.push({ name: prop.getName(), type: prop.getType().getText() });
-        }
-      }
-    } catch (err) {
-      try {
-        const content = fs.readFileSync(atomPath, "utf8");
-        const inMatch = content.match(/interface\s+\w+Input[^{]*\{([^}]+)\}/s);
-        if (inMatch) {
-          inMatch[1].split(";").map((l) => l.trim()).filter(Boolean).forEach((line) => {
-            const [name, type] = line.split(":").map((s) => s.trim());
-            if (name && type) inputs.push({ name, type });
-          });
-        }
-      } catch (e) {
-      }
-    }
-    return { inputs, outputs };
-  }
-  extractStateFields(statePath) {
-    const fields = [];
-    if (!fs.existsSync(statePath)) return fields;
-    try {
-      const sourceFile = this.project.getSourceFile(statePath) || this.project.addSourceFileAtPath(statePath);
-      const stateInterface = sourceFile.getInterface((i) => i.getName().endsWith("State"));
-      if (stateInterface) {
-        for (const prop of stateInterface.getProperties()) {
-          fields.push({ name: prop.getName(), type: prop.getType().getText() });
-        }
-      }
-    } catch (e) {
-      try {
-        const content = fs.readFileSync(statePath, "utf8");
-        const match = content.match(/interface\s+\w+State[^{]*\{([^}]+)\}/s);
-        if (match) {
-          match[1].split(";").map((l) => l.trim()).filter(Boolean).forEach((line) => {
-            const [name, type] = line.split(":").map((s) => s.trim());
-            if (name && type) fields.push({ name, type });
-          });
-        }
-      } catch (err) {
-      }
-    }
-    return fields;
-  }
-  extractHelperNames(helpersDir) {
-    if (!fs.existsSync(helpersDir)) return [];
-    try {
-      return fs.readdirSync(helpersDir).filter((f) => f.endsWith(".ts") && !f.endsWith(".d.ts") && !f.endsWith(".test.ts")).map((f) => f.replace(/\.ts$/, ""));
-    } catch (e) {
-      return [];
-    }
-  }
-};
-
-// ../studio/src/server/ast/AstScanner.ts
-import * as fs2 from "fs";
 import * as path from "path";
-var AstScanner = class {
-  projectRoot;
-  metadataExtractor;
-  constructor(projectRoot, metadataExtractor) {
-    this.projectRoot = projectRoot;
-    this.metadataExtractor = metadataExtractor;
-  }
-  scanWorkspace(positions) {
-    const nodes = [];
-    const edges = [];
-    this.scanEntities(nodes, edges, positions);
-    this.scanSharedFunctionalities(nodes, edges, positions);
-    this.scanLibraries(nodes, edges, positions);
-    this.scanSubApps(nodes, edges, positions);
-    return { nodes, edges };
-  }
-  scanEntities(nodes, edges, positions) {
-    const srcDir = path.join(this.projectRoot, "src");
-    if (!fs2.existsSync(srcDir)) return;
-    for (const entry of fs2.readdirSync(srcDir, { withFileTypes: true })) {
-      if (entry.isFile() && entry.name.endsWith(".ts") && !entry.name.endsWith(".d.ts") && entry.name !== "index.ts") {
-        const entityName = path.basename(entry.name, ".ts");
-        const entityId = `entity:${entityName}`;
-        const entityNode = {
-          id: entityId,
-          name: entityName,
-          type: "entity",
-          filePath: path.join(srcDir, entry.name),
-          functionalities: [],
-          position: positions[entityId]
-        };
-        nodes.push(entityNode);
-      }
-    }
-    const entitiesDir = path.join(this.projectRoot, "src/entities");
-    if (fs2.existsSync(entitiesDir)) {
-      for (const entry of fs2.readdirSync(entitiesDir, { withFileTypes: true })) {
-        if (!entry.isDirectory()) continue;
-        const entityName = entry.name;
-        const entityDir = path.join(entitiesDir, entityName);
-        const entityId = `entity:${entityName}`;
-        const entityNode = {
-          id: entityId,
-          name: entityName,
-          type: "entity",
-          filePath: path.join(entityDir, `${entityName}.ts`),
-          functionalities: [],
-          position: positions[entityId]
-        };
-        nodes.push(entityNode);
-      }
-    }
-  }
-  scanSharedFunctionalities(nodes, edges, positions) {
-    const sharedFuncDir = path.join(this.projectRoot, "src/functionalities");
-    if (!fs2.existsSync(sharedFuncDir)) return;
-    for (const func of fs2.readdirSync(sharedFuncDir, { withFileTypes: true })) {
-      if (!func.isDirectory()) continue;
-      const funcName = func.name;
-      const funcDir = path.join(sharedFuncDir, funcName);
-      const funcId = `functionality:${funcName}`;
-      const atomPath = path.join(funcDir, `${funcName}Atom.ts`);
-      const statePath = path.join(funcDir, "state_data", "state.ts");
-      const helpersDir = path.join(funcDir, "helper_functions");
-      const logicPath = path.join(funcDir, "main_function", "logic.ts");
-      const { inputs, outputs } = this.metadataExtractor.extractInputsAndOutputs(atomPath);
-      const stateFields = this.metadataExtractor.extractStateFields(statePath);
-      const helpers = this.metadataExtractor.extractHelperNames(helpersDir);
-      let uiPath;
-      for (const cand of [path.join(funcDir, "ui.ts"), path.join(funcDir, "view.ts"), path.join(funcDir, `${funcName}View.ts`)]) {
-        if (fs2.existsSync(cand)) {
-          uiPath = cand;
-          break;
-        }
-      }
-      nodes.push({
-        id: funcId,
-        name: funcName,
-        type: "functionality",
-        filePath: logicPath,
-        uiFilePath: uiPath,
-        helpers,
-        inputs,
-        outputs,
-        stateFields,
-        position: positions[funcId]
-      });
-      this.scanConstituents("shared", funcName, funcDir, nodes, edges, positions, inputs, outputs, stateFields, helpers, uiPath);
-    }
-  }
-  scanFunctionalities(entityName, entityDir, entityId, entityNode, nodes, edges, positions) {
-    let funcsDir = path.join(entityDir, "functionalities");
-    if (!fs2.existsSync(funcsDir)) funcsDir = entityDir;
-    for (const func of fs2.readdirSync(funcsDir, { withFileTypes: true })) {
-      if (!func.isDirectory() || func.name === "subsystems") continue;
-      const funcName = func.name;
-      const funcDir = path.join(funcsDir, funcName);
-      const funcId = `functionality:${entityName}:${funcName}`;
-      entityNode.functionalities?.push(funcName);
-      const atomPath = path.join(funcDir, "atom", `${funcName}Atom.ts`);
-      const statePath = path.join(funcDir, "state_data", "state.ts");
-      const helpersDir = path.join(funcDir, "helper_functions");
-      const logicPath = path.join(funcDir, "main_function", "logic.ts");
-      const { inputs, outputs } = this.metadataExtractor.extractInputsAndOutputs(atomPath);
-      const stateFields = this.metadataExtractor.extractStateFields(statePath);
-      const helpers = this.metadataExtractor.extractHelperNames(helpersDir);
-      let uiPath;
-      for (const cand of [path.join(funcDir, "ui.ts"), path.join(funcDir, "view.ts"), path.join(funcDir, `${funcName}View.ts`)]) {
-        if (fs2.existsSync(cand)) {
-          uiPath = cand;
-          break;
-        }
-      }
-      nodes.push({
-        id: funcId,
-        name: funcName,
-        type: "functionality",
-        filePath: logicPath,
-        uiFilePath: uiPath,
-        parentEntity: entityName,
-        helpers,
-        inputs,
-        outputs,
-        stateFields,
-        position: positions[funcId]
-      });
-      edges.push({
-        id: `edge:${entityName}->${funcName}`,
-        source: entityId,
-        target: funcId,
-        type: "contains",
-        deletable: false
-      });
-      this.scanConstituents(entityName, funcName, funcDir, nodes, edges, positions, inputs, outputs, stateFields, helpers, uiPath);
-    }
-  }
-  scanConstituents(entityName, funcName, funcDir, nodes, edges, positions, inputs, outputs, stateFields, helpers, uiPath) {
-    const scope = `functionality:${entityName}:${funcName}`;
-    const atomId = `comp_${entityName}_${funcName}_atom`;
-    const logicId = `comp_${entityName}_${funcName}_logic`;
-    const stateId = `comp_${entityName}_${funcName}_state`;
-    nodes.push({
-      id: atomId,
-      name: `${funcName}Atom`,
-      type: "component_atom",
-      filePath: path.join(funcDir, "atom", `${funcName}Atom.ts`),
-      inputs,
-      outputs,
-      scope,
-      position: positions[atomId]
-    });
-    nodes.push({
-      id: logicId,
-      name: "main_logic",
-      type: "component_logic",
-      filePath: path.join(funcDir, "main_function", "logic.ts"),
-      scope,
-      position: positions[logicId]
-    });
-    nodes.push({
-      id: stateId,
-      name: `${funcName}State`,
-      type: "component_state",
-      filePath: path.join(funcDir, "state_data", "state.ts"),
-      stateFields,
-      scope,
-      position: positions[stateId]
-    });
-    edges.push({ id: `edge_${atomId}_${logicId}`, source: atomId, target: logicId, type: "dataflow", scope, deletable: false });
-    edges.push({ id: `edge_${stateId}_${logicId}`, source: stateId, target: logicId, type: "dataflow", scope, deletable: false });
-    helpers.forEach((h) => {
-      const helperId = `comp_${entityName}_${funcName}_helper_${h}`;
-      nodes.push({
-        id: helperId,
-        name: h,
-        type: "component_helper",
-        filePath: path.join(funcDir, "helper_functions", `${h}.ts`),
-        scope,
-        position: positions[helperId]
-      });
-      edges.push({ id: `edge_${helperId}_${logicId}`, source: helperId, target: logicId, type: "dataflow", scope, deletable: false });
-    });
-    const uiId = `comp_${entityName}_${funcName}_ui`;
-    const resolvedUiPath = uiPath || path.join(funcDir, `${funcName}View.ts`);
-    nodes.push({
-      id: uiId,
-      name: `${funcName}View`,
-      type: "component_ui",
-      filePath: resolvedUiPath,
-      scope,
-      position: positions[uiId]
-    });
-    edges.push({ id: `edge_${logicId}_${uiId}`, source: logicId, target: uiId, type: "dataflow", scope, deletable: false });
-  }
-  scanLibraries(nodes, edges, positions) {
-    for (const cand of [path.join(this.projectRoot, "src/libraries"), path.join(this.projectRoot, "libraries")]) {
-      if (fs2.existsSync(cand)) this.scanLibraryFolder(cand, cand, [], void 0, nodes, edges, positions);
-    }
-  }
-  scanLibraryFolder(base, curr, cats, parent, nodes, edges, positions) {
-    if (!fs2.existsSync(curr)) return;
-    for (const entry of fs2.readdirSync(curr, { withFileTypes: true })) {
-      if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
-      const full = path.join(curr, entry.name);
-      if (entry.isDirectory()) {
-        this.scanLibraryFolder(base, full, [...cats, entry.name], parent, nodes, edges, positions);
-      } else if (/\.(ts|js|mjs)$/.test(entry.name) && !entry.name.endsWith(".d.ts") && !/\.(test|spec)\./.test(entry.name)) {
-        const raw = path.basename(entry.name, path.extname(entry.name));
-        const name = raw === "index" && cats.length > 0 ? cats[cats.length - 1] : raw;
-        const rel = path.relative(base, full).replace(/[\\/.]+/g, "_");
-        const id = parent ? `lib_${parent}_${rel}` : `lib_${rel}`;
-        nodes.push({
-          id,
-          name,
-          type: "library",
-          filePath: full,
-          parentEntity: parent,
-          category: cats.length > 0 ? cats.join(" \u2192 ") : void 0,
-          categoryPath: cats.length > 0 ? cats : void 0,
-          scope: "root",
-          position: positions[id]
-        });
-      }
-    }
-  }
-  scanSubApps(nodes, edges, positions) {
-    const subappDir = path.join(this.projectRoot, "src/subapps");
-    if (!fs2.existsSync(subappDir)) return;
-    for (const app of fs2.readdirSync(subappDir, { withFileTypes: true })) {
-      if (!app.isDirectory()) continue;
-      const appId = `subapp_${app.name}`;
-      nodes.push({
-        id: appId,
-        name: app.name,
-        type: "subapp",
-        filePath: path.join(subappDir, app.name, "index.ts"),
-        position: positions[appId]
-      });
-    }
-  }
-};
-
-// ../studio/src/server/ast/AstOrchestrationMutator.ts
-import * as fs3 from "fs";
-import * as path2 from "path";
-import { SyntaxKind } from "ts-morph";
-var AstOrchestrationMutator = class {
-  projectRoot;
-  project;
-  customEdges = [];
-  constructor(projectRoot, project) {
-    this.projectRoot = projectRoot;
-    this.project = project;
-  }
-  extractOrchestrationEdges(entityName) {
-    const edges = [...this.customEdges];
-    const entityFilePath = path2.join(this.projectRoot, "src/entities", entityName, `${entityName}Entity.ts`);
-    try {
-      const sourceFile = this.project.getSourceFile(entityFilePath) || this.project.addSourceFileAtPath(entityFilePath);
-      const entityClass = sourceFile.getClass((c) => c.getName() === `${entityName}Entity` || c.getName() === entityName);
-      if (!entityClass) return edges;
-      const bootMethod = entityClass.getMethod("boot");
-      if (!bootMethod) return edges;
-      const callExprs = bootMethod.getDescendantsOfKind(SyntaxKind.CallExpression);
-      let previousTarget = null;
-      for (const call of callExprs) {
-        const propAccess = call.getExpression();
-        if (propAccess.getKind() !== SyntaxKind.PropertyAccessExpression) continue;
-        const methodName = propAccess.getText().split(".").pop();
-        if (methodName === "thenFunctionality" || methodName === "thenFunction") {
-          const args2 = call.getArguments();
-          if (args2.length > 0) {
-            const rawTarget = args2[0].getText().replace(/['"]/g, "").trim();
-            const targetId = methodName === "thenFunctionality" ? `func_${entityName}_${rawTarget}` : `func_${rawTarget}`;
-            if (previousTarget && previousTarget !== targetId) {
-              edges.push({
-                id: `orch_edge_${previousTarget}_${targetId}`,
-                source: previousTarget,
-                target: targetId,
-                type: "orchestration_step",
-                deletable: true
-              });
-            }
-            previousTarget = targetId;
-          }
-        }
-      }
-    } catch (e) {
-    }
-    return edges;
-  }
-  connectNodes(source, target, type = "dataflow") {
-    const isTargetFunction = target.startsWith("function:");
-    const isSourceFunction = source.startsWith("function:");
-    if (isTargetFunction && isSourceFunction) {
-      const hasPrecedingFunction = this.customEdges.some(
-        (e) => e.target === source && e.source.startsWith("function:")
-      );
-      if (hasPrecedingFunction) {
-        return {
-          success: false,
-          error: "Cannot chain more than 2 global functions between functionalities. Compose additional logic into a single library function instead."
-        };
-      }
-    }
-    const edgeId = `edge:${source}->${target}:${Date.now()}`;
-    const edge = { id: edgeId, source, target, type, deletable: true };
-    this.customEdges.push(edge);
-    return { success: true, edge };
-  }
-  deleteEdge(edgeId) {
-    this.customEdges = this.customEdges.filter((e) => e.id !== edgeId);
-    return { success: true, deletedEdgeId: edgeId };
-  }
-  addFlowStep(entityFilePath, flowName, stepFunctionName) {
-    return true;
-  }
-  listGlobalLibraryFunctions() {
-    const res = [];
-    const libDir = path2.join(this.projectRoot, "src/libraries");
-    if (!fs3.existsSync(libDir)) return res;
-    try {
-      const libs = fs3.readdirSync(libDir, { withFileTypes: true });
-      for (const lib of libs) {
-        if (!lib.isDirectory()) continue;
-        const libName = lib.name.replace(/\.ts$/, "");
-        res.push({
-          name: `${libName}.process`,
-          libraryName: libName,
-          library: libName,
-          functionName: "process"
-        });
-      }
-    } catch (e) {
-    }
-    return res;
-  }
-  addOrchestrationStep(entityFilePathOrName, orchestrationNameOrFromId, stepTypeOrToId, targetName, libName) {
-    const entityName = entityFilePathOrName.includes("/") ? path2.basename(entityFilePathOrName).replace(/Entity\.ts$/, "") : entityFilePathOrName;
-    const entityFilePath = path2.isAbsolute(entityFilePathOrName) ? entityFilePathOrName : path2.join(this.projectRoot, "src/entities", entityName, `${entityName}Entity.ts`);
-    try {
-      const sourceFile = this.project.getSourceFile(entityFilePath) || this.project.addSourceFileAtPath(entityFilePath);
-      const entityClass = sourceFile.getClass((c) => c.getName() === `${entityName}Entity` || c.getName() === entityName);
-      if (!entityClass) return { success: false, message: `Entity ${entityName} not found` };
-      let bootMethod = entityClass.getMethod("boot");
-      if (!bootMethod) {
-        bootMethod = entityClass.addMethod({ name: "boot", returnType: "this", statements: "return this;" });
-      }
-      const cleanToName = (targetName || stepTypeOrToId).replace(/^func_[^_]+_/, "").replace(/^func_/, "");
-      const chainMethod = stepTypeOrToId === "function" || targetName ? "thenFunction" : "thenFunctionality";
-      const newCall = `.${chainMethod}('${cleanToName}')`;
-      const bodyText = bootMethod.getBodyText() || "return this;";
-      if (bodyText.includes("return this;")) {
-        bootMethod.setBodyText(bodyText.replace("return this;", `return this${newCall};`));
-      } else if (bodyText.includes("return this.")) {
-        bootMethod.setBodyText(bodyText.replace(";", `${newCall};`));
-      } else {
-        bootMethod.setBodyText(`return this${newCall};
-${bodyText}`);
-      }
-      sourceFile.saveSync();
-      return { success: true };
-    } catch (err) {
-      return { success: false, message: err.message || String(err) };
-    }
-  }
-};
-
-// ../studio/src/server/ast/AstNodeMutator.ts
-import * as fs4 from "fs";
-import * as path3 from "path";
-var AstNodeMutator = class {
-  projectRoot;
-  layoutPath;
-  undoStack = [];
-  redoStack = [];
-  constructor(projectRoot) {
-    this.projectRoot = projectRoot;
-    this.layoutPath = path3.join(projectRoot, ".krnl", "layout.json");
-  }
-  loadPositions() {
-    if (fs4.existsSync(this.layoutPath)) {
-      try {
-        return JSON.parse(fs4.readFileSync(this.layoutPath, "utf8"));
-      } catch (e) {
-      }
-    }
-    return {};
-  }
-  savePositions(positions) {
-    try {
-      const dir = path3.dirname(this.layoutPath);
-      if (!fs4.existsSync(dir)) fs4.mkdirSync(dir, { recursive: true });
-      fs4.writeFileSync(this.layoutPath, JSON.stringify(positions, null, 2), "utf8");
-    } catch (e) {
-    }
-  }
-  moveNode(nodeId, x, y) {
-    const pos = this.loadPositions();
-    this.undoStack.push({ ...pos });
-    pos[nodeId] = { x, y };
-    this.savePositions(pos);
-    return { success: true, position: { x, y } };
-  }
-  moveMultipleNodes(positions) {
-    const pos = this.loadPositions();
-    this.undoStack.push({ ...pos });
-    Object.assign(pos, positions);
-    this.savePositions(pos);
-    return { success: true };
-  }
-  alignLayout(algorithm = "hierarchical") {
-    const positions = this.loadPositions();
-    return { success: true, positions };
-  }
-  undo() {
-    if (this.undoStack.length === 0) return { success: false };
-    const cur = this.loadPositions();
-    this.redoStack.push(cur);
-    const prev = this.undoStack.pop();
-    this.savePositions(prev);
-    return { success: true };
-  }
-  redo() {
-    if (this.redoStack.length === 0) return { success: false };
-    const cur = this.loadPositions();
-    this.undoStack.push(cur);
-    const next = this.redoStack.pop();
-    this.savePositions(next);
-    return { success: true };
-  }
-  deleteNode(nodeId) {
-    const pos = this.loadPositions();
-    delete pos[nodeId];
-    this.savePositions(pos);
-    return { success: true, deletedNodeId: nodeId };
-  }
-  createEntity(entityName) {
-    const entityDir = path3.join(this.projectRoot, "src/entities", entityName);
-    fs4.mkdirSync(entityDir, { recursive: true });
-    const entityFilePath = path3.join(entityDir, `${entityName}Entity.ts`);
-    const content = `import { Entity } from '@dinilmusick/krnl-core';
-
-export class ${entityName}Entity extends Entity {
-  public boot() {
-    return this;
-  }
-}
-`;
-    fs4.writeFileSync(entityFilePath, content, "utf8");
-    return { success: true, filePath: entityFilePath };
-  }
-  createFunctionality(entityName, funcName) {
-    const funcDir = path3.join(this.projectRoot, "src/entities", entityName, funcName);
-    fs4.mkdirSync(path3.join(funcDir, "atom"), { recursive: true });
-    fs4.mkdirSync(path3.join(funcDir, "state_data"), { recursive: true });
-    fs4.mkdirSync(path3.join(funcDir, "main_function"), { recursive: true });
-    fs4.mkdirSync(path3.join(funcDir, "helper_functions"), { recursive: true });
-    const f1 = path3.join(funcDir, "atom", `${funcName}Atom.ts`);
-    const f2 = path3.join(funcDir, "state_data", "state.ts");
-    const f3 = path3.join(funcDir, "main_function", "logic.ts");
-    fs4.writeFileSync(f1, `export interface ${funcName}Input { [k: string]: any; }
-export interface ${funcName}Output { success: boolean; }
-`);
-    fs4.writeFileSync(f2, `export interface ${funcName}State { active: boolean; }
-`);
-    fs4.writeFileSync(f3, `import { ${funcName}Input, ${funcName}Output } from '../atom/${funcName}Atom.js';
-
-export async function main(input: ${funcName}Input): Promise<${funcName}Output> {
-  return { success: true };
-}
-`);
-    return { success: true, filesCreated: [f1, f2, f3] };
-  }
-  createLibrary(name) {
-    const clean = name.replace(/Concepts$/, "");
-    const libDir = path3.join(this.projectRoot, "src/libraries", `${clean}Concepts`);
-    fs4.mkdirSync(libDir, { recursive: true });
-    const f = path3.join(libDir, "index.ts");
-    fs4.writeFileSync(f, `export class ${clean}Concepts {
-  static process(d: any) { return { valid: true }; }
-}
-`);
-    return { success: true, filePath: f };
-  }
-};
-
-// ../studio/src/server/AstMutationEngine.ts
-var AstMutationEngine = class {
-  projectRoot;
-  project;
-  metadataExtractor;
-  scanner;
-  orchestrationMutator;
-  nodeMutator;
-  constructor(projectRoot) {
-    this.projectRoot = projectRoot;
-    this.project = new Project2({ skipAddingFilesFromTsConfig: true });
-    this.metadataExtractor = new AstMetadataExtractor(this.project);
-    this.scanner = new AstScanner(this.projectRoot, this.metadataExtractor);
-    this.orchestrationMutator = new AstOrchestrationMutator(this.projectRoot, this.project);
-    this.nodeMutator = new AstNodeMutator(this.projectRoot);
-  }
-  extractArchitectureGraph() {
-    const positions = this.nodeMutator.loadPositions();
-    const graph = this.scanner.scanWorkspace(positions);
-    const entities = graph.nodes.filter((n) => n.type === "entity");
-    for (const ent of entities) {
-      const orchEdges = this.orchestrationMutator.extractOrchestrationEdges(ent.name);
-      graph.edges.push(...orchEdges);
-    }
-    return graph;
-  }
-  moveNode(nodeId, x, y) {
-    return this.nodeMutator.moveNode(nodeId, x, y);
-  }
-  moveMultipleNodes(positions) {
-    return this.nodeMutator.moveMultipleNodes(positions);
-  }
-  alignLayout(algorithm) {
-    return this.nodeMutator.alignLayout(algorithm);
-  }
-  undo() {
-    return this.nodeMutator.undo();
-  }
-  redo() {
-    return this.nodeMutator.redo();
-  }
-  deleteNode(nodeId) {
-    return this.nodeMutator.deleteNode(nodeId);
-  }
-  createEntity(entityName) {
-    return this.nodeMutator.createEntity(entityName);
-  }
-  createFunctionality(entityName, funcName) {
-    return this.nodeMutator.createFunctionality(entityName, funcName);
-  }
-  createLibrary(name) {
-    return this.nodeMutator.createLibrary(name);
-  }
-  connectNodes(source, target, type) {
-    return this.orchestrationMutator.connectNodes(source, target, type);
-  }
-  deleteEdge(edgeId) {
-    return this.orchestrationMutator.deleteEdge(edgeId);
-  }
-  addFlowStep(p1, p2, p3) {
-    return this.orchestrationMutator.addFlowStep(p1, p2, p3);
-  }
-  listGlobalLibraryFunctions() {
-    return this.orchestrationMutator.listGlobalLibraryFunctions();
-  }
-  addOrchestrationStep(p1, p2, p3, p4, p5) {
-    return this.orchestrationMutator.addOrchestrationStep(p1, p2, p3, p4, p5);
-  }
-};
-
-// ../studio/src/server/FunctionExecutor.ts
-import * as path4 from "path";
-import * as fs5 from "fs";
-import { pathToFileURL } from "url";
-import * as esbuild from "esbuild";
-var FunctionExecutor = class {
-  /**
-   * Executes a specific function, entity, or library in an isolated sandbox with metrics.
-   */
-  static async execute(request) {
-    const startTime = performance.now();
-    const initialMem = process.memoryUsage().heapUsed;
-    const logs = [];
-    let absPath = path4.resolve(request.filePath);
-    if (!fs5.existsSync(absPath)) {
-      return {
-        success: false,
-        durationMs: 0,
-        memoryDeltaBytes: 0,
-        error: `File not found: ${absPath}`,
-        logs: []
-      };
-    }
-    if (fs5.lstatSync(absPath).isDirectory()) {
-      const base = path4.basename(absPath);
-      const candidates = [
-        path4.join(absPath, "main_function/logic.ts"),
-        path4.join(absPath, `${base}.ts`),
-        path4.join(absPath, "index.ts"),
-        path4.join(absPath, "entity.ts")
-      ];
-      const found = candidates.find((c) => fs5.existsSync(c));
-      if (found) {
-        absPath = found;
-      } else {
-        return {
-          success: false,
-          durationMs: 0,
-          memoryDeltaBytes: 0,
-          error: `No executable TypeScript entry point found in directory: ${absPath}`,
-          logs: []
-        };
-      }
-    }
-    const dirOfEntry = path4.dirname(absPath);
-    const tempBundlePath = path4.join(
-      dirOfEntry,
-      `.krnl-exec-${Date.now()}-${Math.random().toString(36).substring(7)}.mjs`
-    );
-    const tsResolverPlugin = {
-      name: "ts-resolver-plugin",
-      setup(build2) {
-        build2.onResolve({ filter: /.*/ }, (args2) => {
-          if (args2.path.startsWith(".")) {
-            const dir = args2.resolveDir || path4.dirname(args2.importer);
-            const candidateJs = path4.resolve(dir, args2.path);
-            const candidateTs = candidateJs.replace(/\.js$/, ".ts");
-            if (fs5.existsSync(candidateTs)) {
-              return { path: candidateTs };
-            }
-            if (fs5.existsSync(candidateJs)) {
-              return { path: candidateJs };
-            }
-          }
-          return null;
-        });
-      }
-    };
-    try {
-      await esbuild.build({
-        entryPoints: [absPath],
-        bundle: true,
-        outfile: tempBundlePath,
-        format: "esm",
-        platform: "node",
-        target: "esnext",
-        plugins: [tsResolverPlugin],
-        external: ["@dinilmusick/krnl-core", "vanjs-core", "worker_threads", "ws", "fs", "path", "http", "events"]
-      });
-      const fileUrl = pathToFileURL(tempBundlePath).href;
-      const mod = await import(fileUrl);
-      let targetFn = null;
-      let targetClass = null;
-      if (request.functionName && mod[request.functionName]) {
-        targetFn = mod[request.functionName];
-      } else if (typeof mod.main === "function") {
-        targetFn = mod.main;
-      } else if (typeof mod.register === "function") {
-        targetFn = mod.register;
-      } else if (typeof mod.default === "function") {
-        targetFn = mod.default;
-      } else {
-        for (const key of Object.keys(mod)) {
-          if (typeof mod[key] === "function") {
-            targetFn = mod[key];
-            break;
-          }
-        }
-      }
-      for (const key of Object.keys(mod)) {
-        if (typeof mod[key] === "function" && mod[key].prototype && Object.getOwnPropertyNames(mod[key].prototype).length > 1) {
-          targetClass = mod[key];
-          break;
-        }
-      }
-      let executionOutput = null;
-      if (typeof targetFn === "function") {
-        if (targetFn.prototype && (targetFn.prototype.boot || targetFn.name.endsWith("System") || targetFn.name.endsWith("Entity"))) {
-          const instance = new targetFn();
-          if (typeof instance.boot === "function") {
-            await instance.boot();
-          }
-          const registeredFlows = instance["flows"] ? Array.from(instance["flows"].keys()) : [];
-          if (request.input?.flowName && instance["flows"]?.has(request.input.flowName)) {
-            const flow = instance["flows"].get(request.input.flowName);
-            const flowRes = typeof flow.execute === "function" ? await flow.execute(request.input.payload || {}) : "Flow initiated";
-            executionOutput = {
-              entityId: instance.id || targetFn.name,
-              flowExecuted: request.input.flowName,
-              flowResult: flowRes,
-              status: "FLOW_EXECUTED"
-            };
-          } else {
-            executionOutput = {
-              entityId: instance.id || targetFn.name,
-              version: instance.version || "1.0.0",
-              description: instance.description || "System Entity",
-              status: "BOOTED_AND_READY",
-              registeredFlows
-            };
-          }
-        } else if (targetFn.name === "register" || mod.register === targetFn) {
-          const mockContext = {
-            entity: { id: "TestSandboxEntity", call: async () => ({}), emitEvent: () => {
-            } },
-            logger: { log: (msg) => logs.push(msg), error: (msg) => logs.push("ERROR: " + msg) }
-          };
-          const regResult = await targetFn(mockContext);
-          executionOutput = {
-            subappName: regResult?.name || "SubApp",
-            operations: (regResult?.operations || []).map((o) => ({ name: o.name, description: o.description })),
-            ui: regResult?.ui,
-            status: "REGISTERED"
-          };
-        } else if (targetFn.name.endsWith("Concepts") || targetClass && targetClass.name.endsWith("Concepts")) {
-          const cls = targetClass || targetFn;
-          const staticMethods = Object.getOwnPropertyNames(cls).filter((m) => typeof cls[m] === "function" && m !== "prototype" && m !== "length" && m !== "name");
-          let invokedMethod = request.functionName || request.input?.method;
-          let methodArgs = request.input?.args;
-          if (!invokedMethod && staticMethods.length > 0) {
-            invokedMethod = staticMethods[0];
-          }
-          if (invokedMethod && typeof cls[invokedMethod] === "function") {
-            if (!methodArgs) {
-              if (Array.isArray(request.input)) {
-                methodArgs = request.input;
-              } else if (request.input && typeof request.input === "object" && !request.input.method) {
-                const fnStr = cls[invokedMethod].toString();
-                const paramMatch = fnStr.match(/\(([^)]*)\)/);
-                const paramNames = paramMatch ? paramMatch[1].split(",").map((p) => p.trim().split(":")[0].trim()) : [];
-                if (paramNames.length > 1 && paramNames.every((p) => p in request.input)) {
-                  methodArgs = paramNames.map((p) => request.input[p]);
-                } else {
-                  methodArgs = [request.input];
-                }
-              } else {
-                methodArgs = [];
-              }
-            }
-            const result = await cls[invokedMethod](...methodArgs);
-            executionOutput = {
-              library: cls.name,
-              method: invokedMethod,
-              args: methodArgs,
-              result
-            };
-          } else {
-            executionOutput = {
-              library: cls.name,
-              status: "READY",
-              availableMethods: staticMethods
-            };
-          }
-        } else {
-          const dummyContext = {
-            state: request.state || {},
-            entity: {
-              id: "TestSandbox",
-              call: async () => ({}),
-              emitEvent: () => {
-              }
-            }
-          };
-          executionOutput = await targetFn(request.input || {}, dummyContext);
-        }
-      } else if (mod && typeof mod === "object") {
-        executionOutput = {
-          exports: Object.keys(mod),
-          status: "MODULE_LOADED"
-        };
-      } else {
-        throw new Error(`No executable function or entity class export found in ${absPath}`);
-      }
-      const durationMs = parseFloat((performance.now() - startTime).toFixed(2));
-      const memoryDeltaBytes = Math.max(0, process.memoryUsage().heapUsed - initialMem);
-      return {
-        success: true,
-        output: executionOutput,
-        durationMs,
-        memoryDeltaBytes,
-        logs
-      };
-    } catch (err) {
-      const durationMs = parseFloat((performance.now() - startTime).toFixed(2));
-      return {
-        success: false,
-        durationMs,
-        memoryDeltaBytes: 0,
-        error: err?.message || String(err),
-        logs
-      };
-    } finally {
-      if (fs5.existsSync(tempBundlePath)) {
-        try {
-          fs5.unlinkSync(tempBundlePath);
-        } catch (e) {
-        }
-      }
-    }
-  }
-};
-
-// ../studio/src/server/FileWatcher.ts
-import * as fs6 from "fs";
-import * as path5 from "path";
-var StudioFileWatcher = class {
-  watcher = null;
-  rootDir;
-  listeners = /* @__PURE__ */ new Set();
-  debounceTimers = /* @__PURE__ */ new Map();
-  constructor(rootDir = process.cwd()) {
-    this.rootDir = path5.resolve(rootDir);
-  }
-  start() {
-    if (this.watcher) return;
-    const srcDir = path5.join(this.rootDir, "src");
-    if (!fs6.existsSync(srcDir)) return;
-    this.watcher = fs6.watch(srcDir, { recursive: true }, (eventType, filename) => {
-      if (!filename) return;
-      if (filename.includes("node_modules") || filename.includes("dist") || filename.includes(".git") || filename.endsWith(".d.ts") || filename.endsWith(".log") || filename.endsWith(".tmp") || filename.includes(".krnl-graph") || filename.includes(".DS_Store")) {
-        return;
-      }
-      const fullPath = path5.join(srcDir, filename);
-      if (this.debounceTimers.has(fullPath)) {
-        clearTimeout(this.debounceTimers.get(fullPath));
-      }
-      const timer = setTimeout(() => {
-        this.debounceTimers.delete(fullPath);
-        for (const listener of this.listeners) {
-          try {
-            listener({ eventType, filename, fullPath });
-          } catch (e) {
-          }
-        }
-      }, 300);
-      this.debounceTimers.set(fullPath, timer);
-    });
-  }
-  subscribe(cb) {
-    this.listeners.add(cb);
-    return () => this.listeners.delete(cb);
-  }
-  updateRoot(newRoot) {
-    this.stop();
-    this.rootDir = path5.resolve(newRoot);
-    this.start();
-  }
-  stop() {
-    if (this.watcher) {
-      this.watcher.close();
-      this.watcher = null;
-    }
-  }
-};
-
-// ../studio/src/server/JsonRpcRouter.ts
-import * as fs7 from "fs";
-import * as path6 from "path";
-
-// ../studio/src/server/PreemptiveDocManager.ts
-var PreemptiveDocManager = class {
-  static endpoints = {
-    // 1. Workspace
-    "project.create": {
-      id: "project.create",
-      method: "POST",
-      path: "/api/v1/project/create",
-      rpcMethod: "project.create",
-      title: "Create Project Workspace",
-      description: "Initializes a new Krnl full-stack workspace with standard quad-units, configs, and entity roots.",
-      category: "Workspace",
-      payloadSchema: { name: "string", targetDir: "string (optional)", options: "object (optional)" },
-      examplePayload: { name: "PaymentApp", targetDir: "./projects/PaymentApp" },
-      nextSuggestedEndpoints: ["entity.create", "library.create", "graph.getArchitecture"]
-    },
-    "project.load": {
-      id: "project.load",
-      method: "POST",
-      path: "/api/v1/project/load",
-      rpcMethod: "project.load",
-      title: "Load Project Workspace",
-      description: "Switches the active workspace context and synchronizes the visual node graph and file watcher.",
-      category: "Workspace",
-      payloadSchema: { path: "string (absolute or relative project path)" },
-      examplePayload: { path: "examples/unified-workspace" },
-      nextSuggestedEndpoints: ["graph.getArchitecture", "validate.audit", "test.executeFunction"]
-    },
-    "graph.getArchitecture": {
-      id: "graph.getArchitecture",
-      method: "GET",
-      path: "/api/v1/project/graph",
-      rpcMethod: "graph.getArchitecture",
-      title: "Get Architecture Graph",
-      description: "Inspects source files on disk and returns the complete hierarchical entity, quad-unit, and concept library graph.",
-      category: "Workspace",
-      payloadSchema: {},
-      examplePayload: {},
-      nextSuggestedEndpoints: ["entity.create", "functionality.create", "validate.audit"]
-    },
-    // 2. Interactive Graph Controls & Layout
-    "graph.moveNode": {
-      id: "graph.moveNode",
-      method: "POST",
-      path: "/api/v1/graph/moveNode",
-      rpcMethod: "graph.moveNode",
-      title: "Move Node Coordinates",
-      description: "Updates and persists the (x, y) canvas coordinates of a specific node in real time.",
-      category: "GraphControls",
-      payloadSchema: { nodeId: "string", x: "number", y: "number" },
-      examplePayload: { nodeId: "entity:TradingSystem", x: 250, y: 180 },
-      nextSuggestedEndpoints: ["graph.connectNodes", "graph.getArchitecture"]
-    },
-    "graph.connectNodes": {
-      id: "graph.connectNodes",
-      method: "POST",
-      path: "/api/v1/graph/connectNodes",
-      rpcMethod: "graph.connectNodes",
-      title: "Establish Wire Connection",
-      description: "Creates a directional wire connection between two nodes with support for auto-spawn and dataflow.",
-      category: "GraphControls",
-      payloadSchema: { source: "string", target: "string", type: "string (optional: dataflow/contains/flow_step)" },
-      examplePayload: { source: "entity:TradingSystem", target: "functionality:TradingSystem:ExecuteTrade", type: "contains" },
-      nextSuggestedEndpoints: ["graph.moveNode", "graph.deleteEdge"]
-    },
-    "graph.deleteEdge": {
-      id: "graph.deleteEdge",
-      method: "POST",
-      path: "/api/v1/graph/deleteEdge",
-      rpcMethod: "graph.deleteEdge",
-      title: "Delete Connection (Via Centered Gizmo)",
-      description: "Deletes a wire connection identified by its edge ID.",
-      category: "GraphControls",
-      payloadSchema: { edgeId: "string" },
-      examplePayload: { edgeId: "edge:TradingSystem->QuotePrice" },
-      nextSuggestedEndpoints: ["graph.connectNodes", "graph.alignLayout"]
-    },
-    "graph.deleteNode": {
-      id: "graph.deleteNode",
-      method: "POST",
-      path: "/api/v1/graph/deleteNode",
-      rpcMethod: "graph.deleteNode",
-      title: "Delete Node & Source Assets",
-      description: "Removes a node from the visual graph and safely cleans up its underlying source files from the workspace.",
-      category: "GraphControls",
-      payloadSchema: { nodeId: "string" },
-      examplePayload: { nodeId: "functionality:TradingSystem:QuotePrice" },
-      nextSuggestedEndpoints: ["graph.getArchitecture", "validate.audit"]
-    },
-    "graph.alignLayout": {
-      id: "graph.alignLayout",
-      method: "POST",
-      path: "/api/v1/graph/alignLayout",
-      rpcMethod: "graph.alignLayout",
-      title: "Auto-Align Hierarchical Layout",
-      description: "Re-computes clean hierarchical column-based coordinates for all nodes on the canvas.",
-      category: "GraphControls",
-      payloadSchema: { algorithm: "string (optional: hierarchical/grid)" },
-      examplePayload: { algorithm: "hierarchical" },
-      nextSuggestedEndpoints: ["graph.getArchitecture", "graph.moveNode"]
-    },
-    "graph.undo": {
-      id: "graph.undo",
-      method: "POST",
-      path: "/api/v1/graph/undo",
-      rpcMethod: "graph.undo",
-      title: "Undo Graph Mutation",
-      description: "Reverts the previous canvas or node manipulation step.",
-      category: "GraphControls",
-      payloadSchema: {},
-      examplePayload: {},
-      nextSuggestedEndpoints: ["graph.redo", "graph.getArchitecture"]
-    },
-    "graph.redo": {
-      id: "graph.redo",
-      method: "POST",
-      path: "/api/v1/graph/redo",
-      rpcMethod: "graph.redo",
-      title: "Redo Graph Mutation",
-      description: "Re-applies the previously undone canvas action.",
-      category: "GraphControls",
-      payloadSchema: {},
-      examplePayload: {},
-      nextSuggestedEndpoints: ["graph.undo", "graph.getArchitecture"]
-    },
-    // 3. Scaffolding
-    "entity.create": {
-      id: "entity.create",
-      method: "POST",
-      path: "/api/v1/entity/create",
-      rpcMethod: "graph.createEntity",
-      title: "Scaffold Entity",
-      description: "Surgically creates a new root or component Entity on disk with magnetic auto-discovery hooks.",
-      category: "Scaffolding",
-      payloadSchema: { name: "string (e.g. OrderSystem)" },
-      examplePayload: { name: "OrderSystem" },
-      nextSuggestedEndpoints: ["functionality.create", "flow.addStep", "library.create"]
-    },
-    "functionality.create": {
-      id: "functionality.create",
-      method: "POST",
-      path: "/api/v1/functionality/create",
-      rpcMethod: "graph.createFunctionality",
-      title: "Scaffold Quad-Unit Functionality",
-      description: "Generates a 4-layer quad-unit (Atom, logic.ts, state.ts, helper_functions/) nested in the target Entity.",
-      category: "Scaffolding",
-      payloadSchema: { entityName: "string", name: "string (functionality name)" },
-      examplePayload: { entityName: "OrderSystem", name: "CreateOrder" },
-      nextSuggestedEndpoints: ["test.executeFunction", "flow.addStep", "file.edit"]
-    },
-    "library.create": {
-      id: "library.create",
-      method: "POST",
-      path: "/api/v1/library/create",
-      rpcMethod: "graph.createLibrary",
-      title: "Scaffold Domain Concept Library",
-      description: "Generates a Layer 0 pure domain concept library ({Domain}Concepts.ts) with zero I/O side effects.",
-      category: "Scaffolding",
-      payloadSchema: { name: "string (e.g. Crypto)" },
-      examplePayload: { name: "Crypto" },
-      nextSuggestedEndpoints: ["file.edit", "functionality.create", "validate.audit"]
-    },
-    "flow.addStep": {
-      id: "flow.addStep",
-      method: "POST",
-      path: "/api/v1/flow/addStep",
-      rpcMethod: "graph.addFlowStep",
-      title: "Inject Flow Step",
-      description: "Surgically adds a .then() or .branch() step into an Entity boot flow pipeline without disturbing existing code.",
-      category: "Scaffolding",
-      payloadSchema: { entityFilePath: "string", flowName: "string", stepFunctionName: "string" },
-      examplePayload: {
-        entityFilePath: "src/entities/OrderSystem/OrderSystem.ts",
-        flowName: "CheckoutFlow",
-        stepFunctionName: "CreateOrder"
-      },
-      nextSuggestedEndpoints: ["test.executeFunction", "validate.audit"]
-    },
-    // 4. Code Mutation
-    "file.read": {
-      id: "file.read",
-      method: "POST",
-      path: "/api/v1/file/read",
-      rpcMethod: "file.read",
-      title: "Read Source File",
-      description: "Reads exact source code and metadata of any file in the workspace.",
-      category: "CodeMutation",
-      payloadSchema: { filePath: "string (absolute or relative)" },
-      examplePayload: { filePath: "src/entities/App/functionalities/Hello/main_function/logic.ts" },
-      nextSuggestedEndpoints: ["file.edit", "test.executeFunction"]
-    },
-    "file.edit": {
-      id: "file.edit",
-      method: "POST",
-      path: "/api/v1/file/edit",
-      rpcMethod: "file.edit",
-      title: "Surgical File Mutation",
-      description: "Surgically updates or replaces targeted code blocks in a TypeScript file while preserving comments and formatting.",
-      category: "CodeMutation",
-      payloadSchema: { filePath: "string", newContent: "string" },
-      examplePayload: { filePath: "src/.../logic.ts", newContent: "export const main = async () => ({ ok: true });" },
-      nextSuggestedEndpoints: ["validate.audit", "test.executeFunction"]
-    },
-    "ui.generate": {
-      id: "ui.generate",
-      method: "POST",
-      path: "/api/v1/ui/generate",
-      rpcMethod: "ui.generate",
-      title: "Generate VanJS UI Source",
-      description: "Compiles a visual component tree JSON into clean, reactive VanJS TypeScript source code.",
-      category: "CodeMutation",
-      payloadSchema: { componentTree: "object", targetFilePath: "string (optional)" },
-      examplePayload: { componentTree: { type: "KrnlButton", props: { icon: "\u{1F680}" } } },
-      nextSuggestedEndpoints: ["file.edit", "validate.audit"]
-    },
-    // 5. Validation & Quality Gates
-    "validate.audit": {
-      id: "validate.audit",
-      method: "POST",
-      path: "/api/v1/validate/audit",
-      rpcMethod: "validate.runPurityAudit",
-      title: "Run AST 4-Layer Purity Audit",
-      description: "Runs deep AST analysis across the workspace checking 4-layer function purity, 200-line limits, anti-polling, and import suffixes.",
-      category: "Validation",
-      payloadSchema: { projectPath: "string (optional)" },
-      examplePayload: {},
-      nextSuggestedEndpoints: ["test.executeFunction", "graph.getArchitecture"]
-    },
-    // 6. Sandboxed Testing
-    "test.executeFunction": {
-      id: "test.executeFunction",
-      method: "POST",
-      path: "/api/v1/test/execute",
-      rpcMethod: "test.executeFunction",
-      title: "Execute Function in Isolated Sandbox",
-      description: "Invokes any targeted function in an isolated Node.js Worker sandbox, capturing output, latency (ms), and memory delta.",
-      category: "Testing",
-      payloadSchema: { filePath: "string", functionName: "string (optional)", input: "object" },
-      examplePayload: {
-        filePath: "src/entities/CalculatorSystem/functionalities/Calculate/main_function/logic.ts",
-        input: { op: "add", a: 10, b: 20 }
-      },
-      nextSuggestedEndpoints: ["validate.audit", "flow.addStep"]
-    },
-    // 7. Documentation
-    "docs.endpoints": {
-      id: "docs.endpoints",
-      method: "GET",
-      path: "/api/v1/docs/endpoints",
-      rpcMethod: "docs.endpoints",
-      title: "Get Full API Documentation Catalog",
-      description: "Returns the full list of all available Krnl Studio agentic endpoints with schemas, examples, and next steps.",
-      category: "Documentation",
-      payloadSchema: {},
-      examplePayload: {},
-      nextSuggestedEndpoints: ["graph.getArchitecture", "entity.create"]
-    }
-  };
-  static getAllEndpoints() {
-    return Object.values(this.endpoints);
-  }
-  static getEndpoint(id) {
-    return this.endpoints[id];
-  }
-  static decorateResponse(actionId, payload, host = "localhost:8080") {
-    const ep = this.endpoints[actionId];
-    const nextSteps = (ep?.nextSuggestedEndpoints || ["graph.getArchitecture", "validate.audit", "test.executeFunction"]).map((nextId) => {
-      const nextMeta = this.endpoints[nextId];
-      if (!nextMeta) return null;
-      return {
-        id: nextMeta.id,
-        title: nextMeta.title,
-        endpoint: `${nextMeta.method} ${nextMeta.path}`,
-        rpcMethod: nextMeta.rpcMethod,
-        description: nextMeta.description,
-        examplePayload: nextMeta.examplePayload,
-        curl: nextMeta.method === "GET" ? `curl -X GET http://${host}${nextMeta.path}` : `curl -X POST http://${host}${nextMeta.path} -H 'Content-Type: application/json' -d '${JSON.stringify(nextMeta.examplePayload)}'`
-      };
-    }).filter(Boolean);
-    return {
-      status: "success",
-      payload,
-      preemptiveDocumentation: {
-        action: actionId,
-        description: ep?.description || `Executed ${actionId}`,
-        suggestedNextSteps: nextSteps,
-        documentationIndexEndpoint: `GET http://${host}/api/v1/docs/endpoints`
-      }
-    };
-  }
-};
-
-// ../studio/src/client/ui-builder/VanJSCodeGenerator.ts
-var VanJSCodeGenerator = class {
-  /**
-   * Generates production-ready VanJS TypeScript source code from a component tree.
-   */
-  static generateCode(root, componentName = "GeneratedView") {
-    const usedAtoms = /* @__PURE__ */ new Set();
-    this.collectUsedAtoms(root, usedAtoms);
-    const atomImports = Array.from(usedAtoms).filter((a) => a !== "Container" && a.startsWith("Krnl")).join(", ");
-    let code = `import van from 'vanjs-core';
-`;
-    if (atomImports.length > 0) {
-      code += `import { ${atomImports} } from '@dinilmusick/krnl-ui';
-`;
-    }
-    code += `
-`;
-    code += `export function ${componentName}({ state, entity }: any): HTMLElement {
-`;
-    code += `  const { div } = van.tags;
-
-`;
-    code += `  return ${this.renderNodeToCode(root, 2)};
-`;
-    code += `}
-
-`;
-    code += `export default ${componentName};
-`;
-    return code;
-  }
-  static renderNodeToCode(node, indentLevel) {
-    const indent = " ".repeat(indentLevel);
-    const childIndent = " ".repeat(indentLevel + 2);
-    if (node.type === "Container") {
-      const childCode = (node.children || []).map((c) => this.renderNodeToCode(c, indentLevel + 2)).join(",\n");
-      return `div(
-${childIndent}{ class: '${node.props.class || "krnl-container"}' }${childCode ? `,
-${childCode}` : ""}
-${indent})`;
-    }
-    const propEntries = Object.entries(node.props).map(([k, v]) => {
-      if (typeof v === "string" && (v.startsWith("state.") || v.startsWith("entity."))) {
-        return `${k}: ${v}`;
-      }
-      if (k.startsWith("on") && typeof v === "string") {
-        return `${k}: () => { ${v} }`;
-      }
-      return `${k}: ${JSON.stringify(v)}`;
-    }).join(", ");
-    return `${node.type}({ ${propEntries} })`;
-  }
-  static collectUsedAtoms(node, atoms) {
-    atoms.add(node.type);
-    if (node.children) {
-      for (const c of node.children) {
-        this.collectUsedAtoms(c, atoms);
-      }
-    }
-  }
-};
-
-// ../studio/src/server/JsonRpcRouter.ts
-var JsonRpcRouter = class {
-  astEngine;
-  validator;
-  projectRoot;
-  onMutationCallback;
-  constructor(projectRoot = process.cwd(), onMutation) {
-    this.projectRoot = path6.resolve(projectRoot);
-    this.astEngine = new AstMutationEngine(this.projectRoot);
-    this.validator = new KrnlValidatorEngine({ projectRoot: this.projectRoot });
-    this.onMutationCallback = onMutation;
-  }
-  setProjectRoot(newRoot) {
-    this.projectRoot = path6.resolve(newRoot);
-    this.astEngine = new AstMutationEngine(this.projectRoot);
-    this.validator = new KrnlValidatorEngine({ projectRoot: this.projectRoot });
-  }
-  getProjectRoot() {
-    return this.projectRoot;
-  }
-  async handle(req) {
-    try {
-      const { method, params = {}, id } = req;
-      switch (method) {
-        // 1. Workspace
-        case "project.load":
-        case "project.switch": {
-          const targetPath = params.path || params.projectPath;
-          if (!targetPath) throw new Error("Path is required to load project");
-          const abs = path6.resolve(this.projectRoot, targetPath);
-          if (!fs7.existsSync(abs)) throw new Error(`Project directory not found: ${targetPath}`);
-          this.setProjectRoot(abs);
-          const graph = this.astEngine.extractArchitectureGraph();
-          const decorated = PreemptiveDocManager.decorateResponse("project.load", { success: true, projectRoot: this.projectRoot, graph });
-          return { jsonrpc: "2.0", id, result: decorated };
-        }
-        case "graph.getArchitecture":
-        case "project.getArchitecture": {
-          const graph = this.astEngine.extractArchitectureGraph();
-          const decorated = PreemptiveDocManager.decorateResponse("graph.getArchitecture", graph);
-          return { jsonrpc: "2.0", id, result: decorated };
-        }
-        case "project.getStatus": {
-          const graph = this.astEngine.extractArchitectureGraph();
-          const summary = this.validator.validateAll();
-          const status = {
-            projectRoot: this.projectRoot,
-            entityCount: graph.nodes.filter((n) => n.type === "entity").length,
-            functionalityCount: graph.nodes.filter((n) => n.type === "functionality").length,
-            libraryCount: graph.nodes.filter((n) => n.type === "library").length,
-            subappCount: graph.nodes.filter((n) => n.type === "subapp").length,
-            purityValid: summary.valid,
-            purityErrors: summary.errors.length
-          };
-          const decorated = PreemptiveDocManager.decorateResponse("graph.getArchitecture", status);
-          return { jsonrpc: "2.0", id, result: decorated };
-        }
-        // 2. Interactive Graph Controls & Layout
-        case "graph.moveNode": {
-          const { nodeId, x, y } = params;
-          if (!nodeId || x === void 0 || y === void 0) throw new Error("nodeId, x, and y are required");
-          const res = this.astEngine.moveNode(nodeId, x, y);
-          this.notifyMutation("graph.moveNode", { nodeId, x, y });
-          const decorated = PreemptiveDocManager.decorateResponse("graph.moveNode", res);
-          return { jsonrpc: "2.0", id, result: decorated };
-        }
-        case "graph.moveMultipleNodes": {
-          const { positions } = params;
-          if (!positions) throw new Error("positions map is required");
-          const res = this.astEngine.moveMultipleNodes(positions);
-          this.notifyMutation("graph.moveMultipleNodes", { count: Object.keys(positions).length });
-          const decorated = PreemptiveDocManager.decorateResponse("graph.moveNode", res);
-          return { jsonrpc: "2.0", id, result: decorated };
-        }
-        case "graph.connectNodes": {
-          const { source, target, type } = params;
-          if (!source || !target) throw new Error("source and target node IDs are required");
-          const res = this.astEngine.connectNodes(source, target, type);
-          if (!res.success) {
-            return { jsonrpc: "2.0", id, error: { code: -32002, message: res.error || "Connection rejected by validation rule" } };
-          }
-          const graph = this.astEngine.extractArchitectureGraph();
-          this.notifyMutation("graph.connectNodes", { source, target, ...res });
-          const decorated = PreemptiveDocManager.decorateResponse("graph.connectNodes", { ...res, graph });
-          return { jsonrpc: "2.0", id, result: decorated };
-        }
-        case "graph.deleteEdge": {
-          const { edgeId } = params;
-          if (!edgeId) throw new Error("edgeId is required");
-          const res = this.astEngine.deleteEdge(edgeId);
-          const graph = this.astEngine.extractArchitectureGraph();
-          this.notifyMutation("graph.deleteEdge", { edgeId });
-          const decorated = PreemptiveDocManager.decorateResponse("graph.deleteEdge", { ...res, graph });
-          return { jsonrpc: "2.0", id, result: decorated };
-        }
-        case "graph.deleteNode": {
-          const { nodeId } = params;
-          if (!nodeId) throw new Error("nodeId is required");
-          const res = this.astEngine.deleteNode(nodeId);
-          const graph = this.astEngine.extractArchitectureGraph();
-          this.notifyMutation("graph.deleteNode", { nodeId });
-          const decorated = PreemptiveDocManager.decorateResponse("graph.deleteNode", { ...res, graph });
-          return { jsonrpc: "2.0", id, result: decorated };
-        }
-        case "graph.alignLayout": {
-          const { algorithm } = params;
-          const res = this.astEngine.alignLayout(algorithm);
-          const graph = this.astEngine.extractArchitectureGraph();
-          this.notifyMutation("graph.alignLayout", { algorithm: algorithm || "hierarchical" });
-          const decorated = PreemptiveDocManager.decorateResponse("graph.alignLayout", { ...res, graph });
-          return { jsonrpc: "2.0", id, result: decorated };
-        }
-        case "graph.undo": {
-          const res = this.astEngine.undo();
-          const graph = this.astEngine.extractArchitectureGraph();
-          this.notifyMutation("graph.undo", {});
-          const decorated = PreemptiveDocManager.decorateResponse("graph.undo", { ...res, graph });
-          return { jsonrpc: "2.0", id, result: decorated };
-        }
-        case "graph.redo": {
-          const res = this.astEngine.redo();
-          const graph = this.astEngine.extractArchitectureGraph();
-          this.notifyMutation("graph.redo", {});
-          const decorated = PreemptiveDocManager.decorateResponse("graph.redo", { ...res, graph });
-          return { jsonrpc: "2.0", id, result: decorated };
-        }
-        // 3. Scaffolding
-        case "entity.create":
-        case "graph.createEntity": {
-          const { name } = params;
-          if (!name) throw new Error("Entity name is required");
-          const res = this.astEngine.createEntity(name);
-          const graph = this.astEngine.extractArchitectureGraph();
-          this.notifyMutation("entity.create", { name, ...res });
-          const decorated = PreemptiveDocManager.decorateResponse("entity.create", { ...res, graph });
-          return { jsonrpc: "2.0", id, result: decorated };
-        }
-        case "functionality.create":
-        case "graph.createFunctionality": {
-          const { entityName, name } = params;
-          if (!entityName || !name) throw new Error("entityName and name are required");
-          const res = this.astEngine.createFunctionality(entityName, name);
-          const graph = this.astEngine.extractArchitectureGraph();
-          this.notifyMutation("functionality.create", { entityName, name, ...res });
-          const decorated = PreemptiveDocManager.decorateResponse("functionality.create", { ...res, graph });
-          return { jsonrpc: "2.0", id, result: decorated };
-        }
-        case "library.create":
-        case "graph.createLibrary": {
-          const { name } = params;
-          if (!name) throw new Error("Library name is required");
-          const res = this.astEngine.createLibrary(name);
-          const graph = this.astEngine.extractArchitectureGraph();
-          this.notifyMutation("library.create", { name, ...res });
-          const decorated = PreemptiveDocManager.decorateResponse("library.create", { ...res, graph });
-          return { jsonrpc: "2.0", id, result: decorated };
-        }
-        case "flow.addStep":
-        case "graph.addFlowStep": {
-          const { entityFilePath, flowName, stepFunctionName } = params;
-          const success = this.astEngine.addFlowStep(entityFilePath, flowName, stepFunctionName);
-          const graph = this.astEngine.extractArchitectureGraph();
-          this.notifyMutation("flow.addStep", { flowName, stepFunctionName, success });
-          const decorated = PreemptiveDocManager.decorateResponse("flow.addStep", { success, graph });
-          return { jsonrpc: "2.0", id, result: decorated };
-        }
-        case "library.listFunctions": {
-          const functions = this.astEngine.listGlobalLibraryFunctions();
-          return { jsonrpc: "2.0", id, result: { success: true, functions } };
-        }
-        case "orchestration.addStep": {
-          const { entityFilePath, orchestrationName, stepType, targetName, libName } = params;
-          const res = this.astEngine.addOrchestrationStep(entityFilePath, orchestrationName, stepType, targetName, libName);
-          const graph = this.astEngine.extractArchitectureGraph();
-          this.notifyMutation("orchestration.addStep", { orchestrationName, stepType, targetName, ...res });
-          return { jsonrpc: "2.0", id, result: { ...res, graph } };
-        }
-        // 4. Code Mutation & Robust File Reading
-        case "file.read": {
-          const { filePath } = params;
-          let abs = path6.isAbsolute(filePath) ? filePath : path6.resolve(this.projectRoot, filePath);
-          if (!fs7.existsSync(abs)) throw new Error(`File not found: ${filePath}`);
-          let content = "";
-          if (fs7.lstatSync(abs).isDirectory()) {
-            const base = path6.basename(abs);
-            const candidateTs = path6.join(abs, `${base}.ts`);
-            const candidateIndex = path6.join(abs, "index.ts");
-            if (fs7.existsSync(candidateTs)) {
-              abs = candidateTs;
-              content = fs7.readFileSync(candidateTs, "utf-8");
-            } else if (fs7.existsSync(candidateIndex)) {
-              abs = candidateIndex;
-              content = fs7.readFileSync(candidateIndex, "utf-8");
-            } else {
-              const files = fs7.readdirSync(abs);
-              content = `// Directory: ${base}
-// Files in directory:
-` + files.map((f) => `// - ${f}`).join("\n");
-            }
-          } else {
-            content = fs7.readFileSync(abs, "utf-8");
-          }
-          const decorated = PreemptiveDocManager.decorateResponse("file.read", { filePath: abs, content });
-          return { jsonrpc: "2.0", id, result: decorated };
-        }
-        case "file.edit": {
-          const { filePath, newContent } = params;
-          const abs = path6.resolve(this.projectRoot, filePath);
-          fs7.writeFileSync(abs, newContent, "utf-8");
-          this.notifyMutation("file.edit", { filePath });
-          const decorated = PreemptiveDocManager.decorateResponse("file.edit", { success: true, filePath: abs });
-          return { jsonrpc: "2.0", id, result: decorated };
-        }
-        case "ui.generate": {
-          const { componentTree, componentName, targetFilePath } = params;
-          const code = VanJSCodeGenerator.generateCode(componentTree, componentName || "GeneratedView");
-          if (targetFilePath) {
-            const abs = path6.resolve(this.projectRoot, targetFilePath);
-            fs7.mkdirSync(path6.dirname(abs), { recursive: true });
-            fs7.writeFileSync(abs, code, "utf-8");
-            this.notifyMutation("ui.generate", { targetFilePath });
-          }
-          const decorated = PreemptiveDocManager.decorateResponse("ui.generate", { code, targetFilePath });
-          return { jsonrpc: "2.0", id, result: decorated };
-        }
-        // 5. Validation
-        case "validate.audit":
-        case "validate.runPurityAudit": {
-          const summary = this.validator.validateAll();
-          const decorated = PreemptiveDocManager.decorateResponse("validate.audit", summary);
-          return { jsonrpc: "2.0", id, result: decorated };
-        }
-        // 6. Sandboxed Testing
-        case "test.executeFunction": {
-          const result = await FunctionExecutor.execute(params);
-          this.notifyMutation("test.executeFunction", { filePath: params.filePath, success: result.success, durationMs: result.durationMs });
-          const decorated = PreemptiveDocManager.decorateResponse("test.executeFunction", result);
-          return { jsonrpc: "2.0", id, result: decorated };
-        }
-        // 7. Documentation
-        case "docs.endpoints": {
-          const all = PreemptiveDocManager.getAllEndpoints();
-          const decorated = PreemptiveDocManager.decorateResponse("docs.endpoints", all);
-          return { jsonrpc: "2.0", id, result: decorated };
-        }
-        default:
-          return {
-            jsonrpc: "2.0",
-            id,
-            error: { code: -32601, message: `Method '${method}' not found` }
-          };
-      }
-    } catch (err) {
-      return {
-        jsonrpc: "2.0",
-        id: req.id,
-        error: { code: -32e3, message: err?.message || String(err) }
-      };
-    }
-  }
-  notifyMutation(action, params) {
-    if (this.onMutationCallback) {
-      this.onMutationCallback({ action, params });
-    }
-  }
-};
-
-// ../studio/src/server/StudioServer.ts
-import * as http from "http";
-import * as fs10 from "fs";
-import * as path9 from "path";
-import { WebSocketServer, WebSocket } from "ws";
-
-// ../studio/src/server/StaticFileServer.ts
-import * as fs8 from "fs";
-import * as path7 from "path";
-var MIME_TYPES = {
-  ".js": "application/javascript; charset=utf-8",
-  ".css": "text/css; charset=utf-8",
-  ".html": "text/html; charset=utf-8",
-  ".json": "application/json; charset=utf-8",
-  ".svg": "image/svg+xml",
-  ".png": "image/png"
-};
-var StaticFileServer = class {
-  baseDirs;
-  constructor() {
-    const base = typeof __dirname !== "undefined" ? __dirname : process.cwd();
-    this.baseDirs = [
-      path7.join(base, "../ui"),
-      path7.join(base, "../../src/ui"),
-      path7.join(process.cwd(), "packages/studio/src/ui"),
-      path7.join(process.cwd(), "src/ui")
-    ];
-  }
-  serveFile(req, res, relativePath) {
-    const cleanPath = path7.normalize(relativePath.replace(/^\/ui\/?/, "")).replace(/^(\.\.[\/\\])+/, "");
-    for (const baseDir of this.baseDirs) {
-      const fullPath = path7.join(baseDir, cleanPath);
-      if (fs8.existsSync(fullPath) && fs8.statSync(fullPath).isFile()) {
-        const ext = path7.extname(fullPath).toLowerCase();
-        const mime = MIME_TYPES[ext] || "text/plain; charset=utf-8";
-        const content = fs8.readFileSync(fullPath);
-        res.writeHead(200, {
-          "Content-Type": mime,
-          "Cache-Control": "no-cache, no-store, must-revalidate",
-          "Content-Length": Buffer.byteLength(content)
-        });
-        res.end(content);
-        return true;
-      }
-    }
-    res.writeHead(404, { "Content-Type": "text/plain; charset=utf-8" });
-    res.end(`File not found: ${cleanPath}`);
-    return false;
-  }
-};
-
-// ../studio/src/server/HttpRouteHandler.ts
-import * as fs9 from "fs";
-import * as path8 from "path";
-var ROUTE_MAP = {
-  "/api/v1/project/create": "project.create",
-  "/api/v1/project/load": "project.load",
-  "/api/v1/project/graph": "graph.getArchitecture",
-  "/api/v1/project/status": "project.getStatus",
-  "/api/v1/graph/moveNode": "graph.moveNode",
-  "/api/v1/graph/moveMultipleNodes": "graph.moveMultipleNodes",
-  "/api/v1/graph/connectNodes": "graph.connectNodes",
-  "/api/v1/graph/deleteEdge": "graph.deleteEdge",
-  "/api/v1/graph/deleteNode": "graph.deleteNode",
-  "/api/v1/graph/alignLayout": "graph.alignLayout",
-  "/api/v1/graph/undo": "graph.undo",
-  "/api/v1/graph/redo": "graph.redo",
-  "/api/v1/entity/create": "entity.create",
-  "/api/v1/functionality/create": "functionality.create",
-  "/api/v1/library/create": "library.create",
-  "/api/v1/flow/addStep": "flow.addStep",
-  "/api/v1/file/read": "file.read",
-  "/api/v1/file/edit": "file.edit",
-  "/api/v1/ui/generate": "ui.generate",
-  "/api/v1/validate/audit": "validate.audit",
-  "/api/v1/test/execute": "test.executeFunction",
-  "/api/v1/docs/endpoints": "docs.endpoints"
-};
-var HttpRouteHandler = class {
-  static async handleApiRequest(req, res, url, router, onGraphUpdate) {
-    let body = "";
-    req.on("data", (chunk) => {
-      body += chunk;
-    });
-    req.on("end", async () => {
-      try {
-        let params = {};
-        if (body.trim()) {
-          try {
-            params = JSON.parse(body);
-          } catch (e) {
-          }
-        }
-        const method = ROUTE_MAP[url] || "graph.getArchitecture";
-        const rpcRes = await router.handle({
-          jsonrpc: "2.0",
-          id: "http-req-" + Date.now(),
-          method,
-          params
-        });
-        if (rpcRes.error) {
-          res.writeHead(400, { "Content-Type": "application/json" });
-          res.end(JSON.stringify(rpcRes.error, null, 2));
-        } else {
-          res.writeHead(200, { "Content-Type": "application/json" });
-          res.end(JSON.stringify(rpcRes.result, null, 2));
-          onGraphUpdate();
-        }
-      } catch (err) {
-        res.writeHead(500, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ error: err.message || String(err) }));
-      }
-    });
-  }
-  static getStudioHtml() {
-    const base = typeof __dirname !== "undefined" ? __dirname : process.cwd();
-    const candidates = [
-      path8.join(base, "studio.html"),
-      path8.join(base, "../../src/server/studio.html"),
-      path8.join(process.cwd(), "packages/studio/src/server/studio.html"),
-      path8.join(process.cwd(), "src/server/studio.html")
-    ];
-    for (const candidate of candidates) {
-      if (fs9.existsSync(candidate)) {
-        return fs9.readFileSync(candidate, "utf8");
-      }
-    }
-    return `<!DOCTYPE html><html><body><h1>Krnl Studio Error: studio.html not found.</h1></body></html>`;
-  }
-};
-
-// ../studio/src/server/StudioServer.ts
-var StudioServer = class {
-  port;
-  projectRoot;
-  httpServer;
-  wss;
-  router;
-  watcher;
-  astEngine;
-  staticServer;
-  constructor(options = {}) {
-    this.port = options.port || 8080;
-    const initialRoot = path9.resolve(options.projectRoot || process.cwd());
-    const unifiedPath = path9.join(initialRoot, "examples/unified-workspace");
-    this.projectRoot = !fs10.existsSync(path9.join(initialRoot, "src/entities")) && fs10.existsSync(unifiedPath) ? unifiedPath : initialRoot;
-    this.astEngine = new AstMutationEngine(this.projectRoot);
-    this.watcher = new StudioFileWatcher(this.projectRoot);
-    this.staticServer = new StaticFileServer();
-    this.router = new JsonRpcRouter(this.projectRoot, (mutation) => {
-      this.broadcastAgentActivity(mutation);
-    });
-    this.httpServer = http.createServer((req, res) => this.handleHttpRequest(req, res));
-    this.wss = new WebSocketServer({ server: this.httpServer, path: "/studio/ws", perMessageDeflate: false });
-    this.wss.on("error", (err) => console.warn("WSS Error:", err));
-    this.initWebSocket();
-    this.initFileWatcher();
-  }
-  initWebSocket() {
-    this.wss.on("connection", (ws) => {
-      ws.on("error", (err) => console.warn("WS Client Error:", err?.message));
-      const graph = this.astEngine.extractArchitectureGraph();
-      ws.send(JSON.stringify({ jsonrpc: "2.0", method: "graph.init", params: { ...graph, projectRoot: this.projectRoot } }));
-      ws.on("message", async (data) => {
-        try {
-          const req = JSON.parse(data.toString());
-          if (req.method === "project.openDirectory" && req.params?.directory) {
-            const targetPath = path9.resolve(req.params.directory);
-            if (fs10.existsSync(targetPath)) {
-              this.projectRoot = targetPath;
-              this.astEngine = new AstMutationEngine(this.projectRoot);
-              this.router.setProjectRoot(this.projectRoot);
-              this.watcher.updateRoot(this.projectRoot);
-              ws.send(JSON.stringify({ jsonrpc: "2.0", id: req.id, result: { success: true, projectRoot: this.projectRoot } }));
-              this.broadcastGraphUpdate();
-            } else {
-              ws.send(JSON.stringify({ jsonrpc: "2.0", id: req.id, error: { code: -32001, message: "Directory does not exist: " + targetPath } }));
-            }
-            return;
-          }
-          const res = await this.router.handle(req);
-          if (ws.readyState === WebSocket.OPEN) ws.send(JSON.stringify(res));
-          if (req.method && (req.method.startsWith("graph.") || req.method.startsWith("entity.") || req.method.startsWith("functionality.") || req.method.startsWith("library."))) {
-            this.broadcastGraphUpdate();
-          }
-        } catch (e) {
-          if (ws.readyState === WebSocket.OPEN) {
-            ws.send(JSON.stringify({ jsonrpc: "2.0", error: { code: -32700, message: "Parse error: " + (e.message || String(e)) } }));
-          }
-        }
-      });
-    });
-  }
-  initFileWatcher() {
-    this.watcher.start();
-    this.watcher.subscribe(() => this.broadcastGraphUpdate());
-  }
-  broadcastGraphUpdate() {
-    try {
-      const graph = this.astEngine.extractArchitectureGraph();
-      const payload = JSON.stringify({ jsonrpc: "2.0", method: "graph.updated", params: { ...graph, projectRoot: this.projectRoot } });
-      for (const client of this.wss.clients) {
-        if (client.readyState === WebSocket.OPEN) client.send(payload);
-      }
-    } catch (e) {
-    }
-  }
-  broadcastAgentActivity(mutation) {
-    try {
-      const payload = JSON.stringify({ jsonrpc: "2.0", method: "agent.activity", params: { action: mutation.action, params: mutation.params, timestamp: Date.now() } });
-      for (const client of this.wss.clients) {
-        if (client.readyState === WebSocket.OPEN) client.send(payload);
-      }
-    } catch (e) {
-    }
-  }
-  async handleHttpRequest(req, res) {
-    res.setHeader("Access-Control-Allow-Origin", "*");
-    res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
-    res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
-    if (req.method === "OPTIONS") {
-      res.writeHead(204);
-      res.end();
-      return;
-    }
-    const url = req.url?.split("?")[0] || "/";
-    if (url === "/api/graph") {
-      const graph = this.astEngine.extractArchitectureGraph();
-      res.writeHead(200, { "Content-Type": "application/json" });
-      res.end(JSON.stringify({ status: "success", payload: graph, projectRoot: this.projectRoot }, null, 2));
-      return;
-    }
-    if (url.startsWith("/ui/")) {
-      this.staticServer.serveFile(req, res, url);
-      return;
-    }
-    if (url.startsWith("/api/v1/")) {
-      await HttpRouteHandler.handleApiRequest(req, res, url, this.router, () => this.broadcastGraphUpdate());
-      return;
-    }
-    res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
-    res.end(HttpRouteHandler.getStudioHtml());
-  }
-  async start() {
-    return new Promise((resolve6) => {
-      this.httpServer.listen(this.port, () => {
-        console.log(`
-\u{1F680} [Krnl Studio] Omni Canvas IDE running at: http://localhost:${this.port}`);
-        console.log(`\u{1F4E1} [Krnl Studio] Active Project Root: ${this.projectRoot}`);
-        console.log(`\u{1F4E1} [Krnl Studio] REST API Suite available at: http://localhost:${this.port}/api/v1/*`);
-        console.log(`\u{1F4E1} [Krnl Studio] WebSocket JSON-RPC protocol active on /studio/ws
-`);
-        resolve6();
-      });
-    });
-  }
-  async stop() {
-    this.watcher.stop();
-    return new Promise((resolve6) => {
-      this.wss.close(() => {
-        this.httpServer.close(() => resolve6());
-      });
-    });
-  }
-};
-
-// ../studio/src/client/plugins/VanJSRenderPlugin.ts
-import van from "vanjs-core";
-var { div, span, button } = van.tags;
-
-// src/bin/krnl.ts
+import * as fs from "fs";
 var args = process.argv.slice(2);
 var command = args[0] || "help";
 function detectAppEntrypoint(projectRoot) {
-  const files = fs11.readdirSync(projectRoot);
+  const files = fs.readdirSync(projectRoot);
   for (const f of files) {
     if (f.endsWith(".ts") && !f.endsWith(".d.ts") && f !== "tsup.config.ts") {
-      const full = path10.join(projectRoot, f);
+      const full = path.join(projectRoot, f);
       try {
-        const text = fs11.readFileSync(full, "utf8");
+        const text = fs.readFileSync(full, "utf8");
         if (text.includes("defineApp") || text.includes("@dinilmusick/krnl-core")) {
           return f;
         }
@@ -1871,7 +30,7 @@ function detectAppEntrypoint(projectRoot) {
 async function main() {
   switch (command) {
     case "sync": {
-      const targetDir = args[1] && !args[1].startsWith("-") ? path10.resolve(process.cwd(), args[1]) : process.cwd();
+      const targetDir = args[1] && !args[1].startsWith("-") ? path.resolve(process.cwd(), args[1]) : process.cwd();
       console.log("\u{1F4E6} [Krnl Sync] Reconciling package.json from all manifest.json files...");
       const res = KrnlPackageReconciler.reconcile(targetDir, true);
       console.log(`\u2705 Reconciled dependencies from ${res.totalManifests} manifest.json file(s).`);
@@ -1881,7 +40,7 @@ async function main() {
       break;
     }
     case "validate": {
-      const targetDir = args[1] && !args[1].startsWith("-") ? path10.resolve(process.cwd(), args[1]) : process.cwd();
+      const targetDir = args[1] && !args[1].startsWith("-") ? path.resolve(process.cwd(), args[1]) : process.cwd();
       const valid = await runValidate(targetDir);
       process.exit(valid ? 0 : 1);
       break;
@@ -1897,7 +56,7 @@ async function main() {
       generateMagneticDeclarations(process.cwd());
       if (args.includes("--watch") || args.includes("-w")) {
         console.log("[Krnl Watch] Continuous watcher enabled.");
-        fs11.watch(process.cwd(), { recursive: true }, (evt, filename) => {
+        fs.watch(process.cwd(), { recursive: true }, (evt, filename) => {
           if (filename && (filename.endsWith(".ts") || filename.endsWith(".js")) && !filename.includes("krnl-magnetic.d.ts")) {
             try {
               generateMagneticDeclarations(process.cwd());
@@ -1957,27 +116,23 @@ async function main() {
       } else if (isAll) {
         console.log(`\u26A1 [Krnl Dev] Initializing combined multi-entity workspace on port ${port}...`);
       } else {
-        console.log(`\u26A1 [Krnl Dev] Initializing Krnl Studio visual workspace on port ${port}...`);
+        console.log(`\u26A1 [Krnl Dev] Initializing Krnl backend service workspace on port ${port}...`);
       }
-      const server = new StudioServer({
-        port,
-        projectRoot
-      });
-      generateMagneticDeclarations(server.projectRoot || projectRoot);
-      await server.start();
+      generateMagneticDeclarations(projectRoot);
+      console.log(`\u26A1 [Krnl Dev] Development environment ready.`);
       break;
     }
     case "help":
     default: {
       console.log(`
 \u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557
-\u2551                      Krnl Framework CLI                       \u2551
+\u2551             Krnl Backend Service Framework CLI                \u2551
 \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D
 
 Usage: krnl <command> [options]
 
 Commands:
-  dev               Start Krnl Studio dev server & boot <app_name>.ts entrypoint
+  dev               Start Krnl service dev server & boot service entrypoint
   build             Validate and build project for production
   validate          Run deep AST & 4-layer function purity validation
   sync              Reconcile package.json from all co-located manifest.json files
@@ -1992,7 +147,7 @@ Commands:
 Options:
   --entity <name>   Target a specific entity app variant to run or build
   --all             Run or build all entities as a combined multi-entity build
-  --port <number>   Specify port for Krnl Studio dev server (default: 8080)
+  --port <number>   Specify port for Krnl service dev server (default: 8080)
   --watch, -w       Enable continuous file watcher (for watch command)
   --help, -h        Show this help message
 `);