@constela/runtime 0.19.5 → 0.19.7

package/dist/index.js

@@ -436,6 +436,272 @@ var SAFE_DATE_INSTANCE_METHODS = /* @__PURE__ */ new Set([
   "getSeconds",
   "getMilliseconds"
 ]);
+function getCalendarDays(year, month) {
+  if (typeof year !== "number" || typeof month !== "number") {
+    return void 0;
+  }
+  if (month < 0 || month > 11) {
+    return void 0;
+  }
+  const days = [];
+  const firstDayOfMonth = new Date(year, month, 1);
+  const dayOfWeek = firstDayOfMonth.getDay();
+  const lastDayOfMonth = new Date(year, month + 1, 0);
+  const daysInMonth = lastDayOfMonth.getDate();
+  const prevMonthDays = dayOfWeek;
+  const prevMonthLastDay = new Date(year, month, 0);
+  const prevMonthDaysCount = prevMonthLastDay.getDate();
+  const prevMonth = month === 0 ? 11 : month - 1;
+  const prevYear = month === 0 ? year - 1 : year;
+  for (let i = prevMonthDays - 1; i >= 0; i--) {
+    days.push({
+      date: prevMonthDaysCount - i,
+      month: prevMonth,
+      year: prevYear,
+      isCurrentMonth: false
+    });
+  }
+  for (let i = 1; i <= daysInMonth; i++) {
+    days.push({
+      date: i,
+      month,
+      year,
+      isCurrentMonth: true
+    });
+  }
+  const totalDaysSoFar = days.length;
+  const totalWeeksNeeded = Math.ceil(totalDaysSoFar / 7);
+  const targetDays = totalWeeksNeeded * 7;
+  const nextMonth = month === 11 ? 0 : month + 1;
+  const nextYear = month === 11 ? year + 1 : year;
+  const nextMonthDaysNeeded = targetDays - totalDaysSoFar;
+  for (let i = 1; i <= nextMonthDaysNeeded; i++) {
+    days.push({
+      date: i,
+      month: nextMonth,
+      year: nextYear,
+      isCurrentMonth: false
+    });
+  }
+  return days;
+}
+function getWeekDays(locale) {
+  const effectiveLocale = typeof locale === "string" ? locale : "en-US";
+  const baseSunday = new Date(2024, 0, 7);
+  const weekDays = [];
+  try {
+    const formatter = new Intl.DateTimeFormat(effectiveLocale || "en-US", { weekday: "short" });
+    for (let i = 0; i < 7; i++) {
+      const date = new Date(baseSunday);
+      date.setDate(baseSunday.getDate() + i);
+      weekDays.push(formatter.format(date));
+    }
+    return weekDays;
+  } catch {
+    const fallbackFormatter = new Intl.DateTimeFormat("en-US", { weekday: "short" });
+    for (let i = 0; i < 7; i++) {
+      const date = new Date(baseSunday);
+      date.setDate(baseSunday.getDate() + i);
+      weekDays.push(fallbackFormatter.format(date));
+    }
+    return weekDays;
+  }
+}
+function getMonthName(month, locale) {
+  if (typeof month !== "number" || month < 0 || month > 11) {
+    return void 0;
+  }
+  const effectiveLocale = typeof locale === "string" ? locale : "en-US";
+  try {
+    const date = new Date(2024, month, 1);
+    const formatter = new Intl.DateTimeFormat(effectiveLocale, { month: "long" });
+    return formatter.format(date);
+  } catch {
+    const date = new Date(2024, month, 1);
+    const formatter = new Intl.DateTimeFormat("en-US", { month: "long" });
+    return formatter.format(date);
+  }
+}
+function formatDateISO(year, month, date) {
+  if (typeof year !== "number" || typeof month !== "number" || typeof date !== "number") {
+    return void 0;
+  }
+  const y2 = String(year).padStart(4, "0");
+  const m2 = String(month + 1).padStart(2, "0");
+  const d2 = String(date).padStart(2, "0");
+  return `${y2}-${m2}-${d2}`;
+}
+function sortBy(items, key2, direction) {
+  if (!Array.isArray(items)) {
+    return void 0;
+  }
+  if (typeof key2 !== "string") {
+    return void 0;
+  }
+  const forbiddenKeys = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+  if (forbiddenKeys.has(key2)) {
+    return void 0;
+  }
+  const dir = direction === "desc" ? "desc" : "asc";
+  const sorted = [...items];
+  sorted.sort((a, b2) => {
+    const aVal = a != null && typeof a === "object" ? a[key2] : void 0;
+    const bVal = b2 != null && typeof b2 === "object" ? b2[key2] : void 0;
+    if (aVal == null && bVal == null) return 0;
+    if (aVal == null) return 1;
+    if (bVal == null) return -1;
+    let comparison = 0;
+    if (typeof aVal === "number" && typeof bVal === "number") {
+      comparison = aVal - bVal;
+    } else {
+      comparison = String(aVal).localeCompare(String(bVal));
+    }
+    return dir === "desc" ? -comparison : comparison;
+  });
+  return sorted;
+}
+function getPaginatedItems(items, page, pageSize) {
+  if (!Array.isArray(items)) {
+    return void 0;
+  }
+  if (typeof page !== "number" || page < 0) {
+    return void 0;
+  }
+  if (typeof pageSize !== "number" || pageSize <= 0) {
+    return void 0;
+  }
+  const start = page * pageSize;
+  const end = start + pageSize;
+  return items.slice(start, end);
+}
+function getTotalPages(itemCount, pageSize) {
+  if (typeof itemCount !== "number" || typeof pageSize !== "number") {
+    return 0;
+  }
+  if (itemCount < 0 || pageSize <= 0) {
+    return 0;
+  }
+  if (itemCount === 0) {
+    return 0;
+  }
+  return Math.ceil(itemCount / pageSize);
+}
+function getPageNumbers(currentPage, totalPages, maxVisible) {
+  if (typeof currentPage !== "number" || typeof totalPages !== "number" || typeof maxVisible !== "number") {
+    return [];
+  }
+  if (totalPages <= 0) {
+    return [];
+  }
+  if (currentPage < 0 || currentPage >= totalPages) {
+    return [];
+  }
+  if (totalPages <= maxVisible) {
+    return Array.from({ length: totalPages }, (_2, i) => i);
+  }
+  const result = [];
+  const firstPage = 0;
+  const lastPage = totalPages - 1;
+  result.push(firstPage);
+  const middleSlots = maxVisible - 2;
+  let middleStart = currentPage - Math.floor((middleSlots - 1) / 2);
+  let middleEnd = currentPage + Math.ceil((middleSlots - 1) / 2);
+  if (middleStart <= 1) {
+    middleStart = 1;
+    middleEnd = Math.min(middleSlots, lastPage - 1);
+  }
+  if (middleEnd >= lastPage - 1) {
+    middleEnd = lastPage - 1;
+    middleStart = Math.max(1, lastPage - middleSlots);
+  }
+  if (middleStart > 1) {
+    result.push(-1);
+  }
+  for (let i = middleStart; i <= middleEnd; i++) {
+    if (i > firstPage && i < lastPage) {
+      result.push(i);
+    }
+  }
+  if (middleEnd < lastPage - 1) {
+    result.push(-1);
+  }
+  result.push(lastPage);
+  return result;
+}
+function getVisibleRange(scrollTop, itemHeight, containerHeight, overscan) {
+  if (typeof scrollTop !== "number" || typeof itemHeight !== "number" || typeof containerHeight !== "number" || typeof overscan !== "number") {
+    return void 0;
+  }
+  if (scrollTop < 0 || itemHeight <= 0 || containerHeight <= 0) {
+    return void 0;
+  }
+  const firstVisible = Math.floor(scrollTop / itemHeight);
+  const visibleCount = Math.ceil(containerHeight / itemHeight);
+  const start = Math.max(0, firstVisible - overscan);
+  const end = firstVisible + visibleCount + overscan - 1;
+  return { start, end };
+}
+function getTotalHeight(itemCount, itemHeight) {
+  if (typeof itemCount !== "number" || typeof itemHeight !== "number") {
+    return 0;
+  }
+  if (itemCount < 0 || itemHeight <= 0) {
+    return 0;
+  }
+  return itemCount * itemHeight;
+}
+function formatDate(dateStr, format, locale) {
+  if (typeof dateStr !== "string" || !dateStr) {
+    return void 0;
+  }
+  const isoDateRegex = /^\d{4}-\d{2}-\d{2}$/;
+  if (!isoDateRegex.test(dateStr)) {
+    return void 0;
+  }
+  const [yearStr, monthStr, dayStr] = dateStr.split("-");
+  const year = parseInt(yearStr, 10);
+  const month = parseInt(monthStr, 10) - 1;
+  const day = parseInt(dayStr, 10);
+  const date = new Date(Date.UTC(year, month, day));
+  if (isNaN(date.getTime()) || date.getUTCFullYear() !== year || date.getUTCMonth() !== month || date.getUTCDate() !== day) {
+    return void 0;
+  }
+  const effectiveFormat = typeof format === "string" ? format : "medium";
+  const effectiveLocale = typeof locale === "string" ? locale : "en-US";
+  if (effectiveFormat === "iso") {
+    return dateStr;
+  }
+  try {
+    let options;
+    switch (effectiveFormat) {
+      case "short":
+        if (effectiveLocale.startsWith("ja")) {
+          options = { year: "numeric", month: "2-digit", day: "2-digit", timeZone: "UTC" };
+        } else {
+          options = { year: "2-digit", month: "numeric", day: "numeric", timeZone: "UTC" };
+        }
+        break;
+      case "medium":
+        options = { year: "numeric", month: "short", day: "numeric", timeZone: "UTC" };
+        break;
+      case "long":
+        options = { year: "numeric", month: "long", day: "numeric", timeZone: "UTC" };
+        break;
+      default:
+        options = { year: "numeric", month: "short", day: "numeric", timeZone: "UTC" };
+    }
+    const formatter = new Intl.DateTimeFormat(effectiveLocale, options);
+    return formatter.format(date);
+  } catch {
+    const formatter = new Intl.DateTimeFormat("en-US", {
+      year: "numeric",
+      month: "short",
+      day: "numeric",
+      timeZone: "UTC"
+    });
+    return formatter.format(date);
+  }
+}
 function createLambdaFunction(lambda, ctx) {
   return (item, index) => {
     const lambdaLocals = {
@@ -677,6 +943,50 @@ function callDateInstanceMethod(target, method) {
       return void 0;
   }
 }
+var GLOBAL_FUNCTIONS = {
+  // Date helpers
+  getCalendarDays: (year, month) => getCalendarDays(year, month),
+  getWeekDays: (locale) => getWeekDays(locale),
+  getMonthName: (month, locale) => getMonthName(month, locale),
+  formatDate: (dateStr, format, locale) => formatDate(dateStr, format, locale),
+  formatDateISO: (year, month, date) => formatDateISO(year, month, date),
+  // DataTable helpers
+  sortBy: (items, key2, direction) => sortBy(items, key2, direction),
+  getPaginatedItems: (items, page, pageSize) => getPaginatedItems(items, page, pageSize),
+  getTotalPages: (itemCount, pageSize) => getTotalPages(itemCount, pageSize),
+  getPageNumbers: (currentPage, totalPages, maxVisible) => getPageNumbers(currentPage, totalPages, maxVisible),
+  // Virtual scroll helpers
+  getVisibleRange: (scrollTop, itemHeight, containerHeight, overscan) => getVisibleRange(scrollTop, itemHeight, containerHeight, overscan),
+  getTotalHeight: (itemCount, itemHeight) => getTotalHeight(itemCount, itemHeight),
+  // Chart helpers - Coordinate calculation
+  normalizeValue: (value, min, max) => normalizeValue(value, min, max),
+  scaleValue: (value, domainMin, domainMax, rangeMin, rangeMax) => scaleValue(value, domainMin, domainMax, rangeMin, rangeMax),
+  getBarDimensions: (data, index, width, height, gap, orientation) => getBarDimensions(data, index, width, height, gap, orientation),
+  // Chart helpers - Path generation
+  getLinePath: (points, curved) => getLinePath(points, curved),
+  getAreaPath: (points, baseline, curved) => getAreaPath(points, baseline, curved),
+  getArcPath: (cx, cy, radius, startAngle, endAngle) => getArcPath(cx, cy, radius, startAngle, endAngle),
+  // Chart helpers - Pie/Donut
+  getPieSlices: (data, valueKey) => getPieSlices(data, valueKey),
+  getDonutSlices: (data, valueKey, innerRadius) => getDonutSlices(data, valueKey, innerRadius),
+  // Chart helpers - Radar
+  getRadarPoints: (data, valueKey, cx, cy, radius, maxValue) => getRadarPoints(data, valueKey, cx, cy, radius, maxValue),
+  getRadarAxes: (labels, cx, cy, radius) => getRadarAxes(labels, cx, cy, radius),
+  // Chart helpers - Utilities
+  getChartBounds: (data, valueKey) => getChartBounds(data, valueKey),
+  generateTicks: (min, max, count) => generateTicks(min, max, count),
+  // Chart helpers - Data aggregation
+  binData: (data, valueKey, binCount) => binData(data, valueKey, binCount),
+  aggregateData: (data, groupKey, valueKey, aggregation) => aggregateData(data, groupKey, valueKey, aggregation),
+  downsample: (data, targetCount, method) => downsample(data, targetCount, method)
+};
+function callGlobalFunction(method, args) {
+  const fn = GLOBAL_FUNCTIONS[method];
+  if (!fn) {
+    return void 0;
+  }
+  return fn(...args);
+}
 function evaluate(expr, ctx) {
   switch (expr.expr) {
     case "lit":
@@ -716,7 +1026,21 @@ function evaluate(expr, ctx) {
           String,
           Number,
           Boolean,
-          console
+          console,
+          // Date helper functions
+          getCalendarDays,
+          getWeekDays,
+          getMonthName,
+          formatDate,
+          formatDateISO,
+          // DataTable helper functions
+          sortBy,
+          getPaginatedItems,
+          getTotalPages,
+          getPageNumbers,
+          // Virtual scroll helper functions
+          getVisibleRange,
+          getTotalHeight
         };
         value = safeGlobals[varName];
       }
@@ -727,7 +1051,7 @@ function evaluate(expr, ctx) {
       if (typeof value === "function" && pathParts.length > 0) {
         let parent = ctx.locals[varName];
         if (parent === void 0) {
-          const safeGlobals = { JSON, Math, Date, Object, Array, String, Number, Boolean, console };
+          const safeGlobals = { JSON, Math, Date, Object, Array, String, Number, Boolean, console, getCalendarDays, getWeekDays, getMonthName, formatDate, formatDateISO, sortBy, getPaginatedItems, getTotalPages, getPageNumbers, getVisibleRange, getTotalHeight };
           parent = safeGlobals[varName];
         }
         for (let i = 0; i < pathParts.length - 1; i++) {
@@ -823,12 +1147,14 @@ function evaluate(expr, ctx) {
     }
     case "call": {
       const callExpr = expr;
-      const target = evaluate(callExpr.target, ctx);
-      if (target == null) return void 0;
+      const target = callExpr.target != null ? evaluate(callExpr.target, ctx) : null;
       const args = callExpr.args?.map((arg) => {
         if (arg.expr === "lambda") return arg;
         return evaluate(arg, ctx);
       }) ?? [];
+      if (target === null) {
+        return callGlobalFunction(callExpr.method, args);
+      }
       if (Array.isArray(target)) {
         return callArrayMethod(target, callExpr.method, args, ctx, callExpr.args);
       }
@@ -844,6 +1170,9 @@ function evaluate(expr, ctx) {
       if (target instanceof Date) {
         return callDateInstanceMethod(target, callExpr.method);
       }
+      if (typeof target === "function" && callExpr.method === "call") {
+        return target(...args);
+      }
       return void 0;
     }
     case "lambda":
@@ -972,6 +1301,528 @@ function evaluateBinary(op, left, right, ctx) {
       throw new Error("Unknown binary operator: " + op);
   }
 }
+function normalizeValue(value, min, max) {
+  if (typeof value !== "number" || typeof min !== "number" || typeof max !== "number") {
+    return void 0;
+  }
+  if (max === min) {
+    return 0;
+  }
+  return (value - min) / (max - min);
+}
+function scaleValue(value, domainMin, domainMax, rangeMin, rangeMax) {
+  if (typeof value !== "number" || typeof domainMin !== "number" || typeof domainMax !== "number" || typeof rangeMin !== "number" || typeof rangeMax !== "number") {
+    return void 0;
+  }
+  if (domainMax === domainMin) {
+    return rangeMin;
+  }
+  const normalized = (value - domainMin) / (domainMax - domainMin);
+  return rangeMin + normalized * (rangeMax - rangeMin);
+}
+function getBarDimensions(data, index, width, height, gap, orientation) {
+  if (!Array.isArray(data) || data.length === 0) {
+    return void 0;
+  }
+  if (typeof index !== "number" || index < 0 || index >= data.length) {
+    return void 0;
+  }
+  if (typeof width !== "number" || typeof height !== "number" || typeof gap !== "number") {
+    return void 0;
+  }
+  const isVertical = orientation === "vertical";
+  const barCount = data.length;
+  const values = data.map((d2) => typeof d2 === "number" ? d2 : 0);
+  const maxValue = Math.max(...values);
+  if (isVertical) {
+    const totalGap = gap * (barCount + 1);
+    const barWidth = (width - totalGap) / barCount;
+    const barX = gap + index * (barWidth + gap);
+    const value = values[index] ?? 0;
+    const barHeight = maxValue > 0 ? value / maxValue * height : 0;
+    const barY = height - barHeight;
+    return {
+      x: barX,
+      y: barY,
+      width: barWidth,
+      height: barHeight
+    };
+  } else {
+    const totalGap = gap * barCount;
+    const barHeight = (height - totalGap) / barCount;
+    const barY = gap + index * (barHeight + gap);
+    const value = values[index] ?? 0;
+    const barWidth = maxValue > 0 ? value / maxValue * width : 0;
+    return {
+      x: 0,
+      y: barY,
+      width: barWidth,
+      height: barHeight
+    };
+  }
+}
+function getCurvedPath(points) {
+  if (points.length < 2) {
+    return points.length === 1 ? `M${points[0].x},${points[0].y}` : "";
+  }
+  if (points.length === 2) {
+    return `M${points[0].x},${points[0].y} L${points[1].x},${points[1].y}`;
+  }
+  const pathParts = [`M${points[0].x},${points[0].y}`];
+  for (let i = 0; i < points.length - 1; i++) {
+    const p0 = points[Math.max(0, i - 1)];
+    const p1 = points[i];
+    const p2 = points[i + 1];
+    const p3 = points[Math.min(points.length - 1, i + 2)];
+    const cp1x = p1.x + (p2.x - p0.x) / 6;
+    const cp1y = p1.y + (p2.y - p0.y) / 6;
+    const cp2x = p2.x - (p3.x - p1.x) / 6;
+    const cp2y = p2.y - (p3.y - p1.y) / 6;
+    pathParts.push(`C${cp1x},${cp1y} ${cp2x},${cp2y} ${p2.x},${p2.y}`);
+  }
+  return pathParts.join(" ");
+}
+function getLinePath(points, curved) {
+  if (!Array.isArray(points)) {
+    return void 0;
+  }
+  if (points.length === 0) {
+    return "";
+  }
+  for (const point of points) {
+    if (typeof point !== "object" || point === null || typeof point.x !== "number" || typeof point.y !== "number") {
+      return void 0;
+    }
+  }
+  const validPoints = points;
+  if (validPoints.length === 1) {
+    return `M${validPoints[0].x},${validPoints[0].y}`;
+  }
+  if (curved !== true) {
+    const pathParts = validPoints.map((point, i) => {
+      const command = i === 0 ? "M" : "L";
+      return `${command}${point.x},${point.y}`;
+    });
+    return pathParts.join(" ");
+  }
+  return getCurvedPath(validPoints);
+}
+function getAreaPath(points, baseline, curved) {
+  if (!Array.isArray(points)) {
+    return void 0;
+  }
+  if (typeof baseline !== "number") {
+    return void 0;
+  }
+  if (points.length === 0) {
+    return "";
+  }
+  for (const point of points) {
+    if (typeof point !== "object" || point === null || typeof point.x !== "number" || typeof point.y !== "number") {
+      return void 0;
+    }
+  }
+  const validPoints = points;
+  let upperPath;
+  if (curved === true && validPoints.length > 2) {
+    upperPath = getCurvedPath(validPoints);
+  } else {
+    upperPath = validPoints.map((p2, i) => (i === 0 ? "M" : "L") + `${p2.x},${p2.y}`).join(" ");
+  }
+  const lastPoint = validPoints[validPoints.length - 1];
+  const firstPoint = validPoints[0];
+  return `${upperPath} L${lastPoint.x},${baseline} L${firstPoint.x},${baseline} Z`;
+}
+function getArcPath(cx, cy, radius, startAngle, endAngle) {
+  if (typeof cx !== "number" || typeof cy !== "number" || typeof radius !== "number" || typeof startAngle !== "number" || typeof endAngle !== "number") {
+    return void 0;
+  }
+  if (radius <= 0) {
+    return void 0;
+  }
+  const x1 = cx + radius * Math.cos(startAngle);
+  const y1 = cy + radius * Math.sin(startAngle);
+  const x2 = cx + radius * Math.cos(endAngle);
+  const y2 = cy + radius * Math.sin(endAngle);
+  const angleDiff = endAngle - startAngle;
+  const largeArcFlag = Math.abs(angleDiff) > Math.PI ? 1 : 0;
+  return `M${x1},${y1} A${radius},${radius} 0 ${largeArcFlag},1 ${x2},${y2}`;
+}
+function getPieSlices(data, valueKey) {
+  if (!Array.isArray(data)) {
+    return void 0;
+  }
+  if (typeof valueKey !== "string") {
+    return void 0;
+  }
+  if (data.length === 0) {
+    return [];
+  }
+  const values = data.map((item) => {
+    if (typeof item !== "object" || item === null) return 0;
+    const val = item[valueKey];
+    return typeof val === "number" ? val : 0;
+  });
+  const total = values.reduce((sum, val) => sum + val, 0);
+  const slices = [];
+  let currentAngle = 0;
+  for (let i = 0; i < values.length; i++) {
+    const value = values[i];
+    const percentage = total > 0 ? value / total * 100 : 0;
+    const angleSpan = total > 0 ? value / total * Math.PI * 2 : 0;
+    slices.push({
+      startAngle: currentAngle,
+      endAngle: currentAngle + angleSpan,
+      value,
+      percentage
+    });
+    currentAngle += angleSpan;
+  }
+  return slices;
+}
+function getDonutSlices(data, valueKey, innerRadius) {
+  if (typeof innerRadius !== "number" || innerRadius < 0) {
+    return void 0;
+  }
+  const pieSlices = getPieSlices(data, valueKey);
+  if (pieSlices === void 0) {
+    return void 0;
+  }
+  const outerRadius = 100;
+  return pieSlices.map((slice) => ({
+    ...slice,
+    outerRadius,
+    innerRadius
+  }));
+}
+function getRadarPoints(data, valueKey, cx, cy, radius, maxValue) {
+  if (!Array.isArray(data)) {
+    return void 0;
+  }
+  if (typeof valueKey !== "string") {
+    return void 0;
+  }
+  if (typeof cx !== "number" || typeof cy !== "number" || typeof radius !== "number" || typeof maxValue !== "number") {
+    return void 0;
+  }
+  if (maxValue <= 0) {
+    return void 0;
+  }
+  if (data.length === 0) {
+    return [];
+  }
+  const points = [];
+  const angleStep = Math.PI * 2 / data.length;
+  for (let i = 0; i < data.length; i++) {
+    const item = data[i];
+    const value = typeof item === "object" && item !== null ? item[valueKey] : 0;
+    const numValue = typeof value === "number" ? value : 0;
+    const scaledRadius = numValue / maxValue * radius;
+    const angle = -Math.PI / 2 + i * angleStep;
+    const x2 = cx + scaledRadius * Math.cos(angle);
+    const y2 = cy + scaledRadius * Math.sin(angle);
+    points.push({ x: x2, y: y2 });
+  }
+  return points;
+}
+function getRadarAxes(labels, cx, cy, radius) {
+  if (!Array.isArray(labels)) {
+    return void 0;
+  }
+  if (typeof cx !== "number" || typeof cy !== "number" || typeof radius !== "number") {
+    return void 0;
+  }
+  if (radius < 0) {
+    return void 0;
+  }
+  if (labels.length === 0) {
+    return [];
+  }
+  const axes = [];
+  const angleStep = Math.PI * 2 / labels.length;
+  for (let i = 0; i < labels.length; i++) {
+    const label = String(labels[i]);
+    const angle = -Math.PI / 2 + i * angleStep;
+    const x2 = cx + radius * Math.cos(angle);
+    const y2 = cy + radius * Math.sin(angle);
+    axes.push({
+      x1: cx,
+      y1: cy,
+      x2,
+      y2,
+      label,
+      angle
+    });
+  }
+  return axes;
+}
+function getChartBounds(data, valueKey) {
+  if (!Array.isArray(data) || data.length === 0) {
+    return void 0;
+  }
+  if (typeof valueKey !== "string") {
+    return void 0;
+  }
+  const values = [];
+  for (const item of data) {
+    if (typeof item !== "object" || item === null) {
+      continue;
+    }
+    const val = item[valueKey];
+    if (typeof val === "number") {
+      values.push(val);
+    }
+  }
+  if (values.length === 0) {
+    return void 0;
+  }
+  return {
+    min: Math.min(...values),
+    max: Math.max(...values)
+  };
+}
+function generateTicks(min, max, count) {
+  if (typeof min !== "number" || typeof max !== "number" || typeof count !== "number") {
+    return [];
+  }
+  if (count <= 0) {
+    return [];
+  }
+  if (min === max) {
+    return [min];
+  }
+  if (count === 1) {
+    return [min];
+  }
+  if (count === 2) {
+    return [min, max];
+  }
+  const range = max - min;
+  const rawStep = range / (count - 1);
+  const niceStep = getNiceStep(rawStep);
+  const niceMin = Math.floor(min / niceStep) * niceStep;
+  const ticks = [];
+  for (let i = 0; i < count; i++) {
+    const tick = niceMin + i * niceStep;
+    ticks.push(Math.round(tick * 1e10) / 1e10);
+  }
+  return ticks;
+}
+function getNiceStep(rawStep) {
+  const magnitude = Math.pow(10, Math.floor(Math.log10(rawStep)));
+  const normalized = rawStep / magnitude;
+  let niceNormalized;
+  if (normalized <= 1) {
+    niceNormalized = 1;
+  } else if (normalized <= 2) {
+    niceNormalized = 2;
+  } else if (normalized <= 2.5) {
+    niceNormalized = 2.5;
+  } else if (normalized <= 5) {
+    niceNormalized = 5;
+  } else {
+    niceNormalized = 10;
+  }
+  return niceNormalized * magnitude;
+}
+function binData(data, valueKey, binCount) {
+  if (!Array.isArray(data)) {
+    return void 0;
+  }
+  if (typeof valueKey !== "string") {
+    return void 0;
+  }
+  if (typeof binCount !== "number" || binCount <= 0) {
+    return [];
+  }
+  if (data.length === 0) {
+    return [];
+  }
+  const values = [];
+  for (const item of data) {
+    if (typeof item !== "object" || item === null) continue;
+    const val = item[valueKey];
+    if (typeof val === "number") {
+      values.push(val);
+    }
+  }
+  if (values.length === 0) {
+    return [];
+  }
+  const minVal = Math.min(...values);
+  const maxVal = Math.max(...values);
+  const binWidth = maxVal === minVal ? 1 : (maxVal - minVal) / binCount;
+  const bins = [];
+  for (let i = 0; i < binCount; i++) {
+    bins.push({
+      binStart: minVal + i * binWidth,
+      binEnd: minVal + (i + 1) * binWidth,
+      count: 0,
+      values: []
+    });
+  }
+  for (const val of values) {
+    let binIndex = Math.floor((val - minVal) / binWidth);
+    if (binIndex >= binCount) {
+      binIndex = binCount - 1;
+    }
+    bins[binIndex].count++;
+    bins[binIndex].values.push(val);
+  }
+  return bins;
+}
+function aggregateData(data, groupKey, valueKey, aggregation) {
+  if (!Array.isArray(data)) {
+    return void 0;
+  }
+  if (typeof groupKey !== "string" || typeof valueKey !== "string") {
+    return void 0;
+  }
+  const validAggregations = /* @__PURE__ */ new Set(["sum", "avg", "min", "max", "count"]);
+  if (typeof aggregation !== "string" || !validAggregations.has(aggregation)) {
+    return void 0;
+  }
+  if (data.length === 0) {
+    return [];
+  }
+  const groups = /* @__PURE__ */ new Map();
+  for (const item of data) {
+    if (typeof item !== "object" || item === null) continue;
+    const obj = item;
+    const group = String(obj[groupKey] ?? "");
+    const val = obj[valueKey];
+    const numVal = typeof val === "number" ? val : 0;
+    if (!groups.has(group)) {
+      groups.set(group, []);
+    }
+    groups.get(group).push(numVal);
+  }
+  const result = [];
+  for (const [group, values] of groups) {
+    let aggregatedValue;
+    switch (aggregation) {
+      case "sum":
+        aggregatedValue = values.reduce((sum, v2) => sum + v2, 0);
+        break;
+      case "avg":
+        aggregatedValue = values.reduce((sum, v2) => sum + v2, 0) / values.length;
+        break;
+      case "min":
+        aggregatedValue = Math.min(...values);
+        break;
+      case "max":
+        aggregatedValue = Math.max(...values);
+        break;
+      case "count":
+        aggregatedValue = values.length;
+        break;
+      default:
+        aggregatedValue = 0;
+    }
+    result.push({ group, value: aggregatedValue });
+  }
+  return result;
+}
+function downsample(data, targetCount, method) {
+  if (!Array.isArray(data)) {
+    return void 0;
+  }
+  if (typeof targetCount !== "number" || targetCount <= 0) {
+    return void 0;
+  }
+  const validMethods = /* @__PURE__ */ new Set(["uniform", "lttb"]);
+  if (typeof method !== "string" || !validMethods.has(method)) {
+    return void 0;
+  }
+  if (data.length === 0) {
+    return [];
+  }
+  if (targetCount >= data.length) {
+    return data;
+  }
+  if (method === "uniform") {
+    return downsampleUniform(data, targetCount);
+  } else {
+    return downsampleLTTB(data, targetCount);
+  }
+}
+function downsampleUniform(data, targetCount) {
+  if (targetCount === 1) {
+    return [data[0]];
+  }
+  if (targetCount === 2) {
+    return [data[0], data[data.length - 1]];
+  }
+  const result = [];
+  const step = (data.length - 1) / (targetCount - 1);
+  for (let i = 0; i < targetCount; i++) {
+    const index = Math.round(i * step);
+    result.push(data[index]);
+  }
+  return result;
+}
+function downsampleLTTB(data, targetCount) {
+  if (targetCount === 1) {
+    return [data[0]];
+  }
+  if (targetCount === 2) {
+    return [data[0], data[data.length - 1]];
+  }
+  const getXY = (point) => {
+    if (typeof point !== "object" || point === null) {
+      return { x: 0, y: 0 };
+    }
+    const obj = point;
+    const x2 = typeof obj["x"] === "number" ? obj["x"] : typeof obj["timestamp"] === "number" ? obj["timestamp"] : 0;
+    const y2 = typeof obj["y"] === "number" ? obj["y"] : typeof obj["value"] === "number" ? obj["value"] : 0;
+    return { x: x2, y: y2 };
+  };
+  const result = [];
+  result.push(data[0]);
+  const numBuckets = targetCount - 2;
+  const middleData = data.length - 2;
+  const bucketSize = middleData / numBuckets;
+  let prevSelectedIndex = 0;
+  for (let bucketIndex = 0; bucketIndex < numBuckets; bucketIndex++) {
+    const bucketStart = Math.floor(bucketIndex * bucketSize) + 1;
+    const bucketEnd = Math.floor((bucketIndex + 1) * bucketSize) + 1;
+    const nextBucketStart = bucketEnd;
+    const nextBucketEnd = bucketIndex < numBuckets - 1 ? Math.floor((bucketIndex + 2) * bucketSize) + 1 : data.length;
+    let avgX = 0;
+    let avgY = 0;
+    const nextLen = nextBucketEnd - nextBucketStart;
+    if (nextLen > 0) {
+      for (let j2 = nextBucketStart; j2 < nextBucketEnd; j2++) {
+        const point = getXY(data[j2]);
+        avgX += point.x;
+        avgY += point.y;
+      }
+      avgX /= nextLen;
+      avgY /= nextLen;
+    } else {
+      const lastPoint = getXY(data[data.length - 1]);
+      avgX = lastPoint.x;
+      avgY = lastPoint.y;
+    }
+    const pointA = getXY(data[prevSelectedIndex]);
+    let maxArea = -1;
+    let maxAreaIndex = bucketStart;
+    for (let j2 = bucketStart; j2 < bucketEnd; j2++) {
+      const pointB = getXY(data[j2]);
+      const area = Math.abs(
+        pointA.x * (pointB.y - avgY) + pointB.x * (avgY - pointA.y) + avgX * (pointA.y - pointB.y)
+      );
+      if (area > maxArea) {
+        maxArea = area;
+        maxAreaIndex = j2;
+      }
+    }
+    result.push(data[maxAreaIndex]);
+    prevSelectedIndex = maxAreaIndex;
+  }
+  result.push(data[data.length - 1]);
+  return result;
+}
 function evaluateStyle(expr, ctx) {
   const preset = ctx.styles?.[expr.name];
   if (!preset) return void 0;
@@ -1003,6 +1854,83 @@ function evaluateStyle(expr, ctx) {
   return classes.trim();
 }
 
+// src/connection/sse.ts
+function parseMessageData(data) {
+  try {
+    return JSON.parse(data);
+  } catch {
+    return data;
+  }
+}
+function createSSEConnection(url, handlers, eventTypes) {
+  const eventSource = new EventSource(url, void 0);
+  eventSource.onopen = () => {
+    handlers.onOpen?.();
+  };
+  eventSource.onerror = (event) => {
+    handlers.onError?.(event);
+  };
+  eventSource.onmessage = (event) => {
+    const data = parseMessageData(event.data);
+    handlers.onMessage?.(data, "message");
+  };
+  if (eventTypes && eventTypes.length > 0) {
+    for (const eventType of eventTypes) {
+      eventSource.addEventListener(eventType, (event) => {
+        const data = parseMessageData(event.data);
+        handlers.onMessage?.(data, eventType);
+      });
+    }
+  }
+  return {
+    close() {
+      eventSource.close();
+      handlers.onClose?.();
+    },
+    getState() {
+      switch (eventSource.readyState) {
+        case EventSource.CONNECTING:
+          return "connecting";
+        case EventSource.OPEN:
+          return "open";
+        case EventSource.CLOSED:
+          return "closed";
+        default:
+          return "closed";
+      }
+    }
+  };
+}
+function createSSEConnectionManager() {
+  const connections = /* @__PURE__ */ new Map();
+  return {
+    create(name, url, handlers, eventTypes) {
+      const existing = connections.get(name);
+      if (existing) {
+        existing.close();
+      }
+      const conn = createSSEConnection(url, handlers, eventTypes);
+      connections.set(name, conn);
+    },
+    get(name) {
+      return connections.get(name);
+    },
+    close(name) {
+      const conn = connections.get(name);
+      if (conn) {
+        conn.close();
+        connections.delete(name);
+      }
+    },
+    closeAll() {
+      for (const conn of connections.values()) {
+        conn.close();
+      }
+      connections.clear();
+    }
+  };
+}
+
 // src/action/executor.ts
 function createEvalContext(ctx) {
   return {
@@ -1337,6 +2265,30 @@ async function executeStep(step, ctx) {
     case "focus":
       await executeFocusStep(step, ctx);
       break;
+    case "generate":
+      await executeGenerateStep(step, ctx);
+      break;
+    case "sseConnect":
+      await executeSSEConnectStep(step, ctx);
+      break;
+    case "sseClose":
+      await executeSSECloseStep(step, ctx);
+      break;
+    case "optimistic":
+      await executeOptimisticStep(step, ctx);
+      break;
+    case "confirm":
+      await executeConfirmStep(step, ctx);
+      break;
+    case "reject":
+      await executeRejectStep(step, ctx);
+      break;
+    case "bind":
+      await executeBindStep(step, ctx);
+      break;
+    case "unbind":
+      await executeUnbindStep(step, ctx);
+      break;
   }
 }
 async function executeSetStep(target, value, ctx) {
@@ -1834,6 +2786,158 @@ async function executeFocusStep(step, ctx) {
     }
   }
 }
+async function executeGenerateStep(step, ctx) {
+  const { createDslGenerator } = await import("@constela/ai");
+  const evalCtx = createEvalContext(ctx);
+  const promptValue = evaluate(step.prompt, evalCtx);
+  try {
+    const generator = createDslGenerator({
+      provider: step.provider
+    });
+    const result = await generator.generate({
+      prompt: promptValue,
+      output: step.output
+    });
+    ctx.locals[step.result] = result.dsl;
+    if (!result.validated && result.errors && result.errors.length > 0) {
+      ctx.locals["error"] = {
+        message: `AI generated DSL validation failed: ${result.errors.join(", ")}`,
+        name: "ValidationError"
+      };
+      if (step.onError) {
+        for (const errorStep of step.onError) {
+          await executeStep(errorStep, ctx);
+        }
+      }
+      return;
+    }
+    if (step.onSuccess) {
+      for (const successStep of step.onSuccess) {
+        await executeStep(successStep, ctx);
+      }
+    }
+  } catch (err) {
+    ctx.locals["error"] = {
+      message: err instanceof Error ? err.message : String(err),
+      name: err instanceof Error ? err.name : "Error"
+    };
+    if (step.onError) {
+      for (const errorStep of step.onError) {
+        await executeStep(errorStep, ctx);
+      }
+    }
+  }
+}
+function isSSEConnectionManager(obj) {
+  return obj !== null && typeof obj === "object" && typeof obj.create === "function" && typeof obj.close === "function";
+}
+function ensureSSEManager(ctx) {
+  if (!isSSEConnectionManager(ctx.sse)) {
+    ctx.sse = createSSEConnectionManager();
+  }
+  return ctx.sse;
+}
+async function executeSSEConnectStep(step, ctx) {
+  const evalCtx = createEvalContext(ctx);
+  const url = String(evaluate(step.url, evalCtx));
+  const sseManager = ensureSSEManager(ctx);
+  const handlers = {};
+  if (step.onOpen) {
+    handlers.onOpen = async () => {
+      for (const s of step.onOpen) {
+        await executeStep(s, ctx);
+      }
+    };
+  }
+  if (step.onMessage) {
+    handlers.onMessage = async (data, eventType) => {
+      ctx.locals["event"] = { data, type: eventType };
+      for (const s of step.onMessage) {
+        await executeStep(s, ctx);
+      }
+    };
+  }
+  if (step.onError) {
+    handlers.onError = async (error) => {
+      ctx.locals["error"] = error;
+      for (const s of step.onError) {
+        await executeStep(s, ctx);
+      }
+    };
+  }
+  sseManager.create(step.connection, url, handlers, step.eventTypes);
+}
+async function executeSSECloseStep(step, ctx) {
+  if (isSSEConnectionManager(ctx.sse)) {
+    ctx.sse.close(step.connection);
+  }
+}
+async function executeOptimisticStep(step, ctx) {
+  if (!ctx.optimistic) {
+    return;
+  }
+  const evalCtx = createEvalContext(ctx);
+  const value = evaluate(step.value, evalCtx);
+  const path = step.path ? evaluate(step.path, evalCtx) : void 0;
+  if (step.timeout) {
+    ctx.optimistic.setAutoRollbackTimeout(step.timeout);
+  }
+  const updateId = ctx.optimistic.apply(
+    step.target,
+    path,
+    value,
+    (target) => ctx.state.get(target),
+    (target, val) => ctx.state.set(target, val)
+  );
+  if (step.result) {
+    ctx.locals[step.result] = updateId;
+  }
+}
+async function executeConfirmStep(step, ctx) {
+  const evalCtx = createEvalContext(ctx);
+  const id = evaluate(step.id, evalCtx);
+  ctx.optimistic?.confirm(String(id));
+}
+async function executeRejectStep(step, ctx) {
+  const evalCtx = createEvalContext(ctx);
+  const id = evaluate(step.id, evalCtx);
+  ctx.optimistic?.reject(
+    String(id),
+    (target) => ctx.state.get(target),
+    (target, val) => ctx.state.set(target, val)
+  );
+}
+async function executeBindStep(step, ctx) {
+  if (!ctx.binding) {
+    return;
+  }
+  const evalCtx = createEvalContext(ctx);
+  const config = {
+    connection: step.connection,
+    target: step.target
+  };
+  if (step.eventType !== void 0) {
+    config.eventType = step.eventType;
+  }
+  if (step.path) {
+    config.path = evaluate(step.path, evalCtx);
+  }
+  if (step.patch !== void 0) {
+    config.patch = step.patch;
+  }
+  ctx.binding.bind(config, (target, value, pathOrOptions) => {
+    if (pathOrOptions && typeof pathOrOptions === "object" && "patch" in pathOrOptions) {
+      ctx.state.set(target, value);
+    } else if (Array.isArray(pathOrOptions)) {
+      ctx.state.setPath(target, pathOrOptions, value);
+    } else {
+      ctx.state.set(target, value);
+    }
+  });
+}
+async function executeUnbindStep(step, ctx) {
+  ctx.binding?.unbindByConnection(step.connection);
+}
 
 // ../../node_modules/.pnpm/marked@17.0.1/node_modules/marked/lib/marked.esm.js
 function L() {
@@ -14585,19 +15689,155 @@ function createApp(program, mount) {
         mount.removeChild(mount.firstChild);
       }
     },
-    setState(name, value) {
-      if (destroyed) return;
-      state.set(name, value);
-    },
-    getState(name) {
-      return state.get(name);
-    },
-    subscribe(name, fn) {
-      if (destroyed) return () => {
-      };
-      return state.subscribe(name, fn);
+    setState(name, value) {
+      if (destroyed) return;
+      state.set(name, value);
+    },
+    getState(name) {
+      return state.get(name);
+    },
+    subscribe(name, fn) {
+      if (destroyed) return () => {
+      };
+      return state.subscribe(name, fn);
+    }
+  };
+}
+
+// src/hydrate-island.ts
+function hydrateIsland(options) {
+  const { strategy } = options;
+  switch (strategy) {
+    case "load":
+      hydrateImmediately(options);
+      return () => {
+      };
+    case "idle":
+      return hydrateOnIdle(options, options.strategyOptions?.timeout);
+    case "visible":
+      return hydrateOnVisible(options, options.strategyOptions);
+    case "interaction":
+      return hydrateOnInteraction(options);
+    case "media":
+      return hydrateOnMedia(options, options.strategyOptions?.media);
+    case "never":
+      return () => {
+      };
+    // SSR only, no hydration
+    default:
+      hydrateImmediately(options);
+      return () => {
+      };
+  }
+}
+function hydrateImmediately(options) {
+  options.element.dataset["islandHydrated"] = "true";
+}
+function hydrateOnIdle(options, timeout) {
+  let cancelled = false;
+  let handle2;
+  if ("requestIdleCallback" in window) {
+    handle2 = window.requestIdleCallback(
+      () => {
+        if (!cancelled) hydrateImmediately(options);
+      },
+      timeout ? { timeout } : void 0
+    );
+    return () => {
+      cancelled = true;
+      window.cancelIdleCallback(handle2);
+    };
+  } else {
+    handle2 = setTimeout(() => {
+      if (!cancelled) hydrateImmediately(options);
+    }, timeout ?? 200);
+    return () => {
+      cancelled = true;
+      clearTimeout(handle2);
+    };
+  }
+}
+function hydrateOnVisible(options, strategyOptions) {
+  const observer = new IntersectionObserver(
+    (entries2) => {
+      for (const entry of entries2) {
+        if (entry.isIntersecting) {
+          hydrateImmediately(options);
+          observer.disconnect();
+          break;
+        }
+      }
+    },
+    {
+      threshold: strategyOptions?.threshold ?? 0,
+      rootMargin: strategyOptions?.rootMargin ?? "0px"
+    }
+  );
+  observer.observe(options.element);
+  return () => observer.disconnect();
+}
+function hydrateOnInteraction(options) {
+  const events = ["click", "focusin", "mouseover"];
+  let hydrated = false;
+  const handler = () => {
+    if (hydrated) return;
+    hydrated = true;
+    hydrateImmediately(options);
+    for (const event of events) {
+      options.element.removeEventListener(event, handler);
+    }
+  };
+  for (const event of events) {
+    options.element.addEventListener(event, handler, { passive: true });
+  }
+  return () => {
+    for (const event of events) {
+      options.element.removeEventListener(event, handler);
+    }
+  };
+}
+function hydrateOnMedia(options, media) {
+  if (!media) {
+    hydrateImmediately(options);
+    return () => {
+    };
+  }
+  const mql = window.matchMedia(media);
+  if (mql.matches) {
+    hydrateImmediately(options);
+    return () => {
+    };
+  }
+  const handler = (e) => {
+    if (e.matches) {
+      hydrateImmediately(options);
+      mql.removeEventListener("change", handler);
     }
   };
+  mql.addEventListener("change", handler);
+  return () => mql.removeEventListener("change", handler);
+}
+function detectIslandsInDOM(container) {
+  const islands = [];
+  const elements = container.querySelectorAll("[data-island-id]");
+  for (const element2 of elements) {
+    const id = element2.getAttribute("data-island-id");
+    const strategy = element2.getAttribute(
+      "data-island-strategy"
+    );
+    const optionsJson = element2.getAttribute("data-island-options");
+    const stateJson = element2.getAttribute("data-island-state");
+    if (id && strategy) {
+      islands.push({
+        element: element2,
+        id,
+        strategy,
+        strategyOptions: optionsJson ? JSON.parse(optionsJson) : void 0,
+        state: stateJson ? JSON.parse(stateJson) : void 0
+      });
+    }
+  }
+  return islands;
 }
 
 // src/hydrate.ts
@@ -15642,6 +16882,79 @@ function initCopyButtons(container) {
     });
   });
 }
+function hydrateAppWithIslands(program, options) {
+  const container = options?.container ?? document.getElementById("app") ?? document.body;
+  const cleanupFns = [];
+  const islands = detectIslandsInDOM(container);
+  for (const island of islands) {
+    const cleanup = hydrateIsland({
+      ...island,
+      program
+    });
+    cleanupFns.push(cleanup);
+  }
+  return () => {
+    for (const cleanup of cleanupFns) {
+      cleanup();
+    }
+  };
+}
+
+// src/island-loader.ts
+function createIslandLoader(options = {}) {
+  const basePath = options.basePath ?? "/_constela/islands/";
+  const cache = /* @__PURE__ */ new Map();
+  const pending = /* @__PURE__ */ new Map();
+  async function load(id) {
+    const cached = cache.get(id);
+    if (cached) {
+      return cached;
+    }
+    const pendingPromise = pending.get(id);
+    if (pendingPromise) {
+      return pendingPromise;
+    }
+    const loadPromise = (async () => {
+      try {
+        const module = await loadModule(id);
+        cache.set(id, module);
+        return module;
+      } finally {
+        pending.delete(id);
+      }
+    })();
+    pending.set(id, loadPromise);
+    return loadPromise;
+  }
+  async function loadModule(id) {
+    const sanitizedId = id.replace(/[\/\\:*?"<>|]/g, "_");
+    const modulePath = `${basePath}${sanitizedId}.js`;
+    try {
+      const module = await import(
+        /* @vite-ignore */
+        modulePath
+      );
+      return module;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`Failed to load island "${id}" from ${modulePath}: ${message}`);
+    }
+  }
+  function preload(id) {
+    if (cache.has(id)) {
+      return;
+    }
+    if (pending.has(id)) {
+      return;
+    }
+    load(id).catch(() => {
+    });
+  }
+  return {
+    load,
+    preload
+  };
+}
 
 // src/connection/websocket.ts
 function createWebSocketConnection(url, handlers) {
@@ -15733,6 +17046,380 @@ function createConnectionManager() {
   };
 }
 
+// src/connection/reconnect.ts
+function calculateDelay(strategy, attempt, baseDelay, maxDelay) {
+  let delay;
+  if (strategy === "exponential") {
+    delay = baseDelay * Math.pow(2, attempt);
+  } else if (strategy === "linear") {
+    delay = baseDelay * (attempt + 1);
+  } else {
+    return 0;
+  }
+  return Math.min(delay, maxDelay);
+}
+function createReconnectionManager() {
+  const managedConnections = /* @__PURE__ */ new Map();
+  function shouldReconnect(policy) {
+    return policy.enabled && policy.strategy !== "none";
+  }
+  function clearTimer(managed) {
+    if (managed.timerId !== null) {
+      clearTimeout(managed.timerId);
+      managed.timerId = null;
+    }
+  }
+  function scheduleReconnect(managed) {
+    if (managed.isReconnecting) {
+      return;
+    }
+    const { policy, retryCount } = managed;
+    if (retryCount >= policy.maxRetries) {
+      managed.isReconnecting = false;
+      if (!managed.maxRetriesReached) {
+        managed.maxRetriesReached = true;
+        try {
+          managed.onMaxRetriesReached?.();
+        } catch {
+        }
+      }
+      return;
+    }
+    managed.isReconnecting = true;
+    const delay = calculateDelay(
+      policy.strategy,
+      retryCount,
+      policy.baseDelay,
+      policy.maxDelay
+    );
+    managed.timerId = setTimeout(() => {
+      managed.timerId = null;
+      managed.isReconnecting = false;
+      attemptReconnect(managed);
+    }, delay);
+  }
+  function attemptReconnect(managed) {
+    managedConnections.delete(managed.connection);
+    let newConnection;
+    try {
+      newConnection = managed.reconnectFn();
+    } catch {
+      managed.retryCount++;
+      managedConnections.set(managed.connection, managed);
+      scheduleReconnect(managed);
+      return;
+    }
+    managed.retryCount++;
+    managed.connection = newConnection;
+    managedConnections.set(newConnection, managed);
+    if (shouldReconnect(managed.policy)) {
+      monitorConnection(newConnection, () => {
+        handleConnectionError(managed);
+      });
+    }
+    if (newConnection.getState() === "open") {
+      managed.retryCount = 0;
+      managed.maxRetriesReached = false;
+      try {
+        managed.onReconnect?.();
+      } catch {
+      }
+    } else {
+      scheduleReconnect(managed);
+    }
+  }
+  function handleConnectionError(managed) {
+    if (!shouldReconnect(managed.policy)) {
+      return;
+    }
+    scheduleReconnect(managed);
+  }
+  function monitorConnection(connection, onError) {
+    const originalGetState = connection.getState.bind(connection);
+    function checkForError() {
+      const currentState = originalGetState();
+      if (currentState === "closed") {
+        onError();
+      }
+    }
+    const proto = Object.getPrototypeOf(connection);
+    const allKeys = /* @__PURE__ */ new Set([
+      ...Object.keys(connection),
+      ...proto ? Object.keys(proto) : []
+    ]);
+    for (const key2 of allKeys) {
+      const descriptor = Object.getOwnPropertyDescriptor(connection, key2) || Object.getOwnPropertyDescriptor(proto, key2);
+      if (descriptor && typeof descriptor.value === "function" && key2 !== "getState" && key2 !== "close") {
+        const originalMethod = connection[key2];
+        connection[key2] = function(...args) {
+          const result = originalMethod.apply(connection, args);
+          checkForError();
+          return result;
+        };
+      }
+    }
+  }
+  return {
+    wrap(connection, reconnectFn, policy, onReconnect, onMaxRetriesReached) {
+      const managed = {
+        connection,
+        reconnectFn,
+        policy,
+        onReconnect,
+        onMaxRetriesReached,
+        retryCount: 0,
+        timerId: null,
+        isReconnecting: false,
+        maxRetriesReached: false
+      };
+      managedConnections.set(connection, managed);
+      if (shouldReconnect(policy)) {
+        monitorConnection(connection, () => {
+          handleConnectionError(managed);
+        });
+      }
+      return connection;
+    },
+    triggerReconnect(connection) {
+      const managed = managedConnections.get(connection);
+      if (!managed) {
+        return;
+      }
+      clearTimer(managed);
+      managed.isReconnecting = false;
+      managed.retryCount = 0;
+      managed.maxRetriesReached = false;
+      connection.close();
+      attemptReconnect(managed);
+    },
+    dispose(connection) {
+      const managed = managedConnections.get(connection);
+      if (!managed) {
+        return;
+      }
+      clearTimer(managed);
+      managedConnections.delete(connection);
+    },
+    disposeAll() {
+      for (const managed of managedConnections.values()) {
+        clearTimer(managed);
+      }
+      managedConnections.clear();
+    }
+  };
+}
+
+// src/optimistic/manager.ts
+function deepClone(value) {
+  if (value === null || typeof value !== "object") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map(deepClone);
+  }
+  const cloned = {};
+  for (const key2 in value) {
+    if (Object.prototype.hasOwnProperty.call(value, key2)) {
+      cloned[key2] = deepClone(value[key2]);
+    }
+  }
+  return cloned;
+}
+function getAtPath(obj, path) {
+  let current = obj;
+  for (const key2 of path) {
+    if (current === null || current === void 0) {
+      return void 0;
+    }
+    current = current[key2];
+  }
+  return current;
+}
+function setAtPath(obj, path, value) {
+  if (path.length === 0) {
+    return deepClone(value);
+  }
+  const [head2, ...rest] = path;
+  const key2 = head2;
+  const isArray = Array.isArray(obj);
+  const cloned = isArray ? [...obj] : { ...obj };
+  if (rest.length === 0) {
+    cloned[key2] = deepClone(value);
+  } else {
+    cloned[key2] = setAtPath(
+      obj[key2],
+      rest,
+      value
+    );
+  }
+  return cloned;
+}
+function createOptimisticManager() {
+  const pendingUpdates = /* @__PURE__ */ new Map();
+  const timers = /* @__PURE__ */ new Map();
+  let autoRollbackTimeout = 0;
+  const stateAccessors = /* @__PURE__ */ new Map();
+  function generateId() {
+    return crypto.randomUUID();
+  }
+  function apply2(target, path, value, getState, setState) {
+    const id = generateId();
+    const currentState = getState(target);
+    const originalValue = path && path.length > 0 ? getAtPath(currentState, path) : currentState;
+    let newState;
+    if (path && path.length > 0) {
+      newState = setAtPath(currentState, path, value);
+    } else {
+      newState = deepClone(value);
+    }
+    setState(target, newState);
+    const pendingUpdate = {
+      id,
+      target,
+      path: path && path.length > 0 ? path : void 0,
+      originalValue,
+      optimisticValue: value,
+      timestamp: Date.now()
+    };
+    pendingUpdates.set(id, pendingUpdate);
+    stateAccessors.set(id, { getState, setState });
+    if (autoRollbackTimeout > 0) {
+      const timer = setTimeout(() => {
+        reject(id, getState, setState);
+      }, autoRollbackTimeout);
+      timers.set(id, timer);
+    }
+    return id;
+  }
+  function confirm(id) {
+    const pending = pendingUpdates.get(id);
+    if (!pending) {
+      return false;
+    }
+    const timer = timers.get(id);
+    if (timer) {
+      clearTimeout(timer);
+      timers.delete(id);
+    }
+    pendingUpdates.delete(id);
+    stateAccessors.delete(id);
+    return true;
+  }
+  function reject(id, getState, setState) {
+    const pending = pendingUpdates.get(id);
+    if (!pending) {
+      return false;
+    }
+    const timer = timers.get(id);
+    if (timer) {
+      clearTimeout(timer);
+      timers.delete(id);
+    }
+    const currentState = getState(pending.target);
+    if (pending.path && pending.path.length > 0) {
+      const restoredState = setAtPath(currentState, pending.path, pending.originalValue);
+      setState(pending.target, restoredState);
+    } else {
+      setState(pending.target, pending.originalValue);
+    }
+    pendingUpdates.delete(id);
+    stateAccessors.delete(id);
+    return true;
+  }
+  function getPending(id) {
+    return pendingUpdates.get(id);
+  }
+  function getAllPending() {
+    return Array.from(pendingUpdates.values());
+  }
+  function setAutoRollbackTimeout(ms) {
+    autoRollbackTimeout = ms;
+  }
+  function dispose() {
+    for (const timer of timers.values()) {
+      clearTimeout(timer);
+    }
+    timers.clear();
+    pendingUpdates.clear();
+    stateAccessors.clear();
+  }
+  return {
+    apply: apply2,
+    confirm,
+    reject,
+    getPending,
+    getAllPending,
+    setAutoRollbackTimeout,
+    dispose
+  };
+}
+
+// src/binding/realtime.ts
+function createBindingManager() {
+  const bindings = /* @__PURE__ */ new Map();
+  function bind(config, setState) {
+    const id = crypto.randomUUID();
+    bindings.set(id, { id, config, setState });
+    return id;
+  }
+  function unbind(id) {
+    return bindings.delete(id);
+  }
+  function unbindByConnection(connection) {
+    for (const [id, binding] of bindings) {
+      if (binding.config.connection === connection) {
+        bindings.delete(id);
+      }
+    }
+  }
+  function unbindByTarget(target) {
+    for (const [id, binding] of bindings) {
+      if (binding.config.target === target) {
+        bindings.delete(id);
+      }
+    }
+  }
+  function handleMessage(connection, data, eventType) {
+    for (const binding of bindings.values()) {
+      const { config, setState } = binding;
+      if (config.connection !== connection) {
+        continue;
+      }
+      if (config.eventType !== void 0) {
+        if (eventType !== config.eventType) {
+          continue;
+        }
+      }
+      let value = data;
+      if (config.transform) {
+        value = config.transform(data);
+      }
+      if (config.patch === true) {
+        setState(config.target, value, { patch: true });
+      } else if (config.path !== void 0) {
+        setState(config.target, value, config.path);
+      } else {
+        setState(config.target, value);
+      }
+    }
+  }
+  function getBindings() {
+    return Array.from(bindings.values()).map((b2) => ({ ...b2.config }));
+  }
+  function dispose() {
+    bindings.clear();
+  }
+  return {
+    bind,
+    unbind,
+    unbindByConnection,
+    unbindByTarget,
+    handleMessage,
+    getBindings,
+    dispose
+  };
+}
+
 // src/hmr/client.ts
 var DEFAULT_INITIAL_RECONNECT_DELAY = 1e3;
 var DEFAULT_MAX_RECONNECT_DELAY = 3e4;
@@ -15906,21 +17593,27 @@ function createHMRApp(program, container, route, existingStateStore) {
   };
 }
 function createHMRHandler(options) {
-  const { container, program, route } = options;
+  const { container, program, route, skipInitialRender } = options;
   let currentApp = null;
   let destroyed = false;
-  currentApp = createHMRApp(program, container, route);
+  if (!skipInitialRender) {
+    currentApp = createHMRApp(program, container, route);
+  }
   return {
     handleUpdate(newProgram) {
       if (destroyed) {
         return;
       }
-      let stateSnapshot = {};
-      if (currentApp) {
-        stateSnapshot = currentApp.stateStore.serialize();
-        currentApp.destroy();
-        currentApp = null;
+      if (!currentApp) {
+        while (container.firstChild) {
+          container.removeChild(container.firstChild);
+        }
+        currentApp = createHMRApp(newProgram, container, route);
+        return;
       }
+      const stateSnapshot = currentApp.stateStore.serialize();
+      currentApp.destroy();
+      currentApp = null;
       const newStateStore = createStateStore(newProgram.state);
       const newDefinitions = Object.entries(newProgram.state).map(
         ([name, def]) => ({
@@ -16022,23 +17715,288 @@ function createErrorOverlay() {
     }
   };
 }
+
+// src/theme/provider.ts
+var DEFAULT_COLORS = {};
+var DEFAULT_FONTS = {};
+var DEFAULT_STORAGE_KEY = "constela-theme-mode";
+function createThemeProvider(options) {
+  const config = options?.config ?? {};
+  const storageKey = options?.storageKey ?? DEFAULT_STORAGE_KEY;
+  const useCookies = options?.useCookies ?? false;
+  const defaultMode = options?.defaultMode ?? "system";
+  let lightColors = { ...DEFAULT_COLORS, ...config.colors };
+  let darkColors = { ...DEFAULT_COLORS, ...config.darkColors };
+  const fonts = { ...DEFAULT_FONTS, ...config.fonts };
+  const cssPrefix = config.cssPrefix ?? "";
+  let selectedMode = loadPersistedMode() ?? config.mode ?? defaultMode;
+  const subscribers = /* @__PURE__ */ new Set();
+  let destroyed = false;
+  const mediaQuery = typeof window !== "undefined" ? window.matchMedia("(prefers-color-scheme: dark)") : null;
+  function handleMediaChange(event) {
+    if (destroyed) return;
+    if (selectedMode === "system") {
+      applyTheme();
+      notifySubscribers();
+    }
+  }
+  if (mediaQuery) {
+    mediaQuery.addEventListener("change", handleMediaChange);
+  }
+  function loadPersistedMode() {
+    if (typeof window === "undefined") return null;
+    try {
+      const stored = localStorage.getItem(storageKey);
+      if (stored === "light" || stored === "dark" || stored === "system") {
+        return stored;
+      }
+    } catch {
+    }
+    return null;
+  }
+  function persistMode(mode) {
+    if (typeof window === "undefined") return;
+    try {
+      localStorage.setItem(storageKey, mode);
+    } catch {
+    }
+    if (useCookies && typeof document !== "undefined") {
+      document.cookie = `${storageKey}=${mode}; path=/; max-age=31536000; SameSite=Lax`;
+    }
+  }
+  function resolveMode() {
+    if (selectedMode === "light" || selectedMode === "dark") {
+      return selectedMode;
+    }
+    if (mediaQuery) {
+      return mediaQuery.matches ? "dark" : "light";
+    }
+    return "light";
+  }
+  function getCurrentColors() {
+    const resolved = resolveMode();
+    if (resolved === "dark") {
+      return Object.keys(darkColors).length > 0 ? { ...lightColors, ...darkColors } : lightColors;
+    }
+    return lightColors;
+  }
+  function applyCSSVariables() {
+    if (typeof document === "undefined") return;
+    const root2 = document.documentElement;
+    const colors = getCurrentColors();
+    const prefix = cssPrefix ? `${cssPrefix}-` : "";
+    for (const [key2, value] of Object.entries(colors)) {
+      if (value !== void 0) {
+        root2.style.setProperty(`--${prefix}${key2}`, value);
+      }
+    }
+    for (const [key2, value] of Object.entries(fonts)) {
+      if (value !== void 0) {
+        root2.style.setProperty(`--font-${key2}`, value);
+      }
+    }
+  }
+  function applyDarkClass() {
+    if (typeof document === "undefined") return;
+    const root2 = document.documentElement;
+    if (!root2) return;
+    const resolved = resolveMode();
+    if (resolved === "dark") {
+      root2.classList.add("dark");
+    } else {
+      root2.classList.remove("dark");
+    }
+  }
+  function applyTheme() {
+    applyCSSVariables();
+    applyDarkClass();
+  }
+  function notifySubscribers() {
+    if (destroyed) return;
+    const theme = getTheme();
+    for (const fn of subscribers) {
+      fn(theme);
+    }
+  }
+  function getTheme() {
+    return {
+      resolvedMode: resolveMode(),
+      selectedMode,
+      colors: getCurrentColors(),
+      fonts
+    };
+  }
+  function getMode() {
+    return selectedMode;
+  }
+  function setMode(mode) {
+    if (destroyed) return;
+    if (mode === selectedMode) return;
+    selectedMode = mode;
+    persistMode(mode);
+    applyTheme();
+    notifySubscribers();
+  }
+  function subscribe(fn) {
+    subscribers.add(fn);
+    return () => {
+      subscribers.delete(fn);
+    };
+  }
+  function setColors(colors, mode) {
+    if (destroyed) return;
+    const targetMode = mode ?? "light";
+    if (targetMode === "dark") {
+      darkColors = { ...darkColors, ...colors };
+    } else {
+      lightColors = { ...lightColors, ...colors };
+    }
+    applyTheme();
+    notifySubscribers();
+  }
+  function destroy() {
+    destroyed = true;
+    subscribers.clear();
+    if (mediaQuery) {
+      mediaQuery.removeEventListener("change", handleMediaChange);
+    }
+  }
+  applyTheme();
+  return {
+    getTheme,
+    getMode,
+    setMode,
+    subscribe,
+    setColors,
+    destroy
+  };
+}
+
+// src/prefetch.ts
+var PREFETCH_STRATEGIES = ["hover", "visible", "immediate"];
+function isPrefetchOptions(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  const obj = value;
+  if (!PREFETCH_STRATEGIES.includes(obj["strategy"])) {
+    return false;
+  }
+  if ("threshold" in obj && obj["threshold"] !== void 0) {
+    if (typeof obj["threshold"] !== "number") {
+      return false;
+    }
+  }
+  if ("rootMargin" in obj && obj["rootMargin"] !== void 0) {
+    if (typeof obj["rootMargin"] !== "string") {
+      return false;
+    }
+  }
+  return true;
+}
+var globalLoader = null;
+function setGlobalLoader(loader) {
+  globalLoader = loader;
+}
+function prefetchIsland(id, options) {
+  if (options !== void 0 && !isPrefetchOptions(options)) {
+    return;
+  }
+  if (globalLoader) {
+    globalLoader.preload(id);
+  }
+}
+function createPrefetcher(loader) {
+  const prefetchedIds = /* @__PURE__ */ new Set();
+  function prefetchOnce(id) {
+    if (prefetchedIds.has(id)) {
+      return;
+    }
+    prefetchedIds.add(id);
+    loader.preload(id);
+  }
+  function prefetchOnHover(element2, id) {
+    let cleaned = false;
+    const handler = () => {
+      if (cleaned) return;
+      prefetchOnce(id);
+    };
+    element2.addEventListener("mouseenter", handler, { passive: true });
+    return () => {
+      if (cleaned) return;
+      cleaned = true;
+      element2.removeEventListener("mouseenter", handler, { passive: true });
+    };
+  }
+  function prefetchOnVisible(element2, id, options) {
+    let cleaned = false;
+    let observer = null;
+    const observerOptions = {};
+    if (options?.threshold !== void 0) {
+      observerOptions.threshold = options.threshold;
+    }
+    if (options?.rootMargin !== void 0) {
+      observerOptions.rootMargin = options.rootMargin;
+    }
+    const callback = (entries2) => {
+      for (const entry of entries2) {
+        if (entry.isIntersecting && entry.target === element2) {
+          prefetchOnce(id);
+          if (observer) {
+            observer.unobserve(element2);
+          }
+          break;
+        }
+      }
+    };
+    observer = new IntersectionObserver(callback, observerOptions);
+    observer.observe(element2);
+    return () => {
+      if (cleaned) return;
+      cleaned = true;
+      if (observer) {
+        observer.unobserve(element2);
+        observer = null;
+      }
+    };
+  }
+  return {
+    prefetchOnHover,
+    prefetchOnVisible
+  };
+}
 export {
+  PREFETCH_STRATEGIES,
   createApp,
+  createBindingManager,
   createComputed,
   createConnectionManager,
   createEffect,
   createErrorOverlay,
   createHMRClient,
   createHMRHandler,
+  createIslandLoader,
+  createOptimisticManager,
+  createPrefetcher,
+  createReconnectionManager,
+  createSSEConnection,
+  createSSEConnectionManager,
   createSignal,
   createStateStore,
+  createThemeProvider,
   createTypedStateStore,
   createWebSocketConnection,
+  detectIslandsInDOM,
   evaluate,
   evaluateStyle,
   executeAction,
   hydrateApp,
-  render
+  hydrateAppWithIslands,
+  hydrateIsland,
+  isPrefetchOptions,
+  prefetchIsland,
+  render,
+  setGlobalLoader
 };
 /*! Bundled license information: