@nuvio/shared 0.5.5 → 1.1.0

package/dist/index.js

@@ -1,40 +1,1544 @@
+import {
+  PCC_BRANDABLE_CATEGORIES,
+  PCC_REJECTED_CATEGORIES,
+  PCC_SUPPORTED_CATEGORIES,
+  defaultPccManifestPath,
+  isPccBrandableCategory,
+  isPccRejectedCategory,
+  isPccSupportedCategory,
+  parsePccManifest,
+  pccCategoryLabel,
+  pccHostsForCategory
+} from "./chunk-3R2WM7JQ.js";
+
 // src/constants.ts
 var NUVIO_WS_PATH = "/__nuvio/ws";
+var NUVIO_BRAND_PATH = "/__nuvio/brand";
+var NUVIO_PCC_PATH = "/__nuvio/pcc";
 
-// src/protocol.ts
+// src/brand-kit.ts
 import { z } from "zod";
-var PROTOCOL_VERSION = 7;
-var riskLevelSchema = z.enum(["safe", "caution", "unsupported"]);
-var textTargetSchema = z.object({
+var BRAND_ACCENT_COLORS = ["blue", "purple", "green", "slate", "rose"];
+var BRAND_COLORS = ["none", "neutral", ...BRAND_ACCENT_COLORS];
+var BRAND_RADIUS = ["sharp", "soft", "rounded", "pill"];
+var BRAND_DENSITY = ["compact", "balanced", "spacious"];
+var BRAND_TYPOGRAPHY = ["clean", "bold", "soft"];
+var BRAND_SURFACES = ["white", "muted"];
+var BRAND_BUTTON_VARIANTS = ["solid", "outline"];
+var BRAND_BUTTON_HOVERS = ["none", "darken"];
+var BRAND_CARD_SHADOWS = ["none", "sm", "md"];
+var BRAND_CARD_HOVERS = ["none", "border"];
+var BRAND_APPLY_ACTIONS = [
+  "button",
+  "card",
+  "heading",
+  "text",
+  "table",
+  "form",
+  "badge"
+];
+var BRAND_PRESET_DIMENSIONS_BY_ACTION = {
+  button: ["color", "buttonVariant", "radius", "density", "buttonHover"],
+  card: ["surface", "color", "radius", "density", "cardShadow", "cardHover"],
+  heading: ["color", "typography"],
+  text: ["color"],
+  table: ["color", "radius"],
+  form: ["color", "radius", "density", "surface"],
+  badge: ["color"]
+};
+function brandPresetDimensionsForAction(action) {
+  return BRAND_PRESET_DIMENSIONS_BY_ACTION[action];
+}
+var BRAND_ACCENT_SLOT_BY_ACTION = {
+  button: "fill",
+  card: "border",
+  heading: "text",
+  text: "text",
+  table: "border",
+  form: "border",
+  badge: "tint"
+};
+function getBrandColorSlotLabel(action) {
+  const labels = {
+    button: "Fill",
+    card: "Border color",
+    heading: "Text color",
+    text: "Text color",
+    table: "Border color",
+    form: "Field border",
+    badge: "Tint"
+  };
+  return labels[action];
+}
+function brandColorsForAction(action) {
+  const slot = BRAND_ACCENT_SLOT_BY_ACTION[action];
+  if (slot === "border") {
+    return BRAND_COLORS;
+  }
+  if (slot === "text") {
+    return ["neutral", ...BRAND_ACCENT_COLORS];
+  }
+  if (slot === "tint") {
+    return ["neutral", ...BRAND_ACCENT_COLORS];
+  }
+  return BRAND_ACCENT_COLORS;
+}
+function isBrandAccentColor(color) {
+  return BRAND_ACCENT_COLORS.includes(color);
+}
+var BRAND_RADIUS_FIELD_LABEL = "Corners";
+var BRAND_DENSITY_FIELD_LABEL = "Spacing";
+function getBrandTypographyFieldLabel(action) {
+  return action === "heading" ? "Heading style" : "Typography";
+}
+var BRAND_SURFACE_FIELD_LABEL = "Surface";
+var BRAND_BUTTON_VARIANT_FIELD_LABEL = "Style";
+var BRAND_BUTTON_HOVER_FIELD_LABEL = "Hover";
+var BRAND_CARD_SHADOW_FIELD_LABEL = "Shadow";
+var BRAND_CARD_HOVER_FIELD_LABEL = "Hover";
+function formatAccentForSummary(action, config) {
+  if (config.color === "none" && (action === "card" || action === "table" || action === "form")) {
+    return "No border";
+  }
+  const label = COLOR_LABELS[config.color];
+  switch (action) {
+    case "button":
+      return config.buttonVariant === "outline" ? `${label} outline` : `${label} fill`;
+    case "card":
+    case "table":
+      return `${label} border`;
+    case "form":
+      return `${label} field border`;
+    case "badge":
+      return `${label} tint`;
+    case "heading":
+    case "text":
+      return `${label} text`;
+    default:
+      return label;
+  }
+}
+var DEFAULT_BRAND_CONFIG = {
+  color: "blue",
+  surface: "white",
+  buttonVariant: "solid",
+  buttonHover: "darken",
+  cardShadow: "none",
+  cardHover: "none",
+  radius: "soft",
+  density: "balanced",
+  typography: "clean"
+};
+var brandConfigSchema = z.object({
+  color: z.enum(BRAND_COLORS),
+  surface: z.enum(BRAND_SURFACES),
+  buttonVariant: z.enum(BRAND_BUTTON_VARIANTS),
+  buttonHover: z.enum(BRAND_BUTTON_HOVERS),
+  cardShadow: z.enum(BRAND_CARD_SHADOWS),
+  cardHover: z.enum(BRAND_CARD_HOVERS),
+  radius: z.enum(BRAND_RADIUS),
+  density: z.enum(BRAND_DENSITY),
+  typography: z.enum(BRAND_TYPOGRAPHY)
+});
+var brandTokensSchema = z.object({
+  accent: z.enum(BRAND_COLORS),
+  surface: z.enum(BRAND_SURFACES),
+  radius: z.enum(BRAND_RADIUS),
+  density: z.enum(BRAND_DENSITY),
+  typography: z.enum(BRAND_TYPOGRAPHY),
+  buttonVariant: z.enum(BRAND_BUTTON_VARIANTS),
+  buttonHover: z.enum(BRAND_BUTTON_HOVERS),
+  cardShadow: z.enum(BRAND_CARD_SHADOWS),
+  cardHover: z.enum(BRAND_CARD_HOVERS)
+});
+var brandConfigFileV2Schema = z.object({
+  version: z.literal(2),
+  tokens: brandTokensSchema
+});
+var COLOR_LABELS = {
+  none: "None",
+  neutral: "Neutral",
+  blue: "Blue",
+  purple: "Purple",
+  green: "Green",
+  slate: "Slate",
+  rose: "Rose"
+};
+var RADIUS_LABELS = {
+  sharp: "Sharp",
+  soft: "Soft",
+  rounded: "Rounded",
+  pill: "Pill"
+};
+var DENSITY_LABELS = {
+  compact: "Compact",
+  balanced: "Balanced",
+  spacious: "Spacious"
+};
+var SURFACE_LABELS = {
+  white: "White",
+  muted: "Muted"
+};
+var BUTTON_VARIANT_LABELS = {
+  solid: "Solid",
+  outline: "Outline"
+};
+var BUTTON_HOVER_LABELS = {
+  none: "None",
+  darken: "Darken"
+};
+var CARD_SHADOW_LABELS = {
+  none: "None",
+  sm: "Subtle",
+  md: "Medium"
+};
+var CARD_HOVER_LABELS = {
+  none: "None",
+  border: "Border"
+};
+var TYPOGRAPHY_LABELS = {
+  clean: "Clean",
+  bold: "Bold",
+  soft: "Soft"
+};
+var ACTION_LABELS = {
+  button: "Button",
+  card: "Card",
+  heading: "Heading",
+  text: "Text",
+  table: "Table",
+  form: "Form",
+  badge: "Badge"
+};
+function colorBgClass(color) {
+  if (color === "neutral") {
+    return "bg-gray-600";
+  }
+  return color === "slate" ? "bg-slate-700" : `bg-${color}-600`;
+}
+function colorTextClass(color) {
+  if (color === "neutral") {
+    return "text-gray-700";
+  }
+  return color === "slate" ? "text-slate-700" : `text-${color}-600`;
+}
+function colorBorderClass(color) {
+  if (color === "none") {
+    return null;
+  }
+  if (color === "neutral") {
+    return "border-gray-200";
+  }
+  return color === "slate" ? "border-slate-300" : `border-${color}-300`;
+}
+function colorAccentBorderClass(color) {
+  if (color === "neutral") {
+    return "border-gray-600";
+  }
+  return color === "slate" ? "border-slate-700" : `border-${color}-600`;
+}
+function accentBorderRecipeParts(color) {
+  if (color === "none") {
+    return ["border-0"];
+  }
+  const borderColor = colorBorderClass(color);
+  if (!borderColor) {
+    return [];
+  }
+  return ["border", borderColor];
+}
+function surfaceBgClass(surface) {
+  return surface === "muted" ? "bg-slate-50" : "bg-white";
+}
+function colorBadgeBgClass(color) {
+  if (color === "neutral") {
+    return "bg-gray-100";
+  }
+  return color === "slate" ? "bg-slate-100" : `bg-${color}-100`;
+}
+function colorBadgeTextClass(color) {
+  if (color === "neutral") {
+    return "text-gray-700";
+  }
+  return color === "slate" ? "text-slate-700" : `text-${color}-700`;
+}
+function radiusClass(radius) {
+  const map = {
+    sharp: "rounded-none",
+    soft: "rounded-md",
+    rounded: "rounded-xl",
+    pill: "rounded-full"
+  };
+  return map[radius];
+}
+function densityButtonPadding(density) {
+  const map = {
+    compact: "px-3 py-1.5",
+    balanced: "px-4 py-2",
+    spacious: "px-6 py-3"
+  };
+  return map[density];
+}
+function densityCardPadding(density) {
+  const map = {
+    compact: "p-4",
+    balanced: "p-6",
+    spacious: "p-8"
+  };
+  return map[density];
+}
+function typographyClasses(typography) {
+  const map = {
+    clean: "text-base font-medium",
+    bold: "text-lg font-semibold",
+    soft: "text-sm font-normal"
+  };
+  return map[typography];
+}
+function buttonHoverClass(color, buttonHover, buttonVariant) {
+  if (buttonHover === "none" || color === "none" || color === "neutral") {
+    return null;
+  }
+  if (buttonVariant === "outline") {
+    return color === "slate" ? "hover:bg-slate-100" : `hover:bg-${color}-50`;
+  }
+  return color === "slate" ? "hover:bg-slate-800" : `hover:bg-${color}-700`;
+}
+function cardShadowClass(cardShadow) {
+  if (cardShadow === "none") {
+    return null;
+  }
+  return cardShadow === "sm" ? "shadow-sm" : "shadow-md";
+}
+function cardHoverBorderClass(color, cardHover) {
+  if (cardHover === "none" || color === "none" || color === "neutral") {
+    return null;
+  }
+  return color === "slate" ? "hover:border-slate-400" : `hover:border-${color}-400`;
+}
+function joinRecipeClasses(parts) {
+  return parts.filter(Boolean).join(" ").trim();
+}
+function isFormLabelHost(hint) {
+  const tag = hint?.tagName?.toLowerCase() ?? "";
+  const hostId = hint?.hostId?.toLowerCase() ?? "";
+  return tag === "label" || hostId.endsWith(".label");
+}
+function brandFragmentHostHint(entry) {
+  return {
+    tagName: entry.tagName,
+    hierarchyRole: entry.hierarchyRole,
+    hostId: entry.id
+  };
+}
+function normalizeBrandConfig(input) {
+  const parsed = brandConfigSchema.safeParse(input);
+  if (parsed.success) {
+    return parsed.data;
+  }
+  const v2 = brandConfigFileV2Schema.safeParse(input);
+  if (v2.success) {
+    const { tokens } = v2.data;
+    return {
+      color: tokens.accent,
+      surface: tokens.surface,
+      buttonVariant: tokens.buttonVariant,
+      buttonHover: tokens.buttonHover ?? DEFAULT_BRAND_CONFIG.buttonHover,
+      cardShadow: tokens.cardShadow ?? DEFAULT_BRAND_CONFIG.cardShadow,
+      cardHover: tokens.cardHover ?? DEFAULT_BRAND_CONFIG.cardHover,
+      radius: tokens.radius,
+      density: tokens.density,
+      typography: tokens.typography
+    };
+  }
+  if (input && typeof input === "object") {
+    const partial = input;
+    const tokens = partial.version === 2 && partial.tokens && typeof partial.tokens === "object" ? partial.tokens : null;
+    const source = tokens ?? partial;
+    return {
+      color: brandConfigSchema.shape.color.safeParse(source.accent ?? source.color).success ? source.accent ?? source.color : DEFAULT_BRAND_CONFIG.color,
+      surface: brandConfigSchema.shape.surface.safeParse(source.surface).success ? source.surface : DEFAULT_BRAND_CONFIG.surface,
+      buttonVariant: brandConfigSchema.shape.buttonVariant.safeParse(source.buttonVariant).success ? source.buttonVariant : DEFAULT_BRAND_CONFIG.buttonVariant,
+      buttonHover: brandConfigSchema.shape.buttonHover.safeParse(source.buttonHover).success ? source.buttonHover : DEFAULT_BRAND_CONFIG.buttonHover,
+      cardShadow: brandConfigSchema.shape.cardShadow.safeParse(source.cardShadow).success ? source.cardShadow : DEFAULT_BRAND_CONFIG.cardShadow,
+      cardHover: brandConfigSchema.shape.cardHover.safeParse(source.cardHover).success ? source.cardHover : DEFAULT_BRAND_CONFIG.cardHover,
+      radius: brandConfigSchema.shape.radius.safeParse(source.radius).success ? source.radius : DEFAULT_BRAND_CONFIG.radius,
+      density: brandConfigSchema.shape.density.safeParse(source.density).success ? source.density : DEFAULT_BRAND_CONFIG.density,
+      typography: brandConfigSchema.shape.typography.safeParse(source.typography).success ? source.typography : DEFAULT_BRAND_CONFIG.typography
+    };
+  }
+  return { ...DEFAULT_BRAND_CONFIG };
+}
+function serializeBrandConfig(config) {
+  return {
+    version: 2,
+    tokens: {
+      accent: config.color,
+      surface: config.surface,
+      radius: config.radius,
+      density: config.density,
+      typography: config.typography,
+      buttonVariant: config.buttonVariant,
+      buttonHover: config.buttonHover,
+      cardShadow: config.cardShadow,
+      cardHover: config.cardHover
+    }
+  };
+}
+function brandConfigsEqual(a, b) {
+  return a.color === b.color && a.surface === b.surface && a.buttonVariant === b.buttonVariant && a.buttonHover === b.buttonHover && a.cardShadow === b.cardShadow && a.cardHover === b.cardHover && a.radius === b.radius && a.density === b.density && a.typography === b.typography;
+}
+function buildBrandClassFragment(action, config, hint) {
+  switch (action) {
+    case "button":
+      if (config.buttonVariant === "outline") {
+        return joinRecipeClasses([
+          "border",
+          colorAccentBorderClass(config.color),
+          colorTextClass(config.color),
+          "bg-transparent",
+          radiusClass(config.radius),
+          densityButtonPadding(config.density),
+          buttonHoverClass(config.color, config.buttonHover, config.buttonVariant)
+        ]);
+      }
+      return joinRecipeClasses([
+        colorBgClass(config.color),
+        "text-white",
+        radiusClass(config.radius),
+        densityButtonPadding(config.density),
+        buttonHoverClass(config.color, config.buttonHover, config.buttonVariant)
+      ]);
+    case "card":
+      return joinRecipeClasses([
+        surfaceBgClass(config.surface),
+        ...accentBorderRecipeParts(config.color),
+        radiusClass(config.radius),
+        densityCardPadding(config.density),
+        cardShadowClass(config.cardShadow),
+        cardHoverBorderClass(config.color, config.cardHover)
+      ]);
+    case "heading":
+      return [typographyClasses(config.typography), colorTextClass(config.color)].join(" ").trim();
+    case "text":
+      return joinRecipeClasses(["text-sm font-normal", colorTextClass(config.color)]);
+    case "table":
+      return joinRecipeClasses([
+        "max-w-full",
+        ...accentBorderRecipeParts(config.color),
+        radiusClass(config.radius)
+      ]);
+    case "form":
+      if (isFormLabelHost(hint)) {
+        return "text-sm font-medium text-gray-700";
+      }
+      return joinRecipeClasses([
+        surfaceBgClass(config.surface),
+        ...accentBorderRecipeParts(config.color),
+        radiusClass(config.radius),
+        densityButtonPadding(config.density)
+      ]);
+    case "badge":
+      return [
+        "inline-flex",
+        "items-center",
+        "px-2",
+        "py-0.5",
+        "text-xs",
+        "font-medium",
+        "rounded-full",
+        colorBadgeBgClass(config.color),
+        colorBadgeTextClass(config.color)
+      ].join(" ").trim();
+    default: {
+      const _exhaustive = action;
+      return _exhaustive;
+    }
+  }
+}
+function buildBrandPatchOps(action, config, hint) {
+  return [
+    {
+      kind: "mergeTailwindClassName",
+      classNameFragment: buildBrandClassFragment(action, config, hint)
+    }
+  ];
+}
+function buildBrandPreviewSummary(action, config) {
+  if (action === "text") {
+    return `${ACTION_LABELS.text} \xB7 ${formatAccentForSummary(action, config)} \xB7 Body size`;
+  }
+  if (action === "heading") {
+    return [
+      ACTION_LABELS.heading,
+      formatAccentForSummary(action, config),
+      TYPOGRAPHY_LABELS[config.typography]
+    ].join(" \xB7 ");
+  }
+  if (action === "card") {
+    const parts = [
+      ACTION_LABELS.card,
+      SURFACE_LABELS[config.surface],
+      formatAccentForSummary(action, config),
+      RADIUS_LABELS[config.radius],
+      DENSITY_LABELS[config.density]
+    ];
+    if ((config.cardShadow ?? DEFAULT_BRAND_CONFIG.cardShadow) !== "none") {
+      parts.push(
+        `${CARD_SHADOW_LABELS[config.cardShadow ?? DEFAULT_BRAND_CONFIG.cardShadow]} shadow`
+      );
+    }
+    if ((config.cardHover ?? DEFAULT_BRAND_CONFIG.cardHover) !== "none") {
+      parts.push(`${CARD_HOVER_LABELS[config.cardHover ?? DEFAULT_BRAND_CONFIG.cardHover]} hover`);
+    }
+    return parts.join(" \xB7 ");
+  }
+  if (action === "table") {
+    return [
+      ACTION_LABELS.table,
+      formatAccentForSummary(action, config),
+      RADIUS_LABELS[config.radius]
+    ].join(" \xB7 ");
+  }
+  if (action === "form") {
+    return [
+      ACTION_LABELS.form,
+      formatAccentForSummary(action, config),
+      RADIUS_LABELS[config.radius],
+      DENSITY_LABELS[config.density]
+    ].join(" \xB7 ");
+  }
+  if (action === "badge") {
+    return [
+      ACTION_LABELS.badge,
+      formatAccentForSummary(action, config),
+      RADIUS_LABELS.pill
+    ].join(" \xB7 ");
+  }
+  return [
+    ACTION_LABELS.button,
+    formatAccentForSummary(action, config),
+    BUTTON_VARIANT_LABELS[config.buttonVariant],
+    RADIUS_LABELS[config.radius],
+    DENSITY_LABELS[config.density],
+    (config.buttonHover ?? DEFAULT_BRAND_CONFIG.buttonHover) !== "none" ? `${BUTTON_HOVER_LABELS[config.buttonHover ?? DEFAULT_BRAND_CONFIG.buttonHover]} hover` : null
+  ].filter(Boolean).join(" \xB7 ");
+}
+function getBrandColorLabel(color) {
+  return COLOR_LABELS[color];
+}
+function getBrandRadiusLabel(radius) {
+  return RADIUS_LABELS[radius];
+}
+function getBrandDensityLabel(density) {
+  return DENSITY_LABELS[density];
+}
+function getBrandTypographyLabel(typography) {
+  return TYPOGRAPHY_LABELS[typography];
+}
+function getBrandSurfaceLabel(surface) {
+  return SURFACE_LABELS[surface];
+}
+function getBrandButtonVariantLabel(variant) {
+  return BUTTON_VARIANT_LABELS[variant];
+}
+function getBrandButtonHoverLabel(hover) {
+  return BUTTON_HOVER_LABELS[hover];
+}
+function getBrandCardShadowLabel(shadow) {
+  return CARD_SHADOW_LABELS[shadow];
+}
+function getBrandCardHoverLabel(hover) {
+  return CARD_HOVER_LABELS[hover];
+}
+
+// src/brand-page-discovery.ts
+var BRAND_PAGE_DISCOVERY_PLURALS = {
+  button: "buttons",
+  card: "cards",
+  heading: "headings",
+  text: "text blocks",
+  table: "tables",
+  form: "forms",
+  badge: "badges"
+};
+var BRAND_PAGE_DISCOVERY_SINGULARS = {
+  button: "button",
+  card: "card",
+  heading: "heading",
+  text: "text block",
+  table: "table",
+  form: "form",
+  badge: "badge"
+};
+function formatDiscoveryCount(action, count) {
+  const label = count === 1 ? BRAND_PAGE_DISCOVERY_SINGULARS[action] : BRAND_PAGE_DISCOVERY_PLURALS[action];
+  return `${count} ${label}`;
+}
+function buildBrandPageDiscoveryLine(counts) {
+  const parts = [];
+  for (const action of BRAND_APPLY_ACTIONS) {
+    const count = counts[action] ?? 0;
+    if (count > 0) {
+      parts.push(formatDiscoveryCount(action, count));
+    }
+  }
+  if (parts.length === 0) {
+    return null;
+  }
+  return `On this page: ${parts.join(" \xB7 ")}`;
+}
+
+// src/brand-bulk.ts
+function buildBrandValidateSummary(action, config, count) {
+  const base = buildBrandPreviewSummary(action, config);
+  const noun = count === 1 ? "element" : "elements";
+  return `${base} \xB7 ${count} ${noun}`;
+}
+function buildBrandBulkPreviewSummary(action, config, count) {
+  return buildBrandValidateSummary(action, config, count);
+}
+function buildBrandBulkPatchOps(action, config) {
+  return buildBrandPatchOps(action, config);
+}
+var PATCHABLE_CLASSNAME_MODES = /* @__PURE__ */ new Set([
+  "literal-only",
+  "cn-basic",
+  "cn-conditional",
+  "classnames-static"
+]);
+function isDuplicateId(id, duplicateIds) {
+  return duplicateIds.has(id);
+}
+function isStylePatchableEntry(entry, duplicateIds) {
+  if (isDuplicateId(entry.id, duplicateIds)) {
+    return false;
+  }
+  if (entry.hasLiteralClassName === false) {
+    return false;
+  }
+  const mode = entry.classNameMode ?? "literal-only";
+  if (mode === "unsupported") {
+    return false;
+  }
+  if (!PATCHABLE_CLASSNAME_MODES.has(mode)) {
+    return false;
+  }
+  if (entry.riskLevel === "unsupported" && entry.hasLiteralClassName !== true) {
+    return false;
+  }
+  return resolveBrandBulkPatchHostId(entry) !== null;
+}
+function resolveBrandBulkPatchHostId(entry) {
+  if (entry.patchHostId) {
+    return entry.patchHostId;
+  }
+  if (entry.hasLiteralClassName === true) {
+    return entry.id;
+  }
+  const styleTarget = entry.styleTargets?.find((t) => t.classNamePatchable);
+  return styleTarget?.patchHostId ?? null;
+}
+function entryMatchesBrandBulkAction(entry, action) {
+  const id = entry.id.toLowerCase();
+  const tag = entry.tagName?.toLowerCase() ?? "";
+  const role = entry.hierarchyRole;
+  switch (action) {
+    case "button":
+      return role === "button" || tag === "button" || id.endsWith(".button") || id.includes(".cta") || id.includes(".filter") || id.includes(".seeall");
+    case "card":
+      return role === "card" || id.endsWith(".card") || tag === "card" || tag.startsWith("card");
+    case "heading":
+      if (id.endsWith(".value")) {
+        return false;
+      }
+      return /^h[1-6]$/.test(tag) || id.endsWith(".title") || id.endsWith(".heading") || id.endsWith(".header") || id.includes(".title");
+    case "text":
+      if (role === "button" || role === "card") {
+        return false;
+      }
+      if (/^h[1-6]$/.test(tag)) {
+        return id.endsWith(".value");
+      }
+      return role === "text" || tag === "p" || tag === "span" && (id.endsWith(".label") || id.endsWith(".subtitle") || id.includes(".nametext")) || tag === "label" && !id.startsWith("form.") || id.endsWith(".subtitle") || id.includes(".nametext") || entry.textEditable === true && (tag === "span" || tag === "label" || tag === "div");
+    case "table":
+      return role === "table" || id.endsWith(".table") || id.includes(".header.") || /\.row\./.test(id);
+    case "form":
+      return role === "form" || role === "input" || tag === "input" || tag === "textarea" || tag === "select" || tag === "label" || id.endsWith(".input") || id.endsWith(".label");
+    case "badge":
+      return id.endsWith(".badge") || id.includes(".badge.") || tag === "span" && (id.includes("badge") || id.includes("status") || id.includes("chip"));
+    default: {
+      const _exhaustive = action;
+      return _exhaustive;
+    }
+  }
+}
+function filterBrandBulkCandidates(entries, action, knownIds, duplicateIds, options) {
+  const pccHosts = options?.pccHosts;
+  if (pccHosts && pccHosts.length > 0) {
+    return filterBrandBulkCandidatesFromPccHosts(
+      entries,
+      pccHosts,
+      knownIds,
+      duplicateIds
+    );
+  }
+  const seenHostIds = /* @__PURE__ */ new Set();
+  const targets = [];
+  for (const entry of entries) {
+    if (!knownIds.has(entry.id)) {
+      continue;
+    }
+    if (!isStylePatchableEntry(entry, duplicateIds)) {
+      continue;
+    }
+    if (!entryMatchesBrandBulkAction(entry, action)) {
+      continue;
+    }
+    const hostId = resolveBrandBulkPatchHostId(entry);
+    if (!hostId || !knownIds.has(hostId)) {
+      continue;
+    }
+    if (seenHostIds.has(hostId)) {
+      continue;
+    }
+    seenHostIds.add(hostId);
+    targets.push({
+      hostId,
+      entryId: entry.id,
+      label: entry.id
+    });
+  }
+  return targets;
+}
+function filterBrandBulkCandidatesFromPccHosts(entries, pccHosts, knownIds, duplicateIds) {
+  const byId = new Map(entries.map((entry) => [entry.id, entry]));
+  const seenHostIds = /* @__PURE__ */ new Set();
+  const targets = [];
+  for (const hostId of pccHosts) {
+    const entry = byId.get(hostId);
+    if (!entry || !knownIds.has(hostId)) {
+      continue;
+    }
+    if (!isStylePatchableEntry(entry, duplicateIds)) {
+      continue;
+    }
+    const patchHostId = resolveBrandBulkPatchHostId(entry);
+    if (!patchHostId || !knownIds.has(patchHostId)) {
+      continue;
+    }
+    if (seenHostIds.has(patchHostId)) {
+      continue;
+    }
+    seenHostIds.add(patchHostId);
+    targets.push({
+      hostId: patchHostId,
+      entryId: entry.id,
+      label: entry.id
+    });
+  }
+  return targets;
+}
+function buildBrandBulkTargetOps(action, config, targets, entries) {
+  const byId = entries ? new Map(entries.map((entry) => [entry.id, entry])) : null;
+  return targets.map((target) => {
+    const entry = byId?.get(target.entryId);
+    const hint = entry ? brandFragmentHostHint(entry) : void 0;
+    return {
+      hostId: target.hostId,
+      ops: buildBrandPatchOps(action, config, hint)
+    };
+  });
+}
+
+// src/brand-inspector.ts
+var DIMENSION_LABELS = {
+  color: "Color",
+  radius: "Radius",
+  density: "Density",
+  typography: "Typography",
+  surface: "Surface",
+  buttonVariant: "Style"
+};
+function stripVariantPrefixes(token) {
+  let t = token;
+  while (t.includes(":")) {
+    const idx = t.indexOf(":");
+    t = t.slice(idx + 1);
+  }
+  return t;
+}
+function tokenizeClassName(className) {
+  return className.trim().split(/\s+/).filter(Boolean).map(stripVariantPrefixes);
+}
+function colorBgToken(color) {
+  if (color === "neutral") {
+    return "bg-gray-600";
+  }
+  return color === "slate" ? "bg-slate-700" : `bg-${color}-600`;
+}
+function colorTextToken(color) {
+  if (color === "neutral") {
+    return "text-gray-700";
+  }
+  return color === "slate" ? "text-slate-700" : `text-${color}-600`;
+}
+function colorBorderToken(color) {
+  if (color === "none") {
+    return null;
+  }
+  if (color === "neutral") {
+    return "border-gray-200";
+  }
+  return color === "slate" ? "border-slate-300" : `border-${color}-300`;
+}
+var RADIUS_TOKENS = {
+  sharp: "rounded-none",
+  soft: "rounded-md",
+  rounded: "rounded-xl",
+  pill: "rounded-full"
+};
+var BUTTON_DENSITY_TOKENS = {
+  compact: { px: "px-3", py: "py-1.5" },
+  balanced: { px: "px-4", py: "py-2" },
+  spacious: { px: "px-6", py: "py-3" }
+};
+var CARD_DENSITY_TOKENS = {
+  compact: "p-4",
+  balanced: "p-6",
+  spacious: "p-8"
+};
+var TYPOGRAPHY_TOKENS = {
+  clean: { size: "text-base", weight: "font-medium" },
+  bold: { size: "text-lg", weight: "font-semibold" },
+  soft: { size: "text-sm", weight: "font-normal" }
+};
+function colorBadgeBgToken(color) {
+  if (color === "neutral") {
+    return "bg-gray-100";
+  }
+  return color === "slate" ? "bg-slate-100" : `bg-${color}-100`;
+}
+function colorBadgeTextToken(color) {
+  if (color === "neutral") {
+    return "text-gray-700";
+  }
+  return color === "slate" ? "text-slate-700" : `text-${color}-700`;
+}
+function tokenMatchesBrandColor(token, color, prefix) {
+  if (color === "none") {
+    return false;
+  }
+  const exact = prefix === "bg-" ? [colorBgToken(color), colorBadgeBgToken(color)] : prefix === "text-" ? [colorTextToken(color), colorBadgeTextToken(color)] : [colorBorderToken(color)].filter((value) => value != null);
+  if (exact.includes(token)) {
+    return true;
+  }
+  if (!isBrandAccentColor(color)) {
+    return false;
+  }
+  return token.startsWith(prefix) && token.includes(`-${color}-`);
+}
+function detectCardBorderSlotColor(tokens) {
+  let last = { color: null, token: null };
+  for (const token of tokens) {
+    if (token === "border-gray-200") {
+      last = { color: "neutral", token };
+      continue;
+    }
+    if (token === "border-0" || token === "border-transparent") {
+      last = { color: "none", token };
+      continue;
+    }
+    for (const color of BRAND_COLORS) {
+      if (tokenMatchesBrandColor(token, color, "border-")) {
+        last = { color, token };
+      }
+    }
+  }
+  return last;
+}
+function detectBorderSlotColor(tokens) {
+  let last = { color: null, token: null };
+  let lastAccent = { color: null, token: null };
+  for (const token of tokens) {
+    if (token === "border-gray-200") {
+      last = { color: "neutral", token };
+      continue;
+    }
+    if (token === "border-0" || token === "border-transparent") {
+      last = { color: "none", token };
+      continue;
+    }
+    for (const color of BRAND_COLORS) {
+      if (!tokenMatchesBrandColor(token, color, "border-")) {
+        continue;
+      }
+      last = { color, token };
+      if (isBrandAccentColor(color)) {
+        lastAccent = { color, token };
+      }
+    }
+  }
+  if (lastAccent.color) {
+    return lastAccent;
+  }
+  return last;
+}
+function detectBrandColorForSlot(tokens, slot) {
+  if (slot === "border") {
+    return detectBorderSlotColor(tokens);
+  }
+  let result = { color: null, token: null };
+  for (const token of tokens) {
+    if (slot === "text" && token === "text-gray-700") {
+      result = { color: "neutral", token };
+    }
+    if (slot === "tint" && (token === "bg-gray-100" || token === "text-gray-700")) {
+      result = { color: "neutral", token };
+    }
+    for (const color of BRAND_COLORS) {
+      if (slot === "fill" && tokenMatchesBrandColor(token, color, "bg-")) {
+        result = { color, token };
+      } else if (slot === "text" && tokenMatchesBrandColor(token, color, "text-")) {
+        result = { color, token };
+      } else if (slot === "tint") {
+        if (tokenMatchesBrandColor(token, color, "bg-") || tokenMatchesBrandColor(token, color, "text-")) {
+          result = { color, token };
+        }
+      }
+    }
+  }
+  return result;
+}
+function detectBrandColorForAction(tokens, action) {
+  if (action === "card") {
+    return detectCardBorderSlotColor(tokens);
+  }
+  const slot = BRAND_ACCENT_SLOT_BY_ACTION[action];
+  if (!slot) {
+    return { color: null, token: null };
+  }
+  return detectBrandColorForSlot(tokens, slot);
+}
+function detectBrandColor(tokens) {
+  let result = { color: null, token: null };
+  for (const token of tokens) {
+    for (const color of BRAND_COLORS) {
+      const candidates = [colorBgToken(color), colorTextToken(color), colorBorderToken(color)].filter(
+        (value) => value != null
+      );
+      if (candidates.includes(token)) {
+        result = { color, token };
+      }
+    }
+    if (!token.startsWith("bg-") && !token.startsWith("text-") && !token.startsWith("border-")) {
+      continue;
+    }
+    for (const color of BRAND_COLORS) {
+      if (!isBrandAccentColor(color)) {
+        continue;
+      }
+      if (token.includes(`-${color}-`)) {
+        result = { color, token };
+      }
+    }
+  }
+  return result;
+}
+function detectBrandRadius(tokens) {
+  let result = { radius: null, token: null };
+  let lastRoundedToken = null;
+  for (const token of tokens) {
+    if (!token.startsWith("rounded")) {
+      continue;
+    }
+    lastRoundedToken = token;
+    for (const radius of BRAND_RADIUS) {
+      if (token === RADIUS_TOKENS[radius]) {
+        result = { radius, token };
+      }
+    }
+  }
+  if (result.radius || !lastRoundedToken) {
+    return result;
+  }
+  return { radius: null, token: lastRoundedToken };
+}
+function detectBrandDensityForAction(tokens, action) {
+  if (action === "card") {
+    let result = { density: null, token: null };
+    for (const density of BRAND_DENSITY) {
+      const cardToken = CARD_DENSITY_TOKENS[density];
+      if (tokens.includes(cardToken)) {
+        result = { density, token: cardToken };
+      }
+    }
+    return result;
+  }
+  if (action === "button" || action === "form") {
+    let result = { density: null, token: null };
+    for (const density of BRAND_DENSITY) {
+      const button = BUTTON_DENSITY_TOKENS[density];
+      if (tokens.includes(button.px) && tokens.includes(button.py)) {
+        result = { density, token: `${button.px} ${button.py}` };
+      }
+    }
+    return result;
+  }
+  return { density: null, token: null };
+}
+function detectBrandDensity(tokens) {
+  let result = { density: null, token: null };
+  for (const density of BRAND_DENSITY) {
+    const button = BUTTON_DENSITY_TOKENS[density];
+    if (tokens.includes(button.px) && tokens.includes(button.py)) {
+      result = { density, token: `${button.px} ${button.py}` };
+    }
+  }
+  for (const density of BRAND_DENSITY) {
+    const cardToken = CARD_DENSITY_TOKENS[density];
+    if (tokens.includes(cardToken)) {
+      result = { density, token: cardToken };
+    }
+  }
+  return result;
+}
+var BRAND_SIZE_TOKENS = /* @__PURE__ */ new Set(["text-sm", "text-base", "text-lg"]);
+function detectBrandTypography(tokens) {
+  const size = tokens.filter((token2) => BRAND_SIZE_TOKENS.has(token2)).at(-1) ?? null;
+  const weight = tokens.filter((token2) => token2.startsWith("font-")).at(-1) ?? null;
+  if (!size && !weight) {
+    return { typography: null, token: null };
+  }
+  for (const typography of BRAND_TYPOGRAPHY) {
+    const expected = TYPOGRAPHY_TOKENS[typography];
+    const sizeMatch = !size || size === expected.size;
+    const weightMatch = !weight || weight === expected.weight;
+    if (size && weight) {
+      if (size === expected.size && weight === expected.weight) {
+        return { typography, token: `${expected.size} ${expected.weight}` };
+      }
+      continue;
+    }
+    if (sizeMatch && weightMatch && (size || weight)) {
+      return {
+        typography,
+        token: [size ?? expected.size, weight ?? expected.weight].join(" ")
+      };
+    }
+  }
+  const token = [size, weight].filter(Boolean).join(" ");
+  return { typography: null, token: token || null };
+}
+function radiusLabelFromToken(token) {
+  if (!token) {
+    return "Not set";
+  }
+  for (const radius of BRAND_RADIUS) {
+    if (token === RADIUS_TOKENS[radius]) {
+      return getBrandRadiusLabel(radius);
+    }
+  }
+  const suffix = token.replace("rounded-", "");
+  return suffix ? `Custom (${suffix})` : "Custom radius";
+}
+function densityLabelFromToken(token) {
+  if (!token) {
+    return "Not set";
+  }
+  for (const density of BRAND_DENSITY) {
+    const button = BUTTON_DENSITY_TOKENS[density];
+    if (token === `${button.px} ${button.py}` || token === CARD_DENSITY_TOKENS[density]) {
+      return getBrandDensityLabel(density);
+    }
+  }
+  return "Custom spacing";
+}
+function typographyLabelFromToken(token) {
+  if (!token) {
+    return "Not set";
+  }
+  for (const typography of BRAND_TYPOGRAPHY) {
+    const expected = TYPOGRAPHY_TOKENS[typography];
+    if (token === `${expected.size} ${expected.weight}`) {
+      return getBrandTypographyLabel(typography);
+    }
+  }
+  return "Custom typography";
+}
+function colorLabelFromDetection(color, token) {
+  if (color) {
+    return getBrandColorLabel(color);
+  }
+  if (!token) {
+    return "Not set";
+  }
+  return "Custom color";
+}
+function buildRow(dimension, status, currentLabel, brandLabel, currentToken, expectedToken) {
+  return {
+    dimension,
+    dimensionLabel: DIMENSION_LABELS[dimension],
+    status,
+    currentLabel,
+    brandLabel,
+    currentToken,
+    expectedToken
+  };
+}
+function buildHeadline(matchCount, checkedCount) {
+  if (checkedCount === 0) {
+    return "No brand styles detected on this element.";
+  }
+  if (matchCount === checkedCount) {
+    return "Matches your saved brand.";
+  }
+  if (matchCount === 0) {
+    return "This element does not match your saved brand.";
+  }
+  return `${matchCount} of ${checkedCount} brand traits match your saved brand.`;
+}
+var INSPECT_DIMENSIONS_BY_ACTION = {
+  button: ["color", "buttonVariant", "radius", "density"],
+  card: ["surface", "color", "radius", "density"],
+  heading: ["color", "typography"],
+  text: ["color"],
+  table: ["color", "radius"],
+  form: ["color", "radius", "density", "surface"],
+  badge: ["color"]
+};
+function detectBrandSurface(tokens) {
+  let result = { surface: null, token: null };
+  if (tokens.includes("bg-slate-50")) {
+    result = { surface: "muted", token: "bg-slate-50" };
+  }
+  if (tokens.includes("bg-white")) {
+    result = { surface: "white", token: "bg-white" };
+  }
+  return result;
+}
+function detectBrandButtonVariant(tokens) {
+  if (tokens.includes("bg-transparent")) {
+    return { buttonVariant: "outline", token: "bg-transparent" };
+  }
+  for (const color of BRAND_COLORS) {
+    if (tokens.includes(colorBgToken(color))) {
+      return { buttonVariant: "solid", token: colorBgToken(color) };
+    }
+  }
+  return { buttonVariant: null, token: null };
+}
+function inspectRecipeFragmentMatch(className, expectedFragment) {
+  const expectedTokens = tokenizeClassName(expectedFragment);
+  const actualTokens = tokenizeClassName(className);
+  const matchCount = expectedTokens.filter((token) => actualTokens.includes(token)).length;
+  const checkedCount = expectedTokens.length;
+  return {
+    rows: [],
+    matchCount,
+    checkedCount,
+    headline: buildHeadline(matchCount, checkedCount)
+  };
+}
+function inferBrandPresetsFromTokens(tokens, action) {
+  const buttonVariantDetection = detectBrandButtonVariant([...tokens]);
+  const colorDetection = action === "button" && buttonVariantDetection.buttonVariant === "outline" ? detectBrandColorForSlot([...tokens], "text") : action ? detectBrandColorForAction([...tokens], action) : detectBrandColor([...tokens]);
+  const radiusDetection = detectBrandRadius([...tokens]);
+  const densityDetection = action ? detectBrandDensityForAction([...tokens], action) : detectBrandDensity([...tokens]);
+  const typographyDetection = detectBrandTypography([...tokens]);
+  const surfaceDetection = detectBrandSurface([...tokens]);
+  const dimensions = action ? new Set(INSPECT_DIMENSIONS_BY_ACTION[action]) : null;
+  const patch = {};
+  if (colorDetection.color && (!dimensions || dimensions.has("color"))) {
+    patch.color = colorDetection.color;
+  }
+  if (surfaceDetection.surface && (!dimensions || dimensions.has("surface"))) {
+    patch.surface = surfaceDetection.surface;
+  }
+  if (buttonVariantDetection.buttonVariant && (!dimensions || dimensions.has("buttonVariant"))) {
+    patch.buttonVariant = buttonVariantDetection.buttonVariant;
+  }
+  if (radiusDetection.radius && (!dimensions || dimensions.has("radius"))) {
+    patch.radius = radiusDetection.radius;
+  }
+  if (densityDetection.density && (!dimensions || dimensions.has("density"))) {
+    patch.density = densityDetection.density;
+  }
+  if (typographyDetection.typography && (!dimensions || dimensions.has("typography"))) {
+    patch.typography = typographyDetection.typography;
+  }
+  return patch;
+}
+function inferBrandPresetsFromClassName(className, action) {
+  return inferBrandPresetsFromTokens(tokenizeClassName(className), action);
+}
+function inspectBrandMatchForAction(action, className, brand, hint) {
+  if (action === "text") {
+    return inspectRecipeFragmentMatch(className, buildBrandClassFragment("text", brand));
+  }
+  if (action === "form" || action === "badge") {
+    return inspectRecipeFragmentMatch(className, buildBrandClassFragment(action, brand, hint));
+  }
+  const full = inspectBrandMatch(className, brand);
+  const dimensions = new Set(INSPECT_DIMENSIONS_BY_ACTION[action]);
+  const rows = full.rows.filter((row) => dimensions.has(row.dimension));
+  const checkedRows = rows.filter((row) => row.status !== "not_set");
+  const matchCount = checkedRows.filter((row) => row.status === "match").length;
+  return {
+    rows,
+    matchCount,
+    checkedCount: checkedRows.length,
+    headline: buildHeadline(matchCount, checkedRows.length)
+  };
+}
+function inspectBrandMatch(className, brand) {
+  const tokens = tokenizeClassName(className);
+  const colorDetection = detectBrandColor(tokens);
+  const radiusDetection = detectBrandRadius(tokens);
+  const densityDetection = detectBrandDensity(tokens);
+  const typographyDetection = detectBrandTypography(tokens);
+  const rows = [
+    buildRow(
+      "color",
+      colorDetection.token == null ? "not_set" : colorDetection.color === brand.color ? "match" : "mismatch",
+      colorLabelFromDetection(colorDetection.color, colorDetection.token),
+      getBrandColorLabel(brand.color),
+      colorDetection.token ?? void 0,
+      colorTextToken(brand.color)
+    ),
+    buildRow(
+      "radius",
+      radiusDetection.token == null ? "not_set" : radiusDetection.radius === brand.radius ? "match" : "mismatch",
+      radiusDetection.radius ? getBrandRadiusLabel(radiusDetection.radius) : radiusLabelFromToken(radiusDetection.token),
+      getBrandRadiusLabel(brand.radius),
+      radiusDetection.token ?? void 0,
+      RADIUS_TOKENS[brand.radius]
+    ),
+    buildRow(
+      "density",
+      densityDetection.token == null ? "not_set" : densityDetection.density === brand.density ? "match" : "mismatch",
+      densityDetection.density ? getBrandDensityLabel(densityDetection.density) : densityLabelFromToken(densityDetection.token),
+      getBrandDensityLabel(brand.density),
+      densityDetection.token ?? void 0,
+      `${BUTTON_DENSITY_TOKENS[brand.density].px} ${BUTTON_DENSITY_TOKENS[brand.density].py}`
+    ),
+    buildRow(
+      "typography",
+      typographyDetection.token == null ? "not_set" : typographyDetection.typography === brand.typography ? "match" : "mismatch",
+      typographyDetection.typography ? getBrandTypographyLabel(typographyDetection.typography) : typographyLabelFromToken(typographyDetection.token),
+      getBrandTypographyLabel(brand.typography),
+      typographyDetection.token ?? void 0,
+      `${TYPOGRAPHY_TOKENS[brand.typography].size} ${TYPOGRAPHY_TOKENS[brand.typography].weight}`
+    )
+  ];
+  const checkedRows = rows.filter((row) => row.status !== "not_set");
+  const matchCount = checkedRows.filter((row) => row.status === "match").length;
+  return {
+    rows,
+    matchCount,
+    checkedCount: checkedRows.length,
+    headline: buildHeadline(matchCount, checkedRows.length)
+  };
+}
+
+// src/brand-selection.ts
+function isNonBrandableNavEntry(entry) {
+  const id = entry.id.toLowerCase();
+  return id.startsWith("nav.") || id.includes(".nav.");
+}
+function resolveBrandCategoryForEntry(entry) {
+  if (isNonBrandableNavEntry(entry)) {
+    return null;
+  }
+  for (const action of BRAND_APPLY_ACTIONS) {
+    if (entryMatchesBrandBulkAction(entry, action)) {
+      return action;
+    }
+  }
+  return null;
+}
+function isBrandableEntry(entry) {
+  return resolveBrandCategoryForEntry(entry) !== null;
+}
+
+// src/evaluate-brand-scan.ts
+function classifyHostBrandStatus(entry, brand, action) {
+  if (!entry) {
+    return { status: "missing", inspect: null };
+  }
+  const className = entry.classNameValue ?? "";
+  const hint = brandFragmentHostHint(entry);
+  const inspect = inspectBrandMatchForAction(action, className, brand, hint);
+  if (inspect.checkedCount === 0) {
+    return { status: "no_traits", inspect };
+  }
+  if (inspect.matchCount === inspect.checkedCount) {
+    return { status: "on_brand", inspect };
+  }
+  return { status: "off_brand", inspect };
+}
+function evaluateBrandPageScan(manifest, entries, brandInput) {
+  const brand = normalizeBrandConfig(brandInput ?? DEFAULT_BRAND_CONFIG);
+  const byId = new Map(entries.map((entry) => [entry.id, entry]));
+  const hosts = [];
+  const categories = [];
+  let onBrandCount = 0;
+  let offBrandCount = 0;
+  let noTraitsCount = 0;
+  let missingCount = 0;
+  const categoryKeys = Object.keys(manifest.categories);
+  for (const category of categoryKeys) {
+    if (!isPccBrandableCategory(category)) {
+      continue;
+    }
+    const config = manifest.categories[category];
+    if (!config) {
+      continue;
+    }
+    let onBrand = 0;
+    let offBrand = 0;
+    let noTraits = 0;
+    let missing = 0;
+    for (const hostId of config.hosts) {
+      const { status, inspect } = classifyHostBrandStatus(
+        byId.get(hostId),
+        brand,
+        category
+      );
+      hosts.push({ hostId, category, status, inspect });
+      if (status === "on_brand") {
+        onBrand += 1;
+        onBrandCount += 1;
+      } else if (status === "off_brand") {
+        offBrand += 1;
+        offBrandCount += 1;
+      } else if (status === "no_traits") {
+        noTraits += 1;
+        noTraitsCount += 1;
+      } else {
+        missing += 1;
+        missingCount += 1;
+      }
+    }
+    categories.push({
+      category,
+      expected: config.hosts.length,
+      onBrand,
+      offBrand,
+      noTraits,
+      missing,
+      pass: offBrand === 0 && missing === 0
+    });
+  }
+  return {
+    page: manifest.page,
+    route: manifest.route,
+    brand,
+    categories,
+    hosts,
+    onBrandCount,
+    offBrandCount,
+    noTraitsCount,
+    missingCount,
+    pass: offBrandCount === 0 && missingCount === 0
+  };
+}
+function pccBrandableHostIds(manifest) {
+  const hosts = [];
+  for (const category of Object.keys(manifest.categories)) {
+    if (!isPccBrandableCategory(category)) {
+      continue;
+    }
+    const config = manifest.categories[category];
+    if (config) {
+      hosts.push(...config.hosts);
+    }
+  }
+  return hosts;
+}
+
+// src/evaluate-coverage.ts
+var PATCHABLE_CLASSNAME_MODES2 = /* @__PURE__ */ new Set([
+  "literal-only",
+  "cn-basic",
+  "cn-conditional",
+  "classnames-static"
+]);
+function duplicateIdSet(errors) {
+  return new Set(errors.map((e) => e.id));
+}
+function isHostPatchable(entry, duplicateIds) {
+  if (duplicateIds.has(entry.id)) {
+    return { patchable: false, reason: "duplicate_id" };
+  }
+  if (entry.hasLiteralClassName === false) {
+    return { patchable: false, reason: "no_literal_classname" };
+  }
+  const mode = entry.classNameMode ?? "literal-only";
+  if (mode === "unsupported") {
+    return { patchable: false, reason: `classNameMode:${mode}` };
+  }
+  if (!PATCHABLE_CLASSNAME_MODES2.has(mode)) {
+    return { patchable: false, reason: `classNameMode:${mode}` };
+  }
+  if (entry.riskLevel === "unsupported" && entry.hasLiteralClassName !== true) {
+    return { patchable: false, reason: "risk_unsupported" };
+  }
+  const patchHostId = resolveBrandBulkPatchHostId(entry);
+  if (!patchHostId) {
+    return { patchable: false, reason: "no_patch_host" };
+  }
+  return { patchable: true };
+}
+function evaluatePageCoverage(manifest, entries, duplicateErrors = []) {
+  const byId = new Map(entries.map((e) => [e.id, e]));
+  const duplicateIds = duplicateIdSet(duplicateErrors);
+  const issues = [];
+  const categories = [];
+  let gateIndexed = 0;
+  let gatePatchable = 0;
+  let gateCategorized = 0;
+  let gateEditable = 0;
+  let gateBrandable = 0;
+  let gateExpected = 0;
+  let brandableCount = 0;
+  let editableOnlyCount = 0;
+  const categoryKeys = Object.keys(manifest.categories);
+  for (const category of categoryKeys) {
+    const config = manifest.categories[category];
+    if (!config) {
+      continue;
+    }
+    let indexed = 0;
+    let patchable = 0;
+    let categorized = 0;
+    let editable = 0;
+    let brandable = 0;
+    for (const hostId of config.hosts) {
+      gateExpected += 1;
+      const entry = byId.get(hostId);
+      if (!entry) {
+        issues.push({ kind: "missing", hostId, category });
+        continue;
+      }
+      if (duplicateIds.has(hostId)) {
+        issues.push({ kind: "duplicate_id", hostId, category, reason: "duplicate_id" });
+        continue;
+      }
+      indexed += 1;
+      gateIndexed += 1;
+      categorized += 1;
+      gateCategorized += 1;
+      const patch = isHostPatchable(entry, duplicateIds);
+      if (!patch.patchable) {
+        issues.push({
+          kind: "unpatchable",
+          hostId,
+          category,
+          reason: patch.reason
+        });
+        continue;
+      }
+      patchable += 1;
+      gatePatchable += 1;
+      editable += 1;
+      gateEditable += 1;
+      if (isPccBrandableCategory(category)) {
+        brandable += 1;
+        gateBrandable += 1;
+        brandableCount += 1;
+      } else {
+        editableOnlyCount += 1;
+      }
+    }
+    const expected = config.hosts.length;
+    const pass2 = (!config.required || expected > 0) && issues.filter((i) => i.category === category).length === 0 && indexed === expected && patchable === expected && editable === expected;
+    categories.push({
+      category,
+      required: config.required,
+      expected,
+      indexed,
+      patchable,
+      categorized,
+      editable,
+      brandable,
+      pass: pass2
+    });
+  }
+  const pass = categories.every((c) => c.pass) && issues.length === 0;
+  return {
+    page: manifest.page,
+    route: manifest.route,
+    categories,
+    gates: {
+      expected: gateExpected,
+      indexed: gateIndexed,
+      patchable: gatePatchable,
+      categorized: gateCategorized,
+      editable: gateEditable,
+      brandable: gateBrandable
+    },
+    issues,
+    brandableCount,
+    editableOnlyCount,
+    pass
+  };
+}
+
+// src/pcc-brand-bulk.ts
+function normalizeAppRoute(route) {
+  const pathOnly = route.split("?")[0]?.split("#")[0] ?? "/";
+  const trimmed = pathOnly.trim() || "/";
+  if (trimmed.length > 1 && trimmed.endsWith("/")) {
+    return trimmed.slice(0, -1);
+  }
+  return trimmed;
+}
+function pccHostsForBrandAction(manifest, action) {
+  if (!manifest) {
+    return null;
+  }
+  const hosts = pccHostsForCategory(manifest, action);
+  return hosts.length > 0 ? hosts : null;
+}
+function pccManifestMatchesRoute(manifest, route) {
+  return normalizeAppRoute(manifest.route) === normalizeAppRoute(route);
+}
+
+// src/protocol.ts
+import { z as z2 } from "zod";
+var PROTOCOL_VERSION = 8;
+var riskLevelSchema = z2.enum(["safe", "caution", "unsupported"]);
+var textTargetSchema = z2.object({
   /** Stable within host: `data-nuvio-id` or `loc:line:column`. */
-  key: z.string(),
-  label: z.string(),
-  file: z.string(),
-  line: z.number().int(),
-  column: z.number().int(),
-  tagName: z.string(),
-  textEditable: z.boolean(),
-  textPreview: z.string().optional(),
+  key: z2.string(),
+  label: z2.string(),
+  file: z2.string(),
+  line: z2.number().int(),
+  column: z2.number().int(),
+  tagName: z2.string(),
+  textEditable: z2.boolean(),
+  textPreview: z2.string().optional(),
   /** Present when the text node has its own `data-nuvio-id`. */
-  nuvioId: z.string().optional(),
+  nuvioId: z2.string().optional(),
   /** Host id used for `mergeTailwindClassName` when patching styles for this target. */
-  patchHostId: z.string(),
-  insideMap: z.boolean().optional()
+  patchHostId: z2.string(),
+  insideMap: z2.boolean().optional()
 });
-var styleTargetSchema = z.object({
+var styleTargetSchema = z2.object({
   /** Stable key within host: `data-nuvio-id` or `host` for selected container. */
-  key: z.string(),
-  label: z.string(),
-  file: z.string(),
-  line: z.number().int(),
-  column: z.number().int(),
-  tagName: z.string(),
-  nuvioId: z.string(),
-  patchHostId: z.string(),
-  classNamePatchable: z.boolean(),
+  key: z2.string(),
+  label: z2.string(),
+  file: z2.string(),
+  line: z2.number().int(),
+  column: z2.number().int(),
+  tagName: z2.string(),
+  nuvioId: z2.string(),
+  patchHostId: z2.string(),
+  classNamePatchable: z2.boolean(),
   riskLevel: riskLevelSchema.optional()
 });
-var hierarchyRoleSchema = z.enum([
+var hierarchyRoleSchema = z2.enum([
   "section",
   "card",
   "table",
@@ -47,117 +1551,131 @@ var hierarchyRoleSchema = z.enum([
   "media",
   "unknown"
 ]);
-var rowTargetSchema = z.object({
-  rowKey: z.string(),
-  nuvioId: z.string(),
-  label: z.string(),
-  file: z.string(),
-  line: z.number().int()
+var rowTargetSchema = z2.object({
+  rowKey: z2.string(),
+  nuvioId: z2.string(),
+  label: z2.string(),
+  file: z2.string(),
+  line: z2.number().int()
 });
-var tableMetaSchema = z.object({
-  dataBinding: z.string(),
-  file: z.string(),
-  line: z.number().int(),
-  columns: z.array(z.string()).optional()
+var tableMetaSchema = z2.object({
+  dataBinding: z2.string(),
+  file: z2.string(),
+  line: z2.number().int(),
+  columns: z2.array(z2.string()).optional()
 });
-var tableDataFieldSchema = z.object({
-  arrayName: z.string(),
-  rowKey: z.string(),
-  field: z.string()
+var tableDataFieldSchema = z2.object({
+  arrayName: z2.string(),
+  rowKey: z2.string(),
+  field: z2.string()
 });
-var indexEntrySchema = z.object({
-  id: z.string(),
-  file: z.string(),
-  line: z.number().int(),
-  column: z.number().int(),
+var classNameModeSchema = z2.enum([
+  "literal-only",
+  "cn-basic",
+  "cn-conditional",
+  "classnames-static",
+  "unsupported"
+]);
+var libraryIdSchema = z2.enum(["shadcn", "tailadmin", "daisyui"]);
+var indexEntrySchema = z2.object({
+  id: z2.string(),
+  file: z2.string(),
+  line: z2.number().int(),
+  column: z2.number().int(),
   /** Source index v2 metadata */
-  tagName: z.string().optional(),
-  componentName: z.string().optional(),
-  hasLiteralClassName: z.boolean().optional(),
-  classNameValue: z.string().optional(),
-  textEditable: z.boolean().optional(),
-  structuralEditable: z.boolean().optional(),
+  tagName: z2.string().optional(),
+  componentName: z2.string().optional(),
+  hasLiteralClassName: z2.boolean().optional(),
+  classNameValue: z2.string().optional(),
+  textEditable: z2.boolean().optional(),
+  structuralEditable: z2.boolean().optional(),
   riskLevel: riskLevelSchema.optional(),
-  unsupportedReasons: z.array(z.string()).optional(),
-  insideMap: z.boolean().optional(),
+  unsupportedReasons: z2.array(z2.string()).optional(),
+  insideMap: z2.boolean().optional(),
   /** Index v3: default id for className patches on this host. */
-  patchHostId: z.string().optional(),
+  patchHostId: z2.string().optional(),
   /** Index v3: preferred text target key in `textTargets`. */
-  primaryTextTargetKey: z.string().optional(),
+  primaryTextTargetKey: z2.string().optional(),
   /** Index v3: descendant (and host) text edit targets. */
-  textTargets: z.array(textTargetSchema).optional(),
+  textTargets: z2.array(textTargetSchema).optional(),
   /** Index v3: explicit style patch targets for this selected host. */
-  styleTargets: z.array(styleTargetSchema).optional(),
+  styleTargets: z2.array(styleTargetSchema).optional(),
   /** Index v3: coarse host role, used for defaults/hints only. */
   hierarchyRole: hierarchyRoleSchema.optional(),
   /** Index v3: nearest ancestor host id in JSX ownership hierarchy. */
-  parentHostId: z.string().optional(),
+  parentHostId: z2.string().optional(),
   /** Index v3: descendant host ids under this host (if any). */
-  childTargetIds: z.array(z.string()).optional(),
+  childTargetIds: z2.array(z2.string()).optional(),
   /** Index v4: row hosts when this entry is a table section. */
-  rowTargets: z.array(rowTargetSchema).optional(),
+  rowTargets: z2.array(rowTargetSchema).optional(),
   /** Index v4: static table data binding for Tier C. */
   tableMeta: tableMetaSchema.optional(),
   /** Index v4: when this host maps to a `tableData` field edit. */
-  tableDataField: tableDataFieldSchema.optional()
+  tableDataField: tableDataFieldSchema.optional(),
+  /** Index v5: detected className expression mode for patch routing. */
+  classNameMode: classNameModeSchema.optional(),
+  /** Index v6: shadcn / TailAdmin / DaisyUI hint for this host. */
+  libraryHint: libraryIdSchema.optional()
 });
-var runtimeDiagnosticsSchema = z.object({
-  viteVersion: z.string().optional(),
-  reactVersion: z.string().optional(),
-  tailwindVersion: z.string().optional(),
-  overlayCssMode: z.literal("self-contained").optional()
+var runtimeDiagnosticsSchema = z2.object({
+  viteVersion: z2.string().optional(),
+  reactVersion: z2.string().optional(),
+  tailwindVersion: z2.string().optional(),
+  overlayCssMode: z2.literal("self-contained").optional(),
+  /** Project-level library detection (v0.8). */
+  detectedLibraries: z2.array(libraryIdSchema).optional()
 });
-var duplicateIdOccurrenceSchema = z.object({
-  file: z.string(),
-  line: z.number().int(),
-  column: z.number().int()
+var duplicateIdOccurrenceSchema = z2.object({
+  file: z2.string(),
+  line: z2.number().int(),
+  column: z2.number().int()
 });
-var duplicateIdErrorSchema = z.object({
-  id: z.string(),
-  occurrences: z.array(duplicateIdOccurrenceSchema)
+var duplicateIdErrorSchema = z2.object({
+  id: z2.string(),
+  occurrences: z2.array(duplicateIdOccurrenceSchema)
 });
-var clientPingSchema = z.object({
-  type: z.literal("ping"),
-  protocolVersion: z.number().int(),
-  requestId: z.string().min(1)
+var clientPingSchema = z2.object({
+  type: z2.literal("ping"),
+  protocolVersion: z2.number().int(),
+  requestId: z2.string().min(1)
 });
-var clientSelectSchema = z.object({
-  type: z.literal("select"),
-  protocolVersion: z.number().int(),
-  requestId: z.string().min(1),
-  id: z.string().min(1)
+var clientSelectSchema = z2.object({
+  type: z2.literal("select"),
+  protocolVersion: z2.number().int(),
+  requestId: z2.string().min(1),
+  id: z2.string().min(1)
 });
-var patchOpSetTextSchema = z.object({
-  kind: z.literal("setText"),
-  text: z.string()
+var patchOpSetTextSchema = z2.object({
+  kind: z2.literal("setText"),
+  text: z2.string()
 });
-var patchOpMergeTailwindSchema = z.object({
-  kind: z.literal("mergeTailwindClassName"),
-  classNameFragment: z.string()
+var patchOpMergeTailwindSchema = z2.object({
+  kind: z2.literal("mergeTailwindClassName"),
+  classNameFragment: z2.string()
 });
-var patchOpRemoveTailwindSchema = z.object({
-  kind: z.literal("removeTailwindClassName"),
-  classNameFragment: z.string()
+var patchOpRemoveTailwindSchema = z2.object({
+  kind: z2.literal("removeTailwindClassName"),
+  classNameFragment: z2.string()
 });
-var patchOpMoveSiblingSchema = z.object({
-  kind: z.literal("moveSibling"),
-  direction: z.enum(["up", "down"])
+var patchOpMoveSiblingSchema = z2.object({
+  kind: z2.literal("moveSibling"),
+  direction: z2.enum(["up", "down"])
 });
-var patchOpSetHiddenSchema = z.object({
-  kind: z.literal("setHidden"),
-  hidden: z.boolean()
+var patchOpSetHiddenSchema = z2.object({
+  kind: z2.literal("setHidden"),
+  hidden: z2.boolean()
 });
-var patchOpDuplicateHostSchema = z.object({
-  kind: z.literal("duplicateHost")
+var patchOpDuplicateHostSchema = z2.object({
+  kind: z2.literal("duplicateHost")
 });
-var patchOpSetTableDataFieldSchema = z.object({
-  kind: z.literal("setTableDataField"),
-  arrayName: z.string(),
-  rowKey: z.string(),
-  field: z.string(),
-  value: z.string()
+var patchOpSetTableDataFieldSchema = z2.object({
+  kind: z2.literal("setTableDataField"),
+  arrayName: z2.string(),
+  rowKey: z2.string(),
+  field: z2.string(),
+  value: z2.string()
 });
-var patchOpSchema = z.discriminatedUnion("kind", [
+var patchOpSchema = z2.discriminatedUnion("kind", [
   patchOpSetTextSchema,
   patchOpMergeTailwindSchema,
   patchOpRemoveTailwindSchema,
@@ -166,106 +1684,126 @@ var patchOpSchema = z.discriminatedUnion("kind", [
   patchOpDuplicateHostSchema,
   patchOpSetTableDataFieldSchema
 ]);
-var breakpointSchema = z.enum(["base", "sm", "md", "lg", "xl"]);
-var clientPatchApplySchema = z.object({
-  type: z.literal("patchApply"),
-  protocolVersion: z.number().int(),
-  requestId: z.string().min(1),
-  id: z.string().min(1),
-  ops: z.array(patchOpSchema).min(1),
+var breakpointSchema = z2.enum(["base", "sm", "md", "lg", "xl"]);
+var clientPatchApplySchema = z2.object({
+  type: z2.literal("patchApply"),
+  protocolVersion: z2.number().int(),
+  requestId: z2.string().min(1),
+  id: z2.string().min(1),
+  ops: z2.array(patchOpSchema).min(1),
   /** Optional responsive context for className merges. */
   activeBreakpoint: breakpointSchema.optional(),
   /** When true, server validates and returns `patchAck` with `diffSummary` but does not write disk or push undo. */
-  dryRun: z.boolean().optional()
+  dryRun: z2.boolean().optional()
+});
+var clientPatchUndoSchema = z2.object({
+  type: z2.literal("patchUndo"),
+  protocolVersion: z2.number().int(),
+  requestId: z2.string().min(1)
 });
-var clientPatchUndoSchema = z.object({
-  type: z.literal("patchUndo"),
-  protocolVersion: z.number().int(),
-  requestId: z.string().min(1)
+var clientTagElementSchema = z2.object({
+  type: z2.literal("tagElement"),
+  protocolVersion: z2.number().int(),
+  requestId: z2.string().min(1),
+  file: z2.string().min(1),
+  line: z2.number().int().positive(),
+  column: z2.number().int().nonnegative(),
+  nuvioId: z2.string().min(1)
 });
-var clientMessageSchema = z.discriminatedUnion("type", [
+var clientMessageSchema = z2.discriminatedUnion("type", [
   clientPingSchema,
   clientSelectSchema,
   clientPatchApplySchema,
-  clientPatchUndoSchema
+  clientPatchUndoSchema,
+  clientTagElementSchema
 ]);
-var serverPongSchema = z.object({
-  type: z.literal("pong"),
-  protocolVersion: z.number().int(),
-  requestId: z.string(),
+var serverPongSchema = z2.object({
+  type: z2.literal("pong"),
+  protocolVersion: z2.number().int(),
+  requestId: z2.string(),
   diagnostics: runtimeDiagnosticsSchema.optional()
 });
-var serverErrorSchema = z.object({
-  type: z.literal("error"),
-  code: z.string(),
-  message: z.string(),
-  requestId: z.string().optional()
+var serverErrorSchema = z2.object({
+  type: z2.literal("error"),
+  code: z2.string(),
+  message: z2.string(),
+  requestId: z2.string().optional()
 });
-var serverIndexReadySchema = z.object({
-  type: z.literal("indexReady"),
-  protocolVersion: z.number().int(),
-  indexVersion: z.number().int(),
-  entries: z.array(indexEntrySchema),
-  duplicateErrors: z.array(duplicateIdErrorSchema),
+var serverIndexReadySchema = z2.object({
+  type: z2.literal("indexReady"),
+  protocolVersion: z2.number().int(),
+  indexVersion: z2.number().int(),
+  entries: z2.array(indexEntrySchema),
+  duplicateErrors: z2.array(duplicateIdErrorSchema),
   diagnostics: runtimeDiagnosticsSchema.optional()
 });
-var serverSelectAckSchema = z.object({
-  type: z.literal("selectAck"),
-  protocolVersion: z.number().int(),
-  requestId: z.string(),
-  id: z.string(),
-  ok: z.boolean(),
-  file: z.string().optional(),
-  line: z.number().int().optional(),
-  column: z.number().int().optional(),
+var serverSelectAckSchema = z2.object({
+  type: z2.literal("selectAck"),
+  protocolVersion: z2.number().int(),
+  requestId: z2.string(),
+  id: z2.string(),
+  ok: z2.boolean(),
+  file: z2.string().optional(),
+  line: z2.number().int().optional(),
+  column: z2.number().int().optional(),
   /** Index v3 snapshot for the selected host (also on `indexReady` entries). */
-  patchHostId: z.string().optional(),
-  primaryTextTargetKey: z.string().optional(),
-  textTargets: z.array(textTargetSchema).optional(),
-  styleTargets: z.array(styleTargetSchema).optional(),
+  patchHostId: z2.string().optional(),
+  primaryTextTargetKey: z2.string().optional(),
+  textTargets: z2.array(textTargetSchema).optional(),
+  styleTargets: z2.array(styleTargetSchema).optional(),
   hierarchyRole: hierarchyRoleSchema.optional(),
-  parentHostId: z.string().optional(),
-  childTargetIds: z.array(z.string()).optional(),
-  rowTargets: z.array(rowTargetSchema).optional(),
+  parentHostId: z2.string().optional(),
+  childTargetIds: z2.array(z2.string()).optional(),
+  rowTargets: z2.array(rowTargetSchema).optional(),
   tableMeta: tableMetaSchema.optional(),
   tableDataField: tableDataFieldSchema.optional(),
-  errorCode: z.string().optional(),
-  errorMessage: z.string().optional()
+  errorCode: z2.string().optional(),
+  errorMessage: z2.string().optional()
 });
-var serverPatchAckSchema = z.object({
-  type: z.literal("patchAck"),
-  protocolVersion: z.number().int(),
-  requestId: z.string(),
-  id: z.string(),
-  ok: z.boolean(),
-  diffSummary: z.string().optional(),
+var serverPatchAckSchema = z2.object({
+  type: z2.literal("patchAck"),
+  protocolVersion: z2.number().int(),
+  requestId: z2.string(),
+  id: z2.string(),
+  ok: z2.boolean(),
+  diffSummary: z2.string().optional(),
   /** Present when this ack is for a `patchApply` with `dryRun: true`. */
-  dryRun: z.boolean().optional(),
+  dryRun: z2.boolean().optional(),
   /** Absolute path written on successful non-dry apply (for touched-file log). */
-  writtenFile: z.string().optional(),
+  writtenFile: z2.string().optional(),
   /** Server undo stack size after this apply (non-dry success only). */
-  undoStackDepth: z.number().int().optional(),
-  errorCode: z.string().optional(),
-  errorMessage: z.string().optional()
+  undoStackDepth: z2.number().int().optional(),
+  errorCode: z2.string().optional(),
+  errorMessage: z2.string().optional()
 });
-var serverPatchUndoAckSchema = z.object({
-  type: z.literal("patchUndoAck"),
-  protocolVersion: z.number().int(),
-  requestId: z.string(),
-  ok: z.boolean(),
-  file: z.string().optional(),
+var serverPatchUndoAckSchema = z2.object({
+  type: z2.literal("patchUndoAck"),
+  protocolVersion: z2.number().int(),
+  requestId: z2.string(),
+  ok: z2.boolean(),
+  file: z2.string().optional(),
   /** Remaining in-memory undo snapshots after this undo (success only). */
-  undoStackDepth: z.number().int().optional(),
-  errorCode: z.string().optional(),
-  errorMessage: z.string().optional()
+  undoStackDepth: z2.number().int().optional(),
+  errorCode: z2.string().optional(),
+  errorMessage: z2.string().optional()
+});
+var serverTagElementAckSchema = z2.object({
+  type: z2.literal("tagElementAck"),
+  protocolVersion: z2.number().int(),
+  requestId: z2.string(),
+  ok: z2.boolean(),
+  id: z2.string().optional(),
+  errorCode: z2.string().optional(),
+  errorMessage: z2.string().optional()
 });
-var serverMessageSchema = z.discriminatedUnion("type", [
+var serverMessageSchema = z2.discriminatedUnion("type", [
   serverPongSchema,
   serverErrorSchema,
   serverIndexReadySchema,
   serverSelectAckSchema,
   serverPatchAckSchema,
-  serverPatchUndoAckSchema
+  serverPatchUndoAckSchema,
+  serverTagElementAckSchema
 ]);
 function parseClientMessage(raw) {
   let json;
@@ -290,20 +1828,283 @@ function parseServerMessage(raw) {
 function serializeServerMessage(msg) {
   return JSON.stringify(msg);
 }
+
+// src/library-registry.ts
+var LIBRARY_IDS = ["shadcn", "tailadmin", "daisyui"];
+var SHADCN_COMPOUND_TAGS = /* @__PURE__ */ new Set([
+  "Button",
+  "Card",
+  "CardHeader",
+  "CardTitle",
+  "CardDescription",
+  "CardContent",
+  "CardFooter",
+  "Input",
+  "Label",
+  "Badge",
+  "Table",
+  "TableHeader",
+  "TableBody",
+  "TableRow",
+  "TableCell",
+  "TableHead",
+  "Dialog",
+  "DialogTitle",
+  "DialogContent",
+  "DialogHeader"
+]);
+var SHADCN_TAG_SEGMENTS = {
+  Button: "button",
+  Card: "card",
+  CardHeader: "header",
+  CardTitle: "title",
+  CardDescription: "description",
+  CardContent: "content",
+  CardFooter: "footer",
+  Input: "input",
+  Label: "label",
+  Badge: "badge",
+  Table: "table",
+  TableHeader: "header",
+  TableBody: "body",
+  TableRow: "row",
+  TableCell: "cell",
+  TableHead: "header",
+  Dialog: "dialog",
+  DialogTitle: "title",
+  DialogContent: "content",
+  DialogHeader: "header"
+};
+var DAISYUI_CLASS_HINTS = /* @__PURE__ */ new Set(["btn", "card", "table", "navbar", "badge", "input"]);
+function librarySegmentForTag(tagName, libraryId) {
+  if (libraryId === "shadcn") {
+    return SHADCN_TAG_SEGMENTS[tagName];
+  }
+  if (libraryId === "daisyui") {
+    const lower = tagName.toLowerCase();
+    if (DAISYUI_CLASS_HINTS.has(lower)) {
+      return lower;
+    }
+  }
+  return void 0;
+}
+function isShadcnCompoundTag(tagName) {
+  return SHADCN_COMPOUND_TAGS.has(tagName);
+}
+function inferLibraryFromFilePath(filePath) {
+  const normalized = filePath.replace(/\\/g, "/").toLowerCase();
+  if (normalized.includes("/components/ui/")) {
+    return "shadcn";
+  }
+  if (normalized.includes("/layout/appsidebar") || normalized.includes("/components/ecommerce/") || normalized.includes("tailadmin")) {
+    return "tailadmin";
+  }
+  return void 0;
+}
+function resolveEntryLibraryHint(filePath, tagName, detectedLibraries) {
+  const fromPath = inferLibraryFromFilePath(filePath);
+  if (fromPath) {
+    return fromPath;
+  }
+  if (detectedLibraries.includes("shadcn") && isShadcnCompoundTag(tagName)) {
+    return "shadcn";
+  }
+  if (detectedLibraries.includes("daisyui")) {
+    const lower = tagName.toLowerCase();
+    if (DAISYUI_CLASS_HINTS.has(lower)) {
+      return "daisyui";
+    }
+  }
+  if (detectedLibraries.includes("tailadmin")) {
+    return "tailadmin";
+  }
+  return void 0;
+}
+function detectShadcnComponentMode(tagName) {
+  if (!tagName) {
+    return null;
+  }
+  if (tagName === "Button") {
+    return "button";
+  }
+  if (tagName === "Card" || tagName.startsWith("Card")) {
+    return "card";
+  }
+  if (tagName.startsWith("Table")) {
+    return "table";
+  }
+  if (tagName === "Input" || tagName === "Label") {
+    return "form";
+  }
+  return null;
+}
+function libraryGuidanceForEntry(entry) {
+  if (entry.libraryHint !== "shadcn") {
+    return void 0;
+  }
+  const tag = entry.tagName ?? "";
+  if (isShadcnCompoundTag(tag) && entry.riskLevel === "caution" && !entry.hasLiteralClassName) {
+    return "shadcn component \u2014 add className on the component call site, or tag a native child inside CardContent.";
+  }
+  if (tag.startsWith("Dialog") && entry.riskLevel === "unsupported") {
+    return "Dialog portal content may need a tagged host inside DialogContent.";
+  }
+  return void 0;
+}
+function formatLibraryList(libraries) {
+  if (libraries.length === 0) {
+    return "none detected";
+  }
+  return libraries.join(", ");
+}
+
+// src/suggest-nuvio-id.ts
+var NUVIO_ID_PATTERN = /^[a-z][a-z0-9]*(\.[a-z][a-z0-9]*)+$/;
+function isValidNuvioId(id) {
+  return NUVIO_ID_PATTERN.test(id);
+}
+var NATIVE_TAG_SEGMENT = {
+  h1: "title",
+  h2: "title",
+  h3: "title",
+  h4: "title",
+  h5: "title",
+  h6: "title",
+  p: "text",
+  span: "label",
+  button: "button",
+  a: "link",
+  label: "label",
+  td: "cell",
+  th: "header",
+  li: "item",
+  img: "image",
+  input: "input",
+  div: "block",
+  section: "section",
+  article: "article",
+  header: "header",
+  footer: "footer",
+  nav: "nav",
+  main: "main"
+};
+function uniqueId(base, existing) {
+  if (!existing.has(base)) {
+    return base;
+  }
+  for (let i = 2; i < 100; i++) {
+    const candidate = `${base}${i}`;
+    if (!existing.has(candidate)) {
+      return candidate;
+    }
+  }
+  return `${base}.copy`;
+}
+function suggestNuvioId(options) {
+  const tag = options.tagName;
+  const librarySegment = options.libraryHint ? librarySegmentForTag(tag, options.libraryHint) : void 0;
+  const nativeSegment = NATIVE_TAG_SEGMENT[tag.toLowerCase()];
+  const segment = librarySegment ?? nativeSegment ?? "element";
+  const prefix = options.parentPrefix?.trim();
+  const base = prefix ? `${prefix}.${segment}` : `page.${segment}`;
+  return uniqueId(base, options.existingIds);
+}
 export {
+  BRAND_ACCENT_COLORS,
+  BRAND_ACCENT_SLOT_BY_ACTION,
+  BRAND_APPLY_ACTIONS,
+  BRAND_BUTTON_HOVERS,
+  BRAND_BUTTON_HOVER_FIELD_LABEL,
+  BRAND_BUTTON_VARIANTS,
+  BRAND_BUTTON_VARIANT_FIELD_LABEL,
+  BRAND_CARD_HOVERS,
+  BRAND_CARD_HOVER_FIELD_LABEL,
+  BRAND_CARD_SHADOWS,
+  BRAND_CARD_SHADOW_FIELD_LABEL,
+  BRAND_COLORS,
+  BRAND_DENSITY,
+  BRAND_DENSITY_FIELD_LABEL,
+  BRAND_PAGE_DISCOVERY_PLURALS,
+  BRAND_PRESET_DIMENSIONS_BY_ACTION,
+  BRAND_RADIUS,
+  BRAND_RADIUS_FIELD_LABEL,
+  BRAND_SURFACES,
+  BRAND_SURFACE_FIELD_LABEL,
+  BRAND_TYPOGRAPHY,
+  DEFAULT_BRAND_CONFIG,
+  LIBRARY_IDS,
+  NUVIO_BRAND_PATH,
+  NUVIO_ID_PATTERN,
+  NUVIO_PCC_PATH,
   NUVIO_WS_PATH,
+  PCC_BRANDABLE_CATEGORIES,
+  PCC_REJECTED_CATEGORIES,
+  PCC_SUPPORTED_CATEGORIES,
   PROTOCOL_VERSION,
+  brandColorsForAction,
+  brandConfigSchema,
+  brandConfigsEqual,
+  brandFragmentHostHint,
+  brandPresetDimensionsForAction,
   breakpointSchema,
+  buildBrandBulkPatchOps,
+  buildBrandBulkPreviewSummary,
+  buildBrandBulkTargetOps,
+  buildBrandClassFragment,
+  buildBrandPageDiscoveryLine,
+  buildBrandPatchOps,
+  buildBrandPreviewSummary,
+  buildBrandValidateSummary,
+  classNameModeSchema,
   clientMessageSchema,
   clientPatchApplySchema,
   clientPatchUndoSchema,
   clientPingSchema,
   clientSelectSchema,
+  clientTagElementSchema,
+  defaultPccManifestPath,
+  detectShadcnComponentMode,
   duplicateIdErrorSchema,
   duplicateIdOccurrenceSchema,
+  entryMatchesBrandBulkAction,
+  evaluateBrandPageScan,
+  evaluatePageCoverage,
+  filterBrandBulkCandidates,
+  formatLibraryList,
+  getBrandButtonHoverLabel,
+  getBrandButtonVariantLabel,
+  getBrandCardHoverLabel,
+  getBrandCardShadowLabel,
+  getBrandColorLabel,
+  getBrandColorSlotLabel,
+  getBrandDensityLabel,
+  getBrandRadiusLabel,
+  getBrandSurfaceLabel,
+  getBrandTypographyFieldLabel,
+  getBrandTypographyLabel,
   hierarchyRoleSchema,
   indexEntrySchema,
+  inferBrandPresetsFromClassName,
+  inferBrandPresetsFromTokens,
+  inferLibraryFromFilePath,
+  inspectBrandMatch,
+  inspectBrandMatchForAction,
+  isBrandAccentColor,
+  isBrandableEntry,
+  isHostPatchable,
+  isNonBrandableNavEntry,
+  isPccBrandableCategory,
+  isPccRejectedCategory,
+  isPccSupportedCategory,
+  isShadcnCompoundTag,
+  isValidNuvioId,
+  libraryGuidanceForEntry,
+  libraryIdSchema,
+  librarySegmentForTag,
+  normalizeAppRoute,
+  normalizeBrandConfig,
   parseClientMessage,
+  parsePccManifest,
   parseServerMessage,
   patchOpDuplicateHostSchema,
   patchOpMergeTailwindSchema,
@@ -312,9 +2113,18 @@ export {
   patchOpSetHiddenSchema,
   patchOpSetTableDataFieldSchema,
   patchOpSetTextSchema,
+  pccBrandableHostIds,
+  pccCategoryLabel,
+  pccHostsForBrandAction,
+  pccHostsForCategory,
+  pccManifestMatchesRoute,
+  resolveBrandBulkPatchHostId,
+  resolveBrandCategoryForEntry,
+  resolveEntryLibraryHint,
   riskLevelSchema,
   rowTargetSchema,
   runtimeDiagnosticsSchema,
+  serializeBrandConfig,
   serializeServerMessage,
   serverErrorSchema,
   serverIndexReadySchema,
@@ -323,7 +2133,9 @@ export {
   serverPatchUndoAckSchema,
   serverPongSchema,
   serverSelectAckSchema,
+  serverTagElementAckSchema,
   styleTargetSchema,
+  suggestNuvioId,
   tableDataFieldSchema,
   tableMetaSchema,
   textTargetSchema