@hamak/smart-data-dico 1.6.1 → 1.8.1

package/backend/dist/server.mjs

@@ -19143,18 +19143,18 @@ var require_router = __commonJS({
     var toString2 = Object.prototype.toString;
     var proto = module.exports = function(options2) {
       var opts = options2 || {};
-      function router25(req, res, next) {
-        router25.handle(req, res, next);
-      }
-      __name(router25, "router");
-      setPrototypeOf(router25, proto);
-      router25.params = {};
-      router25._params = [];
-      router25.caseSensitive = opts.caseSensitive;
-      router25.mergeParams = opts.mergeParams;
-      router25.strict = opts.strict;
-      router25.stack = [];
-      return router25;
+      function router27(req, res, next) {
+        router27.handle(req, res, next);
+      }
+      __name(router27, "router");
+      setPrototypeOf(router27, proto);
+      router27.params = {};
+      router27._params = [];
+      router27.caseSensitive = opts.caseSensitive;
+      router27.mergeParams = opts.mergeParams;
+      router27.strict = opts.strict;
+      router27.stack = [];
+      return router27;
     };
     proto.param = /* @__PURE__ */ __name(function param(name21, fn) {
       if (typeof name21 === "function") {
@@ -22278,7 +22278,7 @@ var require_application = __commonJS({
   "backend/node_modules/express/lib/application.js"(exports, module) {
     "use strict";
     var finalhandler = require_finalhandler();
-    var Router29 = require_router();
+    var Router31 = require_router();
     var methods = require_methods();
     var middleware = require_init();
     var query = require_query();
@@ -22343,7 +22343,7 @@ var require_application = __commonJS({
     }, "defaultConfiguration");
     app2.lazyrouter = /* @__PURE__ */ __name(function lazyrouter() {
       if (!this._router) {
-        this._router = new Router29({
+        this._router = new Router31({
           caseSensitive: this.enabled("case sensitive routing"),
           strict: this.enabled("strict routing")
         });
@@ -22352,17 +22352,17 @@ var require_application = __commonJS({
       }
     }, "lazyrouter");
     app2.handle = /* @__PURE__ */ __name(function handle(req, res, callback) {
-      var router25 = this._router;
+      var router27 = this._router;
       var done = callback || finalhandler(req, res, {
         env: this.get("env"),
         onerror: logerror.bind(this)
       });
-      if (!router25) {
+      if (!router27) {
         debug2("no routes defined on app");
         done();
         return;
       }
-      router25.handle(req, res, done);
+      router27.handle(req, res, done);
     }, "handle");
     app2.use = /* @__PURE__ */ __name(function use(fn) {
       var offset = 0;
@@ -22382,15 +22382,15 @@ var require_application = __commonJS({
         throw new TypeError("app.use() requires a middleware function");
       }
       this.lazyrouter();
-      var router25 = this._router;
+      var router27 = this._router;
       fns.forEach(function(fn2) {
         if (!fn2 || !fn2.handle || !fn2.set) {
-          return router25.use(path14, fn2);
+          return router27.use(path14, fn2);
         }
         debug2(".use app under %s", path14);
         fn2.mountpath = path14;
         fn2.parent = this;
-        router25.use(path14, /* @__PURE__ */ __name(function mounted_app(req, res, next) {
+        router27.use(path14, /* @__PURE__ */ __name(function mounted_app(req, res, next) {
           var orig = req.app;
           fn2.handle(req, res, function(err) {
             setPrototypeOf(req, orig.request);
@@ -24275,7 +24275,7 @@ var require_express = __commonJS({
     var mixin = require_merge_descriptors();
     var proto = require_application();
     var Route = require_route();
-    var Router29 = require_router();
+    var Router31 = require_router();
     var req = require_request();
     var res = require_response();
     exports = module.exports = createApplication;
@@ -24299,7 +24299,7 @@ var require_express = __commonJS({
     exports.request = req;
     exports.response = res;
     exports.Route = Route;
-    exports.Router = Router29;
+    exports.Router = Router31;
     exports.json = bodyParser2.json;
     exports.query = require_query();
     exports.raw = bodyParser2.raw;
@@ -43763,7 +43763,7 @@ var init_git_service = __esm({
 // backend/node_modules/@hamak/ui-remote-git-fs-backend/dist/routes/git-routes.js
 function createGitRoutes(config3) {
   const { gitService, debug: debug2 } = config3;
-  const router25 = (0, import_express2.Router)();
+  const router27 = (0, import_express2.Router)();
   const log2 = /* @__PURE__ */ __name((message, ...args) => {
     if (debug2) {
       console.log(`[git-routes] ${message}`, ...args);
@@ -43777,21 +43777,21 @@ function createGitRoutes(config3) {
   const extractPath = /* @__PURE__ */ __name((req) => {
     return req.params[0] || "";
   }, "extractPath");
-  router25.get("/:workspaceId/status/*", asyncHandler(async (req, res) => {
+  router27.get("/:workspaceId/status/*", asyncHandler(async (req, res) => {
     const { workspaceId } = req.params;
     const path14 = extractPath(req);
     log2("Status request", { workspaceId, path: path14 });
     const status = await gitService.getStatus(workspaceId, path14);
     res.json(status);
   }));
-  router25.get("/:workspaceId/branches/*", asyncHandler(async (req, res) => {
+  router27.get("/:workspaceId/branches/*", asyncHandler(async (req, res) => {
     const { workspaceId } = req.params;
     const path14 = extractPath(req);
     log2("List branches request", { workspaceId, path: path14 });
     const branches = await gitService.listBranches(workspaceId, path14);
     res.json(branches);
   }));
-  router25.post("/:workspaceId/checkout/*", asyncHandler(async (req, res) => {
+  router27.post("/:workspaceId/checkout/*", asyncHandler(async (req, res) => {
     const { workspaceId } = req.params;
     const path14 = extractPath(req);
     const { branch, create } = req.body;
@@ -43805,7 +43805,7 @@ function createGitRoutes(config3) {
     await gitService.checkout(workspaceId, path14, branch, create);
     res.json({ success: true, branch });
   }));
-  router25.post("/:workspaceId/branch/*", asyncHandler(async (req, res) => {
+  router27.post("/:workspaceId/branch/*", asyncHandler(async (req, res) => {
     const { workspaceId } = req.params;
     const path14 = extractPath(req);
     const { branch, startPoint } = req.body;
@@ -43819,7 +43819,7 @@ function createGitRoutes(config3) {
     await gitService.createBranch(workspaceId, path14, branch, startPoint);
     res.json({ success: true, branch });
   }));
-  router25.post("/:workspaceId/stage/*", asyncHandler(async (req, res) => {
+  router27.post("/:workspaceId/stage/*", asyncHandler(async (req, res) => {
     const { workspaceId } = req.params;
     const path14 = extractPath(req);
     const { files } = req.body;
@@ -43827,7 +43827,7 @@ function createGitRoutes(config3) {
     await gitService.stage(workspaceId, path14, files);
     res.json({ success: true });
   }));
-  router25.post("/:workspaceId/unstage/*", asyncHandler(async (req, res) => {
+  router27.post("/:workspaceId/unstage/*", asyncHandler(async (req, res) => {
     const { workspaceId } = req.params;
     const path14 = extractPath(req);
     const { files } = req.body;
@@ -43835,7 +43835,7 @@ function createGitRoutes(config3) {
     await gitService.unstage(workspaceId, path14, files);
     res.json({ success: true });
   }));
-  router25.post("/:workspaceId/commit/*", asyncHandler(async (req, res) => {
+  router27.post("/:workspaceId/commit/*", asyncHandler(async (req, res) => {
     const { workspaceId } = req.params;
     const path14 = extractPath(req);
     const { message } = req.body;
@@ -43849,7 +43849,7 @@ function createGitRoutes(config3) {
     const result = await gitService.commit(workspaceId, path14, message);
     res.json(result);
   }));
-  router25.post("/:workspaceId/pull/*", asyncHandler(async (req, res) => {
+  router27.post("/:workspaceId/pull/*", asyncHandler(async (req, res) => {
     const { workspaceId } = req.params;
     const path14 = extractPath(req);
     const { remote, branch } = req.body;
@@ -43857,7 +43857,7 @@ function createGitRoutes(config3) {
     const result = await gitService.pull(workspaceId, path14, remote, branch);
     res.json(result);
   }));
-  router25.post("/:workspaceId/push/*", asyncHandler(async (req, res) => {
+  router27.post("/:workspaceId/push/*", asyncHandler(async (req, res) => {
     const { workspaceId } = req.params;
     const path14 = extractPath(req);
     const { remote, branch } = req.body;
@@ -43865,7 +43865,7 @@ function createGitRoutes(config3) {
     await gitService.push(workspaceId, path14, remote, branch);
     res.json({ success: true });
   }));
-  router25.post("/:workspaceId/fetch/*", asyncHandler(async (req, res) => {
+  router27.post("/:workspaceId/fetch/*", asyncHandler(async (req, res) => {
     const { workspaceId } = req.params;
     const path14 = extractPath(req);
     const { remote } = req.body;
@@ -43873,7 +43873,7 @@ function createGitRoutes(config3) {
     await gitService.fetch(workspaceId, path14, remote);
     res.json({ success: true });
   }));
-  router25.get("/:workspaceId/diff/*", asyncHandler(async (req, res) => {
+  router27.get("/:workspaceId/diff/*", asyncHandler(async (req, res) => {
     const { workspaceId } = req.params;
     const path14 = extractPath(req);
     const { file: file2, staged } = req.query;
@@ -43881,7 +43881,7 @@ function createGitRoutes(config3) {
     const result = await gitService.diff(workspaceId, path14, file2, staged === "true");
     res.json(result);
   }));
-  router25.get("/:workspaceId/log/*", asyncHandler(async (req, res) => {
+  router27.get("/:workspaceId/log/*", asyncHandler(async (req, res) => {
     const { workspaceId } = req.params;
     const path14 = extractPath(req);
     const { maxCount, file: file2 } = req.query;
@@ -43889,21 +43889,21 @@ function createGitRoutes(config3) {
     const result = await gitService.log(workspaceId, path14, maxCount ? parseInt(maxCount, 10) : void 0, file2);
     res.json(result);
   }));
-  router25.get("/:workspaceId/is-repo/*", asyncHandler(async (req, res) => {
+  router27.get("/:workspaceId/is-repo/*", asyncHandler(async (req, res) => {
     const { workspaceId } = req.params;
     const path14 = extractPath(req);
     log2("Is repo request", { workspaceId, path: path14 });
     const isRepo = await gitService.isRepo(workspaceId, path14);
     res.json({ isRepo });
   }));
-  router25.get("/:workspaceId/repo-root/*", asyncHandler(async (req, res) => {
+  router27.get("/:workspaceId/repo-root/*", asyncHandler(async (req, res) => {
     const { workspaceId } = req.params;
     const path14 = extractPath(req);
     log2("Repo root request", { workspaceId, path: path14 });
     const repoRoot = await gitService.getRepoRoot(workspaceId, path14);
     res.json({ repoRoot });
   }));
-  return router25;
+  return router27;
 }
 function gitErrorHandler(err, req, res, next) {
   console.error("[git-routes] Error:", err);
@@ -44158,10 +44158,14 @@ var init_dist = __esm({
 // backend/src/utils/fileOperations.ts
 var fileOperations_exports = {};
 __export(fileOperations_exports, {
+  deleteAction: () => deleteAction,
   deleteCaseFile: () => deleteCaseFile,
   deleteEntityFile: () => deleteEntityFile,
+  deleteStateMachine: () => deleteStateMachine,
   ensureDirectoryStructure: () => ensureDirectoryStructure,
   ensurePackageDirectoryStructure: () => ensurePackageDirectoryStructure,
+  findActionOwner: () => findActionOwner,
+  findStateMachineOwner: () => findStateMachineOwner,
   getAllRelationships: () => getAllRelationships,
   getPackagePath: () => getPackagePath,
   getReservedPackageFiles: () => getReservedPackageFiles,
@@ -44179,6 +44183,7 @@ __export(fileOperations_exports, {
   mergePackageSections: () => mergePackageSections,
   normalizeEntityMetadata: () => normalizeEntityMetadata,
   parseSectionsFromString: () => parseSectionsFromString,
+  readActionsForEntity: () => readActionsForEntity,
   readCaseFile: () => readCaseFile,
   readCaseRules: () => readCaseRules,
   readComments: () => readComments,
@@ -44187,6 +44192,8 @@ __export(fileOperations_exports, {
   readGlobalRules: () => readGlobalRules,
   readPackageRules: () => readPackageRules,
   readRelationshipsFile: () => readRelationshipsFile,
+  readStateMachinesForEntity: () => readStateMachinesForEntity,
+  writeAction: () => writeAction,
   writeCaseFile: () => writeCaseFile,
   writeCaseRules: () => writeCaseRules,
   writeComments: () => writeComments,
@@ -44195,7 +44202,8 @@ __export(fileOperations_exports, {
   writeEntityRules: () => writeEntityRules,
   writeGlobalRules: () => writeGlobalRules,
   writePackageRules: () => writePackageRules,
-  writeRelationshipsFile: () => writeRelationshipsFile
+  writeRelationshipsFile: () => writeRelationshipsFile,
+  writeStateMachine: () => writeStateMachine
 });
 import path4 from "path";
 function getStorage() {
@@ -44330,11 +44338,11 @@ async function listMicroservices() {
 function parseSectionsFromString(raw, label, filename) {
   try {
     const parsed = import_yaml.default.parse(raw);
-    if (!parsed) return { entities: [], relationships: [], rules: [], cases: [] };
+    if (!parsed) return { entities: [], relationships: [], rules: [], cases: [], actions: [], stateMachines: [] };
     if (typeof parsed === "object" && !Array.isArray(parsed) && typeof parsed.uuid === "string" && Array.isArray(parsed.attributes)) {
-      return { entities: [parsed], relationships: [], rules: [], cases: [] };
+      return { entities: [parsed], relationships: [], rules: [], cases: [], actions: [], stateMachines: [] };
     }
-    if (parsed && typeof parsed === "object" && !Array.isArray(parsed) && ("entities" in parsed || "relationships" in parsed || "rules" in parsed || "cases" in parsed || "perspectives" in parsed)) {
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed) && ("entities" in parsed || "relationships" in parsed || "rules" in parsed || "cases" in parsed || "perspectives" in parsed || "actions" in parsed || "stateMachines" in parsed)) {
       let cases = [];
       if (Array.isArray(parsed.cases)) {
         cases = parsed.cases;
@@ -44346,27 +44354,29 @@ function parseSectionsFromString(raw, label, filename) {
         entities: Array.isArray(parsed.entities) ? parsed.entities : [],
         relationships: Array.isArray(parsed.relationships) ? parsed.relationships : [],
         rules: Array.isArray(parsed.rules) ? parsed.rules : [],
-        cases
+        cases,
+        actions: Array.isArray(parsed.actions) ? parsed.actions : [],
+        stateMachines: Array.isArray(parsed.stateMachines) ? parsed.stateMachines : []
       };
     }
     if (Array.isArray(parsed) && filename) {
       if (filename === "relationships.yaml") {
-        return { entities: [], relationships: parsed, rules: [], cases: [] };
+        return { entities: [], relationships: parsed, rules: [], cases: [], actions: [], stateMachines: [] };
       }
       if (filename === "rules.yaml" || filename.endsWith(".rules.yaml")) {
-        return { entities: [], relationships: [], rules: parsed, cases: [] };
+        return { entities: [], relationships: [], rules: parsed, cases: [], actions: [], stateMachines: [] };
       }
     }
-    return { entities: [], relationships: [], rules: [], cases: [] };
+    return { entities: [], relationships: [], rules: [], cases: [], actions: [], stateMachines: [] };
   } catch (e) {
     logger.warn(`Failed to parse YAML: ${label}: ${e}`);
-    return { entities: [], relationships: [], rules: [], cases: [] };
+    return { entities: [], relationships: [], rules: [], cases: [], actions: [], stateMachines: [] };
   }
 }
 async function parseSectionsFromStorage(p, label) {
   const content = await readOrNull(p);
   if (content === null) {
-    return { entities: [], relationships: [], rules: [], cases: [] };
+    return { entities: [], relationships: [], rules: [], cases: [], actions: [], stateMachines: [] };
   }
   const filename = path4.basename(String(p));
   return parseSectionsFromString(content, label, filename);
@@ -44378,12 +44388,18 @@ function mergePackageSections(packageName, parsed) {
     relationships: [],
     rules: [],
     cases: [],
+    actions: [],
+    stateMachines: [],
     ownership: {
       entityByName: /* @__PURE__ */ new Map(),
       entityByUuid: /* @__PURE__ */ new Map(),
       relationshipByUuid: /* @__PURE__ */ new Map(),
       ruleByUuid: /* @__PURE__ */ new Map(),
-      caseByUuid: /* @__PURE__ */ new Map()
+      caseByUuid: /* @__PURE__ */ new Map(),
+      actionByUuid: /* @__PURE__ */ new Map(),
+      stateMachineByUuid: /* @__PURE__ */ new Map(),
+      actionByOwnerAndName: /* @__PURE__ */ new Map(),
+      stateMachineByOwnerAndName: /* @__PURE__ */ new Map()
     }
   };
   for (const { label, sections } of parsed) {
@@ -44439,6 +44455,44 @@ function mergePackageSections(packageName, parsed) {
       model.ownership.caseByUuid.set(c.uuid, label);
       model.cases.push(c);
     }
+    for (const action of sections.actions || []) {
+      if (!action?.uuid || !action?.name || !action?.ownerRef) continue;
+      const byUuid = model.ownership.actionByUuid.get(action.uuid);
+      if (byUuid) {
+        throw new Error(
+          `Duplicate action uuid '${action.uuid}' in package '${packageName}': ${byUuid} and ${label}`
+        );
+      }
+      const ownerNameKey = `${action.ownerRef}::${action.name}`;
+      const byOwnerAndName = model.ownership.actionByOwnerAndName.get(ownerNameKey);
+      if (byOwnerAndName) {
+        throw new Error(
+          `Duplicate action name '${action.name}' for ownerRef '${action.ownerRef}' in package '${packageName}': ${byOwnerAndName} and ${label}`
+        );
+      }
+      model.ownership.actionByUuid.set(action.uuid, label);
+      model.ownership.actionByOwnerAndName.set(ownerNameKey, label);
+      model.actions.push(action);
+    }
+    for (const sm of sections.stateMachines || []) {
+      if (!sm?.uuid || !sm?.name || !sm?.ownerRef) continue;
+      const byUuid = model.ownership.stateMachineByUuid.get(sm.uuid);
+      if (byUuid) {
+        throw new Error(
+          `Duplicate stateMachine uuid '${sm.uuid}' in package '${packageName}': ${byUuid} and ${label}`
+        );
+      }
+      const ownerNameKey = `${sm.ownerRef}::${sm.name}`;
+      const byOwnerAndName = model.ownership.stateMachineByOwnerAndName.get(ownerNameKey);
+      if (byOwnerAndName) {
+        throw new Error(
+          `Duplicate stateMachine name '${sm.name}' for ownerRef '${sm.ownerRef}' in package '${packageName}': ${byOwnerAndName} and ${label}`
+        );
+      }
+      model.ownership.stateMachineByUuid.set(sm.uuid, label);
+      model.ownership.stateMachineByOwnerAndName.set(ownerNameKey, label);
+      model.stateMachines.push(sm);
+    }
   }
   return model;
 }
@@ -44451,6 +44505,8 @@ async function writeSectionsToStorage(p, sections) {
   if (sections.relationships.length > 0) payload.relationships = sections.relationships;
   if (sections.rules.length > 0) payload.rules = sections.rules;
   if (sections.cases.length > 0) payload.cases = sections.cases;
+  if (sections.actions.length > 0) payload.actions = sections.actions;
+  if (sections.stateMachines.length > 0) payload.stateMachines = sections.stateMachines;
   if (Object.keys(payload).length === 0) {
     await deleteIfExists(p);
     return;
@@ -44563,7 +44619,9 @@ async function writeEntityFile(entity, packageName) {
       entities: [entity],
       relationships: [],
       rules: [],
-      cases: []
+      cases: [],
+      actions: [],
+      stateMachines: []
     });
     logger.info(`Entity written to new file: ${String(newFilePath)}`);
     await commitChanges(String(newFilePath), `Added entity: ${entity.name} (${entity.uuid})`);
@@ -45006,6 +45064,186 @@ async function listAllDictionaries() {
     return [];
   }
 }
+async function findActionOwner(actionUuid) {
+  const packages = await listPackages();
+  for (const pkg of packages) {
+    const files = await listPackageYamlFilePaths(pkg);
+    for (const f of files) {
+      const s = await parseSectionsFromStorage(f, String(f));
+      if (s.actions.some((a) => a.uuid === actionUuid)) {
+        return { packageName: pkg, filePath: String(f) };
+      }
+    }
+  }
+  return null;
+}
+async function readActionsForEntity(entityUuid) {
+  const packages = await listPackages();
+  const result = [];
+  for (const pkg of packages) {
+    try {
+      const model = await loadPackage(pkg);
+      result.push(...model.actions.filter((a) => a.ownerRef === entityUuid));
+    } catch {
+    }
+  }
+  return result;
+}
+async function writeAction(action, packageName) {
+  try {
+    await ensurePackageDirectoryStructure(packageName);
+    const files = await listPackageYamlFilePaths(packageName);
+    let ownerFile = null;
+    let ownerSections = null;
+    for (const f of files) {
+      const s = await parseSectionsFromStorage(f, String(f));
+      if (s.actions.some((a) => a.uuid === action.uuid)) {
+        ownerFile = f;
+        ownerSections = s;
+        break;
+      }
+    }
+    if (ownerFile && ownerSections) {
+      ownerSections.actions = ownerSections.actions.filter((a) => a.uuid !== action.uuid);
+      ownerSections.actions.push(action);
+      await writeSectionsToStorage(ownerFile, ownerSections);
+      await commitChanges(String(ownerFile), `Updated action: ${action.name} (${action.uuid})`);
+      return { ok: true, physicalPath: String(ownerFile) };
+    }
+    const entityModel = await loadPackage(packageName);
+    const ownerEntityFile = entityModel.ownership.entityByUuid.get(action.ownerRef);
+    if (ownerEntityFile) {
+      const filePath = pathOf(ownerEntityFile);
+      const s = await parseSectionsFromStorage(filePath, ownerEntityFile);
+      s.actions = s.actions.filter((a) => a.uuid !== action.uuid);
+      s.actions.push(action);
+      await writeSectionsToStorage(filePath, s);
+      await commitChanges(ownerEntityFile, `Added action: ${action.name} (${action.uuid})`);
+      return { ok: true, physicalPath: ownerEntityFile };
+    }
+    const newFilePath = pathOf(`${packageName}/${sanitizeFsName(action.name)}.actions.yaml`);
+    await writeSectionsToStorage(newFilePath, {
+      entities: [],
+      relationships: [],
+      rules: [],
+      cases: [],
+      actions: [action],
+      stateMachines: []
+    });
+    await commitChanges(String(newFilePath), `Added action: ${action.name} (${action.uuid})`);
+    return { ok: true, physicalPath: String(newFilePath) };
+  } catch (error48) {
+    logger.error(`Error writing action: ${error48}`);
+    return { ok: false };
+  }
+}
+async function deleteAction(uuid3) {
+  try {
+    const owner = await findActionOwner(uuid3);
+    if (!owner) return { ok: false };
+    const ownerPath = pathOf(owner.filePath);
+    const s = await parseSectionsFromStorage(ownerPath, owner.filePath);
+    const before = s.actions.length;
+    s.actions = s.actions.filter((a) => a.uuid !== uuid3);
+    if (s.actions.length === before) return { ok: false };
+    await writeSectionsToStorage(ownerPath, s);
+    await commitChanges(owner.filePath, `Deleted action ${uuid3}`);
+    return { ok: true, physicalPath: owner.filePath };
+  } catch (error48) {
+    logger.error(`Error deleting action ${uuid3}: ${error48}`);
+    return { ok: false };
+  }
+}
+async function findStateMachineOwner(smUuid) {
+  const packages = await listPackages();
+  for (const pkg of packages) {
+    const files = await listPackageYamlFilePaths(pkg);
+    for (const f of files) {
+      const s = await parseSectionsFromStorage(f, String(f));
+      if (s.stateMachines.some((m) => m.uuid === smUuid)) {
+        return { packageName: pkg, filePath: String(f) };
+      }
+    }
+  }
+  return null;
+}
+async function readStateMachinesForEntity(entityUuid) {
+  const packages = await listPackages();
+  const result = [];
+  for (const pkg of packages) {
+    try {
+      const model = await loadPackage(pkg);
+      result.push(...model.stateMachines.filter((m) => m.ownerRef === entityUuid));
+    } catch {
+    }
+  }
+  return result;
+}
+async function writeStateMachine(sm, packageName) {
+  try {
+    await ensurePackageDirectoryStructure(packageName);
+    const files = await listPackageYamlFilePaths(packageName);
+    let ownerFile = null;
+    let ownerSections = null;
+    for (const f of files) {
+      const s = await parseSectionsFromStorage(f, String(f));
+      if (s.stateMachines.some((m) => m.uuid === sm.uuid)) {
+        ownerFile = f;
+        ownerSections = s;
+        break;
+      }
+    }
+    if (ownerFile && ownerSections) {
+      ownerSections.stateMachines = ownerSections.stateMachines.filter((m) => m.uuid !== sm.uuid);
+      ownerSections.stateMachines.push(sm);
+      await writeSectionsToStorage(ownerFile, ownerSections);
+      await commitChanges(String(ownerFile), `Updated stateMachine: ${sm.name} (${sm.uuid})`);
+      return { ok: true, physicalPath: String(ownerFile) };
+    }
+    const entityModel = await loadPackage(packageName);
+    const ownerEntityFile = entityModel.ownership.entityByUuid.get(sm.ownerRef);
+    if (ownerEntityFile) {
+      const filePath = pathOf(ownerEntityFile);
+      const s = await parseSectionsFromStorage(filePath, ownerEntityFile);
+      s.stateMachines = s.stateMachines.filter((m) => m.uuid !== sm.uuid);
+      s.stateMachines.push(sm);
+      await writeSectionsToStorage(filePath, s);
+      await commitChanges(ownerEntityFile, `Added stateMachine: ${sm.name} (${sm.uuid})`);
+      return { ok: true, physicalPath: ownerEntityFile };
+    }
+    const newFilePath = pathOf(`${packageName}/${sanitizeFsName(sm.name)}.statemachine.yaml`);
+    await writeSectionsToStorage(newFilePath, {
+      entities: [],
+      relationships: [],
+      rules: [],
+      cases: [],
+      actions: [],
+      stateMachines: [sm]
+    });
+    await commitChanges(String(newFilePath), `Added stateMachine: ${sm.name} (${sm.uuid})`);
+    return { ok: true, physicalPath: String(newFilePath) };
+  } catch (error48) {
+    logger.error(`Error writing stateMachine: ${error48}`);
+    return { ok: false };
+  }
+}
+async function deleteStateMachine(uuid3) {
+  try {
+    const owner = await findStateMachineOwner(uuid3);
+    if (!owner) return { ok: false };
+    const ownerPath = pathOf(owner.filePath);
+    const s = await parseSectionsFromStorage(ownerPath, owner.filePath);
+    const before = s.stateMachines.length;
+    s.stateMachines = s.stateMachines.filter((m) => m.uuid !== uuid3);
+    if (s.stateMachines.length === before) return { ok: false };
+    await writeSectionsToStorage(ownerPath, s);
+    await commitChanges(owner.filePath, `Deleted stateMachine ${uuid3}`);
+    return { ok: true, physicalPath: owner.filePath };
+  } catch (error48) {
+    logger.error(`Error deleting stateMachine ${uuid3}: ${error48}`);
+    return { ok: false };
+  }
+}
 var import_yaml, WS, getDataDir, RESERVED_DIRS, RESERVED_PACKAGE_FILES, VALIDATION_FIELD_NAMES, gitServiceInstance;
 var init_fileOperations = __esm({
   "backend/src/utils/fileOperations.ts"() {
@@ -45083,6 +45321,14 @@ var init_fileOperations = __esm({
     __name(deleteCaseFile, "deleteCaseFile");
     __name(writeDictionaryMetadata, "writeDictionaryMetadata");
     __name(listAllDictionaries, "listAllDictionaries");
+    __name(findActionOwner, "findActionOwner");
+    __name(readActionsForEntity, "readActionsForEntity");
+    __name(writeAction, "writeAction");
+    __name(deleteAction, "deleteAction");
+    __name(findStateMachineOwner, "findStateMachineOwner");
+    __name(readStateMachinesForEntity, "readStateMachinesForEntity");
+    __name(writeStateMachine, "writeStateMachine");
+    __name(deleteStateMachine, "deleteStateMachine");
   }
 });
 
@@ -45302,7 +45548,11 @@ var init_dictionaryService = __esm({
           const model = await loadPackage(packageName);
           entities = model.entities;
           relationships = model.relationships;
-          cases = model.cases.map((c) => ({ uuid: c.uuid, name: c.name }));
+          cases = model.cases.map((c) => ({
+            uuid: c.uuid,
+            name: c.name,
+            ...c.description !== void 0 ? { description: c.description } : {}
+          }));
         } catch (e) {
           logger.warn(`Failed to load package ${packageName}: ${e}`);
         }
@@ -99596,7 +99846,7 @@ async function auth(provider, options2) {
     throw error48;
   }
 }
-async function authInternal(provider, { serverUrl, authorizationCode, scope, resourceMetadataUrl, fetchFn }) {
+async function authInternal(provider, { serverUrl: serverUrl2, authorizationCode, scope, resourceMetadataUrl, fetchFn }) {
   const cachedState = await provider.discoveryState?.();
   let resourceMetadata;
   let authorizationServerUrl;
@@ -99611,7 +99861,7 @@ async function authInternal(provider, { serverUrl, authorizationCode, scope, res
     metadata = cachedState.authorizationServerMetadata ?? await discoverAuthorizationServerMetadata(authorizationServerUrl, { fetchFn });
     if (!resourceMetadata) {
       try {
-        resourceMetadata = await discoverOAuthProtectedResourceMetadata(serverUrl, { resourceMetadataUrl: effectiveResourceMetadataUrl }, fetchFn);
+        resourceMetadata = await discoverOAuthProtectedResourceMetadata(serverUrl2, { resourceMetadataUrl: effectiveResourceMetadataUrl }, fetchFn);
       } catch {
       }
     }
@@ -99624,7 +99874,7 @@ async function authInternal(provider, { serverUrl, authorizationCode, scope, res
       });
     }
   } else {
-    const serverInfo = await discoverOAuthServerInfo(serverUrl, { resourceMetadataUrl: effectiveResourceMetadataUrl, fetchFn });
+    const serverInfo = await discoverOAuthServerInfo(serverUrl2, { resourceMetadataUrl: effectiveResourceMetadataUrl, fetchFn });
     authorizationServerUrl = serverInfo.authorizationServerUrl;
     metadata = serverInfo.authorizationServerMetadata;
     resourceMetadata = serverInfo.resourceMetadata;
@@ -99635,7 +99885,7 @@ async function authInternal(provider, { serverUrl, authorizationCode, scope, res
       authorizationServerMetadata: metadata
     });
   }
-  const resource = await selectResourceURL(serverUrl, provider, resourceMetadata);
+  const resource = await selectResourceURL(serverUrl2, provider, resourceMetadata);
   const resolvedScope = scope || resourceMetadata?.scopes_supported?.join(" ") || provider.clientMetadata.scope;
   let clientInformation = await Promise.resolve(provider.clientInformation());
   if (!clientInformation) {
@@ -99721,8 +99971,8 @@ function isHttpsUrl(value) {
     return false;
   }
 }
-async function selectResourceURL(serverUrl, provider, resourceMetadata) {
-  const defaultResource = resourceUrlFromServerUrl(serverUrl);
+async function selectResourceURL(serverUrl2, provider, resourceMetadata) {
+  const defaultResource = resourceUrlFromServerUrl(serverUrl2);
   if (provider.validateResourceURL) {
     return await provider.validateResourceURL(defaultResource, resourceMetadata?.resource);
   }
@@ -99771,8 +100021,8 @@ function extractFieldFromWwwAuth(response, fieldName) {
   }
   return null;
 }
-async function discoverOAuthProtectedResourceMetadata(serverUrl, opts, fetchFn = fetch) {
-  const response = await discoverMetadataWithFallback(serverUrl, "oauth-protected-resource", fetchFn, {
+async function discoverOAuthProtectedResourceMetadata(serverUrl2, opts, fetchFn = fetch) {
+  const response = await discoverMetadataWithFallback(serverUrl2, "oauth-protected-resource", fetchFn, {
     protocolVersion: opts?.protocolVersion,
     metadataUrl: opts?.resourceMetadataUrl
   });
@@ -99815,8 +100065,8 @@ async function tryMetadataDiscovery(url2, protocolVersion, fetchFn = fetch) {
 function shouldAttemptFallback(response, pathname) {
   return !response || response.status >= 400 && response.status < 500 && pathname !== "/";
 }
-async function discoverMetadataWithFallback(serverUrl, wellKnownType, fetchFn, opts) {
-  const issuer = new URL(serverUrl);
+async function discoverMetadataWithFallback(serverUrl2, wellKnownType, fetchFn, opts) {
+  const issuer = new URL(serverUrl2);
   const protocolVersion = opts?.protocolVersion ?? LATEST_PROTOCOL_VERSION;
   let url2;
   if (opts?.metadataUrl) {
@@ -99892,18 +100142,18 @@ async function discoverAuthorizationServerMetadata(authorizationServerUrl, { fet
   }
   return void 0;
 }
-async function discoverOAuthServerInfo(serverUrl, opts) {
+async function discoverOAuthServerInfo(serverUrl2, opts) {
   let resourceMetadata;
   let authorizationServerUrl;
   try {
-    resourceMetadata = await discoverOAuthProtectedResourceMetadata(serverUrl, { resourceMetadataUrl: opts?.resourceMetadataUrl }, opts?.fetchFn);
+    resourceMetadata = await discoverOAuthProtectedResourceMetadata(serverUrl2, { resourceMetadataUrl: opts?.resourceMetadataUrl }, opts?.fetchFn);
     if (resourceMetadata.authorization_servers && resourceMetadata.authorization_servers.length > 0) {
       authorizationServerUrl = resourceMetadata.authorization_servers[0];
     }
   } catch {
   }
   if (!authorizationServerUrl) {
-    authorizationServerUrl = String(new URL("/", serverUrl));
+    authorizationServerUrl = String(new URL("/", serverUrl2));
   }
   const authorizationServerMetadata = await discoverAuthorizationServerMetadata(authorizationServerUrl, { fetchFn: opts?.fetchFn });
   return {
@@ -114060,21 +114310,21 @@ var chat_routes_exports = {};
 __export(chat_routes_exports, {
   default: () => chat_routes_default
 });
-var import_express16, router15, chat_routes_default;
+var import_express18, router17, chat_routes_default;
 var init_chat_routes = __esm({
   "backend/src/routes/ai/chat.routes.ts"() {
     "use strict";
-    import_express16 = __toESM(require_express2(), 1);
+    import_express18 = __toESM(require_express2(), 1);
     init_aiController();
-    router15 = (0, import_express16.Router)();
-    router15.post("/api/ai/chat", aiChat);
-    router15.get("/api/ai/status", aiStatus);
-    router15.get("/api/ai/config", aiGetConfig);
-    router15.post("/api/ai/config", aiSaveConfig);
-    router15.get("/api/ai/tools", aiTools);
-    router15.get("/api/ai/mentions/search", aiMentionsSearch);
-    router15.post("/api/ai/test-tools", aiTestTools);
-    chat_routes_default = router15;
+    router17 = (0, import_express18.Router)();
+    router17.post("/api/ai/chat", aiChat);
+    router17.get("/api/ai/status", aiStatus);
+    router17.get("/api/ai/config", aiGetConfig);
+    router17.post("/api/ai/config", aiSaveConfig);
+    router17.get("/api/ai/tools", aiTools);
+    router17.get("/api/ai/mentions/search", aiMentionsSearch);
+    router17.post("/api/ai/test-tools", aiTestTools);
+    chat_routes_default = router17;
   }
 });
 
@@ -114083,19 +114333,19 @@ var conversation_routes_exports = {};
 __export(conversation_routes_exports, {
   default: () => conversation_routes_default
 });
-var import_express17, router16, conversation_routes_default;
+var import_express19, router18, conversation_routes_default;
 var init_conversation_routes = __esm({
   "backend/src/routes/ai/conversation.routes.ts"() {
     "use strict";
-    import_express17 = __toESM(require_express2(), 1);
+    import_express19 = __toESM(require_express2(), 1);
     init_aiController();
-    router16 = (0, import_express17.Router)();
-    router16.get("/api/ai/conversations", listConversations);
-    router16.get("/api/ai/conversations/:id", getConversation);
-    router16.post("/api/ai/conversations", saveConversation);
-    router16.patch("/api/ai/conversations/:id", patchConversation);
-    router16.delete("/api/ai/conversations/:id", deleteConversation);
-    conversation_routes_default = router16;
+    router18 = (0, import_express19.Router)();
+    router18.get("/api/ai/conversations", listConversations);
+    router18.get("/api/ai/conversations/:id", getConversation);
+    router18.post("/api/ai/conversations", saveConversation);
+    router18.patch("/api/ai/conversations/:id", patchConversation);
+    router18.delete("/api/ai/conversations/:id", deleteConversation);
+    conversation_routes_default = router18;
   }
 });
 
@@ -114104,19 +114354,19 @@ var prompt_routes_exports = {};
 __export(prompt_routes_exports, {
   default: () => prompt_routes_default
 });
-var import_express18, router17, prompt_routes_default;
+var import_express20, router19, prompt_routes_default;
 var init_prompt_routes = __esm({
   "backend/src/routes/ai/prompt.routes.ts"() {
     "use strict";
-    import_express18 = __toESM(require_express2(), 1);
+    import_express20 = __toESM(require_express2(), 1);
     init_aiController();
-    router17 = (0, import_express18.Router)();
-    router17.get("/api/ai/prompts", listPrompts);
-    router17.get("/api/ai/prompts/:id", getPrompt);
-    router17.post("/api/ai/prompts", createPrompt);
-    router17.put("/api/ai/prompts/:id", updatePrompt);
-    router17.delete("/api/ai/prompts/:id", deletePrompt);
-    prompt_routes_default = router17;
+    router19 = (0, import_express20.Router)();
+    router19.get("/api/ai/prompts", listPrompts);
+    router19.get("/api/ai/prompts/:id", getPrompt);
+    router19.post("/api/ai/prompts", createPrompt);
+    router19.put("/api/ai/prompts/:id", updatePrompt);
+    router19.delete("/api/ai/prompts/:id", deletePrompt);
+    prompt_routes_default = router19;
   }
 });
 
@@ -114152,19 +114402,19 @@ function mergeMaskedRecord(incoming, existing) {
   }
   return out;
 }
-var import_express19, router18, MASK, looksLikeEnvRef, mcp_routes_default;
+var import_express21, router20, MASK, looksLikeEnvRef, mcp_routes_default;
 var init_mcp_routes = __esm({
   "backend/src/routes/ai/mcp.routes.ts"() {
     "use strict";
-    import_express19 = __toESM(require_express2(), 1);
+    import_express21 = __toESM(require_express2(), 1);
     init_mcpClientRegistry();
-    router18 = (0, import_express19.Router)();
+    router20 = (0, import_express21.Router)();
     MASK = "\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022";
     looksLikeEnvRef = /* @__PURE__ */ __name((v) => /\$\{[^}]+\}/.test(v), "looksLikeEnvRef");
     __name(maskRecord, "maskRecord");
     __name(maskConnection, "maskConnection");
     __name(mergeMaskedRecord, "mergeMaskedRecord");
-    router18.get("/api/ai/mcp/connections", (_req, res) => {
+    router20.get("/api/ai/mcp/connections", (_req, res) => {
       try {
         const connections = mcpClientRegistry.getConnections().map(maskConnection);
         res.json({ data: connections });
@@ -114173,7 +114423,7 @@ var init_mcp_routes = __esm({
         res.status(500).json({ error: msg });
       }
     });
-    router18.post("/api/ai/mcp/connections", (req, res) => {
+    router20.post("/api/ai/mcp/connections", (req, res) => {
       try {
         const body = req.body;
         const errors = mcpClientRegistry.validateConnection(body);
@@ -114193,7 +114443,7 @@ var init_mcp_routes = __esm({
         res.status(500).json({ error: msg });
       }
     });
-    router18.delete("/api/ai/mcp/connections/:id", (req, res) => {
+    router20.delete("/api/ai/mcp/connections/:id", (req, res) => {
       try {
         const { id } = req.params;
         const deleted = mcpClientRegistry.deleteConnection(id);
@@ -114206,7 +114456,7 @@ var init_mcp_routes = __esm({
         res.status(500).json({ error: msg });
       }
     });
-    router18.post("/api/ai/mcp/connections/:id/test", async (req, res) => {
+    router20.post("/api/ai/mcp/connections/:id/test", async (req, res) => {
       try {
         const { id } = req.params;
         const result = await mcpClientRegistry.testConnection(id);
@@ -114220,7 +114470,7 @@ var init_mcp_routes = __esm({
         res.status(500).json({ error: msg });
       }
     });
-    mcp_routes_default = router18;
+    mcp_routes_default = router20;
   }
 });
 
@@ -114399,16 +114649,16 @@ var init_workspace_manager = __esm({
 });
 
 // backend/node_modules/@hamak/filesystem-server-impl/dist/routing/file-router.js
-var import_express26, FileRouter;
+var import_express28, FileRouter;
 var init_file_router = __esm({
   "backend/node_modules/@hamak/filesystem-server-impl/dist/routing/file-router.js"() {
-    import_express26 = __toESM(require_express2(), 1);
+    import_express28 = __toESM(require_express2(), 1);
     FileRouter = class {
       static {
         __name(this, "FileRouter");
       }
       constructor(workspaceManager2, options2) {
-        this.router = (0, import_express26.Router)();
+        this.router = (0, import_express28.Router)();
         this.workspaceManager = workspaceManager2;
         this.enricherRegistry = options2?.enricherRegistry;
         this.initializeRoutes();
@@ -114535,7 +114785,7 @@ var init_file_router = __esm({
 
 // backend/node_modules/@hamak/filesystem-server-impl/dist/routing/create-router.js
 function createFileSystemRouter(workspaceManager2, config3) {
-  const app2 = (0, import_express27.Router)();
+  const app2 = (0, import_express29.Router)();
   if (config3.enableCors ?? DEFAULT_FILESYSTEM_SERVER_CONFIG.enableCors) {
     app2.use((0, import_cors.default)());
   }
@@ -114545,10 +114795,10 @@ function createFileSystemRouter(workspaceManager2, config3) {
   app2.use(mountPath, fileRouter2.router);
   return app2;
 }
-var import_express27, import_cors, import_body_parser;
+var import_express29, import_cors, import_body_parser;
 var init_create_router = __esm({
   "backend/node_modules/@hamak/filesystem-server-impl/dist/routing/create-router.js"() {
-    import_express27 = __toESM(require_express2(), 1);
+    import_express29 = __toESM(require_express2(), 1);
     import_cors = __toESM(require_lib3(), 1);
     import_body_parser = __toESM(require_body_parser(), 1);
     init_dist9();
@@ -154254,8 +154504,8 @@ function respondError(res, err, fallbackStatus = 500) {
   res.status(fallbackStatus).json({ error: message });
 }
 function createLogicalFsRouter() {
-  const router25 = (0, import_express28.Router)();
-  router25.get("/:workspace/files/*", async (req, res) => {
+  const router27 = (0, import_express30.Router)();
+  router27.get("/:workspace/files/*", async (req, res) => {
     try {
       const ws = wsId(req.params.workspace);
       const projection = getProjection(ws);
@@ -154273,7 +154523,7 @@ function createLogicalFsRouter() {
       respondError(res, err);
     }
   });
-  router25.get("/:workspace/read/*", async (req, res) => {
+  router27.get("/:workspace/read/*", async (req, res) => {
     try {
       const ws = wsId(req.params.workspace);
       const projection = getProjection(ws);
@@ -154317,9 +154567,9 @@ function createLogicalFsRouter() {
       respondError(res, err);
     }
   }, "writeHandler");
-  router25.put("/:workspace/put/*", writeHandler);
-  router25.post("/:workspace/post/*", writeHandler);
-  router25.delete("/:workspace/delete/*", async (req, res) => {
+  router27.put("/:workspace/put/*", writeHandler);
+  router27.post("/:workspace/post/*", writeHandler);
+  router27.delete("/:workspace/delete/*", async (req, res) => {
     try {
       const ws = wsId(req.params.workspace);
       const projection = getProjection(ws);
@@ -154331,7 +154581,7 @@ function createLogicalFsRouter() {
       respondError(res, err);
     }
   });
-  router25.get("/:workspace/by-uuid/:uuid", (req, res) => {
+  router27.get("/:workspace/by-uuid/:uuid", (req, res) => {
     try {
       const ws = wsId(req.params.workspace);
       const index = getUuidIndex(ws);
@@ -154346,13 +154596,13 @@ function createLogicalFsRouter() {
       respondError(res, err);
     }
   });
-  return router25;
+  return router27;
 }
-var import_express28;
+var import_express30;
 var init_logicalFsRouter = __esm({
   "backend/src/routes/logicalFsRouter.ts"() {
     "use strict";
-    import_express28 = __toESM(require_express2(), 1);
+    import_express30 = __toESM(require_express2(), 1);
     init_types();
     init_ProjectionRegistry();
     init_UuidIndex();
@@ -154363,14 +154613,14 @@ var init_logicalFsRouter = __esm({
 });
 
 // backend/src/server.ts
-var import_express29 = __toESM(require_express2(), 1);
+var import_express31 = __toESM(require_express2(), 1);
 var import_cors2 = __toESM(require_lib3(), 1);
 var import_dotenv2 = __toESM(require_main(), 1);
 import fs5 from "fs";
 import path13 from "path";
 
 // backend/src/routes/index.ts
-var import_express25 = __toESM(require_express2(), 1);
+var import_express27 = __toESM(require_express2(), 1);
 
 // backend/src/routes/auth.routes.ts
 var import_express = __toESM(require_express2(), 1);
@@ -154548,7 +154798,7 @@ router.get("/api/auth/me", verifyToken, getCurrentUser);
 var auth_routes_default = router;
 
 // backend/src/routes/data-dictionary/index.ts
-var import_express15 = __toESM(require_express2(), 1);
+var import_express17 = __toESM(require_express2(), 1);
 
 // backend/src/routes/data-dictionary/package.routes.ts
 var import_express3 = __toESM(require_express2(), 1);
@@ -156731,13 +156981,13 @@ async function resolveProjectPrefixAtRef(ref) {
     logger.warn(`Could not resolve git repo root: ${e}`);
     return null;
   }
-  const candidates = [];
+  const candidates2 = [];
   const rel = path6.relative(repoRoot, config.dataDir);
   const primary = !rel || rel === "." || rel.startsWith("..") ? "" : rel.replace(/\\/g, "/") + "/";
-  candidates.push(primary);
-  if (primary !== "data-dictionaries/") candidates.push("data-dictionaries/");
-  if (primary !== "") candidates.push("");
-  for (const prefix of candidates) {
+  candidates2.push(primary);
+  if (primary !== "data-dictionaries/") candidates2.push("data-dictionaries/");
+  if (primary !== "") candidates2.push("");
+  for (const prefix of candidates2) {
     const marker21 = await readFileAtRef(ref, `${prefix}dico.config.json`);
     if (marker21 !== null) return prefix;
   }
@@ -160592,49 +160842,562 @@ router13.post("/api/revert", authorizeJwt(["admin" /* ADMIN */]), async (req, re
 });
 var publish_routes_default = router13;
 
-// backend/src/routes/data-dictionary/index.ts
+// backend/src/routes/data-dictionary/action.routes.ts
+var import_express15 = __toESM(require_express2(), 1);
+
+// backend/src/models/Action.ts
+var FLOW_STEP_KINDS = /* @__PURE__ */ new Set([
+  "assign",
+  "emitEvent",
+  "invokeAction",
+  "branch",
+  "wait",
+  "callExternal"
+]);
+
+// backend/src/services/actionService.ts
+init_fileOperations();
+init_uuid();
+init_logger();
+function checkInvokeRefs(steps, knownActionUuids, pathPrefix, errors) {
+  for (let i = 0; i < steps.length; i++) {
+    const step = steps[i];
+    const path14 = `${pathPrefix}[${i}]`;
+    if (step.kind === "invokeAction") {
+      if (!knownActionUuids.has(step.actionRef)) {
+        errors.push({
+          field: `${path14}.actionRef`,
+          message: `invokeAction references unknown action UUID '${step.actionRef}' at ${path14}`
+        });
+      }
+    } else if (step.kind === "branch") {
+      if (step.then && step.then.length > 0) {
+        checkInvokeRefs(step.then, knownActionUuids, `${path14}.then`, errors);
+      }
+      if (step.else && step.else.length > 0) {
+        checkInvokeRefs(step.else, knownActionUuids, `${path14}.else`, errors);
+      }
+    }
+  }
+}
+__name(checkInvokeRefs, "checkInvokeRefs");
+function validateAction(action, knownActionUuids) {
+  const errors = [];
+  if (!action.uuid) errors.push({ field: "uuid", message: "uuid is required" });
+  if (!action.name) errors.push({ field: "name", message: "name is required" });
+  if (!action.ownerRef) errors.push({ field: "ownerRef", message: "ownerRef is required" });
+  if (action.params && action.params.length > 0) {
+    const names = action.params.map((p) => p.name);
+    const unique = new Set(names);
+    if (unique.size !== names.length) {
+      errors.push({ field: "params", message: "Action params must have unique names" });
+    }
+    for (const p of action.params) {
+      if (!p.name) errors.push({ field: "params", message: "Each param must have a name" });
+      if (!p.type) errors.push({ field: "params", message: `Param '${p.name}' must have a type` });
+    }
+  }
+  if (action.flow) {
+    for (let i = 0; i < action.flow.length; i++) {
+      const step = action.flow[i];
+      if (!step.kind || !FLOW_STEP_KINDS.has(step.kind)) {
+        errors.push({
+          field: `flow[${i}].kind`,
+          message: `Invalid flow step kind '${step.kind}'. Must be one of: ${[...FLOW_STEP_KINDS].join(", ")}`
+        });
+      }
+    }
+    if (knownActionUuids !== void 0) {
+      checkInvokeRefs(action.flow, knownActionUuids, "flow", errors);
+    }
+  }
+  return errors;
+}
+__name(validateAction, "validateAction");
+var ActionService = class {
+  static {
+    __name(this, "ActionService");
+  }
+  /** List all actions. Optionally filter by ownerRef (entity UUID). */
+  async list(filters = {}) {
+    try {
+      if (filters.ownerRef) {
+        return await readActionsForEntity(filters.ownerRef);
+      }
+      const packages = await listPackages();
+      const result = [];
+      for (const pkg of packages) {
+        const model = await loadPackage(pkg);
+        result.push(...model.actions);
+      }
+      return result;
+    } catch (error48) {
+      logger.error(`Error listing actions: ${error48}`);
+      return [];
+    }
+  }
+  /** Get one action by UUID. */
+  async getByUuid(uuid3) {
+    try {
+      const owner = await findActionOwner(uuid3);
+      if (!owner) return null;
+      const model = await loadPackage(owner.packageName);
+      return model.actions.find((a) => a.uuid === uuid3) ?? null;
+    } catch (error48) {
+      logger.error(`Error getting action ${uuid3}: ${error48}`);
+      return null;
+    }
+  }
+  /**
+   * Create a new action. `ownerRef` must point to an existing entity UUID.
+   * Returns the created action or a validation error list.
+   */
+  async create(data) {
+    const action = {
+      uuid: data.uuid || generateUUID(),
+      name: data.name || "",
+      description: data.description,
+      ownerRef: data.ownerRef || "",
+      internal: data.internal ?? false,
+      params: data.params ?? [],
+      returns: data.returns,
+      flow: data.flow ?? [],
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const { packageModel, packageName } = await this.resolvePackageContext(action.ownerRef);
+    if (!packageModel || !packageName) {
+      return { errors: [{ field: "ownerRef", message: `Entity '${action.ownerRef}' not found in any package` }] };
+    }
+    const knownActionUuids = new Set(packageModel.ownership.actionByUuid.keys());
+    knownActionUuids.add(action.uuid);
+    const errors = validateAction(action, knownActionUuids);
+    if (errors.length > 0) return { errors };
+    const result = await writeAction(action, packageName);
+    if (!result.ok) {
+      return { errors: [{ field: "_", message: "Failed to persist action" }] };
+    }
+    return action;
+  }
+  /**
+   * Update an existing action.
+   */
+  async update(uuid3, data) {
+    const existing = await this.getByUuid(uuid3);
+    if (!existing) return null;
+    const updated = {
+      ...existing,
+      ...data,
+      uuid: uuid3,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const { packageModel, packageName } = await this.resolvePackageContext(updated.ownerRef);
+    if (!packageModel || !packageName) {
+      return { errors: [{ field: "ownerRef", message: `Entity '${updated.ownerRef}' not found in any package` }] };
+    }
+    const knownActionUuids = new Set(packageModel.ownership.actionByUuid.keys());
+    knownActionUuids.add(uuid3);
+    const errors = validateAction(updated, knownActionUuids);
+    if (errors.length > 0) return { errors };
+    const result = await writeAction(updated, packageName);
+    if (!result.ok) {
+      return { errors: [{ field: "_", message: "Failed to persist action" }] };
+    }
+    return updated;
+  }
+  /**
+   * Delete an action by UUID.
+   */
+  async delete(uuid3) {
+    const result = await deleteAction(uuid3);
+    return result.ok;
+  }
+  /** Find the package and loaded model for the entity with the given UUID. */
+  async resolvePackageContext(entityUuid) {
+    const packages = await listPackages();
+    for (const pkg of packages) {
+      const model = await loadPackage(pkg);
+      if (model.ownership.entityByUuid.has(entityUuid)) {
+        return { packageModel: model, packageName: pkg };
+      }
+    }
+    return { packageModel: null, packageName: null };
+  }
+};
+var actionService = new ActionService();
+
+// backend/src/controllers/actionController.ts
+init_logger();
+var listActionsForEntity = /* @__PURE__ */ __name(async (req, res) => {
+  try {
+    const actions = await actionService.list({ ownerRef: req.params.uuid });
+    res.json({ message: "Success", data: actions });
+  } catch (error48) {
+    logger.error("Error listing actions for entity", error48);
+    res.status(500).json({ message: "Error listing actions for entity", error: error48 });
+  }
+}, "listActionsForEntity");
+var getAction = /* @__PURE__ */ __name(async (req, res) => {
+  try {
+    const action = await actionService.getByUuid(req.params.uuid);
+    if (!action) return res.status(404).json({ message: "Action not found" });
+    res.json({ message: "Success", data: action });
+  } catch (error48) {
+    logger.error("Error fetching action", error48);
+    res.status(500).json({ message: "Error fetching action", error: error48 });
+  }
+}, "getAction");
+var createAction = /* @__PURE__ */ __name(async (req, res) => {
+  try {
+    const result = await actionService.create(req.body);
+    if ("errors" in result) {
+      return res.status(400).json({ message: "Failed to create action", errors: result.errors });
+    }
+    res.status(201).json({ message: "Action created successfully", data: result });
+  } catch (error48) {
+    logger.error("Error creating action", error48);
+    res.status(500).json({ message: "Error creating action", error: error48 });
+  }
+}, "createAction");
+var updateAction = /* @__PURE__ */ __name(async (req, res) => {
+  try {
+    const result = await actionService.update(req.params.uuid, req.body);
+    if (result === null) {
+      return res.status(404).json({ message: "Action not found" });
+    }
+    if ("errors" in result) {
+      return res.status(400).json({ message: "Failed to update action", errors: result.errors });
+    }
+    res.json({ message: "Action updated successfully", data: result });
+  } catch (error48) {
+    logger.error("Error updating action", error48);
+    res.status(500).json({ message: "Error updating action", error: error48 });
+  }
+}, "updateAction");
+var deleteAction2 = /* @__PURE__ */ __name(async (req, res) => {
+  try {
+    const ok2 = await actionService.delete(req.params.uuid);
+    if (!ok2) return res.status(404).json({ message: "Action not found" });
+    res.json({ message: "Action deleted successfully" });
+  } catch (error48) {
+    logger.error("Error deleting action", error48);
+    res.status(500).json({ message: "Error deleting action", error: error48 });
+  }
+}, "deleteAction");
+
+// backend/src/routes/data-dictionary/action.routes.ts
 var router14 = (0, import_express15.Router)();
-router14.use(package_routes_default);
-router14.use(relationship_routes_default);
-router14.use(entity_routes_default);
-router14.use(stereotype_routes_default);
-router14.use(case_routes_default);
-router14.use(rule_routes_default);
-router14.use(integrity_routes_default);
-router14.use(model_metadata_routes_default);
-router14.use(dico_config_routes_default);
-router14.use(diff_routes_default);
-router14.use(import_export_routes_default);
-router14.use(publish_routes_default);
-var data_dictionary_default = router14;
+router14.get("/api/entities/:uuid/actions", listActionsForEntity);
+router14.get("/api/actions/:uuid", getAction);
+router14.post("/api/actions", authorizeJwt(["admin" /* ADMIN */, "editor" /* EDITOR */]), createAction);
+router14.put("/api/actions/:uuid", authorizeJwt(["admin" /* ADMIN */, "editor" /* EDITOR */]), updateAction);
+router14.delete("/api/actions/:uuid", authorizeJwt(["admin" /* ADMIN */]), deleteAction2);
+var action_routes_default = router14;
+
+// backend/src/routes/data-dictionary/state-machine.routes.ts
+var import_express16 = __toESM(require_express2(), 1);
+
+// backend/src/services/stateMachineService.ts
+init_fileOperations();
+init_uuid();
+init_logger();
+function validateStateMachine(sm, knownActionUuids, ownerAttributes) {
+  const errors = [];
+  if (!sm.uuid) errors.push({ field: "uuid", message: "uuid is required" });
+  if (!sm.name) errors.push({ field: "name", message: "name is required" });
+  if (!sm.ownerRef) errors.push({ field: "ownerRef", message: "ownerRef is required" });
+  if (!sm.initialState) errors.push({ field: "initialState", message: "initialState is required" });
+  if (!sm.states || sm.states.length === 0) {
+    errors.push({ field: "states", message: "At least one state is required" });
+  }
+  if (sm.stateAttribute && ownerAttributes !== void 0) {
+    if (!ownerAttributes.includes(sm.stateAttribute)) {
+      errors.push({
+        field: "stateAttribute",
+        message: `stateAttribute '${sm.stateAttribute}' is not an attribute on the owner entity`
+      });
+    }
+  }
+  if (sm.states && sm.states.length > 0 && sm.initialState) {
+    const stateNames = new Set(sm.states.map((s) => s.name));
+    if (stateNames.size !== sm.states.length) {
+      errors.push({ field: "states", message: "State names must be unique within a state machine" });
+    }
+    if (!stateNames.has(sm.initialState)) {
+      errors.push({ field: "initialState", message: `initialState '${sm.initialState}' is not a declared state` });
+    }
+    if (sm.transitions) {
+      const transitionUuids = /* @__PURE__ */ new Set();
+      for (let i = 0; i < sm.transitions.length; i++) {
+        const t = sm.transitions[i];
+        if (!t.uuid) {
+          errors.push({ field: `transitions[${i}].uuid`, message: "Transition uuid is required" });
+        } else if (transitionUuids.has(t.uuid)) {
+          errors.push({ field: `transitions[${i}].uuid`, message: `Duplicate transition uuid '${t.uuid}'` });
+        } else {
+          transitionUuids.add(t.uuid);
+        }
+        if (!t.from) {
+          errors.push({ field: `transitions[${i}].from`, message: "Transition from is required" });
+        } else if (t.from !== "*" && !stateNames.has(t.from)) {
+          errors.push({
+            field: `transitions[${i}].from`,
+            message: `Transition from '${t.from}' is not a declared state (use "*" for wildcard)`
+          });
+        }
+        if (!t.to) {
+          errors.push({ field: `transitions[${i}].to`, message: "Transition to is required" });
+        } else if (!stateNames.has(t.to)) {
+          errors.push({
+            field: `transitions[${i}].to`,
+            message: `Transition to '${t.to}' is not a declared state`
+          });
+        }
+        if (!t.on) {
+          errors.push({ field: `transitions[${i}].on`, message: "Transition event (on) is required" });
+        }
+        if (knownActionUuids !== void 0 && t.invoke) {
+          for (const actionUuid of t.invoke) {
+            if (!knownActionUuids.has(actionUuid)) {
+              errors.push({
+                field: `transitions[${i}].invoke`,
+                message: `invoke references unknown action UUID '${actionUuid}' in transition '${t.uuid}'`
+              });
+            }
+          }
+        }
+      }
+    }
+  }
+  return errors;
+}
+__name(validateStateMachine, "validateStateMachine");
+var StateMachineService = class {
+  static {
+    __name(this, "StateMachineService");
+  }
+  /** List all state machines. Optionally filter by ownerRef (entity UUID). */
+  async list(filters = {}) {
+    try {
+      if (filters.ownerRef) {
+        return await readStateMachinesForEntity(filters.ownerRef);
+      }
+      const packages = await listPackages();
+      const result = [];
+      for (const pkg of packages) {
+        const model = await loadPackage(pkg);
+        result.push(...model.stateMachines);
+      }
+      return result;
+    } catch (error48) {
+      logger.error(`Error listing state machines: ${error48}`);
+      return [];
+    }
+  }
+  /** Get one state machine by UUID. */
+  async getByUuid(uuid3) {
+    try {
+      const owner = await findStateMachineOwner(uuid3);
+      if (!owner) return null;
+      const model = await loadPackage(owner.packageName);
+      return model.stateMachines.find((m) => m.uuid === uuid3) ?? null;
+    } catch (error48) {
+      logger.error(`Error getting stateMachine ${uuid3}: ${error48}`);
+      return null;
+    }
+  }
+  /**
+   * Create a new state machine.
+   */
+  async create(data) {
+    const sm = {
+      uuid: data.uuid || generateUUID(),
+      name: data.name || "",
+      description: data.description,
+      ownerRef: data.ownerRef || "",
+      stateAttribute: data.stateAttribute,
+      initialState: data.initialState || "",
+      states: data.states ?? [],
+      transitions: data.transitions ?? [],
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const { packageModel, packageName } = await this.resolvePackageContext(sm.ownerRef);
+    if (!packageModel || !packageName) {
+      return { errors: [{ field: "ownerRef", message: `Entity '${sm.ownerRef}' not found in any package` }] };
+    }
+    const knownActionUuids = new Set(packageModel.ownership.actionByUuid.keys());
+    const ownerEntity = packageModel.entities.find((e) => e.uuid === sm.ownerRef);
+    const ownerAttributes = ownerEntity?.attributes?.map((a) => a.name) ?? [];
+    const errors = validateStateMachine(sm, knownActionUuids, ownerAttributes);
+    if (errors.length > 0) return { errors };
+    const result = await writeStateMachine(sm, packageName);
+    if (!result.ok) {
+      return { errors: [{ field: "_", message: "Failed to persist state machine" }] };
+    }
+    return sm;
+  }
+  /**
+   * Update an existing state machine.
+   */
+  async update(uuid3, data) {
+    const existing = await this.getByUuid(uuid3);
+    if (!existing) return null;
+    const updated = {
+      ...existing,
+      ...data,
+      uuid: uuid3,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const { packageModel, packageName } = await this.resolvePackageContext(updated.ownerRef);
+    if (!packageModel || !packageName) {
+      return { errors: [{ field: "ownerRef", message: `Entity '${updated.ownerRef}' not found in any package` }] };
+    }
+    const knownActionUuids = new Set(packageModel.ownership.actionByUuid.keys());
+    const ownerEntity = packageModel.entities.find((e) => e.uuid === updated.ownerRef);
+    const ownerAttributes = ownerEntity?.attributes?.map((a) => a.name) ?? [];
+    const errors = validateStateMachine(updated, knownActionUuids, ownerAttributes);
+    if (errors.length > 0) return { errors };
+    const result = await writeStateMachine(updated, packageName);
+    if (!result.ok) {
+      return { errors: [{ field: "_", message: "Failed to persist state machine" }] };
+    }
+    return updated;
+  }
+  /**
+   * Delete a state machine by UUID.
+   */
+  async delete(uuid3) {
+    const result = await deleteStateMachine(uuid3);
+    return result.ok;
+  }
+  /** Find the package and loaded model for the entity with the given UUID. */
+  async resolvePackageContext(entityUuid) {
+    const packages = await listPackages();
+    for (const pkg of packages) {
+      const model = await loadPackage(pkg);
+      if (model.ownership.entityByUuid.has(entityUuid)) {
+        return { packageModel: model, packageName: pkg };
+      }
+    }
+    return { packageModel: null, packageName: null };
+  }
+};
+var stateMachineService = new StateMachineService();
+
+// backend/src/controllers/stateMachineController.ts
+init_logger();
+var listStateMachinesForEntity = /* @__PURE__ */ __name(async (req, res) => {
+  try {
+    const machines = await stateMachineService.list({ ownerRef: req.params.uuid });
+    res.json({ message: "Success", data: machines });
+  } catch (error48) {
+    logger.error("Error listing state machines for entity", error48);
+    res.status(500).json({ message: "Error listing state machines for entity", error: error48 });
+  }
+}, "listStateMachinesForEntity");
+var getStateMachine = /* @__PURE__ */ __name(async (req, res) => {
+  try {
+    const sm = await stateMachineService.getByUuid(req.params.uuid);
+    if (!sm) return res.status(404).json({ message: "State machine not found" });
+    res.json({ message: "Success", data: sm });
+  } catch (error48) {
+    logger.error("Error fetching state machine", error48);
+    res.status(500).json({ message: "Error fetching state machine", error: error48 });
+  }
+}, "getStateMachine");
+var createStateMachine = /* @__PURE__ */ __name(async (req, res) => {
+  try {
+    const result = await stateMachineService.create(req.body);
+    if ("errors" in result) {
+      return res.status(400).json({ message: "Failed to create state machine", errors: result.errors });
+    }
+    res.status(201).json({ message: "State machine created successfully", data: result });
+  } catch (error48) {
+    logger.error("Error creating state machine", error48);
+    res.status(500).json({ message: "Error creating state machine", error: error48 });
+  }
+}, "createStateMachine");
+var updateStateMachine = /* @__PURE__ */ __name(async (req, res) => {
+  try {
+    const result = await stateMachineService.update(req.params.uuid, req.body);
+    if (result === null) {
+      return res.status(404).json({ message: "State machine not found" });
+    }
+    if ("errors" in result) {
+      return res.status(400).json({ message: "Failed to update state machine", errors: result.errors });
+    }
+    res.json({ message: "State machine updated successfully", data: result });
+  } catch (error48) {
+    logger.error("Error updating state machine", error48);
+    res.status(500).json({ message: "Error updating state machine", error: error48 });
+  }
+}, "updateStateMachine");
+var deleteStateMachine2 = /* @__PURE__ */ __name(async (req, res) => {
+  try {
+    const ok2 = await stateMachineService.delete(req.params.uuid);
+    if (!ok2) return res.status(404).json({ message: "State machine not found" });
+    res.json({ message: "State machine deleted successfully" });
+  } catch (error48) {
+    logger.error("Error deleting state machine", error48);
+    res.status(500).json({ message: "Error deleting state machine", error: error48 });
+  }
+}, "deleteStateMachine");
+
+// backend/src/routes/data-dictionary/state-machine.routes.ts
+var router15 = (0, import_express16.Router)();
+router15.get("/api/entities/:uuid/state-machines", listStateMachinesForEntity);
+router15.get("/api/state-machines/:uuid", getStateMachine);
+router15.post("/api/state-machines", authorizeJwt(["admin" /* ADMIN */, "editor" /* EDITOR */]), createStateMachine);
+router15.put("/api/state-machines/:uuid", authorizeJwt(["admin" /* ADMIN */, "editor" /* EDITOR */]), updateStateMachine);
+router15.delete("/api/state-machines/:uuid", authorizeJwt(["admin" /* ADMIN */]), deleteStateMachine2);
+var state_machine_routes_default = router15;
+
+// backend/src/routes/data-dictionary/index.ts
+var router16 = (0, import_express17.Router)();
+router16.use(package_routes_default);
+router16.use(relationship_routes_default);
+router16.use(entity_routes_default);
+router16.use(stereotype_routes_default);
+router16.use(case_routes_default);
+router16.use(rule_routes_default);
+router16.use(integrity_routes_default);
+router16.use(model_metadata_routes_default);
+router16.use(dico_config_routes_default);
+router16.use(diff_routes_default);
+router16.use(import_export_routes_default);
+router16.use(publish_routes_default);
+router16.use(action_routes_default);
+router16.use(state_machine_routes_default);
+var data_dictionary_default = router16;
 
 // backend/src/routes/ai/index.ts
-var import_express20 = __toESM(require_express2(), 1);
-var router19 = (0, import_express20.Router)();
+var import_express22 = __toESM(require_express2(), 1);
+var router21 = (0, import_express22.Router)();
 (async () => {
   try {
     const chatRoutes = (await Promise.resolve().then(() => (init_chat_routes(), chat_routes_exports))).default;
     const conversationRoutes = (await Promise.resolve().then(() => (init_conversation_routes(), conversation_routes_exports))).default;
     const promptRoutes = (await Promise.resolve().then(() => (init_prompt_routes(), prompt_routes_exports))).default;
     const mcpRoutes = (await Promise.resolve().then(() => (init_mcp_routes(), mcp_routes_exports))).default;
-    router19.use(chatRoutes);
-    router19.use(conversationRoutes);
-    router19.use(promptRoutes);
-    router19.use(mcpRoutes);
+    router21.use(chatRoutes);
+    router21.use(conversationRoutes);
+    router21.use(promptRoutes);
+    router21.use(mcpRoutes);
   } catch {
   }
 })();
-var ai_default = router19;
+var ai_default = router21;
 
 // backend/src/routes/search.routes.ts
-var import_express21 = __toESM(require_express2(), 1);
-var router20 = (0, import_express21.Router)();
-router20.get("/api/entities/flat", getFlatEntitiesAndAttributes);
-router20.get("/api/search", searchEntities);
-var search_routes_default = router20;
+var import_express23 = __toESM(require_express2(), 1);
+var router22 = (0, import_express23.Router)();
+router22.get("/api/entities/flat", getFlatEntitiesAndAttributes);
+router22.get("/api/search", searchEntities);
+var search_routes_default = router22;
 
 // backend/src/routes/visualization.routes.ts
-var import_express22 = __toESM(require_express2(), 1);
+var import_express24 = __toESM(require_express2(), 1);
 
 // backend/src/controllers/diagramController.ts
 init_diagramService();
@@ -160763,21 +161526,21 @@ var DiagramController = class {
 var diagramController = new DiagramController();
 
 // backend/src/routes/visualization.routes.ts
-var router21 = (0, import_express22.Router)();
-router21.get("/api/graph/:service", getGraphData);
-router21.get("/api/entities/:uuid/impact", getImpactAnalysis);
-router21.get("/api/entities/:uuid/lineage", getLineage);
-router21.get("/api/diagrams", diagramController.listDiagramLayouts.bind(diagramController));
-router21.post("/api/diagrams", authorizeJwt(["admin" /* ADMIN */, "editor" /* EDITOR */]), diagramController.saveDiagramLayout.bind(diagramController));
-router21.get("/api/diagrams/:id", diagramController.loadDiagramLayout.bind(diagramController));
-router21.put("/api/diagrams/:id", authorizeJwt(["admin" /* ADMIN */, "editor" /* EDITOR */]), diagramController.updateDiagramLayout.bind(diagramController));
-router21.delete("/api/diagrams/:id", authorizeJwt(["admin" /* ADMIN */]), diagramController.deleteDiagramLayout.bind(diagramController));
-var visualization_routes_default = router21;
+var router23 = (0, import_express24.Router)();
+router23.get("/api/graph/:service", getGraphData);
+router23.get("/api/entities/:uuid/impact", getImpactAnalysis);
+router23.get("/api/entities/:uuid/lineage", getLineage);
+router23.get("/api/diagrams", diagramController.listDiagramLayouts.bind(diagramController));
+router23.post("/api/diagrams", authorizeJwt(["admin" /* ADMIN */, "editor" /* EDITOR */]), diagramController.saveDiagramLayout.bind(diagramController));
+router23.get("/api/diagrams/:id", diagramController.loadDiagramLayout.bind(diagramController));
+router23.put("/api/diagrams/:id", authorizeJwt(["admin" /* ADMIN */, "editor" /* EDITOR */]), diagramController.updateDiagramLayout.bind(diagramController));
+router23.delete("/api/diagrams/:id", authorizeJwt(["admin" /* ADMIN */]), diagramController.deleteDiagramLayout.bind(diagramController));
+var visualization_routes_default = router23;
 
 // backend/src/routes/status.routes.ts
-var import_express23 = __toESM(require_express2(), 1);
-var router22 = (0, import_express23.Router)();
-router22.get("/api/status", (req, res) => {
+var import_express25 = __toESM(require_express2(), 1);
+var router24 = (0, import_express25.Router)();
+router24.get("/api/status", (req, res) => {
   const profile = process.env.PROFILE || "local";
   res.json({
     status: "operational",
@@ -160787,16 +161550,16 @@ router22.get("/api/status", (req, res) => {
     auth: profile === "local" ? "none" : "jwt"
   });
 });
-var status_routes_default = router22;
+var status_routes_default = router24;
 
 // backend/src/routes/project.routes.ts
-var import_express24 = __toESM(require_express2(), 1);
+var import_express26 = __toESM(require_express2(), 1);
 init_config();
 import fs2 from "fs";
 import path9 from "path";
 import os2 from "os";
-var router23 = (0, import_express24.Router)();
-router23.get("/api/filesystem/browse", (req, res) => {
+var router25 = (0, import_express26.Router)();
+router25.get("/api/filesystem/browse", (req, res) => {
   if (config.profile !== "local") {
     return res.status(403).json({ message: "Filesystem browsing is only available in local mode" });
   }
@@ -160821,7 +161584,7 @@ router23.get("/api/filesystem/browse", (req, res) => {
     res.status(500).json({ message: `Failed to read directory: ${e}` });
   }
 });
-router23.get("/api/project", (req, res) => {
+router25.get("/api/project", (req, res) => {
   const dataDir = config.dataDir;
   const isOpen = fs2.existsSync(path9.join(dataDir, "dico.config.json"));
   res.json({
@@ -160833,7 +161596,7 @@ router23.get("/api/project", (req, res) => {
     }
   });
 });
-router23.get("/api/project/status", async (_req, res) => {
+router25.get("/api/project/status", async (_req, res) => {
   try {
     const { versionService: versionService2 } = await Promise.resolve().then(() => (init_versionService(), versionService_exports));
     const status = await versionService2.getWorkingTreeStatus();
@@ -160842,7 +161605,7 @@ router23.get("/api/project/status", async (_req, res) => {
     res.status(500).json({ message: `Failed to read project status: ${e}` });
   }
 });
-router23.post("/api/project/open", authorizeJwt(["admin" /* ADMIN */]), (req, res) => {
+router25.post("/api/project/open", authorizeJwt(["admin" /* ADMIN */]), (req, res) => {
   if (config.profile !== "local") {
     return res.status(403).json({ message: "Project switching is only available in local mode" });
   }
@@ -160865,7 +161628,7 @@ router23.post("/api/project/open", authorizeJwt(["admin" /* ADMIN */]), (req, re
   if (roots) roots.set("dictionaries", dataDir);
   res.json({ message: `Project opened: ${dataDir}`, data: { path: dataDir, name: path9.basename(path9.dirname(dataDir)) } });
 });
-router23.post("/api/project/close", authorizeJwt(["admin" /* ADMIN */]), (req, res) => {
+router25.post("/api/project/close", authorizeJwt(["admin" /* ADMIN */]), (req, res) => {
   if (config.profile !== "local") {
     return res.status(403).json({ message: "Project switching is only available in local mode" });
   }
@@ -160876,7 +161639,7 @@ router23.post("/api/project/close", authorizeJwt(["admin" /* ADMIN */]), (req, r
   if (roots) roots.set("dictionaries", emptyDir);
   res.json({ message: "Project closed" });
 });
-router23.post("/api/project/init", authorizeJwt(["admin" /* ADMIN */]), (req, res) => {
+router25.post("/api/project/init", authorizeJwt(["admin" /* ADMIN */]), (req, res) => {
   if (config.profile !== "local") {
     return res.status(403).json({ message: "Project initialization is only available in local mode" });
   }
@@ -160905,18 +161668,18 @@ router23.post("/api/project/init", authorizeJwt(["admin" /* ADMIN */]), (req, re
     res.status(500).json({ message: `Failed to initialize project: ${e}` });
   }
 });
-var project_routes_default = router23;
+var project_routes_default = router25;
 
 // backend/src/routes/index.ts
-var router24 = (0, import_express25.Router)();
-router24.use(status_routes_default);
-router24.use(auth_routes_default);
-router24.use(search_routes_default);
-router24.use(visualization_routes_default);
-router24.use(project_routes_default);
-router24.use(data_dictionary_default);
-router24.use(ai_default);
-var routes_default = router24;
+var router26 = (0, import_express27.Router)();
+router26.use(status_routes_default);
+router26.use(auth_routes_default);
+router26.use(search_routes_default);
+router26.use(visualization_routes_default);
+router26.use(project_routes_default);
+router26.use(data_dictionary_default);
+router26.use(ai_default);
+var routes_default = router26;
 
 // backend/src/server.ts
 init_logger();
@@ -161444,7 +162207,7 @@ __name(seedFromDisk, "seedFromDisk");
 // backend/src/server.ts
 init_mcpClientRegistry();
 import_dotenv2.default.config();
-var app = (0, import_express29.default)();
+var app = (0, import_express31.default)();
 var port = config.port;
 app.use((0, import_cors2.default)());
 app.use((req, res, next) => {
@@ -161461,7 +162224,7 @@ app.use((req, res, next) => {
   });
   next();
 });
-app.use(import_express29.default.json());
+app.use(import_express31.default.json());
 if (!config.isProduction) {
   app.get("/", (req, res) => {
     res.json({ message: "Welcome to the Data Dictionary Management System API" });
@@ -161554,8 +162317,8 @@ mountFrameworkRoutes().catch((err) => {
   logger.warn(`Failed to mount framework routes: ${err}`);
 });
 if (config.isProduction) {
-  const getServerDir = new Function("return new URL(import.meta.url).pathname");
-  const serverDir = path13.dirname(getServerDir());
+  const serverUrl = eval("import.meta.url");
+  const serverDir = path13.dirname(new URL(serverUrl).pathname);
   const candidates = [
     path13.join(serverDir, "..", "..", "frontend", "dist"),
     // npm package (server is at backend/src/)
@@ -161574,7 +162337,7 @@ if (config.isProduction) {
     }
   });
   if (publicDir) {
-    app.use(import_express29.default.static(publicDir));
+    app.use(import_express31.default.static(publicDir));
     app.get("*", (req, res, next) => {
       if (req.path.startsWith("/api") || req.path.startsWith("/fs") || req.path.startsWith("/api-docs") || req.path.includes(".")) {
         return next();