@hamak/smart-data-dico 1.12.6 → 1.13.0

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 router28(req, res, next) {
-        router28.handle(req, res, next);
-      }
-      __name(router28, "router");
-      setPrototypeOf(router28, proto);
-      router28.params = {};
-      router28._params = [];
-      router28.caseSensitive = opts.caseSensitive;
-      router28.mergeParams = opts.mergeParams;
-      router28.strict = opts.strict;
-      router28.stack = [];
-      return router28;
+      function router29(req, res, next) {
+        router29.handle(req, res, next);
+      }
+      __name(router29, "router");
+      setPrototypeOf(router29, proto);
+      router29.params = {};
+      router29._params = [];
+      router29.caseSensitive = opts.caseSensitive;
+      router29.mergeParams = opts.mergeParams;
+      router29.strict = opts.strict;
+      router29.stack = [];
+      return router29;
     };
     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 Router32 = require_router();
+    var Router33 = 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 Router32({
+        this._router = new Router33({
           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 router28 = this._router;
+      var router29 = this._router;
       var done = callback || finalhandler(req, res, {
         env: this.get("env"),
         onerror: logerror.bind(this)
       });
-      if (!router28) {
+      if (!router29) {
         debug2("no routes defined on app");
         done();
         return;
       }
-      router28.handle(req, res, done);
+      router29.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 router28 = this._router;
+      var router29 = this._router;
       fns.forEach(function(fn2) {
         if (!fn2 || !fn2.handle || !fn2.set) {
-          return router28.use(path14, fn2);
+          return router29.use(path14, fn2);
         }
         debug2(".use app under %s", path14);
         fn2.mountpath = path14;
         fn2.parent = this;
-        router28.use(path14, /* @__PURE__ */ __name(function mounted_app(req, res, next) {
+        router29.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 Router32 = require_router();
+    var Router33 = 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 = Router32;
+    exports.Router = Router33;
     exports.json = bodyParser2.json;
     exports.query = require_query();
     exports.raw = bodyParser2.raw;
@@ -43798,7 +43798,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 router28 = (0, import_express2.Router)();
+  const router29 = (0, import_express2.Router)();
   const log2 = /* @__PURE__ */ __name((message, ...args) => {
     if (debug2) {
       console.log(`[git-routes] ${message}`, ...args);
@@ -43812,21 +43812,21 @@ function createGitRoutes(config3) {
   const extractPath = /* @__PURE__ */ __name((req) => {
     return req.params[0] || "";
   }, "extractPath");
-  router28.get("/:workspaceId/status/*", asyncHandler(async (req, res) => {
+  router29.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);
   }));
-  router28.get("/:workspaceId/branches/*", asyncHandler(async (req, res) => {
+  router29.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);
   }));
-  router28.post("/:workspaceId/checkout/*", asyncHandler(async (req, res) => {
+  router29.post("/:workspaceId/checkout/*", asyncHandler(async (req, res) => {
     const { workspaceId } = req.params;
     const path14 = extractPath(req);
     const { branch, create } = req.body;
@@ -43840,7 +43840,7 @@ function createGitRoutes(config3) {
     await gitService.checkout(workspaceId, path14, branch, create);
     res.json({ success: true, branch });
   }));
-  router28.post("/:workspaceId/branch/*", asyncHandler(async (req, res) => {
+  router29.post("/:workspaceId/branch/*", asyncHandler(async (req, res) => {
     const { workspaceId } = req.params;
     const path14 = extractPath(req);
     const { branch, startPoint } = req.body;
@@ -43854,7 +43854,7 @@ function createGitRoutes(config3) {
     await gitService.createBranch(workspaceId, path14, branch, startPoint);
     res.json({ success: true, branch });
   }));
-  router28.post("/:workspaceId/stage/*", asyncHandler(async (req, res) => {
+  router29.post("/:workspaceId/stage/*", asyncHandler(async (req, res) => {
     const { workspaceId } = req.params;
     const path14 = extractPath(req);
     const { files } = req.body;
@@ -43862,7 +43862,7 @@ function createGitRoutes(config3) {
     await gitService.stage(workspaceId, path14, files);
     res.json({ success: true });
   }));
-  router28.post("/:workspaceId/unstage/*", asyncHandler(async (req, res) => {
+  router29.post("/:workspaceId/unstage/*", asyncHandler(async (req, res) => {
     const { workspaceId } = req.params;
     const path14 = extractPath(req);
     const { files } = req.body;
@@ -43870,7 +43870,7 @@ function createGitRoutes(config3) {
     await gitService.unstage(workspaceId, path14, files);
     res.json({ success: true });
   }));
-  router28.post("/:workspaceId/commit/*", asyncHandler(async (req, res) => {
+  router29.post("/:workspaceId/commit/*", asyncHandler(async (req, res) => {
     const { workspaceId } = req.params;
     const path14 = extractPath(req);
     const { message } = req.body;
@@ -43884,7 +43884,7 @@ function createGitRoutes(config3) {
     const result = await gitService.commit(workspaceId, path14, message);
     res.json(result);
   }));
-  router28.post("/:workspaceId/pull/*", asyncHandler(async (req, res) => {
+  router29.post("/:workspaceId/pull/*", asyncHandler(async (req, res) => {
     const { workspaceId } = req.params;
     const path14 = extractPath(req);
     const { remote, branch } = req.body;
@@ -43892,7 +43892,7 @@ function createGitRoutes(config3) {
     const result = await gitService.pull(workspaceId, path14, remote, branch);
     res.json(result);
   }));
-  router28.post("/:workspaceId/push/*", asyncHandler(async (req, res) => {
+  router29.post("/:workspaceId/push/*", asyncHandler(async (req, res) => {
     const { workspaceId } = req.params;
     const path14 = extractPath(req);
     const { remote, branch } = req.body;
@@ -43900,7 +43900,7 @@ function createGitRoutes(config3) {
     await gitService.push(workspaceId, path14, remote, branch);
     res.json({ success: true });
   }));
-  router28.post("/:workspaceId/fetch/*", asyncHandler(async (req, res) => {
+  router29.post("/:workspaceId/fetch/*", asyncHandler(async (req, res) => {
     const { workspaceId } = req.params;
     const path14 = extractPath(req);
     const { remote } = req.body;
@@ -43908,7 +43908,7 @@ function createGitRoutes(config3) {
     await gitService.fetch(workspaceId, path14, remote);
     res.json({ success: true });
   }));
-  router28.get("/:workspaceId/diff/*", asyncHandler(async (req, res) => {
+  router29.get("/:workspaceId/diff/*", asyncHandler(async (req, res) => {
     const { workspaceId } = req.params;
     const path14 = extractPath(req);
     const { file: file2, staged } = req.query;
@@ -43916,7 +43916,7 @@ function createGitRoutes(config3) {
     const result = await gitService.diff(workspaceId, path14, file2, staged === "true");
     res.json(result);
   }));
-  router28.get("/:workspaceId/log/*", asyncHandler(async (req, res) => {
+  router29.get("/:workspaceId/log/*", asyncHandler(async (req, res) => {
     const { workspaceId } = req.params;
     const path14 = extractPath(req);
     const { maxCount, file: file2 } = req.query;
@@ -43924,21 +43924,21 @@ function createGitRoutes(config3) {
     const result = await gitService.log(workspaceId, path14, maxCount ? parseInt(maxCount, 10) : void 0, file2);
     res.json(result);
   }));
-  router28.get("/:workspaceId/is-repo/*", asyncHandler(async (req, res) => {
+  router29.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 });
   }));
-  router28.get("/:workspaceId/repo-root/*", asyncHandler(async (req, res) => {
+  router29.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 router28;
+  return router29;
 }
 function gitErrorHandler(err, req, res, next) {
   console.error("[git-routes] Error:", err);
@@ -44196,10 +44196,12 @@ __export(fileOperations_exports, {
   deleteAction: () => deleteAction,
   deleteCaseFile: () => deleteCaseFile,
   deleteEntityFile: () => deleteEntityFile,
+  deleteEvent: () => deleteEvent,
   deleteStateMachine: () => deleteStateMachine,
   ensureDirectoryStructure: () => ensureDirectoryStructure,
   ensurePackageDirectoryStructure: () => ensurePackageDirectoryStructure,
   findActionOwner: () => findActionOwner,
+  findEventOwner: () => findEventOwner,
   findStateMachineOwner: () => findStateMachineOwner,
   getAllRelationships: () => getAllRelationships,
   getPackagePath: () => getPackagePath,
@@ -44220,11 +44222,14 @@ __export(fileOperations_exports, {
   normalizeEntityMetadata: () => normalizeEntityMetadata,
   parseSectionsFromString: () => parseSectionsFromString,
   readActionsForEntity: () => readActionsForEntity,
+  readActionsForPackage: () => readActionsForPackage,
   readCaseFile: () => readCaseFile,
   readCaseRules: () => readCaseRules,
   readComments: () => readComments,
   readEntityFile: () => readEntityFile,
   readEntityRules: () => readEntityRules,
+  readEventsForEntity: () => readEventsForEntity,
+  readEventsForPackage: () => readEventsForPackage,
   readGlobalRules: () => readGlobalRules,
   readPackageRules: () => readPackageRules,
   readRelationshipsFile: () => readRelationshipsFile,
@@ -44236,6 +44241,7 @@ __export(fileOperations_exports, {
   writeDictionaryMetadata: () => writeDictionaryMetadata,
   writeEntityFile: () => writeEntityFile,
   writeEntityRules: () => writeEntityRules,
+  writeEvent: () => writeEvent,
   writeGlobalRules: () => writeGlobalRules,
   writePackageRules: () => writePackageRules,
   writeRelationshipsFile: () => writeRelationshipsFile,
@@ -44374,11 +44380,11 @@ async function listMicroservices() {
 function parseSectionsFromString(raw, label, filename) {
   try {
     const parsed = import_yaml.default.parse(raw);
-    if (!parsed) return { entities: [], relationships: [], rules: [], cases: [], actions: [], stateMachines: [] };
+    if (!parsed) return { entities: [], relationships: [], rules: [], cases: [], actions: [], stateMachines: [], events: [] };
     if (typeof parsed === "object" && !Array.isArray(parsed) && typeof parsed.uuid === "string" && Array.isArray(parsed.attributes)) {
-      return { entities: [parsed], relationships: [], rules: [], cases: [], actions: [], stateMachines: [] };
+      return { entities: [parsed], relationships: [], rules: [], cases: [], actions: [], stateMachines: [], events: [] };
     }
-    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)) {
+    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 || "events" in parsed)) {
       let cases = [];
       if (Array.isArray(parsed.cases)) {
         cases = parsed.cases;
@@ -44392,27 +44398,28 @@ function parseSectionsFromString(raw, label, filename) {
         rules: Array.isArray(parsed.rules) ? parsed.rules : [],
         cases,
         actions: Array.isArray(parsed.actions) ? parsed.actions : [],
-        stateMachines: Array.isArray(parsed.stateMachines) ? parsed.stateMachines : []
+        stateMachines: Array.isArray(parsed.stateMachines) ? parsed.stateMachines : [],
+        events: Array.isArray(parsed.events) ? parsed.events : []
       };
     }
     if (Array.isArray(parsed) && filename) {
       if (filename === "relationships.yaml") {
-        return { entities: [], relationships: parsed, rules: [], cases: [], actions: [], stateMachines: [] };
+        return { entities: [], relationships: parsed, rules: [], cases: [], actions: [], stateMachines: [], events: [] };
       }
       if (filename === "rules.yaml" || filename.endsWith(".rules.yaml")) {
-        return { entities: [], relationships: [], rules: parsed, cases: [], actions: [], stateMachines: [] };
+        return { entities: [], relationships: [], rules: parsed, cases: [], actions: [], stateMachines: [], events: [] };
       }
     }
-    return { entities: [], relationships: [], rules: [], cases: [], actions: [], stateMachines: [] };
+    return { entities: [], relationships: [], rules: [], cases: [], actions: [], stateMachines: [], events: [] };
   } catch (e) {
     logger.warn(`Failed to parse YAML: ${label}: ${e}`);
-    return { entities: [], relationships: [], rules: [], cases: [], actions: [], stateMachines: [] };
+    return { entities: [], relationships: [], rules: [], cases: [], actions: [], stateMachines: [], events: [] };
   }
 }
 async function parseSectionsFromStorage(p, label) {
   const content = await readOrNull(p);
   if (content === null) {
-    return { entities: [], relationships: [], rules: [], cases: [], actions: [], stateMachines: [] };
+    return { entities: [], relationships: [], rules: [], cases: [], actions: [], stateMachines: [], events: [] };
   }
   const filename = path4.basename(String(p));
   return parseSectionsFromString(content, label, filename);
@@ -44426,6 +44433,7 @@ function mergePackageSections(packageName, parsed) {
     cases: [],
     actions: [],
     stateMachines: [],
+    events: [],
     ownership: {
       entityByName: /* @__PURE__ */ new Map(),
       entityByUuid: /* @__PURE__ */ new Map(),
@@ -44434,6 +44442,8 @@ function mergePackageSections(packageName, parsed) {
       caseByUuid: /* @__PURE__ */ new Map(),
       actionByUuid: /* @__PURE__ */ new Map(),
       stateMachineByUuid: /* @__PURE__ */ new Map(),
+      eventByUuid: /* @__PURE__ */ new Map(),
+      eventByName: /* @__PURE__ */ new Map(),
       actionByOwnerAndName: /* @__PURE__ */ new Map(),
       stateMachineByOwnerAndName: /* @__PURE__ */ new Map()
     }
@@ -44529,6 +44539,24 @@ function mergePackageSections(packageName, parsed) {
       model.ownership.stateMachineByOwnerAndName.set(ownerNameKey, label);
       model.stateMachines.push(sm);
     }
+    for (const event of sections.events || []) {
+      if (!event?.uuid || !event?.name) continue;
+      const byUuid = model.ownership.eventByUuid.get(event.uuid);
+      if (byUuid) {
+        throw new Error(
+          `Duplicate event uuid '${event.uuid}' in package '${packageName}': ${byUuid} and ${label}`
+        );
+      }
+      const byName = model.ownership.eventByName.get(event.name);
+      if (byName) {
+        throw new Error(
+          `Duplicate event name '${event.name}' in package '${packageName}': ${byName} and ${label}`
+        );
+      }
+      model.ownership.eventByUuid.set(event.uuid, label);
+      model.ownership.eventByName.set(event.name, label);
+      model.events.push(event);
+    }
   }
   return model;
 }
@@ -44543,6 +44571,7 @@ async function writeSectionsToStorage(p, sections) {
   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 (sections.events.length > 0) payload.events = sections.events;
   const pkgSeg = String(p).replace(/^\/+/, "").split("/")[0];
   if (pkgSeg) invalidatePackageCache(pkgSeg);
   if (Object.keys(payload).length === 0) {
@@ -44667,7 +44696,8 @@ async function writeEntityFile(entity, packageName) {
       rules: [],
       cases: [],
       actions: [],
-      stateMachines: []
+      stateMachines: [],
+      events: []
     });
     logger.info(`Entity written to new file: ${String(newFilePath)}`);
     await commitChanges(String(newFilePath), `Added entity: ${entity.name} (${entity.uuid})`);
@@ -45129,6 +45159,14 @@ async function findActionOwner(actionUuid) {
   }
   return null;
 }
+async function readActionsForPackage(packageName) {
+  try {
+    const model = await loadPackage(packageName);
+    return model.actions;
+  } catch {
+    return [];
+  }
+}
 async function readActionsForEntity(entityUuid) {
   const packages = await listPackages();
   const result = [];
@@ -45180,7 +45218,8 @@ async function writeAction(action, packageName) {
       rules: [],
       cases: [],
       actions: [action],
-      stateMachines: []
+      stateMachines: [],
+      events: []
     });
     await commitChanges(String(newFilePath), `Added action: ${action.name} (${action.uuid})`);
     return { ok: true, physicalPath: String(newFilePath) };
@@ -45206,6 +45245,107 @@ async function deleteAction(uuid3) {
     return { ok: false };
   }
 }
+async function findEventOwner(eventUuid) {
+  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.events.some((e) => e.uuid === eventUuid)) {
+        return { packageName: pkg, filePath: String(f) };
+      }
+    }
+  }
+  return null;
+}
+async function readEventsForPackage(packageName) {
+  try {
+    const model = await loadPackage(packageName);
+    return model.events;
+  } catch {
+    return [];
+  }
+}
+async function readEventsForEntity(entityUuid) {
+  const packages = await listPackages();
+  const result = [];
+  for (const pkg of packages) {
+    try {
+      const model = await loadPackage(pkg);
+      result.push(...model.events.filter((e) => e.ownerRef === entityUuid));
+    } catch {
+    }
+  }
+  return result;
+}
+async function writeEvent(event, 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.events.some((e) => e.uuid === event.uuid)) {
+        ownerFile = f;
+        ownerSections = s;
+        break;
+      }
+    }
+    if (ownerFile && ownerSections) {
+      ownerSections.events = ownerSections.events.filter((e) => e.uuid !== event.uuid);
+      ownerSections.events.push(event);
+      await writeSectionsToStorage(ownerFile, ownerSections);
+      await commitChanges(String(ownerFile), `Updated event: ${event.name} (${event.uuid})`);
+      return { ok: true, physicalPath: String(ownerFile) };
+    }
+    if (event.ownerRef) {
+      const entityModel = await loadPackage(packageName);
+      const ownerEntityFile = entityModel.ownership.entityByUuid.get(event.ownerRef);
+      if (ownerEntityFile) {
+        const filePath = pathOf(ownerEntityFile);
+        const s = await parseSectionsFromStorage(filePath, ownerEntityFile);
+        s.events = s.events.filter((e) => e.uuid !== event.uuid);
+        s.events.push(event);
+        await writeSectionsToStorage(filePath, s);
+        await commitChanges(ownerEntityFile, `Added event: ${event.name} (${event.uuid})`);
+        return { ok: true, physicalPath: ownerEntityFile };
+      }
+    }
+    const newFilePath = pathOf(`${packageName}/${sanitizeFsName(event.name)}.events.yaml`);
+    await writeSectionsToStorage(newFilePath, {
+      entities: [],
+      relationships: [],
+      rules: [],
+      cases: [],
+      actions: [],
+      stateMachines: [],
+      events: [event]
+    });
+    await commitChanges(String(newFilePath), `Added event: ${event.name} (${event.uuid})`);
+    return { ok: true, physicalPath: String(newFilePath) };
+  } catch (error48) {
+    logger.error(`Error writing event: ${error48}`);
+    return { ok: false };
+  }
+}
+async function deleteEvent(uuid3) {
+  try {
+    const owner = await findEventOwner(uuid3);
+    if (!owner) return { ok: false };
+    const ownerPath = pathOf(owner.filePath);
+    const s = await parseSectionsFromStorage(ownerPath, owner.filePath);
+    const before = s.events.length;
+    s.events = s.events.filter((e) => e.uuid !== uuid3);
+    if (s.events.length === before) return { ok: false };
+    await writeSectionsToStorage(ownerPath, s);
+    await commitChanges(owner.filePath, `Deleted event ${uuid3}`);
+    return { ok: true, physicalPath: owner.filePath };
+  } catch (error48) {
+    logger.error(`Error deleting event ${uuid3}: ${error48}`);
+    return { ok: false };
+  }
+}
 async function findStateMachineOwner(smUuid) {
   const packages = await listPackages();
   for (const pkg of packages) {
@@ -45270,7 +45410,8 @@ async function writeStateMachine(sm, packageName) {
       rules: [],
       cases: [],
       actions: [],
-      stateMachines: [sm]
+      stateMachines: [sm],
+      events: []
     });
     await commitChanges(String(newFilePath), `Added stateMachine: ${sm.name} (${sm.uuid})`);
     return { ok: true, physicalPath: String(newFilePath) };
@@ -45378,9 +45519,15 @@ var init_fileOperations = __esm({
     __name(writeDictionaryMetadata, "writeDictionaryMetadata");
     __name(listAllDictionaries, "listAllDictionaries");
     __name(findActionOwner, "findActionOwner");
+    __name(readActionsForPackage, "readActionsForPackage");
     __name(readActionsForEntity, "readActionsForEntity");
     __name(writeAction, "writeAction");
     __name(deleteAction, "deleteAction");
+    __name(findEventOwner, "findEventOwner");
+    __name(readEventsForPackage, "readEventsForPackage");
+    __name(readEventsForEntity, "readEventsForEntity");
+    __name(writeEvent, "writeEvent");
+    __name(deleteEvent, "deleteEvent");
     __name(findStateMachineOwner, "findStateMachineOwner");
     __name(readStateMachinesForEntity, "readStateMachinesForEntity");
     __name(writeStateMachine, "writeStateMachine");
@@ -115147,22 +115294,22 @@ var chat_routes_exports = {};
 __export(chat_routes_exports, {
   default: () => chat_routes_default
 });
-var import_express18, router17, chat_routes_default;
+var import_express19, router18, chat_routes_default;
 var init_chat_routes = __esm({
   "backend/src/routes/ai/chat.routes.ts"() {
     "use strict";
-    import_express18 = __toESM(require_express2(), 1);
+    import_express19 = __toESM(require_express2(), 1);
     init_aiController();
-    router17 = (0, import_express18.Router)();
-    router17.post("/api/ai/chat", aiChat);
-    router17.post("/api/ai/chat/approve", aiChatApprove);
-    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;
+    router18 = (0, import_express19.Router)();
+    router18.post("/api/ai/chat", aiChat);
+    router18.post("/api/ai/chat/approve", aiChatApprove);
+    router18.get("/api/ai/status", aiStatus);
+    router18.get("/api/ai/config", aiGetConfig);
+    router18.post("/api/ai/config", aiSaveConfig);
+    router18.get("/api/ai/tools", aiTools);
+    router18.get("/api/ai/mentions/search", aiMentionsSearch);
+    router18.post("/api/ai/test-tools", aiTestTools);
+    chat_routes_default = router18;
   }
 });
 
@@ -115171,19 +115318,19 @@ var conversation_routes_exports = {};
 __export(conversation_routes_exports, {
   default: () => conversation_routes_default
 });
-var import_express19, router18, conversation_routes_default;
+var import_express20, router19, conversation_routes_default;
 var init_conversation_routes = __esm({
   "backend/src/routes/ai/conversation.routes.ts"() {
     "use strict";
-    import_express19 = __toESM(require_express2(), 1);
+    import_express20 = __toESM(require_express2(), 1);
     init_aiController();
-    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;
+    router19 = (0, import_express20.Router)();
+    router19.get("/api/ai/conversations", listConversations);
+    router19.get("/api/ai/conversations/:id", getConversation);
+    router19.post("/api/ai/conversations", saveConversation);
+    router19.patch("/api/ai/conversations/:id", patchConversation);
+    router19.delete("/api/ai/conversations/:id", deleteConversation);
+    conversation_routes_default = router19;
   }
 });
 
@@ -115192,19 +115339,19 @@ var prompt_routes_exports = {};
 __export(prompt_routes_exports, {
   default: () => prompt_routes_default
 });
-var import_express20, router19, prompt_routes_default;
+var import_express21, router20, prompt_routes_default;
 var init_prompt_routes = __esm({
   "backend/src/routes/ai/prompt.routes.ts"() {
     "use strict";
-    import_express20 = __toESM(require_express2(), 1);
+    import_express21 = __toESM(require_express2(), 1);
     init_aiController();
-    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;
+    router20 = (0, import_express21.Router)();
+    router20.get("/api/ai/prompts", listPrompts);
+    router20.get("/api/ai/prompts/:id", getPrompt);
+    router20.post("/api/ai/prompts", createPrompt);
+    router20.put("/api/ai/prompts/:id", updatePrompt);
+    router20.delete("/api/ai/prompts/:id", deletePrompt);
+    prompt_routes_default = router20;
   }
 });
 
@@ -115240,19 +115387,19 @@ function mergeMaskedRecord(incoming, existing) {
   }
   return out;
 }
-var import_express21, router20, MASK, looksLikeEnvRef, mcp_routes_default;
+var import_express22, router21, MASK, looksLikeEnvRef, mcp_routes_default;
 var init_mcp_routes = __esm({
   "backend/src/routes/ai/mcp.routes.ts"() {
     "use strict";
-    import_express21 = __toESM(require_express2(), 1);
+    import_express22 = __toESM(require_express2(), 1);
     init_mcpClientRegistry();
-    router20 = (0, import_express21.Router)();
+    router21 = (0, import_express22.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");
-    router20.get("/api/ai/mcp/connections", (_req, res) => {
+    router21.get("/api/ai/mcp/connections", (_req, res) => {
       try {
         const connections = mcpClientRegistry.getConnections().map(maskConnection);
         res.json({ data: connections });
@@ -115261,7 +115408,7 @@ var init_mcp_routes = __esm({
         res.status(500).json({ error: msg });
       }
     });
-    router20.post("/api/ai/mcp/connections", (req, res) => {
+    router21.post("/api/ai/mcp/connections", (req, res) => {
       try {
         const body = req.body;
         const errors = mcpClientRegistry.validateConnection(body);
@@ -115281,7 +115428,7 @@ var init_mcp_routes = __esm({
         res.status(500).json({ error: msg });
       }
     });
-    router20.delete("/api/ai/mcp/connections/:id", (req, res) => {
+    router21.delete("/api/ai/mcp/connections/:id", (req, res) => {
       try {
         const { id } = req.params;
         const deleted = mcpClientRegistry.deleteConnection(id);
@@ -115294,7 +115441,7 @@ var init_mcp_routes = __esm({
         res.status(500).json({ error: msg });
       }
     });
-    router20.post("/api/ai/mcp/connections/:id/test", async (req, res) => {
+    router21.post("/api/ai/mcp/connections/:id/test", async (req, res) => {
       try {
         const { id } = req.params;
         const result = await mcpClientRegistry.testConnection(id);
@@ -115308,7 +115455,7 @@ var init_mcp_routes = __esm({
         res.status(500).json({ error: msg });
       }
     });
-    mcp_routes_default = router20;
+    mcp_routes_default = router21;
   }
 });
 
@@ -115487,16 +115634,16 @@ var init_workspace_manager = __esm({
 });
 
 // backend/node_modules/@hamak/filesystem-server-impl/dist/routing/file-router.js
-var import_express29, FileRouter;
+var import_express30, FileRouter;
 var init_file_router = __esm({
   "backend/node_modules/@hamak/filesystem-server-impl/dist/routing/file-router.js"() {
-    import_express29 = __toESM(require_express2(), 1);
+    import_express30 = __toESM(require_express2(), 1);
     FileRouter = class {
       static {
         __name(this, "FileRouter");
       }
       constructor(workspaceManager2, options2) {
-        this.router = (0, import_express29.Router)();
+        this.router = (0, import_express30.Router)();
         this.workspaceManager = workspaceManager2;
         this.enricherRegistry = options2?.enricherRegistry;
         this.initializeRoutes();
@@ -115623,7 +115770,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_express30.Router)();
+  const app2 = (0, import_express31.Router)();
   if (config3.enableCors ?? DEFAULT_FILESYSTEM_SERVER_CONFIG.enableCors) {
     app2.use((0, import_cors.default)());
   }
@@ -115633,10 +115780,10 @@ function createFileSystemRouter(workspaceManager2, config3) {
   app2.use(mountPath, fileRouter2.router);
   return app2;
 }
-var import_express30, import_cors, import_body_parser;
+var import_express31, import_cors, import_body_parser;
 var init_create_router = __esm({
   "backend/node_modules/@hamak/filesystem-server-impl/dist/routing/create-router.js"() {
-    import_express30 = __toESM(require_express2(), 1);
+    import_express31 = __toESM(require_express2(), 1);
     import_cors = __toESM(require_lib3(), 1);
     import_body_parser = __toESM(require_body_parser(), 1);
     init_dist9();
@@ -155345,8 +155492,8 @@ function respondError(res, err, fallbackStatus = 500) {
   res.status(fallbackStatus).json({ error: message });
 }
 function createLogicalFsRouter() {
-  const router28 = (0, import_express31.Router)();
-  router28.get("/:workspace/files/*", async (req, res) => {
+  const router29 = (0, import_express32.Router)();
+  router29.get("/:workspace/files/*", async (req, res) => {
     try {
       const ws = wsId(req.params.workspace);
       const projection = getProjection(ws);
@@ -155364,7 +155511,7 @@ function createLogicalFsRouter() {
       respondError(res, err);
     }
   });
-  router28.get("/:workspace/read/*", async (req, res) => {
+  router29.get("/:workspace/read/*", async (req, res) => {
     try {
       const ws = wsId(req.params.workspace);
       const projection = getProjection(ws);
@@ -155408,9 +155555,9 @@ function createLogicalFsRouter() {
       respondError(res, err);
     }
   }, "writeHandler");
-  router28.put("/:workspace/put/*", writeHandler);
-  router28.post("/:workspace/post/*", writeHandler);
-  router28.delete("/:workspace/delete/*", async (req, res) => {
+  router29.put("/:workspace/put/*", writeHandler);
+  router29.post("/:workspace/post/*", writeHandler);
+  router29.delete("/:workspace/delete/*", async (req, res) => {
     try {
       const ws = wsId(req.params.workspace);
       const projection = getProjection(ws);
@@ -155422,7 +155569,7 @@ function createLogicalFsRouter() {
       respondError(res, err);
     }
   });
-  router28.get("/:workspace/by-uuid/:uuid", (req, res) => {
+  router29.get("/:workspace/by-uuid/:uuid", (req, res) => {
     try {
       const ws = wsId(req.params.workspace);
       const index = getUuidIndex(ws);
@@ -155437,13 +155584,13 @@ function createLogicalFsRouter() {
       respondError(res, err);
     }
   });
-  return router28;
+  return router29;
 }
-var import_express31;
+var import_express32;
 var init_logicalFsRouter = __esm({
   "backend/src/routes/logicalFsRouter.ts"() {
     "use strict";
-    import_express31 = __toESM(require_express2(), 1);
+    import_express32 = __toESM(require_express2(), 1);
     init_types();
     init_ProjectionRegistry();
     init_UuidIndex();
@@ -155454,7 +155601,7 @@ var init_logicalFsRouter = __esm({
 });
 
 // backend/src/server.ts
-var import_express32 = __toESM(require_express2(), 1);
+var import_express33 = __toESM(require_express2(), 1);
 var import_cors2 = __toESM(require_lib3(), 1);
 var import_dotenv2 = __toESM(require_main(), 1);
 import fs5 from "fs";
@@ -155462,7 +155609,7 @@ import path13 from "path";
 import os3 from "os";
 
 // backend/src/routes/index.ts
-var import_express28 = __toESM(require_express2(), 1);
+var import_express29 = __toESM(require_express2(), 1);
 
 // backend/src/routes/auth.routes.ts
 var import_express = __toESM(require_express2(), 1);
@@ -155640,7 +155787,7 @@ router.get("/api/auth/me", verifyToken, getCurrentUser);
 var auth_routes_default = router;
 
 // backend/src/routes/data-dictionary/index.ts
-var import_express17 = __toESM(require_express2(), 1);
+var import_express18 = __toESM(require_express2(), 1);
 
 // backend/src/routes/data-dictionary/package.routes.ts
 var import_express3 = __toESM(require_express2(), 1);
@@ -161605,6 +161752,7 @@ var FLOW_STEP_KINDS = /* @__PURE__ */ new Set([
   "wait",
   "callExternal"
 ]);
+var ACTION_KINDS = /* @__PURE__ */ new Set(["command", "query"]);
 
 // backend/src/services/actionService.ts
 init_fileOperations();
@@ -161632,11 +161780,39 @@ function checkInvokeRefs(steps, knownActionUuids, pathPrefix, errors) {
   }
 }
 __name(checkInvokeRefs, "checkInvokeRefs");
-function validateAction(action, knownActionUuids) {
+function checkEventRefs(steps, knownEventUuids, pathPrefix, errors) {
+  for (let i = 0; i < steps.length; i++) {
+    const step = steps[i];
+    const path14 = `${pathPrefix}[${i}]`;
+    if (step.kind === "emitEvent" || step.kind === "wait") {
+      if (step.eventRef && !knownEventUuids.has(step.eventRef)) {
+        errors.push({
+          field: `${path14}.eventRef`,
+          message: `${step.kind} references unknown event UUID '${step.eventRef}' at ${path14}`
+        });
+      }
+    } else if (step.kind === "branch") {
+      if (step.then && step.then.length > 0) {
+        checkEventRefs(step.then, knownEventUuids, `${path14}.then`, errors);
+      }
+      if (step.else && step.else.length > 0) {
+        checkEventRefs(step.else, knownEventUuids, `${path14}.else`, errors);
+      }
+    }
+  }
+}
+__name(checkEventRefs, "checkEventRefs");
+function validateAction(action, knownActionUuids, knownEventUuids) {
   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.actionKind !== void 0 && !ACTION_KINDS.has(action.actionKind)) {
+    errors.push({
+      field: "actionKind",
+      message: `Invalid actionKind '${action.actionKind}'. Must be one of: ${[...ACTION_KINDS].join(", ")}`
+    });
+  }
   if (action.params && action.params.length > 0) {
     const names = action.params.map((p) => p.name);
     const unique = new Set(names);
@@ -161661,6 +161837,9 @@ function validateAction(action, knownActionUuids) {
     if (knownActionUuids !== void 0) {
       checkInvokeRefs(action.flow, knownActionUuids, "flow", errors);
     }
+    if (knownEventUuids !== void 0) {
+      checkEventRefs(action.flow, knownEventUuids, "flow", errors);
+    }
   }
   return errors;
 }
@@ -161669,12 +161848,15 @@ var ActionService = class {
   static {
     __name(this, "ActionService");
   }
-  /** List all actions. Optionally filter by ownerRef (entity UUID). */
+  /** List all actions. Optionally filter by ownerRef (entity UUID) or package. */
   async list(filters = {}) {
     try {
       if (filters.ownerRef) {
         return await readActionsForEntity(filters.ownerRef);
       }
+      if (filters.packageName) {
+        return await readActionsForPackage(filters.packageName);
+      }
       const packages = await listPackages();
       const result = [];
       for (const pkg of packages) {
@@ -161710,6 +161892,7 @@ var ActionService = class {
       description: data.description,
       ownerRef: data.ownerRef || "",
       internal: data.internal ?? false,
+      actionKind: data.actionKind,
       params: data.params ?? [],
       returns: data.returns,
       flow: data.flow ?? [],
@@ -161722,7 +161905,8 @@ var ActionService = class {
     }
     const knownActionUuids = new Set(packageModel.ownership.actionByUuid.keys());
     knownActionUuids.add(action.uuid);
-    const errors = validateAction(action, knownActionUuids);
+    const knownEventUuids = new Set(packageModel.ownership.eventByUuid.keys());
+    const errors = validateAction(action, knownActionUuids, knownEventUuids);
     if (errors.length > 0) return { errors };
     const result = await writeAction(action, packageName);
     if (!result.ok) {
@@ -161748,7 +161932,8 @@ var ActionService = class {
     }
     const knownActionUuids = new Set(packageModel.ownership.actionByUuid.keys());
     knownActionUuids.add(uuid3);
-    const errors = validateAction(updated, knownActionUuids);
+    const knownEventUuids = new Set(packageModel.ownership.eventByUuid.keys());
+    const errors = validateAction(updated, knownActionUuids, knownEventUuids);
     if (errors.length > 0) return { errors };
     const result = await writeAction(updated, packageName);
     if (!result.ok) {
@@ -161779,6 +161964,16 @@ var actionService = new ActionService();
 
 // backend/src/controllers/actionController.ts
 init_logger();
+var listActions = /* @__PURE__ */ __name(async (req, res) => {
+  try {
+    const packageName = typeof req.query.package === "string" ? req.query.package : void 0;
+    const actions = await actionService.list({ packageName });
+    res.json({ message: "Success", data: actions });
+  } catch (error48) {
+    logger.error("Error listing actions", error48);
+    res.status(500).json({ message: "Error listing actions", error: error48 });
+  }
+}, "listActions");
 var listActionsForEntity = /* @__PURE__ */ __name(async (req, res) => {
   try {
     const actions = await actionService.list({ ownerRef: req.params.uuid });
@@ -161839,15 +162034,229 @@ var deleteAction2 = /* @__PURE__ */ __name(async (req, res) => {
 // backend/src/routes/data-dictionary/action.routes.ts
 var router14 = (0, import_express15.Router)();
 router14.get("/api/entities/:uuid/actions", listActionsForEntity);
+router14.get("/api/actions", listActions);
 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
+// backend/src/routes/data-dictionary/event.routes.ts
 var import_express16 = __toESM(require_express2(), 1);
 
+// backend/src/services/eventService.ts
+init_fileOperations();
+init_uuid();
+init_logger();
+function validateEvent(event) {
+  const errors = [];
+  if (!event.uuid) errors.push({ field: "uuid", message: "uuid is required" });
+  if (!event.name) errors.push({ field: "name", message: "name is required" });
+  if (event.payload && event.payload.length > 0) {
+    const names = event.payload.map((a) => a.name);
+    if (new Set(names).size !== names.length) {
+      errors.push({ field: "payload", message: "Event payload attributes must have unique names" });
+    }
+    for (const a of event.payload) {
+      if (!a.name) errors.push({ field: "payload", message: "Each payload attribute must have a name" });
+    }
+  }
+  return errors;
+}
+__name(validateEvent, "validateEvent");
+var EventService = class {
+  static {
+    __name(this, "EventService");
+  }
+  /**
+   * List events. Filter by `ownerRef` (entity UUID) or `packageName`; with no
+   * filter, scan all packages.
+   */
+  async list(filters = {}) {
+    try {
+      if (filters.ownerRef) return await readEventsForEntity(filters.ownerRef);
+      if (filters.packageName) return await readEventsForPackage(filters.packageName);
+      const packages = await listPackages();
+      const result = [];
+      for (const pkg of packages) {
+        const model = await loadPackage(pkg);
+        result.push(...model.events);
+      }
+      return result;
+    } catch (error48) {
+      logger.error(`Error listing events: ${error48}`);
+      return [];
+    }
+  }
+  /** Get one event by UUID. */
+  async getByUuid(uuid3) {
+    try {
+      const owner = await findEventOwner(uuid3);
+      if (!owner) return null;
+      const model = await loadPackage(owner.packageName);
+      return model.events.find((e) => e.uuid === uuid3) ?? null;
+    } catch (error48) {
+      logger.error(`Error getting event ${uuid3}: ${error48}`);
+      return null;
+    }
+  }
+  /**
+   * Create a new event. The target package is derived from `ownerRef` (the
+   * owning entity's package) or an explicit `packageName`.
+   */
+  async create(data) {
+    const event = {
+      uuid: data.uuid || generateUUID(),
+      name: data.name || "",
+      description: data.description,
+      ownerRef: data.ownerRef || void 0,
+      payload: data.payload ?? void 0,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const resolved = await this.resolveTargetPackage(event.ownerRef, data.packageName);
+    if ("errors" in resolved) return resolved;
+    const packageName = resolved.packageName;
+    const errors = validateEvent(event);
+    const model = await loadPackage(packageName);
+    if (model.events.some((e) => e.name === event.name && e.uuid !== event.uuid)) {
+      errors.push({ field: "name", message: `An event named '${event.name}' already exists in package '${packageName}'` });
+    }
+    if (errors.length > 0) return { errors };
+    const result = await writeEvent(event, packageName);
+    if (!result.ok) return { errors: [{ field: "_", message: "Failed to persist event" }] };
+    return event;
+  }
+  /** Update an existing event. */
+  async update(uuid3, data) {
+    const owner = await findEventOwner(uuid3);
+    if (!owner) return null;
+    const existing = (await loadPackage(owner.packageName)).events.find((e) => e.uuid === uuid3);
+    if (!existing) return null;
+    const updated = {
+      ...existing,
+      ...data,
+      uuid: uuid3,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const errors = validateEvent(updated);
+    const model = await loadPackage(owner.packageName);
+    if (model.events.some((e) => e.name === updated.name && e.uuid !== uuid3)) {
+      errors.push({ field: "name", message: `An event named '${updated.name}' already exists in package '${owner.packageName}'` });
+    }
+    if (errors.length > 0) return { errors };
+    const result = await writeEvent(updated, owner.packageName);
+    if (!result.ok) return { errors: [{ field: "_", message: "Failed to persist event" }] };
+    return updated;
+  }
+  /** Delete an event by UUID. */
+  async delete(uuid3) {
+    const result = await deleteEvent(uuid3);
+    return result.ok;
+  }
+  /** Resolve the package a new event should be written to. */
+  async resolveTargetPackage(ownerRef, explicitPackage) {
+    const packages = await listPackages();
+    if (ownerRef) {
+      for (const pkg of packages) {
+        const model = await loadPackage(pkg);
+        if (model.ownership.entityByUuid.has(ownerRef)) return { packageName: pkg };
+      }
+      return { errors: [{ field: "ownerRef", message: `Entity '${ownerRef}' not found in any package` }] };
+    }
+    if (explicitPackage) {
+      if (!packages.includes(explicitPackage)) {
+        return { errors: [{ field: "packageName", message: `Package '${explicitPackage}' not found` }] };
+      }
+      return { packageName: explicitPackage };
+    }
+    return { errors: [{ field: "ownerRef", message: "Either ownerRef (entity) or packageName is required" }] };
+  }
+};
+var eventService = new EventService();
+
+// backend/src/controllers/eventController.ts
+init_logger();
+var listEvents = /* @__PURE__ */ __name(async (req, res) => {
+  try {
+    const packageName = typeof req.query.package === "string" ? req.query.package : void 0;
+    const events = await eventService.list({ packageName });
+    res.json({ message: "Success", data: events });
+  } catch (error48) {
+    logger.error("Error listing events", error48);
+    res.status(500).json({ message: "Error listing events", error: error48 });
+  }
+}, "listEvents");
+var listEventsForEntity = /* @__PURE__ */ __name(async (req, res) => {
+  try {
+    const events = await eventService.list({ ownerRef: req.params.uuid });
+    res.json({ message: "Success", data: events });
+  } catch (error48) {
+    logger.error("Error listing events for entity", error48);
+    res.status(500).json({ message: "Error listing events for entity", error: error48 });
+  }
+}, "listEventsForEntity");
+var getEvent = /* @__PURE__ */ __name(async (req, res) => {
+  try {
+    const event = await eventService.getByUuid(req.params.uuid);
+    if (!event) return res.status(404).json({ message: "Event not found" });
+    res.json({ message: "Success", data: event });
+  } catch (error48) {
+    logger.error("Error fetching event", error48);
+    res.status(500).json({ message: "Error fetching event", error: error48 });
+  }
+}, "getEvent");
+var createEvent = /* @__PURE__ */ __name(async (req, res) => {
+  try {
+    const result = await eventService.create(req.body);
+    if ("errors" in result) {
+      return res.status(400).json({ message: "Failed to create event", errors: result.errors });
+    }
+    res.status(201).json({ message: "Event created successfully", data: result });
+  } catch (error48) {
+    logger.error("Error creating event", error48);
+    res.status(500).json({ message: "Error creating event", error: error48 });
+  }
+}, "createEvent");
+var updateEvent = /* @__PURE__ */ __name(async (req, res) => {
+  try {
+    const result = await eventService.update(req.params.uuid, req.body);
+    if (result === null) {
+      return res.status(404).json({ message: "Event not found" });
+    }
+    if ("errors" in result) {
+      return res.status(400).json({ message: "Failed to update event", errors: result.errors });
+    }
+    res.json({ message: "Event updated successfully", data: result });
+  } catch (error48) {
+    logger.error("Error updating event", error48);
+    res.status(500).json({ message: "Error updating event", error: error48 });
+  }
+}, "updateEvent");
+var deleteEvent2 = /* @__PURE__ */ __name(async (req, res) => {
+  try {
+    const ok2 = await eventService.delete(req.params.uuid);
+    if (!ok2) return res.status(404).json({ message: "Event not found" });
+    res.json({ message: "Event deleted successfully" });
+  } catch (error48) {
+    logger.error("Error deleting event", error48);
+    res.status(500).json({ message: "Error deleting event", error: error48 });
+  }
+}, "deleteEvent");
+
+// backend/src/routes/data-dictionary/event.routes.ts
+var router15 = (0, import_express16.Router)();
+router15.get("/api/events", listEvents);
+router15.get("/api/entities/:uuid/events", listEventsForEntity);
+router15.get("/api/events/:uuid", getEvent);
+router15.post("/api/events", authorizeJwt(["admin" /* ADMIN */, "editor" /* EDITOR */]), createEvent);
+router15.put("/api/events/:uuid", authorizeJwt(["admin" /* ADMIN */, "editor" /* EDITOR */]), updateEvent);
+router15.delete("/api/events/:uuid", authorizeJwt(["admin" /* ADMIN */]), deleteEvent2);
+var event_routes_default = router15;
+
+// backend/src/routes/data-dictionary/state-machine.routes.ts
+var import_express17 = __toESM(require_express2(), 1);
+
 // backend/src/services/stateMachineService.ts
 init_fileOperations();
 init_uuid();
@@ -162096,59 +162505,60 @@ var deleteStateMachine2 = /* @__PURE__ */ __name(async (req, res) => {
 }, "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;
+var router16 = (0, import_express17.Router)();
+router16.get("/api/entities/:uuid/state-machines", listStateMachinesForEntity);
+router16.get("/api/state-machines/:uuid", getStateMachine);
+router16.post("/api/state-machines", authorizeJwt(["admin" /* ADMIN */, "editor" /* EDITOR */]), createStateMachine);
+router16.put("/api/state-machines/:uuid", authorizeJwt(["admin" /* ADMIN */, "editor" /* EDITOR */]), updateStateMachine);
+router16.delete("/api/state-machines/:uuid", authorizeJwt(["admin" /* ADMIN */]), deleteStateMachine2);
+var state_machine_routes_default = router16;
 
 // 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;
+var router17 = (0, import_express18.Router)();
+router17.use(package_routes_default);
+router17.use(relationship_routes_default);
+router17.use(entity_routes_default);
+router17.use(stereotype_routes_default);
+router17.use(case_routes_default);
+router17.use(rule_routes_default);
+router17.use(integrity_routes_default);
+router17.use(model_metadata_routes_default);
+router17.use(dico_config_routes_default);
+router17.use(diff_routes_default);
+router17.use(import_export_routes_default);
+router17.use(publish_routes_default);
+router17.use(action_routes_default);
+router17.use(event_routes_default);
+router17.use(state_machine_routes_default);
+var data_dictionary_default = router17;
 
 // backend/src/routes/ai/index.ts
-var import_express22 = __toESM(require_express2(), 1);
-var router21 = (0, import_express22.Router)();
+var import_express23 = __toESM(require_express2(), 1);
+var router22 = (0, import_express23.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;
-    router21.use(chatRoutes);
-    router21.use(conversationRoutes);
-    router21.use(promptRoutes);
-    router21.use(mcpRoutes);
+    router22.use(chatRoutes);
+    router22.use(conversationRoutes);
+    router22.use(promptRoutes);
+    router22.use(mcpRoutes);
   } catch {
   }
 })();
-var ai_default = router21;
+var ai_default = router22;
 
 // backend/src/routes/search.routes.ts
-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;
+var import_express24 = __toESM(require_express2(), 1);
+var router23 = (0, import_express24.Router)();
+router23.get("/api/entities/flat", getFlatEntitiesAndAttributes);
+router23.get("/api/search", searchEntities);
+var search_routes_default = router23;
 
 // backend/src/routes/visualization.routes.ts
-var import_express24 = __toESM(require_express2(), 1);
+var import_express25 = __toESM(require_express2(), 1);
 
 // backend/src/controllers/diagramController.ts
 init_diagramService();
@@ -162277,21 +162687,21 @@ var DiagramController = class {
 var diagramController = new DiagramController();
 
 // backend/src/routes/visualization.routes.ts
-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;
+var router24 = (0, import_express25.Router)();
+router24.get("/api/graph/:service", getGraphData);
+router24.get("/api/entities/:uuid/impact", getImpactAnalysis);
+router24.get("/api/entities/:uuid/lineage", getLineage);
+router24.get("/api/diagrams", diagramController.listDiagramLayouts.bind(diagramController));
+router24.post("/api/diagrams", authorizeJwt(["admin" /* ADMIN */, "editor" /* EDITOR */]), diagramController.saveDiagramLayout.bind(diagramController));
+router24.get("/api/diagrams/:id", diagramController.loadDiagramLayout.bind(diagramController));
+router24.put("/api/diagrams/:id", authorizeJwt(["admin" /* ADMIN */, "editor" /* EDITOR */]), diagramController.updateDiagramLayout.bind(diagramController));
+router24.delete("/api/diagrams/:id", authorizeJwt(["admin" /* ADMIN */]), diagramController.deleteDiagramLayout.bind(diagramController));
+var visualization_routes_default = router24;
 
 // backend/src/routes/status.routes.ts
-var import_express25 = __toESM(require_express2(), 1);
-var router24 = (0, import_express25.Router)();
-router24.get("/api/status", (req, res) => {
+var import_express26 = __toESM(require_express2(), 1);
+var router25 = (0, import_express26.Router)();
+router25.get("/api/status", (req, res) => {
   const profile = process.env.PROFILE || "local";
   res.json({
     status: "operational",
@@ -162301,17 +162711,17 @@ router24.get("/api/status", (req, res) => {
     auth: profile === "local" ? "none" : "jwt"
   });
 });
-var status_routes_default = router24;
+var status_routes_default = router25;
 
 // backend/src/routes/project.routes.ts
-var import_express26 = __toESM(require_express2(), 1);
+var import_express27 = __toESM(require_express2(), 1);
 init_config();
 import fs2 from "fs";
 import path9 from "path";
 import os2 from "os";
 init_appDir();
 init_logger();
-var router25 = (0, import_express26.Router)();
+var router26 = (0, import_express27.Router)();
 var RESTART_EXIT_CODE = 75;
 function applyProjectSwitch(req, res, dataDir, message) {
   if (process.env.SDD_MANAGED === "1") {
@@ -162354,7 +162764,7 @@ function applyProjectSwitch(req, res, dataDir, message) {
   res.json({ message, data: { path: dataDir, name: path9.basename(path9.dirname(dataDir)) }, restarting: false });
 }
 __name(applyProjectSwitch, "applyProjectSwitch");
-router25.get("/api/filesystem/browse", (req, res) => {
+router26.get("/api/filesystem/browse", (req, res) => {
   if (config.profile !== "local") {
     return res.status(403).json({ message: "Filesystem browsing is only available in local mode" });
   }
@@ -162379,7 +162789,7 @@ router25.get("/api/filesystem/browse", (req, res) => {
     res.status(500).json({ message: `Failed to read directory: ${e}` });
   }
 });
-router25.get("/api/project", (req, res) => {
+router26.get("/api/project", (req, res) => {
   const dataDir = config.dataDir;
   const isOpen = fs2.existsSync(path9.join(dataDir, "dico.config.json"));
   res.json({
@@ -162391,7 +162801,7 @@ router25.get("/api/project", (req, res) => {
     }
   });
 });
-router25.get("/api/project/status", async (_req, res) => {
+router26.get("/api/project/status", async (_req, res) => {
   try {
     const { versionService: versionService2 } = await Promise.resolve().then(() => (init_versionService(), versionService_exports));
     const status = await versionService2.getWorkingTreeStatus();
@@ -162400,7 +162810,7 @@ router25.get("/api/project/status", async (_req, res) => {
     res.status(500).json({ message: `Failed to read project status: ${e}` });
   }
 });
-router25.post("/api/project/open", authorizeJwt(["admin" /* ADMIN */]), (req, res) => {
+router26.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" });
   }
@@ -162420,7 +162830,7 @@ router25.post("/api/project/open", authorizeJwt(["admin" /* ADMIN */]), (req, re
   }
   applyProjectSwitch(req, res, dataDir, `Project opened: ${dataDir}`);
 });
-router25.post("/api/project/close", authorizeJwt(["admin" /* ADMIN */]), (req, res) => {
+router26.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" });
   }
@@ -162428,7 +162838,7 @@ router25.post("/api/project/close", authorizeJwt(["admin" /* ADMIN */]), (req, r
   if (!fs2.existsSync(emptyDir)) fs2.mkdirSync(emptyDir, { recursive: true });
   applyProjectSwitch(req, res, emptyDir, "Project closed");
 });
-router25.post("/api/project/init", authorizeJwt(["admin" /* ADMIN */]), (req, res) => {
+router26.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" });
   }
@@ -162454,10 +162864,10 @@ router25.post("/api/project/init", authorizeJwt(["admin" /* ADMIN */]), (req, re
     res.status(500).json({ message: `Failed to initialize project: ${e}` });
   }
 });
-var project_routes_default = router25;
+var project_routes_default = router26;
 
 // backend/src/routes/orm.routes.ts
-var import_express27 = __toESM(require_express2(), 1);
+var import_express28 = __toESM(require_express2(), 1);
 
 // backend/src/models/ormVocabulary.ts
 var ORM_PREFIX = "orm.";
@@ -162520,23 +162930,23 @@ var ORM_FLAG_KEYS = new Set(
 );
 
 // backend/src/routes/orm.routes.ts
-var router26 = (0, import_express27.Router)();
-router26.get("/api/orm/vocabulary", (_req, res) => {
+var router27 = (0, import_express28.Router)();
+router27.get("/api/orm/vocabulary", (_req, res) => {
   res.json({ data: { prefix: ORM_PREFIX, scopes: ORM_VOCABULARY } });
 });
-var orm_routes_default = router26;
+var orm_routes_default = router27;
 
 // backend/src/routes/index.ts
-var router27 = (0, import_express28.Router)();
-router27.use(status_routes_default);
-router27.use(auth_routes_default);
-router27.use(search_routes_default);
-router27.use(visualization_routes_default);
-router27.use(project_routes_default);
-router27.use(orm_routes_default);
-router27.use(data_dictionary_default);
-router27.use(ai_default);
-var routes_default = router27;
+var router28 = (0, import_express29.Router)();
+router28.use(status_routes_default);
+router28.use(auth_routes_default);
+router28.use(search_routes_default);
+router28.use(visualization_routes_default);
+router28.use(project_routes_default);
+router28.use(orm_routes_default);
+router28.use(data_dictionary_default);
+router28.use(ai_default);
+var routes_default = router28;
 
 // backend/src/server.ts
 init_logger();
@@ -163075,7 +163485,7 @@ if (process.env.SDD_DEV === "1") {
   } catch {
   }
 }
-var app = (0, import_express32.default)();
+var app = (0, import_express33.default)();
 var port = config.port;
 app.use((0, import_cors2.default)());
 app.use((req, res, next) => {
@@ -163092,7 +163502,7 @@ app.use((req, res, next) => {
   });
   next();
 });
-app.use(import_express32.default.json());
+app.use(import_express33.default.json());
 if (!config.isProduction) {
   app.get("/", (req, res) => {
     res.json({ message: "Welcome to the Data Dictionary Management System API" });
@@ -163210,7 +163620,7 @@ if (config.isProduction) {
     }
   });
   if (publicDir) {
-    app.use(import_express32.default.static(publicDir));
+    app.use(import_express33.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();