@contractspec/example.analytics-dashboard 1.57.0 → 1.58.0

package/dist/browser/index.js

@@ -0,0 +1,1677 @@
+// src/dashboard.feature.ts
+import { defineFeature } from "@contractspec/lib.contracts";
+var AnalyticsDashboardFeature = defineFeature({
+  meta: {
+    key: "analytics-dashboard",
+    version: "1.0.0",
+    title: "Analytics Dashboard",
+    description: "Analytics dashboards with customizable widgets and queries",
+    domain: "analytics",
+    owners: ["@analytics-dashboard"],
+    tags: ["analytics", "dashboards", "widgets", "queries"],
+    stability: "experimental"
+  },
+  operations: [
+    { key: "analytics.dashboard.create", version: "1.0.0" },
+    { key: "analytics.dashboard.list", version: "1.0.0" },
+    { key: "analytics.dashboard.get", version: "1.0.0" },
+    { key: "analytics.widget.add", version: "1.0.0" },
+    { key: "analytics.query.create", version: "1.0.0" },
+    { key: "analytics.query.execute", version: "1.0.0" }
+  ],
+  events: [
+    { key: "analytics.dashboard.created", version: "1.0.0" },
+    { key: "analytics.widget.added", version: "1.0.0" },
+    { key: "analytics.query.created", version: "1.0.0" }
+  ],
+  presentations: [
+    { key: "analytics.dashboard.viewList", version: "1.0.0" },
+    { key: "analytics.dashboard.view", version: "1.0.0" },
+    { key: "analytics.dashboard.editor", version: "1.0.0" },
+    { key: "analytics.query.list", version: "1.0.0" },
+    { key: "analytics.query.builder", version: "1.0.0" }
+  ],
+  opToPresentation: [
+    {
+      op: { key: "analytics.dashboard.list", version: "1.0.0" },
+      pres: { key: "analytics.dashboard.viewList", version: "1.0.0" }
+    },
+    {
+      op: { key: "analytics.dashboard.get", version: "1.0.0" },
+      pres: { key: "analytics.dashboard.view", version: "1.0.0" }
+    },
+    {
+      op: { key: "analytics.dashboard.create", version: "1.0.0" },
+      pres: { key: "analytics.dashboard.editor", version: "1.0.0" }
+    },
+    {
+      op: { key: "analytics.query.create", version: "1.0.0" },
+      pres: { key: "analytics.query.builder", version: "1.0.0" }
+    }
+  ],
+  presentationsTargets: [
+    {
+      key: "analytics.dashboard.viewList",
+      version: "1.0.0",
+      targets: ["react", "markdown", "application/json"]
+    },
+    {
+      key: "analytics.dashboard.view",
+      version: "1.0.0",
+      targets: ["react", "markdown"]
+    },
+    {
+      key: "analytics.dashboard.editor",
+      version: "1.0.0",
+      targets: ["react"]
+    },
+    {
+      key: "analytics.query.builder",
+      version: "1.0.0",
+      targets: ["react"]
+    }
+  ],
+  capabilities: {
+    requires: [
+      { key: "identity", version: "1.0.0" },
+      { key: "metering", version: "1.0.0" },
+      { key: "audit-trail", version: "1.0.0" }
+    ]
+  }
+});
+
+// src/datasource/posthog-datasource.ts
+class PosthogQueryEngine {
+  reader;
+  defaultLimit;
+  constructor(reader, options = {}) {
+    this.reader = reader;
+    this.defaultLimit = options.defaultLimit ?? 100;
+  }
+  async execute(definition, params) {
+    const startTime = Date.now();
+    const validation = this.validateQuery(definition);
+    if (!validation.valid) {
+      return {
+        data: [],
+        columns: [],
+        rowCount: 0,
+        executionTimeMs: Date.now() - startTime,
+        cached: false,
+        error: validation.errors.join(", ")
+      };
+    }
+    if (!this.reader.queryHogQL) {
+      return {
+        data: [],
+        columns: [],
+        rowCount: 0,
+        executionTimeMs: Date.now() - startTime,
+        cached: false,
+        error: "Analytics reader does not support HogQL queries."
+      };
+    }
+    try {
+      const result = await this.executeHogQL(definition, params);
+      return {
+        data: result.data,
+        columns: result.columns,
+        rowCount: result.rowCount,
+        executionTimeMs: Date.now() - startTime,
+        cached: false
+      };
+    } catch (error) {
+      return {
+        data: [],
+        columns: [],
+        rowCount: 0,
+        executionTimeMs: Date.now() - startTime,
+        cached: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      };
+    }
+  }
+  validateQuery(definition) {
+    const errors = [];
+    if (definition.type === "SQL" && !definition.sql) {
+      errors.push("SQL query is missing.");
+    }
+    if (definition.type === "AGGREGATION" && !definition.aggregation) {
+      errors.push("Aggregation definition is missing.");
+    }
+    if (definition.type === "METRIC" && !definition.metricIds?.length) {
+      errors.push("Metric IDs are missing.");
+    }
+    if (definition.type === "CUSTOM" && !definition.custom?.handler) {
+      errors.push("Custom handler is missing.");
+    }
+    return { valid: errors.length === 0, errors };
+  }
+  async executeHogQL(definition, params) {
+    if (!this.reader.queryHogQL) {
+      throw new Error("Analytics reader does not support HogQL queries.");
+    }
+    if (definition.type === "SQL") {
+      const result = await this.reader.queryHogQL({
+        query: definition.sql ?? "",
+        values: params.parameters ?? {}
+      });
+      return mapHogqlResult(result);
+    }
+    if (definition.type === "AGGREGATION" && definition.aggregation) {
+      const { query, values } = buildAggregationQuery(definition.aggregation, params);
+      const result = await this.reader.queryHogQL({ query, values });
+      return mapHogqlResult(result);
+    }
+    if (definition.type === "METRIC" && definition.metricIds) {
+      const { query, values } = buildMetricQuery(definition.metricIds, params);
+      const result = await this.reader.queryHogQL({ query, values });
+      return mapHogqlResult(result);
+    }
+    throw new Error("Unsupported query type for PostHog datasource.");
+  }
+}
+function createPosthogQueryEngine(reader, options) {
+  return new PosthogQueryEngine(reader, options);
+}
+function buildMetricQuery(metricIds, params) {
+  const range = resolveDateRange(params);
+  const values = {
+    dateFrom: range?.from.toISOString(),
+    dateTo: range?.to.toISOString()
+  };
+  const metricClauses = metricIds.map((metricId, index) => {
+    values[`metric${index}`] = metricId;
+    return `event = {metric${index}}`;
+  });
+  const whereClauses = [
+    metricClauses.length ? `(${metricClauses.join(" or ")})` : "",
+    range ? "timestamp >= {dateFrom} and timestamp < {dateTo}" : ""
+  ].filter(Boolean).join(" and ");
+  return {
+    query: [
+      "select",
+      "  event as metric,",
+      "  count() as total",
+      "from events",
+      whereClauses ? `where ${whereClauses}` : "",
+      "group by metric"
+    ].filter(Boolean).join(`
+`),
+    values
+  };
+}
+function buildAggregationQuery(aggregation, params) {
+  const measures = aggregation.measures.map((measure) => ({
+    ...measure,
+    expression: buildMeasureExpression(measure.field, measure.aggregation)
+  }));
+  const dimensions = aggregation.dimensions.map((dimension) => ({
+    ...dimension,
+    expression: buildDimensionExpression(dimension.field, dimension.type, dimension.granularity)
+  }));
+  const selections = [
+    ...dimensions.map((dimension) => `${dimension.expression} as ${dimension.name}`),
+    ...measures.map((measure) => `${measure.expression} as ${measure.name}`)
+  ];
+  const values = {};
+  const filters = buildFilterClauses(aggregation, params, values);
+  const limit = aggregation.limit ?? 100;
+  const orderBy = aggregation.orderBy?.length ? `order by ${aggregation.orderBy.map((order) => `${order.field} ${order.direction}`).join(", ")}` : "";
+  return {
+    query: [
+      "select",
+      `  ${selections.join(`,
+  `)}`,
+      `from ${aggregation.source}`,
+      filters.length ? `where ${filters.join(" and ")}` : "",
+      dimensions.length ? `group by ${dimensions.map((d) => d.name).join(", ")}` : "",
+      orderBy,
+      `limit ${limit}`
+    ].filter(Boolean).join(`
+`),
+    values
+  };
+}
+function buildMeasureExpression(field, aggregation) {
+  switch (aggregation) {
+    case "COUNT":
+      return field === "*" ? "count()" : `count(${field})`;
+    case "COUNT_DISTINCT":
+      return `countDistinct(${field})`;
+    case "SUM":
+      return `sum(${field})`;
+    case "AVG":
+      return `avg(${field})`;
+    case "MIN":
+      return `min(${field})`;
+    case "MAX":
+      return `max(${field})`;
+    default:
+      return `count(${field})`;
+  }
+}
+function buildDimensionExpression(field, type, granularity) {
+  if (type === "TIME") {
+    switch (granularity) {
+      case "HOUR":
+        return `toStartOfHour(${field})`;
+      case "WEEK":
+        return `toStartOfWeek(${field})`;
+      case "MONTH":
+        return `toStartOfMonth(${field})`;
+      case "YEAR":
+        return `toStartOfYear(${field})`;
+      case "DAY":
+      default:
+        return `toStartOfDay(${field})`;
+    }
+  }
+  return field;
+}
+function buildFilterClauses(aggregation, params, values) {
+  const clauses = [];
+  const range = resolveDateRange(params);
+  if (range) {
+    values.dateFrom = range.from.toISOString();
+    values.dateTo = range.to.toISOString();
+    clauses.push(`timestamp >= {dateFrom} and timestamp < {dateTo}`);
+  }
+  aggregation.filters?.forEach((filter, index) => {
+    const key = `filter${index}`;
+    switch (filter.operator) {
+      case "eq":
+        values[key] = filter.value;
+        clauses.push(`${filter.field} = {${key}}`);
+        break;
+      case "neq":
+        values[key] = filter.value;
+        clauses.push(`${filter.field} != {${key}}`);
+        break;
+      case "gt":
+        values[key] = filter.value;
+        clauses.push(`${filter.field} > {${key}}`);
+        break;
+      case "gte":
+        values[key] = filter.value;
+        clauses.push(`${filter.field} >= {${key}}`);
+        break;
+      case "lt":
+        values[key] = filter.value;
+        clauses.push(`${filter.field} < {${key}}`);
+        break;
+      case "lte":
+        values[key] = filter.value;
+        clauses.push(`${filter.field} <= {${key}}`);
+        break;
+      case "contains":
+        values[key] = filter.value;
+        clauses.push(`${filter.field} LIKE '%' || {${key}} || '%'`);
+        break;
+      case "between": {
+        if (Array.isArray(filter.value) && filter.value.length >= 2) {
+          values[`${key}Start`] = filter.value[0];
+          values[`${key}End`] = filter.value[1];
+          clauses.push(`${filter.field} BETWEEN {${key}Start} AND {${key}End}`);
+        }
+        break;
+      }
+      case "in":
+      case "nin":
+        if (Array.isArray(filter.value)) {
+          const placeholders = [];
+          filter.value.forEach((value, valueIndex) => {
+            const valueKey = `${key}_${valueIndex}`;
+            values[valueKey] = value;
+            placeholders.push(`{${valueKey}}`);
+          });
+          if (placeholders.length) {
+            clauses.push(`${filter.field} ${filter.operator === "in" ? "IN" : "NOT IN"} (${placeholders.join(", ")})`);
+          }
+        }
+        break;
+      default:
+        break;
+    }
+  });
+  return clauses;
+}
+function resolveDateRange(params) {
+  const range = params.dateRange;
+  if (!range)
+    return null;
+  return { from: range.start, to: range.end };
+}
+function mapHogqlResult(result) {
+  if (!Array.isArray(result.results) || !Array.isArray(result.columns)) {
+    return { data: [], columns: [], rowCount: 0 };
+  }
+  const columns = result.columns.map((name) => ({
+    name,
+    type: "STRING"
+  }));
+  const data = result.results.map((row) => {
+    if (!Array.isArray(row))
+      return {};
+    const record = {};
+    result.columns?.forEach((column, index) => {
+      record[column] = row[index];
+    });
+    return record;
+  });
+  return {
+    data,
+    columns,
+    rowCount: data.length
+  };
+}
+
+// src/handlers/analytics.handlers.ts
+import { web } from "@contractspec/lib.runtime-sandbox";
+var { generateId } = web;
+function rowToDashboard(row) {
+  return {
+    id: row.id,
+    projectId: row.projectId,
+    organizationId: row.organizationId,
+    name: row.name,
+    slug: row.slug,
+    description: row.description ?? undefined,
+    status: row.status,
+    refreshInterval: row.refreshInterval,
+    isPublic: row.isPublic === 1,
+    shareToken: row.shareToken ?? undefined,
+    createdAt: new Date(row.createdAt),
+    updatedAt: new Date(row.updatedAt)
+  };
+}
+function rowToWidget(row) {
+  return {
+    id: row.id,
+    dashboardId: row.dashboardId,
+    name: row.name,
+    type: row.type,
+    gridX: row.gridX,
+    gridY: row.gridY,
+    gridWidth: row.gridWidth,
+    gridHeight: row.gridHeight,
+    queryId: row.queryId ?? undefined,
+    config: row.config ? JSON.parse(row.config) : undefined,
+    createdAt: new Date(row.createdAt),
+    updatedAt: new Date(row.updatedAt)
+  };
+}
+function rowToQuery(row) {
+  return {
+    id: row.id,
+    projectId: row.projectId,
+    organizationId: row.organizationId,
+    name: row.name,
+    description: row.description ?? undefined,
+    type: row.type,
+    definition: JSON.parse(row.definition),
+    sql: row.sql ?? undefined,
+    cacheTtlSeconds: row.cacheTtlSeconds,
+    isShared: row.isShared === 1,
+    createdAt: new Date(row.createdAt),
+    updatedAt: new Date(row.updatedAt)
+  };
+}
+function createAnalyticsHandlers(db) {
+  async function listDashboards(input) {
+    const { projectId, status, search, limit = 20, offset = 0 } = input;
+    let whereClause = "WHERE projectId = ?";
+    const params = [projectId];
+    if (status && status !== "all") {
+      whereClause += " AND status = ?";
+      params.push(status);
+    }
+    if (search) {
+      whereClause += " AND (name LIKE ? OR description LIKE ?)";
+      params.push(`%${search}%`, `%${search}%`);
+    }
+    const countResult = (await db.query(`SELECT COUNT(*) as count FROM analytics_dashboard ${whereClause}`, params)).rows;
+    const total = countResult[0]?.count ?? 0;
+    const rows = (await db.query(`SELECT * FROM analytics_dashboard ${whereClause} ORDER BY updatedAt DESC LIMIT ? OFFSET ?`, [...params, limit, offset])).rows;
+    return {
+      dashboards: rows.map(rowToDashboard),
+      total
+    };
+  }
+  async function createDashboard(input, context) {
+    const id = generateId("dash");
+    const now = new Date().toISOString();
+    await db.execute(`INSERT INTO analytics_dashboard (id, projectId, organizationId, name, slug, description, status, refreshInterval, isPublic, createdAt, updatedAt)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+      id,
+      context.projectId,
+      context.organizationId,
+      input.name,
+      input.slug,
+      input.description ?? null,
+      "DRAFT",
+      input.refreshInterval ?? "NONE",
+      0,
+      now,
+      now
+    ]);
+    const rows = (await db.query(`SELECT * FROM analytics_dashboard WHERE id = ?`, [id])).rows;
+    return rowToDashboard(rows[0]);
+  }
+  async function getDashboard(input) {
+    let whereClause = "";
+    const params = [];
+    if (input.dashboardId) {
+      whereClause = "WHERE id = ?";
+      params.push(input.dashboardId);
+    } else if (input.slug) {
+      whereClause = "WHERE slug = ?";
+      params.push(input.slug);
+    } else if (input.shareToken) {
+      whereClause = "WHERE shareToken = ?";
+      params.push(input.shareToken);
+    } else {
+      return null;
+    }
+    const rows = (await db.query(`SELECT * FROM analytics_dashboard ${whereClause}`, params)).rows;
+    return rows[0] ? rowToDashboard(rows[0]) : null;
+  }
+  async function updateDashboard(dashboardId, updates) {
+    const now = new Date().toISOString();
+    const setClauses = ["updatedAt = ?"];
+    const params = [now];
+    if (updates.name !== undefined) {
+      setClauses.push("name = ?");
+      params.push(updates.name);
+    }
+    if (updates.description !== undefined) {
+      setClauses.push("description = ?");
+      params.push(updates.description);
+    }
+    if (updates.status !== undefined) {
+      setClauses.push("status = ?");
+      params.push(updates.status);
+    }
+    if (updates.refreshInterval !== undefined) {
+      setClauses.push("refreshInterval = ?");
+      params.push(updates.refreshInterval);
+    }
+    if (updates.isPublic !== undefined) {
+      setClauses.push("isPublic = ?");
+      params.push(updates.isPublic ? 1 : 0);
+      if (updates.isPublic) {
+        setClauses.push("shareToken = ?");
+        params.push(generateId("share"));
+      } else {
+        setClauses.push("shareToken = NULL");
+      }
+    }
+    params.push(dashboardId);
+    await db.execute(`UPDATE analytics_dashboard SET ${setClauses.join(", ")} WHERE id = ?`, params);
+    const rows = (await db.query(`SELECT * FROM analytics_dashboard WHERE id = ?`, [
+      dashboardId
+    ])).rows;
+    return rowToDashboard(rows[0]);
+  }
+  async function getWidgets(dashboardId) {
+    const rows = (await db.query(`SELECT * FROM analytics_widget WHERE dashboardId = ? ORDER BY gridY, gridX`, [dashboardId])).rows;
+    return rows.map(rowToWidget);
+  }
+  async function addWidget(input) {
+    const id = generateId("widget");
+    const now = new Date().toISOString();
+    await db.execute(`INSERT INTO analytics_widget (id, dashboardId, name, type, gridX, gridY, gridWidth, gridHeight, queryId, config, createdAt, updatedAt)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+      id,
+      input.dashboardId,
+      input.name,
+      input.type,
+      input.gridX ?? 0,
+      input.gridY ?? 0,
+      input.gridWidth ?? 6,
+      input.gridHeight ?? 4,
+      input.queryId ?? null,
+      input.config ? JSON.stringify(input.config) : null,
+      now,
+      now
+    ]);
+    const rows = (await db.query(`SELECT * FROM analytics_widget WHERE id = ?`, [id])).rows;
+    return rowToWidget(rows[0]);
+  }
+  async function updateWidget(widgetId, updates) {
+    const now = new Date().toISOString();
+    const setClauses = ["updatedAt = ?"];
+    const params = [now];
+    if (updates.name !== undefined) {
+      setClauses.push("name = ?");
+      params.push(updates.name);
+    }
+    if (updates.gridX !== undefined) {
+      setClauses.push("gridX = ?");
+      params.push(updates.gridX);
+    }
+    if (updates.gridY !== undefined) {
+      setClauses.push("gridY = ?");
+      params.push(updates.gridY);
+    }
+    if (updates.gridWidth !== undefined) {
+      setClauses.push("gridWidth = ?");
+      params.push(updates.gridWidth);
+    }
+    if (updates.gridHeight !== undefined) {
+      setClauses.push("gridHeight = ?");
+      params.push(updates.gridHeight);
+    }
+    if (updates.queryId !== undefined) {
+      setClauses.push("queryId = ?");
+      params.push(updates.queryId ?? null);
+    }
+    if (updates.config !== undefined) {
+      setClauses.push("config = ?");
+      params.push(updates.config ? JSON.stringify(updates.config) : null);
+    }
+    params.push(widgetId);
+    await db.execute(`UPDATE analytics_widget SET ${setClauses.join(", ")} WHERE id = ?`, params);
+    const rows = (await db.query(`SELECT * FROM analytics_widget WHERE id = ?`, [widgetId])).rows;
+    return rowToWidget(rows[0]);
+  }
+  async function deleteWidget(widgetId) {
+    await db.execute(`DELETE FROM analytics_widget WHERE id = ?`, [widgetId]);
+  }
+  async function listQueries(input) {
+    const { projectId, type, isShared, search, limit = 20, offset = 0 } = input;
+    let whereClause = "WHERE projectId = ?";
+    const params = [projectId];
+    if (type && type !== "all") {
+      whereClause += " AND type = ?";
+      params.push(type);
+    }
+    if (isShared !== undefined) {
+      whereClause += " AND isShared = ?";
+      params.push(isShared ? 1 : 0);
+    }
+    if (search) {
+      whereClause += " AND (name LIKE ? OR description LIKE ?)";
+      params.push(`%${search}%`, `%${search}%`);
+    }
+    const countResult = (await db.query(`SELECT COUNT(*) as count FROM analytics_query ${whereClause}`, params)).rows;
+    const total = countResult[0]?.count ?? 0;
+    const rows = (await db.query(`SELECT * FROM analytics_query ${whereClause} ORDER BY updatedAt DESC LIMIT ? OFFSET ?`, [...params, limit, offset])).rows;
+    return {
+      queries: rows.map(rowToQuery),
+      total
+    };
+  }
+  async function createQuery(input, context) {
+    const id = generateId("query");
+    const now = new Date().toISOString();
+    await db.execute(`INSERT INTO analytics_query (id, projectId, organizationId, name, description, type, definition, sql, cacheTtlSeconds, isShared, createdAt, updatedAt)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+      id,
+      context.projectId,
+      context.organizationId,
+      input.name,
+      input.description ?? null,
+      input.type,
+      JSON.stringify(input.definition),
+      input.sql ?? null,
+      input.cacheTtlSeconds ?? 300,
+      input.isShared ? 1 : 0,
+      now,
+      now
+    ]);
+    const rows = (await db.query(`SELECT * FROM analytics_query WHERE id = ?`, [id])).rows;
+    return rowToQuery(rows[0]);
+  }
+  async function getQuery(queryId) {
+    const rows = (await db.query(`SELECT * FROM analytics_query WHERE id = ?`, [queryId])).rows;
+    return rows[0] ? rowToQuery(rows[0]) : null;
+  }
+  return {
+    listDashboards,
+    createDashboard,
+    getDashboard,
+    updateDashboard,
+    getWidgets,
+    addWidget,
+    updateWidget,
+    deleteWidget,
+    listQueries,
+    createQuery,
+    getQuery
+  };
+}
+
+// src/query/query.enum.ts
+import { defineEnum } from "@contractspec/lib.schema";
+var QueryTypeEnum = defineEnum("QueryType", [
+  "SQL",
+  "METRIC",
+  "AGGREGATION",
+  "CUSTOM"
+]);
+
+// src/query/query.schema.ts
+import { defineSchemaModel, ScalarTypeEnum } from "@contractspec/lib.schema";
+var QueryModel = defineSchemaModel({
+  name: "QueryModel",
+  fields: {
+    id: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    name: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    description: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    type: { type: QueryTypeEnum, isOptional: false },
+    definition: { type: ScalarTypeEnum.JSON(), isOptional: false },
+    sql: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    cacheTtlSeconds: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
+    isShared: { type: ScalarTypeEnum.Boolean(), isOptional: false },
+    createdAt: { type: ScalarTypeEnum.DateTime(), isOptional: false }
+  }
+});
+var QueryResultModel = defineSchemaModel({
+  name: "QueryResultModel",
+  fields: {
+    queryId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    data: { type: ScalarTypeEnum.JSON(), isOptional: false },
+    columns: { type: ScalarTypeEnum.JSON(), isOptional: false },
+    rowCount: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
+    executionTimeMs: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
+    cachedAt: { type: ScalarTypeEnum.DateTime(), isOptional: true },
+    error: { type: ScalarTypeEnum.String_unsecure(), isOptional: true }
+  }
+});
+var CreateQueryInputModel = defineSchemaModel({
+  name: "CreateQueryInput",
+  fields: {
+    name: { type: ScalarTypeEnum.NonEmptyString(), isOptional: false },
+    description: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    type: { type: QueryTypeEnum, isOptional: false },
+    definition: { type: ScalarTypeEnum.JSON(), isOptional: false },
+    sql: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    metricIds: {
+      type: ScalarTypeEnum.String_unsecure(),
+      isArray: true,
+      isOptional: true
+    },
+    cacheTtlSeconds: { type: ScalarTypeEnum.Int_unsecure(), isOptional: true },
+    isShared: { type: ScalarTypeEnum.Boolean(), isOptional: true }
+  }
+});
+var ExecuteQueryInputModel = defineSchemaModel({
+  name: "ExecuteQueryInput",
+  fields: {
+    queryId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    parameters: { type: ScalarTypeEnum.JSON(), isOptional: true },
+    dateRange: { type: ScalarTypeEnum.JSON(), isOptional: true },
+    filters: { type: ScalarTypeEnum.JSON(), isOptional: true },
+    forceRefresh: { type: ScalarTypeEnum.Boolean(), isOptional: true }
+  }
+});
+
+// src/query/query.operation.ts
+import {
+  defineCommand,
+  defineQuery
+} from "@contractspec/lib.contracts/operations";
+var OWNERS = ["@example.analytics-dashboard"];
+var CreateQueryContract = defineCommand({
+  meta: {
+    key: "analytics.query.create",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["analytics", "query", "create"],
+    description: "Create a data query.",
+    goal: "Define reusable data queries.",
+    context: "Query builder."
+  },
+  io: { input: CreateQueryInputModel, output: QueryModel },
+  policy: { auth: "user" },
+  sideEffects: {
+    emits: [
+      {
+        key: "analytics.query.created",
+        version: "1.0.0",
+        stability: "stable",
+        owners: [...OWNERS],
+        tags: ["analytics", "query", "created"],
+        when: "Query created",
+        payload: QueryModel
+      }
+    ],
+    audit: ["analytics.query.created"]
+  },
+  acceptance: {
+    scenarios: [
+      {
+        key: "create-query-happy-path",
+        given: ["User is authenticated"],
+        when: ["User submits valid query definition"],
+        then: ["Query is created", "QueryCreated event is emitted"]
+      }
+    ],
+    examples: [
+      {
+        key: "create-sql-query",
+        input: {
+          name: "Monthly Revenue",
+          sql: "SELECT SUM(amount) FROM orders WHERE date >= :startDate"
+        },
+        output: { id: "query-123", name: "Monthly Revenue", type: "sql" }
+      }
+    ]
+  }
+});
+var ExecuteQueryContract = defineQuery({
+  meta: {
+    key: "analytics.query.execute",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["analytics", "query", "execute"],
+    description: "Execute a data query.",
+    goal: "Fetch data for visualizations.",
+    context: "Dashboard rendering."
+  },
+  io: { input: ExecuteQueryInputModel, output: QueryResultModel },
+  policy: { auth: "user" },
+  acceptance: {
+    scenarios: [
+      {
+        key: "execute-query-happy-path",
+        given: ["Query exists"],
+        when: ["User executes query with parameters"],
+        then: ["Query results are returned"]
+      }
+    ],
+    examples: [
+      {
+        key: "execute-with-params",
+        input: { queryId: "query-123", params: { startDate: "2025-01-01" } },
+        output: { columns: ["total"], rows: [{ total: 50000 }], rowCount: 1 }
+      }
+    ]
+  }
+});
+// src/ui/renderers/analytics.markdown.ts
+var mockDashboards = [
+  {
+    id: "dash-1",
+    name: "Sales Overview",
+    slug: "sales-overview",
+    status: "PUBLISHED",
+    widgetCount: 8,
+    viewCount: 1250,
+    lastViewedAt: "2024-01-16T12:00:00Z"
+  },
+  {
+    id: "dash-2",
+    name: "User Engagement",
+    slug: "user-engagement",
+    status: "PUBLISHED",
+    widgetCount: 6,
+    viewCount: 890,
+    lastViewedAt: "2024-01-16T10:00:00Z"
+  },
+  {
+    id: "dash-3",
+    name: "Product Analytics",
+    slug: "product-analytics",
+    status: "PUBLISHED",
+    widgetCount: 10,
+    viewCount: 560,
+    lastViewedAt: "2024-01-15T14:00:00Z"
+  },
+  {
+    id: "dash-4",
+    name: "Finance Report",
+    slug: "finance-report",
+    status: "DRAFT",
+    widgetCount: 4,
+    viewCount: 0,
+    lastViewedAt: null
+  }
+];
+var mockWidgets = [
+  {
+    id: "w-1",
+    dashboardId: "dash-1",
+    name: "Total Revenue",
+    type: "METRIC",
+    value: 125000,
+    change: 12.5
+  },
+  {
+    id: "w-2",
+    dashboardId: "dash-1",
+    name: "Active Users",
+    type: "METRIC",
+    value: 4500,
+    change: 8.2
+  },
+  {
+    id: "w-3",
+    dashboardId: "dash-1",
+    name: "Revenue Trend",
+    type: "LINE_CHART",
+    dataPoints: 30
+  },
+  {
+    id: "w-4",
+    dashboardId: "dash-1",
+    name: "Top Products",
+    type: "BAR_CHART",
+    dataPoints: 10
+  },
+  {
+    id: "w-5",
+    dashboardId: "dash-2",
+    name: "Daily Active Users",
+    type: "LINE_CHART",
+    dataPoints: 30
+  },
+  {
+    id: "w-6",
+    dashboardId: "dash-2",
+    name: "Session Duration",
+    type: "METRIC",
+    value: 245,
+    change: -3.1
+  }
+];
+var mockQueries = [
+  {
+    id: "q-1",
+    name: "Monthly Revenue",
+    type: "AGGREGATION",
+    isShared: true,
+    executionCount: 1500
+  },
+  {
+    id: "q-2",
+    name: "User Growth",
+    type: "METRIC",
+    isShared: true,
+    executionCount: 890
+  },
+  {
+    id: "q-3",
+    name: "Product Sales",
+    type: "SQL",
+    isShared: false,
+    executionCount: 340
+  },
+  {
+    id: "q-4",
+    name: "Conversion Funnel",
+    type: "AGGREGATION",
+    isShared: true,
+    executionCount: 450
+  }
+];
+function formatNumber(value) {
+  if (value >= 1e6) {
+    return `${(value / 1e6).toFixed(1)}M`;
+  }
+  if (value >= 1000) {
+    return `${(value / 1000).toFixed(1)}K`;
+  }
+  return value.toString();
+}
+function formatChange(change) {
+  const icon = change >= 0 ? "\uD83D\uDCC8" : "\uD83D\uDCC9";
+  const sign = change >= 0 ? "+" : "";
+  return `${icon} ${sign}${change.toFixed(1)}%`;
+}
+var analyticsDashboardMarkdownRenderer = {
+  target: "markdown",
+  render: async (desc) => {
+    if (desc.source.type !== "component" || desc.source.componentKey !== "AnalyticsDashboard") {
+      throw new Error("analyticsDashboardMarkdownRenderer: not AnalyticsDashboard");
+    }
+    const dashboards = mockDashboards;
+    const widgets = mockWidgets;
+    const queries = mockQueries;
+    const dashboard = dashboards[0];
+    if (!dashboard) {
+      return {
+        mimeType: "text/markdown",
+        body: `# No Dashboards
+
+No dashboards available.`
+      };
+    }
+    const dashboardWidgets = widgets.filter((w) => w.dashboardId === dashboard.id);
+    const publishedDashboards = dashboards.filter((d) => d.status === "PUBLISHED");
+    const totalViews = dashboards.reduce((sum, d) => sum + d.viewCount, 0);
+    const sharedQueries = queries.filter((q) => q.isShared);
+    const lines = [
+      `# ${dashboard.name}`,
+      "",
+      "> Analytics dashboard overview",
+      "",
+      "## Key Metrics",
+      ""
+    ];
+    const metricWidgets = dashboardWidgets.filter((w) => w.type === "METRIC");
+    for (const widget of metricWidgets) {
+      const w = widget;
+      lines.push(`### ${w.name}`);
+      lines.push(`**${formatNumber(w.value)}** ${formatChange(w.change)}`);
+      lines.push("");
+    }
+    lines.push("## Visualizations");
+    lines.push("");
+    const chartWidgets = dashboardWidgets.filter((w) => w.type !== "METRIC");
+    for (const widget of chartWidgets) {
+      const w = widget;
+      lines.push(`- **${w.name}** (${w.type.replace("_", " ")}) - ${w.dataPoints} data points`);
+    }
+    lines.push("");
+    lines.push("## Dashboard Stats");
+    lines.push("");
+    lines.push("| Metric | Value |");
+    lines.push("|--------|-------|");
+    lines.push(`| Total Dashboards | ${dashboards.length} |`);
+    lines.push(`| Published | ${publishedDashboards.length} |`);
+    lines.push(`| Total Views | ${totalViews.toLocaleString()} |`);
+    lines.push(`| Shared Queries | ${sharedQueries.length} |`);
+    return {
+      mimeType: "text/markdown",
+      body: lines.join(`
+`)
+    };
+  }
+};
+var dashboardListMarkdownRenderer = {
+  target: "markdown",
+  render: async (desc) => {
+    if (desc.source.type !== "component" || desc.source.componentKey !== "DashboardList") {
+      throw new Error("dashboardListMarkdownRenderer: not DashboardList");
+    }
+    const dashboards = mockDashboards;
+    const lines = [
+      "# Dashboards",
+      "",
+      "> Browse and manage analytics dashboards",
+      "",
+      "| Dashboard | Widgets | Views | Status | Last Viewed |",
+      "|-----------|---------|-------|--------|-------------|"
+    ];
+    for (const dashboard of dashboards) {
+      const lastViewed = dashboard.lastViewedAt ? new Date(dashboard.lastViewedAt).toLocaleDateString() : "Never";
+      const statusIcon = dashboard.status === "PUBLISHED" ? "\uD83D\uDFE2" : "⚫";
+      lines.push(`| [${dashboard.name}](/dashboards/${dashboard.slug}) | ${dashboard.widgetCount} | ${dashboard.viewCount.toLocaleString()} | ${statusIcon} ${dashboard.status} | ${lastViewed} |`);
+    }
+    lines.push("");
+    lines.push("## Quick Actions");
+    lines.push("");
+    lines.push("- **Create Dashboard** - Start with a blank canvas");
+    lines.push("- **Import Template** - Use a pre-built template");
+    lines.push("- **Clone Dashboard** - Duplicate an existing dashboard");
+    return {
+      mimeType: "text/markdown",
+      body: lines.join(`
+`)
+    };
+  }
+};
+var queryBuilderMarkdownRenderer = {
+  target: "markdown",
+  render: async (desc) => {
+    if (desc.source.type !== "component" || desc.source.componentKey !== "QueryBuilder") {
+      throw new Error("queryBuilderMarkdownRenderer: not QueryBuilder");
+    }
+    const queries = mockQueries;
+    const lines = [
+      "# Query Builder",
+      "",
+      "> Create and manage data queries",
+      "",
+      "## Saved Queries",
+      "",
+      "| Query | Type | Shared | Executions |",
+      "|-------|------|--------|------------|"
+    ];
+    for (const query of queries) {
+      const sharedIcon = query.isShared ? "\uD83C\uDF10" : "\uD83D\uDD12";
+      lines.push(`| ${query.name} | ${query.type} | ${sharedIcon} | ${query.executionCount.toLocaleString()} |`);
+    }
+    lines.push("");
+    lines.push("## Query Types");
+    lines.push("");
+    lines.push("### METRIC");
+    lines.push("Query usage metrics from the metering system.");
+    lines.push("");
+    lines.push("### AGGREGATION");
+    lines.push("Build aggregations with measures and dimensions without writing SQL.");
+    lines.push("");
+    lines.push("### SQL");
+    lines.push("Write custom SQL queries for advanced analysis.");
+    lines.push("");
+    lines.push("## Features");
+    lines.push("");
+    lines.push("- Visual query builder");
+    lines.push("- Auto-complete for fields and functions");
+    lines.push("- Query validation and optimization");
+    lines.push("- Result caching");
+    lines.push("- Query sharing and collaboration");
+    return {
+      mimeType: "text/markdown",
+      body: lines.join(`
+`)
+    };
+  }
+};
+// src/ui/hooks/useAnalyticsData.ts
+import { useCallback, useEffect, useState } from "react";
+import { useTemplateRuntime } from "@contractspec/lib.example-shared-ui";
+"use client";
+function useAnalyticsData(projectId = "local-project") {
+  const { handlers } = useTemplateRuntime();
+  const analytics = handlers.analytics;
+  const [dashboards, setDashboards] = useState([]);
+  const [queries, setQueries] = useState([]);
+  const [selectedDashboard, setSelectedDashboard] = useState(null);
+  const [widgets, setWidgets] = useState([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const fetchData = useCallback(async () => {
+    try {
+      setLoading(true);
+      setError(null);
+      const [dashResult, queryResult] = await Promise.all([
+        analytics.listDashboards({ projectId, limit: 100 }),
+        analytics.listQueries({ projectId, limit: 100 })
+      ]);
+      setDashboards(dashResult.dashboards);
+      setQueries(queryResult.queries);
+      if (dashResult.dashboards.length > 0 && !selectedDashboard) {
+        const first = dashResult.dashboards[0];
+        if (first) {
+          setSelectedDashboard(first);
+          const dashboardWidgets = await analytics.getWidgets(first.id);
+          setWidgets(dashboardWidgets);
+        }
+      }
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to load analytics"));
+    } finally {
+      setLoading(false);
+    }
+  }, [analytics, projectId, selectedDashboard]);
+  useEffect(() => {
+    fetchData();
+  }, [fetchData]);
+  const selectDashboard = useCallback(async (dashboard) => {
+    setSelectedDashboard(dashboard);
+    const dashboardWidgets = await analytics.getWidgets(dashboard.id);
+    setWidgets(dashboardWidgets);
+  }, [analytics]);
+  const stats = {
+    totalDashboards: dashboards.length,
+    publishedDashboards: dashboards.filter((d) => d.status === "PUBLISHED").length,
+    totalQueries: queries.length,
+    sharedQueries: queries.filter((q) => q.isShared).length
+  };
+  return {
+    dashboards,
+    queries,
+    selectedDashboard,
+    widgets,
+    loading,
+    error,
+    stats,
+    refetch: fetchData,
+    selectDashboard
+  };
+}
+
+// src/ui/AnalyticsDashboard.tsx
+import { useState as useState2 } from "react";
+import {
+  Button,
+  ErrorState,
+  LoaderBlock,
+  StatCard,
+  StatCardGroup
+} from "@contractspec/lib.design-system";
+import { jsxDEV } from "react/jsx-dev-runtime";
+"use client";
+var STATUS_COLORS = {
+  PUBLISHED: "bg-green-100 text-green-700 dark:bg-green-900/30 dark:text-green-400",
+  DRAFT: "bg-gray-100 text-gray-700 dark:bg-gray-900/30 dark:text-gray-400",
+  ARCHIVED: "bg-yellow-100 text-yellow-700 dark:bg-yellow-900/30 dark:text-yellow-400"
+};
+var WIDGET_ICONS = {
+  LINE_CHART: "\uD83D\uDCC8",
+  BAR_CHART: "\uD83D\uDCCA",
+  PIE_CHART: "\uD83E\uDD67",
+  AREA_CHART: "\uD83D\uDCC9",
+  SCATTER_PLOT: "⚬",
+  METRIC: "\uD83D\uDD22",
+  TABLE: "\uD83D\uDCCB",
+  HEATMAP: "\uD83D\uDDFA️",
+  FUNNEL: "⏬",
+  MAP: "\uD83C\uDF0D",
+  TEXT: "\uD83D\uDCDD",
+  EMBED: "\uD83D\uDD17"
+};
+var QUERY_TYPE_COLORS = {
+  SQL: "bg-blue-100 text-blue-700 dark:bg-blue-900/30 dark:text-blue-400",
+  METRIC: "bg-purple-100 text-purple-700 dark:bg-purple-900/30 dark:text-purple-400",
+  AGGREGATION: "bg-indigo-100 text-indigo-700 dark:bg-indigo-900/30 dark:text-indigo-400",
+  CUSTOM: "bg-gray-100 text-gray-700 dark:bg-gray-900/30 dark:text-gray-400"
+};
+function AnalyticsDashboard() {
+  const [activeTab, setActiveTab] = useState2("dashboards");
+  const {
+    dashboards,
+    queries,
+    selectedDashboard,
+    widgets,
+    loading,
+    error,
+    stats,
+    refetch,
+    selectDashboard
+  } = useAnalyticsData();
+  const tabs = [
+    { id: "dashboards", label: "Dashboards", icon: "\uD83D\uDCCA" },
+    { id: "queries", label: "Queries", icon: "\uD83D\uDD0D" }
+  ];
+  if (loading) {
+    return /* @__PURE__ */ jsxDEV(LoaderBlock, {
+      label: "Loading Analytics..."
+    }, undefined, false, undefined, this);
+  }
+  if (error) {
+    return /* @__PURE__ */ jsxDEV(ErrorState, {
+      title: "Failed to load Analytics",
+      description: error.message,
+      onRetry: refetch,
+      retryLabel: "Retry"
+    }, undefined, false, undefined, this);
+  }
+  return /* @__PURE__ */ jsxDEV("div", {
+    className: "space-y-6",
+    children: [
+      /* @__PURE__ */ jsxDEV("div", {
+        className: "flex items-center justify-between",
+        children: [
+          /* @__PURE__ */ jsxDEV("h2", {
+            className: "text-2xl font-bold",
+            children: "Analytics Dashboard"
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV(Button, {
+            onClick: () => alert("Create dashboard modal"),
+            children: [
+              /* @__PURE__ */ jsxDEV("span", {
+                className: "mr-2",
+                children: "+"
+              }, undefined, false, undefined, this),
+              " New Dashboard"
+            ]
+          }, undefined, true, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      /* @__PURE__ */ jsxDEV(StatCardGroup, {
+        children: [
+          /* @__PURE__ */ jsxDEV(StatCard, {
+            label: "Dashboards",
+            value: stats.totalDashboards,
+            hint: `${stats.publishedDashboards} published`
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV(StatCard, {
+            label: "Queries",
+            value: stats.totalQueries,
+            hint: `${stats.sharedQueries} shared`
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV(StatCard, {
+            label: "Widgets",
+            value: widgets.length,
+            hint: "on current dashboard"
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      /* @__PURE__ */ jsxDEV("nav", {
+        className: "bg-muted flex gap-1 rounded-lg p-1",
+        role: "tablist",
+        children: tabs.map((tab) => /* @__PURE__ */ jsxDEV(Button, {
+          type: "button",
+          role: "tab",
+          "aria-selected": activeTab === tab.id,
+          onClick: () => setActiveTab(tab.id),
+          className: `flex flex-1 items-center justify-center gap-2 rounded-md px-4 py-2 text-sm font-medium transition-colors ${activeTab === tab.id ? "bg-background text-foreground shadow-sm" : "text-muted-foreground hover:text-foreground"}`,
+          children: [
+            /* @__PURE__ */ jsxDEV("span", {
+              children: tab.icon
+            }, undefined, false, undefined, this),
+            tab.label
+          ]
+        }, tab.id, true, undefined, this))
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV("div", {
+        className: "min-h-[400px]",
+        role: "tabpanel",
+        children: [
+          activeTab === "dashboards" && /* @__PURE__ */ jsxDEV("div", {
+            className: "space-y-6",
+            children: [
+              /* @__PURE__ */ jsxDEV("div", {
+                className: "grid gap-4 sm:grid-cols-2 lg:grid-cols-3",
+                children: [
+                  dashboards.map((dashboard) => /* @__PURE__ */ jsxDEV("div", {
+                    onClick: () => selectDashboard(dashboard),
+                    className: `border-border bg-card cursor-pointer rounded-lg border p-4 transition-all ${selectedDashboard?.id === dashboard.id ? "ring-primary ring-2" : "hover:bg-muted/50"}`,
+                    role: "button",
+                    tabIndex: 0,
+                    onKeyDown: (e) => {
+                      if (e.key === "Enter" || e.key === " ")
+                        selectDashboard(dashboard);
+                    },
+                    children: [
+                      /* @__PURE__ */ jsxDEV("div", {
+                        className: "mb-2 flex items-center justify-between",
+                        children: [
+                          /* @__PURE__ */ jsxDEV("h3", {
+                            className: "font-medium",
+                            children: dashboard.name
+                          }, undefined, false, undefined, this),
+                          /* @__PURE__ */ jsxDEV("span", {
+                            className: `inline-flex rounded-full px-2 py-0.5 text-xs font-medium ${STATUS_COLORS[dashboard.status] ?? ""}`,
+                            children: dashboard.status
+                          }, undefined, false, undefined, this)
+                        ]
+                      }, undefined, true, undefined, this),
+                      /* @__PURE__ */ jsxDEV("p", {
+                        className: "text-muted-foreground mb-3 text-sm",
+                        children: dashboard.description
+                      }, undefined, false, undefined, this),
+                      /* @__PURE__ */ jsxDEV("div", {
+                        className: "text-muted-foreground flex items-center justify-between text-xs",
+                        children: [
+                          /* @__PURE__ */ jsxDEV("span", {
+                            children: [
+                              "/",
+                              dashboard.slug
+                            ]
+                          }, undefined, true, undefined, this),
+                          dashboard.isPublic && /* @__PURE__ */ jsxDEV("span", {
+                            className: "text-green-600 dark:text-green-400",
+                            children: "\uD83C\uDF10 Public"
+                          }, undefined, false, undefined, this)
+                        ]
+                      }, undefined, true, undefined, this)
+                    ]
+                  }, dashboard.id, true, undefined, this)),
+                  dashboards.length === 0 && /* @__PURE__ */ jsxDEV("div", {
+                    className: "text-muted-foreground col-span-full flex h-64 items-center justify-center",
+                    children: "No dashboards created yet"
+                  }, undefined, false, undefined, this)
+                ]
+              }, undefined, true, undefined, this),
+              selectedDashboard && widgets.length > 0 && /* @__PURE__ */ jsxDEV("div", {
+                children: [
+                  /* @__PURE__ */ jsxDEV("h3", {
+                    className: "mb-4 text-lg font-semibold",
+                    children: [
+                      'Widgets in "',
+                      selectedDashboard.name,
+                      '"'
+                    ]
+                  }, undefined, true, undefined, this),
+                  /* @__PURE__ */ jsxDEV("div", {
+                    className: "grid gap-4 sm:grid-cols-2 lg:grid-cols-3",
+                    children: widgets.map((widget) => /* @__PURE__ */ jsxDEV("div", {
+                      className: "border-border bg-card rounded-lg border p-4",
+                      children: [
+                        /* @__PURE__ */ jsxDEV("div", {
+                          className: "mb-2 flex items-center gap-2",
+                          children: [
+                            /* @__PURE__ */ jsxDEV("span", {
+                              className: "text-xl",
+                              children: WIDGET_ICONS[widget.type] ?? "\uD83D\uDCCA"
+                            }, undefined, false, undefined, this),
+                            /* @__PURE__ */ jsxDEV("span", {
+                              className: "font-medium",
+                              children: widget.name
+                            }, undefined, false, undefined, this)
+                          ]
+                        }, undefined, true, undefined, this),
+                        /* @__PURE__ */ jsxDEV("div", {
+                          className: "text-muted-foreground text-sm",
+                          children: widget.type.replace(/_/g, " ")
+                        }, undefined, false, undefined, this),
+                        /* @__PURE__ */ jsxDEV("div", {
+                          className: "text-muted-foreground mt-2 text-xs",
+                          children: [
+                            "Position: (",
+                            widget.gridX,
+                            ", ",
+                            widget.gridY,
+                            ") •",
+                            " ",
+                            widget.gridWidth,
+                            "x",
+                            widget.gridHeight
+                          ]
+                        }, undefined, true, undefined, this)
+                      ]
+                    }, widget.id, true, undefined, this))
+                  }, undefined, false, undefined, this)
+                ]
+              }, undefined, true, undefined, this)
+            ]
+          }, undefined, true, undefined, this),
+          activeTab === "queries" && /* @__PURE__ */ jsxDEV("div", {
+            className: "border-border rounded-lg border",
+            children: /* @__PURE__ */ jsxDEV("table", {
+              className: "w-full",
+              children: [
+                /* @__PURE__ */ jsxDEV("thead", {
+                  className: "border-border bg-muted/30 border-b",
+                  children: /* @__PURE__ */ jsxDEV("tr", {
+                    children: [
+                      /* @__PURE__ */ jsxDEV("th", {
+                        className: "px-4 py-3 text-left text-sm font-medium",
+                        children: "Query"
+                      }, undefined, false, undefined, this),
+                      /* @__PURE__ */ jsxDEV("th", {
+                        className: "px-4 py-3 text-left text-sm font-medium",
+                        children: "Type"
+                      }, undefined, false, undefined, this),
+                      /* @__PURE__ */ jsxDEV("th", {
+                        className: "px-4 py-3 text-left text-sm font-medium",
+                        children: "Cache TTL"
+                      }, undefined, false, undefined, this),
+                      /* @__PURE__ */ jsxDEV("th", {
+                        className: "px-4 py-3 text-left text-sm font-medium",
+                        children: "Shared"
+                      }, undefined, false, undefined, this)
+                    ]
+                  }, undefined, true, undefined, this)
+                }, undefined, false, undefined, this),
+                /* @__PURE__ */ jsxDEV("tbody", {
+                  className: "divide-border divide-y",
+                  children: [
+                    queries.map((query) => /* @__PURE__ */ jsxDEV("tr", {
+                      className: "hover:bg-muted/50",
+                      children: [
+                        /* @__PURE__ */ jsxDEV("td", {
+                          className: "px-4 py-3",
+                          children: [
+                            /* @__PURE__ */ jsxDEV("div", {
+                              className: "font-medium",
+                              children: query.name
+                            }, undefined, false, undefined, this),
+                            /* @__PURE__ */ jsxDEV("div", {
+                              className: "text-muted-foreground text-sm",
+                              children: query.description
+                            }, undefined, false, undefined, this)
+                          ]
+                        }, undefined, true, undefined, this),
+                        /* @__PURE__ */ jsxDEV("td", {
+                          className: "px-4 py-3",
+                          children: /* @__PURE__ */ jsxDEV("span", {
+                            className: `inline-flex rounded-full px-2 py-0.5 text-xs font-medium ${QUERY_TYPE_COLORS[query.type] ?? ""}`,
+                            children: query.type
+                          }, undefined, false, undefined, this)
+                        }, undefined, false, undefined, this),
+                        /* @__PURE__ */ jsxDEV("td", {
+                          className: "text-muted-foreground px-4 py-3 text-sm",
+                          children: [
+                            query.cacheTtlSeconds,
+                            "s"
+                          ]
+                        }, undefined, true, undefined, this),
+                        /* @__PURE__ */ jsxDEV("td", {
+                          className: "px-4 py-3",
+                          children: query.isShared ? /* @__PURE__ */ jsxDEV("span", {
+                            className: "text-green-600 dark:text-green-400",
+                            children: "✓"
+                          }, undefined, false, undefined, this) : /* @__PURE__ */ jsxDEV("span", {
+                            className: "text-muted-foreground",
+                            children: "—"
+                          }, undefined, false, undefined, this)
+                        }, undefined, false, undefined, this)
+                      ]
+                    }, query.id, true, undefined, this)),
+                    queries.length === 0 && /* @__PURE__ */ jsxDEV("tr", {
+                      children: /* @__PURE__ */ jsxDEV("td", {
+                        colSpan: 4,
+                        className: "text-muted-foreground px-4 py-8 text-center",
+                        children: "No queries saved"
+                      }, undefined, false, undefined, this)
+                    }, undefined, false, undefined, this)
+                  ]
+                }, undefined, true, undefined, this)
+              ]
+            }, undefined, true, undefined, this)
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+
+// src/ui/hooks/index.ts
+"use client";
+// src/query-engine/index.ts
+class InMemoryQueryCache {
+  cache = new Map;
+  async get(key) {
+    const entry = this.cache.get(key);
+    if (!entry)
+      return null;
+    if (entry.expiresAt < new Date) {
+      this.cache.delete(key);
+      return null;
+    }
+    return { ...entry.result, cached: true, cachedAt: entry.expiresAt };
+  }
+  async set(key, result, ttlSeconds) {
+    const expiresAt = new Date(Date.now() + ttlSeconds * 1000);
+    this.cache.set(key, { result, expiresAt });
+  }
+  async invalidate(pattern) {
+    const regex = new RegExp(pattern);
+    for (const key of this.cache.keys()) {
+      if (regex.test(key)) {
+        this.cache.delete(key);
+      }
+    }
+  }
+}
+
+class BasicQueryEngine {
+  cache;
+  constructor(cache) {
+    this.cache = cache ?? new InMemoryQueryCache;
+  }
+  async execute(definition, params) {
+    const startTime = Date.now();
+    const validation = this.validateQuery(definition);
+    if (!validation.valid) {
+      return {
+        data: [],
+        columns: [],
+        rowCount: 0,
+        executionTimeMs: Date.now() - startTime,
+        cached: false,
+        error: validation.errors.join(", ")
+      };
+    }
+    const cacheKey = this.buildCacheKey(definition, params);
+    const cachedResult = await this.cache.get(cacheKey);
+    if (cachedResult) {
+      return cachedResult;
+    }
+    let result;
+    switch (definition.type) {
+      case "AGGREGATION":
+        if (!definition.aggregation) {
+          throw new Error("Aggregation definition is missing");
+        }
+        result = await this.executeAggregation(definition.aggregation, params);
+        break;
+      case "METRIC":
+        if (!definition.metricIds) {
+          throw new Error("Metric IDs are missing");
+        }
+        result = await this.executeMetric(definition.metricIds, params);
+        break;
+      case "SQL":
+        if (!definition.sql) {
+          throw new Error("SQL query is missing");
+        }
+        result = await this.executeSql(definition.sql, params);
+        break;
+      default:
+        result = {
+          data: [],
+          columns: [],
+          rowCount: 0,
+          executionTimeMs: Date.now() - startTime,
+          cached: false,
+          error: `Unknown query type: ${definition.type}`
+        };
+    }
+    result.executionTimeMs = Date.now() - startTime;
+    result.cached = false;
+    await this.cache.set(cacheKey, result, 300);
+    return result;
+  }
+  validateQuery(definition) {
+    const errors = [];
+    if (!definition.type) {
+      errors.push("Query type is required");
+    }
+    switch (definition.type) {
+      case "SQL":
+        if (!definition.sql) {
+          errors.push("SQL query is required for SQL type");
+        }
+        break;
+      case "METRIC":
+        if (!definition.metricIds || definition.metricIds.length === 0) {
+          errors.push("Metric IDs are required for METRIC type");
+        }
+        break;
+      case "AGGREGATION":
+        if (!definition.aggregation) {
+          errors.push("Aggregation definition is required for AGGREGATION type");
+        } else {
+          if (!definition.aggregation.source) {
+            errors.push("Aggregation source is required");
+          }
+          if (!definition.aggregation.measures || definition.aggregation.measures.length === 0) {
+            errors.push("At least one measure is required");
+          }
+        }
+        break;
+    }
+    return { valid: errors.length === 0, errors };
+  }
+  buildCacheKey(definition, params) {
+    return JSON.stringify({ definition, params });
+  }
+  async executeAggregation(aggregation, params) {
+    const columns = [
+      ...aggregation.dimensions.map((d) => ({
+        name: d.name,
+        type: d.type === "NUMBER" ? "NUMBER" : d.type === "TIME" ? "DATE" : "STRING",
+        label: d.name
+      })),
+      ...aggregation.measures.map((m) => ({
+        name: m.name,
+        type: "NUMBER",
+        label: m.name,
+        format: m.format
+      }))
+    ];
+    const data = this.generateMockData(aggregation, params);
+    return {
+      data,
+      columns,
+      rowCount: data.length,
+      executionTimeMs: 0,
+      cached: false
+    };
+  }
+  async executeMetric(metricIds, _params) {
+    const data = metricIds.map((id) => ({
+      metricId: id,
+      value: Math.random() * 1000,
+      change: (Math.random() - 0.5) * 20
+    }));
+    return {
+      data,
+      columns: [
+        { name: "metricId", type: "STRING" },
+        { name: "value", type: "NUMBER" },
+        { name: "change", type: "NUMBER" }
+      ],
+      rowCount: data.length,
+      executionTimeMs: 0,
+      cached: false
+    };
+  }
+  async executeSql(_sql, _params) {
+    return {
+      data: [],
+      columns: [],
+      rowCount: 0,
+      executionTimeMs: 0,
+      cached: false,
+      error: "SQL execution not implemented in demo"
+    };
+  }
+  generateMockData(aggregation, params) {
+    const data = [];
+    const rowCount = 10;
+    const timeDimension = aggregation.dimensions.find((d) => d.type === "TIME");
+    for (let i = 0;i < rowCount; i++) {
+      const row = {};
+      for (const dim of aggregation.dimensions) {
+        if (dim.type === "TIME") {
+          const date = new Date(params.dateRange?.start ?? new Date);
+          date.setDate(date.getDate() + i);
+          row[dim.name] = date.toISOString().split("T")[0];
+        } else {
+          row[dim.name] = `${dim.name}_${i % 5}`;
+        }
+      }
+      for (const measure of aggregation.measures) {
+        const baseValue = timeDimension ? 100 + i * 10 : Math.random() * 1000;
+        const noise = (Math.random() - 0.5) * 20;
+        row[measure.name] = Math.round((baseValue + noise) * 100) / 100;
+      }
+      data.push(row);
+    }
+    return data;
+  }
+}
+function createQueryEngine(cache) {
+  return new BasicQueryEngine(cache);
+}
+export {
+  useAnalyticsData,
+  queryBuilderMarkdownRenderer,
+  dashboardListMarkdownRenderer,
+  createQueryEngine,
+  createPosthogQueryEngine,
+  createAnalyticsHandlers,
+  analyticsDashboardMarkdownRenderer,
+  QueryTypeEnum,
+  QueryResultModel,
+  QueryModel,
+  PosthogQueryEngine,
+  InMemoryQueryCache,
+  ExecuteQueryInputModel,
+  ExecuteQueryContract,
+  CreateQueryInputModel,
+  CreateQueryContract,
+  BasicQueryEngine,
+  AnalyticsDashboardFeature,
+  AnalyticsDashboard
+};