@stina/extension-api 0.52.0 → 0.56.0

package/dist/schemas/index.cjs

@@ -23,7 +23,15 @@ __export(schemas_exports, {
   AllowedCSSPropertySchema: () => AllowedCSSPropertySchema,
   AuthorSchema: () => AuthorSchema,
   ButtonPropsSchema: () => ButtonPropsSchema,
+  CHAT_CARD_COMPONENTS: () => CHAT_CARD_COMPONENTS,
+  CalendarEventPropsSchema: () => CalendarEventPropsSchema,
+  CalendarEventStatusSchema: () => CalendarEventStatusSchema,
   CapabilityPermissionSchema: () => CapabilityPermissionSchema,
+  ChartKindSchema: () => ChartKindSchema,
+  ChartPropsSchema: () => ChartPropsSchema,
+  ChartSeriesSchema: () => ChartSeriesSchema,
+  ChatCardComponentSchema: () => ChatCardComponentSchema,
+  ChatCardSchema: () => ChatCardSchema,
   CheckboxPropsSchema: () => CheckboxPropsSchema,
   CollapsiblePropsSchema: () => CollapsiblePropsSchema,
   CommandDefinitionSchema: () => CommandDefinitionSchema,
@@ -49,12 +57,16 @@ __export(schemas_exports, {
   IconButtonTypeSchema: () => IconButtonTypeSchema,
   IconPickerPropsSchema: () => IconPickerPropsSchema,
   IconPropsSchema: () => IconPropsSchema,
+  KeyValueListPropsSchema: () => KeyValueListPropsSchema,
+  KeyValueRowSchema: () => KeyValueRowSchema,
   LabelPropsSchema: () => LabelPropsSchema,
   ListPropsSchema: () => ListPropsSchema,
   LocalizedStringSchema: () => LocalizedStringSchema,
   MarkdownPropsSchema: () => MarkdownPropsSchema,
   ModalPropsSchema: () => ModalPropsSchema,
   NetworkPermissionSchema: () => NetworkPermissionSchema,
+  NotePropsSchema: () => NotePropsSchema,
+  NoteVariantSchema: () => NoteVariantSchema,
   PERMISSION_PATTERNS: () => PERMISSION_PATTERNS,
   PanelActionDataSourceSchema: () => PanelActionDataSourceSchema,
   PanelActionSchema: () => PanelActionSchema,
@@ -73,10 +85,15 @@ __export(schemas_exports, {
   ProviderConfigViewSchema: () => ProviderConfigViewSchema,
   ProviderDefinitionSchema: () => ProviderDefinitionSchema,
   SelectPropsSchema: () => SelectPropsSchema,
+  StatTilePropsSchema: () => StatTilePropsSchema,
+  StatTrendSchema: () => StatTrendSchema,
   StoragePermissionSchema: () => StoragePermissionSchema,
   SystemPermissionSchema: () => SystemPermissionSchema,
   TextInputPropsSchema: () => TextInputPropsSchema,
   TextPreviewPropsSchema: () => TextPreviewPropsSchema,
+  TimelineEntrySchema: () => TimelineEntrySchema,
+  TimelinePropsSchema: () => TimelinePropsSchema,
+  TimelineVariantSchema: () => TimelineVariantSchema,
   TogglePropsSchema: () => TogglePropsSchema,
   ToolDefinitionSchema: () => ToolDefinitionSchema,
   ToolSettingsActionDataSourceSchema: () => ToolSettingsActionDataSourceSchema,
@@ -89,7 +106,14 @@ __export(schemas_exports, {
   UserDataPermissionSchema: () => UserDataPermissionSchema,
   VALID_PERMISSIONS: () => VALID_PERMISSIONS,
   VerticalStackPropsSchema: () => VerticalStackPropsSchema,
-  isValidPermission: () => isValidPermission
+  WeatherConditionSchema: () => WeatherConditionSchema,
+  WeatherForecastPropsSchema: () => WeatherForecastPropsSchema,
+  WeatherForecastStepSchema: () => WeatherForecastStepSchema,
+  WeatherNowPropsSchema: () => WeatherNowPropsSchema,
+  WeatherWindSchema: () => WeatherWindSchema,
+  describeChatCardProfile: () => describeChatCardProfile,
+  isValidPermission: () => isValidPermission,
+  validateChatCard: () => validateChatCard
 });
 module.exports = __toCommonJS(schemas_exports);
 
@@ -486,6 +510,146 @@ var ListPropsSchema = import_zod2.z.object({
   children: ExtensionComponentChildrenSchema.describe("Child components rendered as list items"),
   style: ExtensionComponentStyleSchema.optional()
 }).passthrough().describe("List component");
+var WeatherConditionSchema = import_zod2.z.enum([
+  "clear",
+  "partly-cloudy",
+  "cloudy",
+  "overcast",
+  "fog",
+  "light-rain",
+  "rain",
+  "heavy-rain",
+  "sleet",
+  "light-snow",
+  "snow",
+  "heavy-snow",
+  "thunderstorm",
+  "hail",
+  "windy"
+]).describe("Weather condition");
+var WeatherWindSchema = import_zod2.z.object({
+  speed: import_zod2.z.number().describe("Sustained wind speed"),
+  unit: import_zod2.z.string().optional().describe("Unit written after the speed. Defaults to m/s"),
+  direction: import_zod2.z.string().optional().describe("Compass direction, in the caller's own words"),
+  gust: import_zod2.z.number().optional().describe("Gust speed, in the same unit")
+}).passthrough().describe("Wind reading");
+var WeatherNowPropsSchema = import_zod2.z.object({
+  component: import_zod2.z.literal("WeatherNow"),
+  place: import_zod2.z.string().describe("Where the reading is from"),
+  condition: WeatherConditionSchema,
+  conditionLabel: import_zod2.z.string().optional().describe("The condition in the user's own language"),
+  temperature: import_zod2.z.number().describe("Current temperature"),
+  feelsLike: import_zod2.z.number().optional().describe("Apparent temperature"),
+  unit: import_zod2.z.string().optional().describe("Written after every temperature. Defaults to \xB0"),
+  wind: WeatherWindSchema.optional(),
+  night: import_zod2.z.boolean().optional().describe("Draw the night variant of the icon"),
+  summary: import_zod2.z.string().optional().describe("One line of context under the numbers"),
+  style: ExtensionComponentStyleSchema.optional()
+}).passthrough().describe("Current weather component");
+var WeatherForecastStepSchema = import_zod2.z.object({
+  label: import_zod2.z.string().describe("Short step label, e.g. 14 or Tors"),
+  condition: WeatherConditionSchema,
+  conditionLabel: import_zod2.z.string().optional(),
+  high: import_zod2.z.number().describe("The warmer temperature, or the only one"),
+  low: import_zod2.z.number().optional().describe("The colder temperature"),
+  night: import_zod2.z.boolean().optional(),
+  precipitation: import_zod2.z.number().min(0).max(100).optional().describe("Chance of precipitation, 0-100"),
+  current: import_zod2.z.boolean().optional().describe("The step the reader is at; drawn larger")
+}).passthrough().describe("One forecast step");
+var WeatherForecastPropsSchema = import_zod2.z.object({
+  component: import_zod2.z.literal("WeatherForecast"),
+  title: import_zod2.z.string().optional().describe("Heading above the row"),
+  icon: import_zod2.z.string().optional().describe("Icon shown to the left of the title"),
+  unit: import_zod2.z.string().optional().describe("Written after every temperature. Defaults to \xB0"),
+  steps: import_zod2.z.array(WeatherForecastStepSchema).min(1).describe("Steps, hourly or daily"),
+  style: ExtensionComponentStyleSchema.optional()
+}).passthrough().describe("Weather forecast component");
+var ChartKindSchema = import_zod2.z.enum(["line", "bar", "area"]).describe("How the chart draws");
+var ChartSeriesSchema = import_zod2.z.object({
+  name: import_zod2.z.string().optional().describe("Named in the legend"),
+  points: import_zod2.z.array(import_zod2.z.number().nullable()).describe("One value per label. null is a gap, drawn as one")
+}).passthrough().describe("One chart series");
+var ChartPropsSchema = import_zod2.z.object({
+  component: import_zod2.z.literal("Chart"),
+  chart: ChartKindSchema.optional().describe("Defaults to line"),
+  series: import_zod2.z.array(ChartSeriesSchema).min(1).max(8).describe("At most eight series"),
+  labels: import_zod2.z.array(import_zod2.z.string()).optional().describe("One per point, along the horizontal axis"),
+  title: import_zod2.z.string().optional().describe("Heading above the plot"),
+  icon: import_zod2.z.string().optional().describe("Icon shown to the left of the title"),
+  unit: import_zod2.z.string().optional().describe("Written after every value"),
+  zeroBaseline: import_zod2.z.boolean().optional().describe("Force the value axis to include zero"),
+  height: import_zod2.z.number().min(4).max(24).optional().describe("Plot height in rem. Defaults to 9"),
+  style: ExtensionComponentStyleSchema.optional()
+}).passthrough().describe("Chart component");
+var StatTrendSchema = import_zod2.z.enum(["up", "down", "flat"]).describe("Direction of change");
+var StatTilePropsSchema = import_zod2.z.object({
+  component: import_zod2.z.literal("StatTile"),
+  label: import_zod2.z.string().describe("What the number is"),
+  value: import_zod2.z.union([import_zod2.z.string(), import_zod2.z.number()]).describe("The number itself"),
+  unit: import_zod2.z.string().optional().describe("Written after the value in smaller type"),
+  caption: import_zod2.z.string().optional().describe("One quiet line under the number"),
+  icon: import_zod2.z.string().optional().describe("Icon name"),
+  trend: StatTrendSchema.optional(),
+  trendLabel: import_zod2.z.string().optional().describe("The change in words"),
+  trendIsGood: import_zod2.z.boolean().optional().describe("Whether up is the good direction. Defaults to true"),
+  style: ExtensionComponentStyleSchema.optional()
+}).passthrough().describe("Single-number stat tile component");
+var KeyValueRowSchema = import_zod2.z.object({
+  label: import_zod2.z.string(),
+  value: import_zod2.z.string(),
+  icon: import_zod2.z.string().optional().describe("Icon name")
+}).passthrough().describe("One key/value row");
+var KeyValueListPropsSchema = import_zod2.z.object({
+  component: import_zod2.z.literal("KeyValueList"),
+  rows: import_zod2.z.array(KeyValueRowSchema).min(1).describe("Facts in two aligned columns"),
+  style: ExtensionComponentStyleSchema.optional()
+}).passthrough().describe("Key/value list component");
+var TimelineVariantSchema = import_zod2.z.enum(["default", "accent", "success", "warning", "danger"]).describe("How much a timeline entry stands out");
+var TimelineEntrySchema = import_zod2.z.object({
+  time: import_zod2.z.string().describe("When it happens, worded as it should be read"),
+  title: import_zod2.z.string(),
+  description: import_zod2.z.string().optional().describe("A line under the title"),
+  icon: import_zod2.z.string().optional().describe("Icon name"),
+  duration: import_zod2.z.string().optional().describe("How long it lasts, in words"),
+  badge: import_zod2.z.string().optional().describe("Trailing badge"),
+  current: import_zod2.z.boolean().optional().describe("The entry the reader is at"),
+  past: import_zod2.z.boolean().optional().describe("Already behind us; drawn recessive"),
+  variant: TimelineVariantSchema.optional()
+}).passthrough().describe("One timeline entry");
+var TimelinePropsSchema = import_zod2.z.object({
+  component: import_zod2.z.literal("Timeline"),
+  title: import_zod2.z.string().optional().describe("Heading above the rail"),
+  icon: import_zod2.z.string().optional().describe("Icon shown to the left of the title"),
+  entries: import_zod2.z.array(TimelineEntrySchema).min(1).describe("Entries, in the order they happen"),
+  style: ExtensionComponentStyleSchema.optional()
+}).passthrough().describe("Vertical timeline component");
+var NoteVariantSchema = import_zod2.z.enum(["default", "accent", "success", "warning", "danger"]).describe("How much a note stands out");
+var NotePropsSchema = import_zod2.z.object({
+  component: import_zod2.z.literal("Note"),
+  title: import_zod2.z.string().optional(),
+  icon: import_zod2.z.string().optional().describe("Icon shown to the left of the title"),
+  badge: import_zod2.z.string().optional().describe("Trailing badge next to the title"),
+  content: import_zod2.z.string().describe("The body, as markdown"),
+  footer: import_zod2.z.string().optional().describe("One quiet line at the bottom"),
+  variant: NoteVariantSchema.optional(),
+  style: ExtensionComponentStyleSchema.optional()
+}).passthrough().describe("Titled block of prose component");
+var CalendarEventStatusSchema = import_zod2.z.enum(["confirmed", "tentative", "cancelled"]).describe("Whether an event is going ahead");
+var CalendarEventPropsSchema = import_zod2.z.object({
+  component: import_zod2.z.literal("CalendarEvent"),
+  title: import_zod2.z.string(),
+  start: import_zod2.z.string().describe("ISO 8601 with an offset"),
+  end: import_zod2.z.string().optional().describe("ISO 8601 with an offset"),
+  allDay: import_zod2.z.boolean().optional(),
+  location: import_zod2.z.string().optional(),
+  organizer: import_zod2.z.string().optional(),
+  attendees: import_zod2.z.array(import_zod2.z.string()).optional(),
+  calendar: import_zod2.z.string().optional().describe("Which calendar it sits in; shown as a badge"),
+  status: CalendarEventStatusSchema.optional(),
+  recurrence: import_zod2.z.string().optional().describe("How it repeats, in words"),
+  notes: import_zod2.z.string().optional(),
+  style: ExtensionComponentStyleSchema.optional()
+}).passthrough().describe("Single calendar event component");
 
 // src/schemas/contributions.schema.ts
 var LocalizedStringSchema = import_zod3.z.union([import_zod3.z.string(), import_zod3.z.record(import_zod3.z.string())]).describe("String or localized string map");
@@ -633,12 +797,382 @@ var ExtensionManifestSchema = import_zod4.z.object({
   permissions: import_zod4.z.array(PermissionSchema).describe("Required permissions"),
   contributes: ExtensionContributionsSchema.optional().describe("What the extension contributes")
 }).describe("Extension manifest format");
+
+// src/schemas/card.schema.ts
+var import_zod5 = require("zod");
+var style = ExtensionComponentStyleSchema.optional();
+var children = import_zod5.z.lazy(
+  () => import_zod5.z.array(ChatCardComponentSchema).max(40)
+);
+var VerticalStackCardSchema = import_zod5.z.object({
+  component: import_zod5.z.literal("VerticalStack"),
+  children,
+  style
+}).strict();
+var HorizontalStackCardSchema = import_zod5.z.object({
+  component: import_zod5.z.literal("HorizontalStack"),
+  children,
+  style
+}).strict();
+var GridCardSchema = import_zod5.z.object({
+  component: import_zod5.z.literal("Grid"),
+  columns: import_zod5.z.number().min(1).max(6),
+  children,
+  style
+}).strict();
+var FrameCardSchema = import_zod5.z.object({
+  component: import_zod5.z.literal("Frame"),
+  // Only the string form: the components form of a title is for panels that
+  // put controls in their header, which a card has no business doing.
+  title: import_zod5.z.string().optional(),
+  collapsible: import_zod5.z.boolean().optional(),
+  defaultExpanded: import_zod5.z.boolean().optional(),
+  variant: FrameVariantSchema.optional(),
+  children,
+  style
+}).strict();
+var ListCardSchema = import_zod5.z.object({ component: import_zod5.z.literal("List"), children, style }).strict();
+var DividerCardSchema = import_zod5.z.object({ component: import_zod5.z.literal("Divider"), style }).strict();
+var HeaderCardSchema = import_zod5.z.object({
+  component: import_zod5.z.literal("Header"),
+  level: import_zod5.z.number().min(1).max(6),
+  title: import_zod5.z.string(),
+  description: import_zod5.z.union([import_zod5.z.string(), import_zod5.z.array(import_zod5.z.string())]).optional(),
+  icon: import_zod5.z.string().optional(),
+  style
+}).strict();
+var LabelCardSchema = import_zod5.z.object({ component: import_zod5.z.literal("Label"), text: import_zod5.z.string(), style }).strict();
+var ParagraphCardSchema = import_zod5.z.object({ component: import_zod5.z.literal("Paragraph"), text: import_zod5.z.string(), style }).strict();
+var MarkdownCardSchema = import_zod5.z.object({ component: import_zod5.z.literal("Markdown"), content: import_zod5.z.string(), style }).strict();
+var IconCardSchema = import_zod5.z.object({
+  component: import_zod5.z.literal("Icon"),
+  name: import_zod5.z.string(),
+  title: import_zod5.z.string().optional(),
+  style
+}).strict();
+var PillCardSchema = import_zod5.z.object({
+  component: import_zod5.z.literal("Pill"),
+  text: import_zod5.z.string(),
+  icon: import_zod5.z.string().optional(),
+  variant: PillVariantSchema.optional(),
+  style
+}).strict();
+var WeatherNowCardSchema = import_zod5.z.object({
+  component: import_zod5.z.literal("WeatherNow"),
+  place: import_zod5.z.string(),
+  condition: WeatherConditionSchema,
+  conditionLabel: import_zod5.z.string().optional(),
+  temperature: import_zod5.z.number(),
+  feelsLike: import_zod5.z.number().optional(),
+  unit: import_zod5.z.string().optional(),
+  wind: WeatherWindSchema.optional(),
+  night: import_zod5.z.boolean().optional(),
+  summary: import_zod5.z.string().optional(),
+  style
+}).strict();
+var WeatherForecastCardSchema = import_zod5.z.object({
+  component: import_zod5.z.literal("WeatherForecast"),
+  title: import_zod5.z.string().optional(),
+  icon: import_zod5.z.string().optional(),
+  unit: import_zod5.z.string().optional(),
+  steps: import_zod5.z.array(
+    import_zod5.z.object({
+      label: import_zod5.z.string(),
+      condition: WeatherConditionSchema,
+      conditionLabel: import_zod5.z.string().optional(),
+      high: import_zod5.z.number(),
+      low: import_zod5.z.number().optional(),
+      night: import_zod5.z.boolean().optional(),
+      precipitation: import_zod5.z.number().min(0).max(100).optional(),
+      current: import_zod5.z.boolean().optional()
+    }).strict()
+  ).min(1).max(24),
+  style
+}).strict();
+var ChartCardSchema = import_zod5.z.object({
+  component: import_zod5.z.literal("Chart"),
+  chart: ChartKindSchema.optional(),
+  series: import_zod5.z.array(
+    import_zod5.z.object({
+      name: import_zod5.z.string().optional(),
+      points: import_zod5.z.array(import_zod5.z.number().nullable()).min(1).max(200)
+    }).strict()
+  ).min(1).max(8),
+  labels: import_zod5.z.array(import_zod5.z.string()).max(200).optional(),
+  title: import_zod5.z.string().optional(),
+  icon: import_zod5.z.string().optional(),
+  unit: import_zod5.z.string().optional(),
+  zeroBaseline: import_zod5.z.boolean().optional(),
+  height: import_zod5.z.number().min(4).max(24).optional(),
+  style
+}).strict();
+var StatTileCardSchema = import_zod5.z.object({
+  component: import_zod5.z.literal("StatTile"),
+  label: import_zod5.z.string(),
+  value: import_zod5.z.union([import_zod5.z.string(), import_zod5.z.number()]),
+  unit: import_zod5.z.string().optional(),
+  caption: import_zod5.z.string().optional(),
+  icon: import_zod5.z.string().optional(),
+  trend: StatTrendSchema.optional(),
+  trendLabel: import_zod5.z.string().optional(),
+  trendIsGood: import_zod5.z.boolean().optional(),
+  style
+}).strict();
+var KeyValueListCardSchema = import_zod5.z.object({
+  component: import_zod5.z.literal("KeyValueList"),
+  rows: import_zod5.z.array(
+    import_zod5.z.object({ label: import_zod5.z.string(), value: import_zod5.z.string(), icon: import_zod5.z.string().optional() }).strict()
+  ).min(1).max(40),
+  style
+}).strict();
+var TimelineCardSchema = import_zod5.z.object({
+  component: import_zod5.z.literal("Timeline"),
+  title: import_zod5.z.string().optional(),
+  icon: import_zod5.z.string().optional(),
+  entries: import_zod5.z.array(
+    import_zod5.z.object({
+      time: import_zod5.z.string(),
+      title: import_zod5.z.string(),
+      description: import_zod5.z.string().optional(),
+      icon: import_zod5.z.string().optional(),
+      duration: import_zod5.z.string().optional(),
+      badge: import_zod5.z.string().optional(),
+      current: import_zod5.z.boolean().optional(),
+      past: import_zod5.z.boolean().optional(),
+      variant: TimelineVariantSchema.optional()
+    }).strict()
+  ).min(1).max(40),
+  style
+}).strict();
+var NoteCardSchema = import_zod5.z.object({
+  component: import_zod5.z.literal("Note"),
+  title: import_zod5.z.string().optional(),
+  icon: import_zod5.z.string().optional(),
+  badge: import_zod5.z.string().optional(),
+  content: import_zod5.z.string(),
+  footer: import_zod5.z.string().optional(),
+  variant: NoteVariantSchema.optional(),
+  style
+}).strict();
+var CalendarEventCardSchema = import_zod5.z.object({
+  component: import_zod5.z.literal("CalendarEvent"),
+  title: import_zod5.z.string(),
+  start: import_zod5.z.string(),
+  end: import_zod5.z.string().optional(),
+  allDay: import_zod5.z.boolean().optional(),
+  location: import_zod5.z.string().optional(),
+  organizer: import_zod5.z.string().optional(),
+  attendees: import_zod5.z.array(import_zod5.z.string()).max(40).optional(),
+  calendar: import_zod5.z.string().optional(),
+  status: CalendarEventStatusSchema.optional(),
+  recurrence: import_zod5.z.string().optional(),
+  notes: import_zod5.z.string().optional(),
+  style
+}).strict();
+var CHAT_CARD_COMPONENTS = [
+  "VerticalStack",
+  "HorizontalStack",
+  "Grid",
+  "Frame",
+  "List",
+  "Divider",
+  "Header",
+  "Label",
+  "Paragraph",
+  "Markdown",
+  "Icon",
+  "Pill",
+  "WeatherNow",
+  "WeatherForecast",
+  "Chart",
+  "StatTile",
+  "KeyValueList",
+  "Timeline",
+  "Note",
+  "CalendarEvent"
+];
+var CARD_MEMBERS = [
+  VerticalStackCardSchema,
+  HorizontalStackCardSchema,
+  GridCardSchema,
+  FrameCardSchema,
+  ListCardSchema,
+  DividerCardSchema,
+  HeaderCardSchema,
+  LabelCardSchema,
+  ParagraphCardSchema,
+  MarkdownCardSchema,
+  IconCardSchema,
+  PillCardSchema,
+  WeatherNowCardSchema,
+  WeatherForecastCardSchema,
+  ChartCardSchema,
+  StatTileCardSchema,
+  KeyValueListCardSchema,
+  TimelineCardSchema,
+  NoteCardSchema,
+  CalendarEventCardSchema
+];
+var ChatCardComponentSchema = import_zod5.z.lazy(
+  () => import_zod5.z.discriminatedUnion(
+    "component",
+    CARD_MEMBERS
+  )
+);
+var ChatCardSchema = ChatCardComponentSchema;
+var MAX_CARD_DEPTH = 8;
+function findScopeReference(value, path) {
+  if (typeof value === "string") {
+    return value.startsWith("$") ? path : null;
+  }
+  if (Array.isArray(value)) {
+    for (let i = 0; i < value.length; i++) {
+      const found = findScopeReference(value[i], `${path}[${i}]`);
+      if (found) return found;
+    }
+    return null;
+  }
+  if (value && typeof value === "object") {
+    for (const [key, child] of Object.entries(value)) {
+      const found = findScopeReference(child, path ? `${path}.${key}` : key);
+      if (found) return found;
+    }
+  }
+  return null;
+}
+function cardDepth(value) {
+  if (!value || typeof value !== "object") return 0;
+  const kids = value.children;
+  if (!Array.isArray(kids) || kids.length === 0) return 1;
+  let deepest = 0;
+  for (const child of kids) {
+    const depth = cardDepth(child);
+    if (depth > deepest) deepest = depth;
+  }
+  return deepest + 1;
+}
+function findMisalignedChart(value) {
+  if (!value || typeof value !== "object") return null;
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      const found = findMisalignedChart(item);
+      if (found) return found;
+    }
+    return null;
+  }
+  const node = value;
+  if (node.component === "Chart" && Array.isArray(node.labels) && Array.isArray(node.series)) {
+    const expected = node.labels.length;
+    for (let i = 0; i < node.series.length; i++) {
+      const points = node.series[i]?.points;
+      if (Array.isArray(points) && points.length !== expected) {
+        return `Chart series ${i} has ${points.length} points but there are ${expected} labels. Points line up with labels by position \u2014 use null for a reading you do not have.`;
+      }
+    }
+  }
+  for (const child of Object.values(node)) {
+    const found = findMisalignedChart(child);
+    if (found) return found;
+  }
+  return null;
+}
+var CARD_GAP_REM = 0.75;
+function applyCardSpacing(card) {
+  if (card.component === "VerticalStack" || card.component === "HorizontalStack" || card.component === "Grid") {
+    card["gap"] = CARD_GAP_REM;
+  }
+  if (Array.isArray(card["children"])) {
+    for (const child of card["children"]) applyCardSpacing(child);
+  }
+  return card;
+}
+function validateChatCard(card) {
+  const parsed = ChatCardSchema.safeParse(card);
+  if (!parsed.success) {
+    const issue = parsed.error.issues[0];
+    const where = issue?.path.length ? ` at ${issue.path.join(".")}` : "";
+    return { ok: false, error: `${issue?.message ?? "Invalid card"}${where}` };
+  }
+  const depth = cardDepth(parsed.data);
+  if (depth > MAX_CARD_DEPTH) {
+    return {
+      ok: false,
+      error: `Card nests ${depth} levels deep; at most ${MAX_CARD_DEPTH} are allowed. Flatten it.`
+    };
+  }
+  const misaligned = findMisalignedChart(parsed.data);
+  if (misaligned) {
+    return { ok: false, error: misaligned };
+  }
+  const reference = findScopeReference(parsed.data, "");
+  if (reference) {
+    return {
+      ok: false,
+      error: `The value at ${reference} starts with "$", which the component system reads as a reference to data that a card does not have, so it would render as nothing. Write the value without the leading "$".`
+    };
+  }
+  return { ok: true, card: applyCardSpacing(parsed.data) };
+}
+function describeType(schema) {
+  const def = schema._def;
+  switch (def.typeName) {
+    case "ZodOptional":
+    case "ZodNullable":
+    case "ZodDefault":
+      return describeType(schema.unwrap());
+    case "ZodLazy":
+      return "component[]";
+    case "ZodArray": {
+      const inner = describeType(def.type);
+      return `${inner}[]`;
+    }
+    case "ZodObject": {
+      const shape = schema.shape;
+      const fields = Object.entries(shape).map(
+        ([key, value]) => `${key}${value.isOptional() ? "?" : ""}`
+      );
+      return `{${fields.join(", ")}}`;
+    }
+    case "ZodEnum":
+      return (def.values ?? []).join("|");
+    case "ZodUnion":
+      return (def.options ?? []).map(describeType).join("|");
+    case "ZodLiteral":
+      return String(def.value);
+    case "ZodString":
+      return "string";
+    case "ZodNumber":
+      return "number";
+    case "ZodBoolean":
+      return "boolean";
+    case "ZodRecord":
+      return "object";
+    default:
+      return "value";
+  }
+}
+function describeChatCardProfile() {
+  return CARD_MEMBERS.map((member) => {
+    const shape = member.shape;
+    const name = shape["component"]._def.value;
+    const fields = Object.entries(shape).filter(([key]) => key !== "component" && key !== "style").map(([key, value]) => `${key}${value.isOptional() ? "?" : ""}: ${describeType(value)}`);
+    return fields.length ? `${name} \u2014 ${fields.join("; ")}` : name;
+  }).join("\n");
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AllowedCSSPropertySchema,
   AuthorSchema,
   ButtonPropsSchema,
+  CHAT_CARD_COMPONENTS,
+  CalendarEventPropsSchema,
+  CalendarEventStatusSchema,
   CapabilityPermissionSchema,
+  ChartKindSchema,
+  ChartPropsSchema,
+  ChartSeriesSchema,
+  ChatCardComponentSchema,
+  ChatCardSchema,
   CheckboxPropsSchema,
   CollapsiblePropsSchema,
   CommandDefinitionSchema,
@@ -664,12 +1198,16 @@ var ExtensionManifestSchema = import_zod4.z.object({
   IconButtonTypeSchema,
   IconPickerPropsSchema,
   IconPropsSchema,
+  KeyValueListPropsSchema,
+  KeyValueRowSchema,
   LabelPropsSchema,
   ListPropsSchema,
   LocalizedStringSchema,
   MarkdownPropsSchema,
   ModalPropsSchema,
   NetworkPermissionSchema,
+  NotePropsSchema,
+  NoteVariantSchema,
   PERMISSION_PATTERNS,
   PanelActionDataSourceSchema,
   PanelActionSchema,
@@ -688,10 +1226,15 @@ var ExtensionManifestSchema = import_zod4.z.object({
   ProviderConfigViewSchema,
   ProviderDefinitionSchema,
   SelectPropsSchema,
+  StatTilePropsSchema,
+  StatTrendSchema,
   StoragePermissionSchema,
   SystemPermissionSchema,
   TextInputPropsSchema,
   TextPreviewPropsSchema,
+  TimelineEntrySchema,
+  TimelinePropsSchema,
+  TimelineVariantSchema,
   TogglePropsSchema,
   ToolDefinitionSchema,
   ToolSettingsActionDataSourceSchema,
@@ -704,6 +1247,13 @@ var ExtensionManifestSchema = import_zod4.z.object({
   UserDataPermissionSchema,
   VALID_PERMISSIONS,
   VerticalStackPropsSchema,
-  isValidPermission
+  WeatherConditionSchema,
+  WeatherForecastPropsSchema,
+  WeatherForecastStepSchema,
+  WeatherNowPropsSchema,
+  WeatherWindSchema,
+  describeChatCardProfile,
+  isValidPermission,
+  validateChatCard
 });
 //# sourceMappingURL=index.cjs.map