yamchart 0.7.2 → 0.8.1

package/dist/{dev-EUWIRL4N.js → dev-MRZ76V74.js}

@@ -1,7 +1,7 @@
 import {
   loadEnvFile,
   validateProject
-} from "./chunk-5VA43CTW.js";
+} from "./chunk-E2UZXDF6.js";
 import {
   box,
   detail,
@@ -16,9 +16,19 @@ import {
   ChartSchema,
   ConnectionSchema,
   DashboardSchema,
+  EventSchema,
+  EventsFileSchema,
   ProjectSchema,
-  ScheduleSchema
-} from "./chunk-UDRJFEJU.js";
+  ScheduleSchema,
+  SemanticQuerySchema
+} from "./chunk-X6LQGWUX.js";
+import {
+  AuthDatabase,
+  generateSessionToken,
+  hashPassword,
+  parseTtl,
+  verifyPassword
+} from "./chunk-4P5UHWYK.js";
 import {
   DuckDBConnector,
   MySQLConnector,
@@ -40,14 +50,13 @@ import {
   resolveMySQLAuth,
   resolvePostgresAuth,
   resolveSnowflakeAuth
-} from "./chunk-SSUVEADJ.js";
+} from "./chunk-JYQKDWLG.js";
 import {
-  AuthDatabase,
-  generateSessionToken,
-  hashPassword,
-  parseTtl,
-  verifyPassword
-} from "./chunk-4P5UHWYK.js";
+  SemanticModelBuilder,
+  SemanticQueryCompiler,
+  SemanticValidationError,
+  validateSemanticQuery
+} from "./chunk-UND73EOB.js";
 import "./chunk-DGUM43GV.js";
 
 // src/commands/dev.ts
@@ -76,6 +85,8 @@ var ConfigLoader = class {
   dashboardFolders = /* @__PURE__ */ new Map();
   dashboardFilePaths = /* @__PURE__ */ new Map();
   schedules = /* @__PURE__ */ new Map();
+  events = [];
+  validationErrors = /* @__PURE__ */ new Map();
   watcher = null;
   onChangeCallbacks = [];
   constructor(projectDir) {
@@ -91,12 +102,15 @@ var ConfigLoader = class {
     this.dashboardFolders.clear();
     this.dashboardFilePaths.clear();
     this.schedules.clear();
+    this.events = [];
+    this.validationErrors.clear();
     await this.loadProject();
     await this.loadConnections();
     await this.loadCharts();
     await this.loadModels();
     await this.loadDashboards();
     await this.loadSchedules();
+    await this.loadEvents();
   }
   async loadProject() {
     const projectPath = join(this.projectDir, "yamchart.yaml");
@@ -165,7 +179,16 @@ var ConfigLoader = class {
           const relDir = relative(baseDir, dirname(fullPath)).replace(/\\/g, "/");
           this.chartFolders.set(name, relDir || "");
         } else {
-          console.warn(`Invalid chart file ${entry.name}: ${result.error.message}`);
+          const relPath = relative(baseDir, fullPath);
+          const name = parsed && typeof parsed === "object" && "name" in parsed && typeof parsed.name === "string" ? parsed.name : void 0;
+          const errorMsg = result.error.errors.map((e) => {
+            const path = e.path.length > 0 ? e.path.join(".") : "(root)";
+            return `${path}: ${e.message}`;
+          }).join("; ");
+          console.warn(`Invalid chart file ${relPath}: ${errorMsg}`);
+          if (name) {
+            this.validationErrors.set(name, { file: relPath, message: errorMsg });
+          }
         }
       }
     }
@@ -230,7 +253,16 @@ var ConfigLoader = class {
           const relDir = relative(baseDir, dirname(fullPath)).replace(/\\/g, "/");
           this.dashboardFolders.set(name, relDir || "");
         } else {
-          console.warn(`Invalid dashboard file ${entry.name}: ${result.error.message}`);
+          const relPath = relative(baseDir, fullPath);
+          const name = parsed && typeof parsed === "object" && "name" in parsed && typeof parsed.name === "string" ? parsed.name : void 0;
+          const errorMsg = result.error.errors.map((e) => {
+            const path = e.path.length > 0 ? e.path.join(".") : "(root)";
+            return `${path}: ${e.message}`;
+          }).join("; ");
+          console.warn(`Invalid dashboard file ${relPath}: ${errorMsg}`);
+          if (name) {
+            this.validationErrors.set(name, { file: relPath, message: errorMsg });
+          }
         }
       }
     }
@@ -257,6 +289,22 @@ var ConfigLoader = class {
       }
     }
   }
+  async loadEvents() {
+    const eventsPath = join(this.projectDir, "events.yaml");
+    try {
+      await access(eventsPath);
+    } catch {
+      return;
+    }
+    const content = await readFile(eventsPath, "utf-8");
+    const parsed = parseYaml(content);
+    const result = EventsFileSchema.safeParse(parsed);
+    if (result.success) {
+      this.events = result.data.events;
+    } else {
+      console.warn(`Invalid events.yaml: ${result.error.message}`);
+    }
+  }
   startWatching() {
     if (this.watcher)
       return;
@@ -266,7 +314,8 @@ var ConfigLoader = class {
       join(this.projectDir, "charts"),
       join(this.projectDir, "models"),
       join(this.projectDir, "dashboards"),
-      join(this.projectDir, "schedules")
+      join(this.projectDir, "schedules"),
+      join(this.projectDir, "events.yaml")
     ];
     this.watcher = watch(watchPaths, {
       ignored: /(^|[\/\\])\../,
@@ -288,6 +337,17 @@ var ConfigLoader = class {
       console.log(`File removed: ${path}`);
       await this.reload();
     });
+    this.watcher.on("error", (err) => {
+      const code = err.code;
+      if (code === "EMFILE") {
+        console.warn(`Warning: Too many open files for file watching. The server will continue running but won't auto-reload on file changes.
+Fix: run "ulimit -n 10240" before starting yamchart dev, or add it to your shell profile.`);
+        this.watcher?.close();
+        this.watcher = null;
+      } else {
+        console.error("File watcher error:", err);
+      }
+    });
   }
   async reload() {
     try {
@@ -364,6 +424,18 @@ var ConfigLoader = class {
   getSchedules() {
     return Array.from(this.schedules.values());
   }
+  getEvents() {
+    return this.events;
+  }
+  getProjectDir() {
+    return this.projectDir;
+  }
+  getValidationError(name) {
+    return this.validationErrors.get(name);
+  }
+  getValidationErrors() {
+    return this.validationErrors;
+  }
 };
 
 // ../server/dist/services/cache.js
@@ -507,6 +579,24 @@ var QueryService = class {
   getCacheStats() {
     return this.cache.getStats();
   }
+  async executeRawSql(sql) {
+    return this.connector.execute(sql);
+  }
+  async executeModel(modelName, params, userContext, limit = 1e3, filters) {
+    const model = this.models.get(modelName);
+    if (!model) {
+      throw new Error(`Unknown model: ${modelName}`);
+    }
+    const context = createTemplateContext(params, this.refs, userContext);
+    let sql = renderTemplate(model.sql, context);
+    if (filters && Object.keys(filters).length > 0) {
+      const clauses = Object.entries(filters).map(([field, value]) => `${field} = '${value.replace(/'/g, "''")}'`);
+      sql = `SELECT * FROM (${sql}) _detail WHERE ${clauses.join(" AND ")} LIMIT ${limit}`;
+    } else {
+      sql = `SELECT * FROM (${sql}) _detail LIMIT ${limit}`;
+    }
+    return this.connector.execute(sql);
+  }
   async executeParameterOptions(modelName, valueField, labelField) {
     const model = this.models.get(modelName);
     if (!model) {
@@ -778,13 +868,30 @@ function buildComparisonResponse(input) {
     previousPeriodLabel: formatPeriodLabel(previousStart, previousEnd)
   };
 }
+function chartNotFoundResponse(configLoader, name) {
+  const validationError = configLoader.getValidationError(name);
+  if (validationError) {
+    return {
+      status: 422,
+      body: {
+        error: `Invalid chart config "${name}" (${validationError.file}): ${validationError.message}`,
+        errorType: "validation_error"
+      }
+    };
+  }
+  return {
+    status: 404,
+    body: { error: `Chart not found: ${name}`, errorType: "not_found" }
+  };
+}
 async function chartRoutes(fastify, options) {
   const { configLoader, queryService } = options;
   fastify.get("/api/charts/:name", async (request, reply) => {
     const { name } = request.params;
     const chart = configLoader.getChartByName(name);
     if (!chart) {
-      return reply.status(404).send({ error: `Chart not found: ${name}`, errorType: "not_found" });
+      const resp = chartNotFoundResponse(configLoader, name);
+      return reply.status(resp.status).send(resp.body);
     }
     return {
       name: chart.name,
@@ -801,7 +908,8 @@ async function chartRoutes(fastify, options) {
     const includeConfig = request.query.includeConfig === "true";
     const chart = configLoader.getChartByName(name);
     if (!chart) {
-      return reply.status(404).send({ error: `Chart not found: ${name}`, errorType: "not_found" });
+      const resp = chartNotFoundResponse(configLoader, name);
+      return reply.status(resp.status).send(resp.body);
     }
     try {
       const result = await queryService.executeChart(chart, params, getUserContext(request));
@@ -867,18 +975,70 @@ async function chartRoutes(fastify, options) {
           title: chart.title,
           description: chart.description,
           parameters: chart.parameters ?? [],
-          chart: chart.chart
+          chart: chart.chart,
+          drillDown: chart.drillDown
         };
       }
       if (comparison) {
         response.comparison = comparison;
       }
+      let goalData = void 0;
+      const goals = chart.chart?.goals;
+      const modelGoal = goals?.find((g) => g.type === "model" && g.source?.model);
+      if (modelGoal?.source) {
+        try {
+          const goalResult = await queryService.executeModel(modelGoal.source.model, params, getUserContext(request));
+          goalData = { rows: goalResult.rows };
+        } catch {
+        }
+      }
+      if (goalData) {
+        response.goalData = goalData;
+      }
       return response;
     } catch (error2) {
       const message = error2 instanceof Error ? error2.message : "Query execution failed";
       return reply.status(500).send({ error: message, errorType: classifyError(error2) });
     }
   });
+  fastify.post("/api/charts/:name/detail", async (request, reply) => {
+    const { name } = request.params;
+    const params = request.body ?? {};
+    const chart = configLoader.getChartByName(name);
+    if (!chart) {
+      const resp = chartNotFoundResponse(configLoader, name);
+      return reply.status(resp.status).send(resp.body);
+    }
+    const detailModel = chart.drillDown?.model;
+    if (!detailModel) {
+      return reply.status(400).send({
+        error: "Chart has no detail model configured",
+        errorType: "validation_error"
+      });
+    }
+    try {
+      const dd = chart.drillDown;
+      const drillFields = dd.fields ? typeof dd.fields === "string" ? [dd.fields] : dd.fields : dd.field ? [dd.field] : [];
+      const drillFilters = {};
+      for (const f of drillFields) {
+        if (params[f] != null && params[f] !== "") {
+          drillFilters[f] = String(params[f]);
+        }
+      }
+      const result = await queryService.executeModel(detailModel, params, getUserContext(request), 1e3, Object.keys(drillFilters).length > 0 ? drillFilters : void 0);
+      return {
+        columns: result.columns,
+        rows: result.rows,
+        meta: {
+          rowCount: result.rowCount,
+          durationMs: result.durationMs
+        }
+      };
+    } catch (error2) {
+      const message = error2 instanceof Error ? error2.message : "Detail query failed";
+      return reply.status(500).send({ error: message, errorType: classifyError(error2) });
+    }
+  });
   fastify.post("/api/charts/batch", async (request, reply) => {
     const { charts, includeConfig } = request.body;
     if (!charts || !Array.isArray(charts)) {
@@ -887,7 +1047,8 @@ async function chartRoutes(fastify, options) {
     const results = await Promise.all(charts.map(async ({ name, params = {} }) => {
       const chart = configLoader.getChartByName(name);
       if (!chart) {
-        return { name, error: `Chart not found: ${name}`, errorType: "not_found" };
+        const resp = chartNotFoundResponse(configLoader, name);
+        return { name, ...resp.body };
       }
       try {
         const result = await queryService.executeChart(chart, params, getUserContext(request));
@@ -908,9 +1069,19 @@ async function chartRoutes(fastify, options) {
             title: chart.title,
             description: chart.description,
             parameters: chart.parameters ?? [],
-            chart: chart.chart
+            chart: chart.chart,
+            drillDown: chart.drillDown
           };
         }
+        const goals = chart.chart?.goals;
+        const modelGoal = goals?.find((g) => g.type === "model" && g.source?.model);
+        if (modelGoal?.source) {
+          try {
+            const goalResult = await queryService.executeModel(modelGoal.source.model, params, getUserContext(request));
+            response.goalData = { rows: goalResult.rows };
+          } catch {
+          }
+        }
         return response;
       } catch (error2) {
         const message = error2 instanceof Error ? error2.message : "Query failed";
@@ -923,7 +1094,8 @@ async function chartRoutes(fastify, options) {
     const { name } = request.params;
     const chart = configLoader.getChartByName(name);
     if (!chart) {
-      return reply.status(404).send({ error: `Chart not found: ${name}`, errorType: "not_found" });
+      const resp = chartNotFoundResponse(configLoader, name);
+      return reply.status(resp.status).send(resp.body);
     }
     queryService.invalidateChart(name);
     return { success: true, message: `Cache invalidated for chart: ${name}` };
@@ -932,7 +1104,8 @@ async function chartRoutes(fastify, options) {
     const { chartName, paramName } = request.params;
     const chart = configLoader.getChartByName(chartName);
     if (!chart) {
-      return reply.status(404).send({ error: `Chart not found: ${chartName}`, errorType: "not_found" });
+      const resp = chartNotFoundResponse(configLoader, chartName);
+      return reply.status(resp.status).send(resp.body);
     }
     const param = chart.parameters?.find((p) => p.name === paramName);
     if (!param) {
@@ -954,10 +1127,73 @@ async function chartRoutes(fastify, options) {
   });
 }
 
-// ../server/dist/routes/dashboards.js
-import { writeFile } from "fs/promises";
+// ../server/dist/routes/chart-events.js
+import { readFile as readFile2, writeFile } from "fs/promises";
 import { join as join3 } from "path";
-import { stringify as stringifyYaml } from "yaml";
+import { parse as parseYaml2, stringify as stringifyYaml } from "yaml";
+async function readEventsFile(projectDir) {
+  const eventsPath = join3(projectDir, "events.yaml");
+  try {
+    const content = await readFile2(eventsPath, "utf-8");
+    const parsed = parseYaml2(content);
+    const result = EventsFileSchema.safeParse(parsed);
+    return result.success ? result.data.events : [];
+  } catch {
+    return [];
+  }
+}
+async function writeEventsFile(projectDir, events) {
+  const eventsPath = join3(projectDir, "events.yaml");
+  await writeFile(eventsPath, stringifyYaml({ events }));
+}
+async function chartEventsRoutes(fastify, options) {
+  const { configLoader, projectDir } = options;
+  fastify.get("/api/chart-events", async () => {
+    return { events: configLoader.getEvents() };
+  });
+  fastify.post("/api/chart-events", async (request, reply) => {
+    const result = EventSchema.safeParse(request.body);
+    if (!result.success) {
+      return reply.status(400).send({ error: result.error.message });
+    }
+    const events = await readEventsFile(projectDir);
+    events.push(result.data);
+    await writeEventsFile(projectDir, events);
+    await configLoader.load();
+    return reply.status(201).send({ event: result.data, index: events.length - 1 });
+  });
+  fastify.delete("/api/chart-events/:index", async (request, reply) => {
+    const index = parseInt(request.params.index, 10);
+    const events = await readEventsFile(projectDir);
+    if (isNaN(index) || index < 0 || index >= events.length) {
+      return reply.status(404).send({ error: "Event not found" });
+    }
+    events.splice(index, 1);
+    await writeEventsFile(projectDir, events);
+    await configLoader.load();
+    return { success: true };
+  });
+  fastify.put("/api/chart-events/:index", async (request, reply) => {
+    const index = parseInt(request.params.index, 10);
+    const events = await readEventsFile(projectDir);
+    if (isNaN(index) || index < 0 || index >= events.length) {
+      return reply.status(404).send({ error: "Event not found" });
+    }
+    const result = EventSchema.safeParse(request.body);
+    if (!result.success) {
+      return reply.status(400).send({ error: result.error.message });
+    }
+    events[index] = result.data;
+    await writeEventsFile(projectDir, events);
+    await configLoader.load();
+    return { event: result.data };
+  });
+}
+
+// ../server/dist/routes/dashboards.js
+import { writeFile as writeFile2 } from "fs/promises";
+import { join as join4 } from "path";
+import { stringify as stringifyYaml2 } from "yaml";
 function classifyError2(error2) {
   const msg = error2 instanceof Error ? error2.message : String(error2);
   const lower = msg.toLowerCase();
@@ -969,6 +1205,22 @@ function classifyError2(error2) {
   }
   return "query_error";
 }
+function dashboardNotFoundResponse(configLoader, name) {
+  const validationError = configLoader.getValidationError(name);
+  if (validationError) {
+    return {
+      status: 422,
+      body: {
+        error: `Invalid dashboard config "${name}" (${validationError.file}): ${validationError.message}`,
+        errorType: "validation_error"
+      }
+    };
+  }
+  return {
+    status: 404,
+    body: { error: `Dashboard not found: ${name}`, errorType: "not_found" }
+  };
+}
 async function dashboardRoutes(fastify, options) {
   const { configLoader, gitService, projectDir } = options;
   fastify.get("/api/dashboards", async () => {
@@ -984,7 +1236,8 @@ async function dashboardRoutes(fastify, options) {
     const { id } = request.params;
     const dashboard = configLoader.getDashboardByName(id);
     if (!dashboard) {
-      return reply.status(404).send({ error: `Dashboard not found: ${id}`, errorType: "not_found" });
+      const resp = dashboardNotFoundResponse(configLoader, id);
+      return reply.status(resp.status).send(resp.body);
     }
     const currentBranch = await gitService.getCurrentBranch();
     return {
@@ -1018,8 +1271,8 @@ async function dashboardRoutes(fastify, options) {
       }
       updated = { ...dashboard, layout };
     }
-    const filePath = configLoader.getDashboardFilePath(id) ?? join3(projectDir, "dashboards", `${id}.yaml`);
-    await writeFile(filePath, stringifyYaml(updated));
+    const filePath = configLoader.getDashboardFilePath(id) ?? join4(projectDir, "dashboards", `${id}.yaml`);
+    await writeFile2(filePath, stringifyYaml2(updated));
     await configLoader.load();
     const commitMessage = message || `Update ${dashboard.title} layout`;
     const result = await gitService.commitAndPush(commitMessage);
@@ -1066,6 +1319,10 @@ async function dashboardRoutes(fastify, options) {
     const results = await Promise.all(chartRefs.map(async (chartRef) => {
       const chart = configLoader.getChartByName(chartRef);
       if (!chart) {
+        const validationError = configLoader.getValidationError(chartRef);
+        if (validationError) {
+          return { chart: chartRef, error: `Invalid chart config: ${validationError.message}`, errorType: "validation_error" };
+        }
         return { chart: chartRef, error: "Chart not found", errorType: "not_found" };
       }
       try {
@@ -1132,6 +1389,143 @@ async function dashboardRoutes(fastify, options) {
   });
 }
 
+// ../server/dist/routes/semantic.js
+async function semanticRoutes(fastify, options) {
+  const { semanticService, queryService, projectDir } = options;
+  fastify.get("/api/semantic/meta", async (_request2, reply) => {
+    const model = semanticService.getModel();
+    if (!model) {
+      return reply.status(503).send({
+        error: "Semantic model not built. Ensure catalog.json exists or models are loaded.",
+        errorType: "not_ready"
+      });
+    }
+    return model;
+  });
+  fastify.post("/api/semantic/query", async (request, reply) => {
+    const parseResult = SemanticQuerySchema.safeParse(request.body);
+    if (!parseResult.success) {
+      return reply.status(400).send({
+        error: parseResult.error.issues.map((i) => i.message).join("; "),
+        errorType: "validation_error"
+      });
+    }
+    const query = parseResult.data;
+    try {
+      const result = semanticService.compileQuery(query);
+      if (queryService && typeof queryService.executeRawSql === "function") {
+        try {
+          const startTime = Date.now();
+          const queryResult = await queryService.executeRawSql(result.sql);
+          const duration = Date.now() - startTime;
+          return {
+            columns: queryResult.columns,
+            rows: queryResult.rows,
+            meta: {
+              compiled_sql: result.sql,
+              duration_ms: duration,
+              tier: result.tier,
+              entity: result.entity,
+              row_count: queryResult.rows.length
+            }
+          };
+        } catch (execError) {
+          const message = execError instanceof Error ? execError.message : String(execError);
+          return reply.status(500).send({
+            error: message,
+            errorType: "query_error",
+            compiled_sql: result.sql
+          });
+        }
+      }
+      return {
+        columns: [],
+        rows: [],
+        meta: {
+          compiled_sql: result.sql,
+          tier: result.tier,
+          entity: result.entity
+        }
+      };
+    } catch (error2) {
+      if (error2 instanceof SemanticValidationError) {
+        return reply.status(400).send({
+          error: error2.message,
+          errorType: "validation_error",
+          code: error2.code,
+          available: error2.available
+        });
+      }
+      throw error2;
+    }
+  });
+  fastify.post("/api/semantic/save-model", async (request, reply) => {
+    const { name, sql, path: filePath } = request.body;
+    if (!name || !sql || !filePath) {
+      return reply.status(400).send({
+        error: "name, sql, and path are required",
+        errorType: "validation_error"
+      });
+    }
+    const { writeFileSync, mkdirSync } = await import("fs");
+    const { join: join7, dirname: dirname3 } = await import("path");
+    const fullPath = join7(projectDir, filePath);
+    mkdirSync(dirname3(fullPath), { recursive: true });
+    writeFileSync(fullPath, sql, "utf-8");
+    return { saved: true, path: filePath };
+  });
+  fastify.post("/api/semantic/rebuild", async () => {
+    semanticService.buildFromDisk();
+    const model = semanticService.getModel();
+    return {
+      rebuilt: true,
+      entity_count: model?.entities.length ?? 0,
+      generated_at: model?.generated_at
+    };
+  });
+}
+
+// ../server/dist/services/semantic-service.js
+import { readFileSync, existsSync } from "fs";
+import { join as join5 } from "path";
+var SemanticService = class {
+  model = null;
+  builder;
+  compiler = new SemanticQueryCompiler();
+  projectDir;
+  constructor(options) {
+    this.projectDir = options.projectDir;
+    this.builder = new SemanticModelBuilder(options.config);
+  }
+  getModel() {
+    return this.model;
+  }
+  build(input) {
+    this.model = this.builder.build(input);
+  }
+  buildFromDisk(models, chartHints) {
+    const catalogPath = join5(this.projectDir, ".yamchart", "catalog.json");
+    let catalog;
+    if (existsSync(catalogPath)) {
+      const raw = readFileSync(catalogPath, "utf-8");
+      catalog = JSON.parse(raw);
+    }
+    this.build({ catalog, models, chartHints });
+  }
+  compileQuery(query) {
+    if (!this.model) {
+      throw new Error("Semantic model not built. Run build() first.");
+    }
+    validateSemanticQuery(this.model, query);
+    const sql = this.compiler.compile(this.model, query);
+    return {
+      sql,
+      tier: "direct",
+      entity: query.model
+    };
+  }
+};
+
 // ../server/dist/services/slack-notifier.js
 var MAX_TABLE_ROWS = 10;
 var OPERATOR_SYMBOLS = {
@@ -4122,8 +4516,8 @@ var RealtimeChannel = class _RealtimeChannel {
   _trigger(type, payload, ref) {
     var _a, _b;
     const typeLower = type.toLocaleLowerCase();
-    const { close, error: error2, leave, join: join5 } = CHANNEL_EVENTS;
-    const events = [close, error2, leave, join5];
+    const { close, error: error2, leave, join: join7 } = CHANNEL_EVENTS;
+    const events = [close, error2, leave, join7];
     if (ref && events.indexOf(typeLower) >= 0 && ref !== this._joinRef()) {
       return;
     }
@@ -13352,6 +13746,10 @@ async function publicRoutes(fastify, options) {
       return;
     const chart = configLoader.getChartByName(name);
     if (!chart) {
+      const validationError = configLoader.getValidationError(name);
+      if (validationError) {
+        return reply.status(422).send({ error: `Invalid chart config "${name}" (${validationError.file}): ${validationError.message}` });
+      }
       return reply.status(404).send({ error: `Chart not found: ${name}` });
     }
     try {
@@ -13390,6 +13788,10 @@ async function publicRoutes(fastify, options) {
       return;
     const chart = configLoader.getChartByName(name);
     if (!chart) {
+      const validationError = configLoader.getValidationError(name);
+      if (validationError) {
+        return reply.status(422).send({ error: `Invalid chart config "${name}" (${validationError.file}): ${validationError.message}` });
+      }
       return reply.status(404).send({ error: `Chart not found: ${name}` });
     }
     return {
@@ -13407,6 +13809,10 @@ async function publicRoutes(fastify, options) {
       return;
     const dashboard = configLoader.getDashboardByName(id);
     if (!dashboard) {
+      const validationError = configLoader.getValidationError(id);
+      if (validationError) {
+        return reply.status(422).send({ error: `Invalid dashboard config "${id}" (${validationError.file}): ${validationError.message}` });
+      }
       return reply.status(404).send({ error: `Dashboard not found: ${id}` });
     }
     return {
@@ -13457,8 +13863,13 @@ async function publicRoutes(fastify, options) {
         return { name, error: "Access denied" };
       }
       const chart = configLoader.getChartByName(name);
-      if (!chart)
+      if (!chart) {
+        const validationError = configLoader.getValidationError(name);
+        if (validationError) {
+          return { name, error: `Invalid chart config "${name}" (${validationError.file}): ${validationError.message}` };
+        }
         return { name, error: `Chart not found: ${name}` };
+      }
       try {
         const result = await queryService.executeChart(chart, params);
         const response = {
@@ -13608,7 +14019,7 @@ async function chatRoutes(fastify, options) {
         systemParts.push("Output ONLY the new text to insert. Do NOT repeat the existing content.");
       }
       const systemPrompt = systemParts.join("\n");
-      const { AnthropicProvider } = await import("./dist-YTGUIBKG.js");
+      const { AnthropicProvider } = await import("./dist-WDTDQDTX.js");
       const provider = new AnthropicProvider(apiKey);
       const response = await provider.chat({
         system: systemPrompt,
@@ -13647,6 +14058,12 @@ async function eventsRoute(fastify) {
     });
   });
 }
+function closeAllClients() {
+  for (const client of clients) {
+    client.end();
+  }
+  clients.clear();
+}
 function broadcastConfigChange() {
   const data = JSON.stringify({ type: "config-change", timestamp: Date.now() });
   const message = `event: config-change
@@ -13659,17 +14076,18 @@ data: ${data}
 }
 
 // ../server/dist/server.js
-import { join as join4, dirname as dirname2 } from "path";
+import { join as join6, dirname as dirname2 } from "path";
 import { fileURLToPath } from "url";
-import { access as access2, readFile as readFile2 } from "fs/promises";
+import { access as access2, readFile as readFile3 } from "fs/promises";
+import { watch as fsWatch } from "fs";
 var __dirname = dirname2(fileURLToPath(import.meta.url));
-var packageJsonPath = join4(__dirname, "..", "package.json");
-var packageJson = JSON.parse(await readFile2(packageJsonPath, "utf-8"));
+var packageJsonPath = join6(__dirname, "..", "package.json");
+var packageJson = JSON.parse(await readFile3(packageJsonPath, "utf-8"));
 var VERSION = packageJson.version;
 async function enrichRefsFromCatalog(projectDir, refs) {
   try {
-    const catalogPath = join4(projectDir, ".yamchart", "catalog.json");
-    const catalogData = JSON.parse(await readFile2(catalogPath, "utf-8"));
+    const catalogPath = join6(projectDir, ".yamchart", "catalog.json");
+    const catalogData = JSON.parse(await readFile3(catalogPath, "utf-8"));
     for (const model of catalogData.models ?? []) {
       if (model.name && model.table) {
         refs[model.name] = model.table;
@@ -13679,7 +14097,7 @@ async function enrichRefsFromCatalog(projectDir, refs) {
   }
 }
 async function createServer(options) {
-  const { projectDir, port = 3001, host = "0.0.0.0", watch: watch2 = false, serveStatic = process.env.NODE_ENV === "production", staticDir = join4(__dirname, "public"), auth } = options;
+  const { projectDir, port = 3001, host = "0.0.0.0", watch: watch2 = false, serveStatic = process.env.NODE_ENV === "production", staticDir = join6(__dirname, "public"), auth } = options;
   if (auth) {
     initAuthServer(auth.supabaseUrl, auth.supabaseServiceKey);
   }
@@ -13734,6 +14152,12 @@ async function createServer(options) {
     models,
     refs
   });
+  const semanticService = new SemanticService({
+    projectDir,
+    config: project.semantic
+  });
+  semanticService.buildFromDisk();
+  fastify.log.info(`Semantic model built: ${semanticService.getModel()?.entities.length ?? 0} entities`);
   const notifier = new SlackNotifier();
   const baseUrl = project.defaults?.base_url ?? process.env.BASE_URL ?? void 0;
   const schedulerService = new SchedulerService(queryService, configLoader, notifier, baseUrl);
@@ -13767,6 +14191,7 @@ async function createServer(options) {
       });
     }
   });
+  await fastify.register(semanticRoutes, { semanticService, queryService, projectDir });
   if (authDb) {
     const secureCookies = process.env.NODE_ENV === "production";
     const sessionTtlMs = options.localAuth.sessionTtlMs;
@@ -13802,6 +14227,7 @@ async function createServer(options) {
       protectedRoutes.addHook("preHandler", orgMiddleware);
       await protectedRoutes.register(configRoutes, { configLoader, projectDir, queryService });
       await protectedRoutes.register(chartRoutes, { configLoader, queryService });
+      await protectedRoutes.register(chartEventsRoutes, { configLoader, projectDir });
       await protectedRoutes.register(dashboardRoutes, { configLoader, gitService, projectDir, queryService });
       await protectedRoutes.register(chatRoutes, { configLoader, queryService, projectDir });
     });
@@ -13811,6 +14237,7 @@ async function createServer(options) {
       protectedRoutes.addHook("preHandler", localMiddleware);
       await protectedRoutes.register(configRoutes, { configLoader, projectDir, queryService });
       await protectedRoutes.register(chartRoutes, { configLoader, queryService });
+      await protectedRoutes.register(chartEventsRoutes, { configLoader, projectDir });
       await protectedRoutes.register(dashboardRoutes, { configLoader, gitService, projectDir, queryService });
       await protectedRoutes.register(chatRoutes, { configLoader, queryService, projectDir });
       await protectedRoutes.register(sharesRoutes, { authDb });
@@ -13818,10 +14245,11 @@ async function createServer(options) {
   } else {
     await fastify.register(configRoutes, { configLoader, projectDir, queryService });
     await fastify.register(chartRoutes, { configLoader, queryService });
+    await fastify.register(chartEventsRoutes, { configLoader, projectDir });
     await fastify.register(dashboardRoutes, { configLoader, gitService, projectDir, queryService });
     await fastify.register(chatRoutes, { configLoader, queryService, projectDir });
   }
-  const assetsDir = join4(projectDir, "assets");
+  const assetsDir = join6(projectDir, "assets");
   try {
     await access2(assetsDir);
     await fastify.register(fastifyStatic, {
@@ -13832,10 +14260,10 @@ async function createServer(options) {
   } catch {
   }
   if (project.theme?.customCss) {
-    const cssPath = join4(projectDir, project.theme.customCss);
+    const cssPath = join6(projectDir, project.theme.customCss);
     fastify.get("/api/theme/custom.css", async (_request2, reply) => {
       try {
-        const content = await readFile2(cssPath, "utf-8");
+        const content = await readFile3(cssPath, "utf-8");
         return reply.type("text/css").send(content);
       } catch {
         return reply.status(404).send("");
@@ -13873,6 +14301,7 @@ async function createServer(options) {
     await enrichRefsFromCatalog(projectDir, refs2);
     return { models: models2, refs: refs2 };
   }
+  let catalogWatcher = null;
   if (watch2) {
     await fastify.register(eventsRoute);
     configLoader.startWatching();
@@ -13886,8 +14315,18 @@ async function createServer(options) {
       if (newSchedules.length > 0) {
         schedulerService.start(newSchedules);
       }
+      semanticService.buildFromDisk();
+      fastify.log.info(`Semantic model rebuilt: ${semanticService.getModel()?.entities.length ?? 0} entities`);
       broadcastConfigChange();
     });
+    const catalogPath = join6(projectDir, ".yamchart", "catalog.json");
+    try {
+      catalogWatcher = fsWatch(catalogPath, () => {
+        semanticService.buildFromDisk();
+        fastify.log.info(`Semantic model rebuilt (catalog change): ${semanticService.getModel()?.entities.length ?? 0} entities`);
+      });
+    } catch {
+    }
   }
   return {
     fastify,
@@ -13915,6 +14354,8 @@ async function createServer(options) {
       await configLoader.stop();
       await connector.disconnect();
       authDb?.close();
+      catalogWatcher?.close();
+      closeAllClients();
       await fastify.close();
     }
   };
@@ -13942,9 +14383,9 @@ async function runDevServer(projectDir, options) {
   let usesBrowserAuth = false;
   let localAuth;
   try {
-    const { readFileSync } = await import("fs");
+    const { readFileSync: readFileSync2 } = await import("fs");
     const { parse } = await import("yaml");
-    const raw = readFileSync(resolve(projectDir, "yamchart.yaml"), "utf-8");
+    const raw = readFileSync2(resolve(projectDir, "yamchart.yaml"), "utf-8");
     const projectConfig = parse(raw);
     if (projectConfig?.auth?.enabled) {
       localAuth = {
@@ -13957,7 +14398,7 @@ async function runDevServer(projectDir, options) {
     const targetConn = process.env.YAMCHART_CONNECTION || projectConfig?.defaults?.connection;
     if (targetConn) {
       try {
-        const connRaw = readFileSync(resolve(connectionDir, `${targetConn}.yaml`), "utf-8");
+        const connRaw = readFileSync2(resolve(connectionDir, `${targetConn}.yaml`), "utf-8");
         const connConfig = parse(connRaw);
         if (connConfig?.auth?.type === "externalbrowser") {
           usesBrowserAuth = true;
@@ -14023,4 +14464,4 @@ async function runDevServer(projectDir, options) {
 export {
   runDevServer
 };
-//# sourceMappingURL=dev-EUWIRL4N.js.map
+//# sourceMappingURL=dev-MRZ76V74.js.map