@tangle-network/agent-app 0.25.0 → 0.27.2

package/dist/{DesignCanvas-MA5EH324.js → DesignCanvas-73IUJJUP.js}

@@ -1,10 +1,10 @@
 import {
   DesignCanvas,
   DesignCanvas_default
-} from "./chunk-LPAVBGVY.js";
+} from "./chunk-27LQXQSS.js";
 import "./chunk-JZAJE3JL.js";
 export {
   DesignCanvas,
   DesignCanvas_default as default
 };
-//# sourceMappingURL=DesignCanvas-MA5EH324.js.map
+//# sourceMappingURL=DesignCanvas-73IUJJUP.js.map

package/dist/DesignCanvasEditor-6F2UTOSW.js

@@ -0,0 +1,9 @@
+import {
+  DesignCanvasEditor
+} from "./chunk-HABVCJJT.js";
+import "./chunk-27LQXQSS.js";
+import "./chunk-JZAJE3JL.js";
+export {
+  DesignCanvasEditor
+};
+//# sourceMappingURL=DesignCanvasEditor-6F2UTOSW.js.map

package/dist/brand-extraction/index.d.ts

@@ -0,0 +1,212 @@
+/**
+ * Typed contract for a brand kit extracted from a website (+ optional shared
+ * source files). The extractor degrades gracefully: every field is best-effort,
+ * absence is represented explicitly (empty arrays, undefined), never faked.
+ *
+ * A consuming product (gtm, creative) maps this onto its own durable brand
+ * store — see the gtm `WorkspaceBrand`. This module owns only extraction; it
+ * does NOT persist, render, or judge confidence.
+ */
+/** A logo / brand-mark candidate discovered on a page. */
+interface BrandLogoCandidate {
+    /** Absolute URL to the asset. */
+    url: string;
+    /** Where it came from — drives ranking and lets callers cite provenance. */
+    source: 'favicon' | 'apple-touch-icon' | 'og:image' | 'img-logo' | 'svg-inline' | 'manifest';
+    /** Higher = more likely the canonical logo. 0..1. */
+    confidence: number;
+    /** Declared width in px when known (from <link sizes> or <img width>). */
+    width?: number;
+    /** Declared height in px when known. */
+    height?: number;
+    /** MIME type when inferable from the extension. */
+    mimeType?: string;
+    /** alt / title text when present — a "logo" alt is a strong signal. */
+    alt?: string;
+}
+/** A color extracted from the page, with where it was seen. */
+interface BrandColor {
+    /** Normalized 6- or 8-digit `#rrggbb` / `#rrggbbaa` hex (lowercase). */
+    hex: string;
+    /** How many distinct declarations referenced this color (popularity proxy). */
+    occurrences: number;
+    /** True when sourced from a `:root` CSS custom property (highest fidelity). */
+    fromToken: boolean;
+    /** The custom-property name when fromToken (e.g. `--accent`). */
+    tokenName?: string;
+}
+/** A font-family discovered in CSS, with role inference. */
+interface BrandFont {
+    /** Primary family name, unquoted (e.g. `Inter`, `Playfair Display`). */
+    family: string;
+    /** The full declared stack as written, in order. */
+    stack: string[];
+    /** Inferred role from the selector the declaration was attached to. */
+    role: 'display' | 'body' | 'unknown';
+    /** Declaration count — popularity proxy for picking the dominant family. */
+    occurrences: number;
+}
+/** A prominent product / hero image candidate (not a logo). */
+interface BrandImage {
+    url: string;
+    source: 'og:image' | 'twitter:image' | 'img-hero' | 'img-content';
+    /** alt text when present. */
+    alt?: string;
+    width?: number;
+    height?: number;
+}
+/**
+ * The full extracted kit. The shape every consumer reads. Each list is ranked
+ * best-first; empty lists mean "found nothing", never a fabricated default.
+ */
+interface BrandKit {
+    /** The site the kit was extracted from (normalized, absolute). */
+    sourceUrl: string;
+    /** Best-guess brand / product name from <title>, og:site_name, manifest. */
+    name?: string;
+    /** Tagline / description from meta description or og:description. */
+    description?: string;
+    /** Logo candidates, ranked best-first. */
+    logos: BrandLogoCandidate[];
+    /** Colors, ranked by token-first then popularity. */
+    palette: BrandColor[];
+    /** Fonts, ranked display-then-body then popularity. */
+    fonts: BrandFont[];
+    /** Prominent images (hero / og), ranked best-first. */
+    images: BrandImage[];
+    /** Absolute URLs / labels the kit was derived from — for provenance. */
+    extractedFrom: string[];
+}
+/**
+ * Typed outcome. Callers MUST inspect `succeeded` before reading `kit`.
+ * No silent empties: a fetch failure is `succeeded:false` with a real error,
+ * NOT an empty BrandKit that downstream code mistakes for "this brand has
+ * nothing".
+ */
+type BrandExtractionResult = {
+    succeeded: true;
+    kit: BrandKit;
+    warnings: string[];
+} | {
+    succeeded: false;
+    error: string;
+    stage: 'fetch' | 'parse' | 'input';
+};
+/** Fetch boundary, injectable so callers (Workers, Node, tests) supply their
+ *  own fetch and so tests can run fully offline against fixture HTML. */
+type FetchLike = (url: string, init?: {
+    signal?: AbortSignal;
+    headers?: Record<string, string>;
+}) => Promise<{
+    ok: boolean;
+    status: number;
+    text(): Promise<string>;
+    headers?: {
+        get(name: string): string | null;
+    };
+}>;
+interface ExtractBrandKitOptions {
+    /** Raw HTML for the page. When supplied, no network fetch happens — used by
+     *  tests and by callers that already hold the HTML. */
+    html?: string;
+    /** Fetch implementation. Required when `html` is omitted. */
+    fetchImpl?: FetchLike;
+    /** Per-request timeout in ms (default 15000). Applied to the page fetch. */
+    timeoutMs?: number;
+    /** Cap on each ranked list (default 12). Keeps payloads bounded. */
+    maxPerList?: number;
+}
+
+/**
+ * Brand-kit extraction engine.
+ *
+ * Given a website URL (or raw HTML), parse the page and pull a typed BrandKit:
+ * logo candidates, color palette, fonts, and prominent images. Parsing is
+ * regex-based on purpose — this runs on Cloudflare Workers and other edge
+ * runtimes where DOM libraries (jsdom/cheerio) are unavailable, and the page
+ * structures we read (link tags, meta tags, CSS custom properties, font-family
+ * declarations) are flat enough that a DOM buys nothing.
+ *
+ * Degrades gracefully: a missing favicon, no CSS tokens, or an image-only page
+ * each narrow the kit rather than failing it. The ONLY hard failures are a bad
+ * input (no html and no fetch) and a fetch error — both returned as a typed
+ * `{ succeeded: false }` outcome so callers never mistake an empty kit for a
+ * real one.
+ */
+
+/** Normalize a user-supplied site URL: add https:// when scheme-less, validate. */
+declare function normalizeSiteUrl(raw: string): string | null;
+/** Normalize any CSS color literal to #rrggbb / #rrggbbaa hex, or null. */
+declare function normalizeColor(raw: string): string | null;
+/** Parse already-fetched HTML into a BrandKit. Pure — no network. Exposed so
+ *  callers that hold the HTML (or want to combine multiple pages) can reuse the
+ *  parsing without re-fetching. */
+declare function parseBrandKit(html: string, sourceUrl: string, maxPerList?: number): BrandKit;
+/**
+ * Fetch a website (or use supplied HTML) and extract its BrandKit.
+ *
+ * Returns a typed outcome — callers MUST check `succeeded`. A fetch failure or
+ * empty input is a real, surfaced error, never an empty kit masquerading as a
+ * result. Parsing itself never throws: a malformed page yields a sparse kit
+ * with warnings, which is information, not failure.
+ */
+declare function extractBrandKit(url: string, options?: ExtractBrandKitOptions): Promise<BrandExtractionResult>;
+
+/**
+ * Pure mapping helpers from an extracted BrandKit onto consumable shapes.
+ *
+ * Extraction yields ranked candidate lists; products need decided roles
+ * (background vs accent, display vs body). These helpers make the obvious,
+ * defensible default choice and expose the reasoning so a confirmation UI can
+ * show "we picked X — change it?". They NEVER invent a value: when a role can't
+ * be filled from the kit, it is omitted, and the caller decides the fallback.
+ */
+
+/** Relative luminance (0..1) of an #rrggbb(aa) hex — for light/dark sorting. */
+declare function luminance(hex: string): number;
+interface DecidedPalette {
+    /** Lightest neutral — page background. */
+    background?: string;
+    /** A raised neutral one step from background. */
+    surface?: string;
+    /** Darkest readable color — primary text. */
+    textPrimary?: string;
+    /** Mid-tone neutral — secondary text. */
+    textSecondary?: string;
+    /** Most saturated / popular brand color — accent. */
+    accent?: string;
+    /** Readable text color to sit on the accent (black or white by contrast). */
+    accentText?: string;
+}
+/**
+ * Assign palette roles from the ranked colors. Heuristic, not authoritative —
+ * a confirmation step should let the user correct it. Roles only appear when
+ * the kit actually contained a color that fits.
+ */
+declare function decidePalette(palette: BrandColor[]): DecidedPalette;
+interface DecidedFonts {
+    display?: BrandFont;
+    body?: BrandFont;
+}
+/** Pick a display and body font from the ranked list. When only one usable
+ *  font exists it fills both roles — a single-typeface brand is valid. */
+declare function decideFonts(fonts: BrandFont[]): DecidedFonts;
+/** Everything a confirmation step needs from a kit, with roles decided. */
+interface DecidedBrandKit {
+    name?: string;
+    description?: string;
+    sourceUrl: string;
+    palette: DecidedPalette;
+    fonts: DecidedFonts;
+    /** Best logo URL, when any candidate was found. */
+    primaryLogoUrl?: string;
+    /** All logo URLs, ranked. */
+    logoUrls: string[];
+    /** Prominent image URLs, ranked. */
+    imageUrls: string[];
+    extractedFrom: string[];
+}
+/** Collapse a raw BrandKit into decided roles — the shape a product persists. */
+declare function decideBrandKit(kit: BrandKit): DecidedBrandKit;
+
+export { type BrandColor, type BrandExtractionResult, type BrandFont, type BrandImage, type BrandKit, type BrandLogoCandidate, type DecidedBrandKit, type DecidedFonts, type DecidedPalette, type ExtractBrandKitOptions, type FetchLike, decideBrandKit, decideFonts, decidePalette, extractBrandKit, luminance, normalizeColor, normalizeSiteUrl, parseBrandKit };

package/dist/brand-extraction/index.js

@@ -0,0 +1,446 @@
+// src/brand-extraction/extract.ts
+var DEFAULT_TIMEOUT_MS = 15e3;
+var DEFAULT_MAX_PER_LIST = 12;
+function normalizeSiteUrl(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed) return null;
+  if (/^[a-z][a-z0-9+.-]*:/i.test(trimmed) && !/^https?:\/\//i.test(trimmed)) return null;
+  const withScheme = /^https?:\/\//i.test(trimmed) ? trimmed : `https://${trimmed}`;
+  try {
+    const u = new URL(withScheme);
+    if (u.protocol !== "http:" && u.protocol !== "https:") return null;
+    return u.toString();
+  } catch {
+    return null;
+  }
+}
+function absolutize(href, base) {
+  const v = href.trim();
+  if (!v || v.startsWith("data:") || v.startsWith("javascript:")) return null;
+  try {
+    const u = new URL(v, base);
+    if (u.protocol !== "http:" && u.protocol !== "https:") return null;
+    return u.toString();
+  } catch {
+    return null;
+  }
+}
+function matchTags(html, tag) {
+  const re = new RegExp(`<${tag}\\b[^>]*>`, "gi");
+  return html.match(re) ?? [];
+}
+function attr(tag, name) {
+  const quoted = new RegExp(`\\b${name}\\s*=\\s*["']([^"']*)["']`, "i").exec(tag);
+  if (quoted) return decodeEntities(quoted[1] ?? "");
+  const bare = new RegExp(`\\b${name}\\s*=\\s*([^\\s"'>]+)`, "i").exec(tag);
+  return bare ? decodeEntities(bare[1] ?? "") : void 0;
+}
+function decodeEntities(s) {
+  return s.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&#x2F;/gi, "/");
+}
+function extractName(html) {
+  for (const tag of matchTags(html, "meta")) {
+    const prop = (attr(tag, "property") ?? attr(tag, "name"))?.toLowerCase();
+    if (prop === "og:site_name") {
+      const c = attr(tag, "content")?.trim();
+      if (c) return c;
+    }
+  }
+  const title = /<title[^>]*>([\s\S]*?)<\/title>/i.exec(html)?.[1];
+  if (title) {
+    const head = (decodeEntities(title).split(/\s+[|–—\-:·]\s+/)[0] ?? "").trim();
+    if (head) return head;
+  }
+  return void 0;
+}
+function extractDescription(html) {
+  for (const tag of matchTags(html, "meta")) {
+    const prop = (attr(tag, "property") ?? attr(tag, "name"))?.toLowerCase();
+    if (prop === "description" || prop === "og:description") {
+      const c = attr(tag, "content")?.trim();
+      if (c) return c;
+    }
+  }
+  return void 0;
+}
+var MIME_BY_EXT = {
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  webp: "image/webp",
+  svg: "image/svg+xml",
+  ico: "image/x-icon"
+};
+function mimeFromUrl(url) {
+  const ext = new URL(url).pathname.split(".").pop()?.toLowerCase();
+  return ext ? MIME_BY_EXT[ext] : void 0;
+}
+function parseSizes(sizes) {
+  if (!sizes) return {};
+  const m = /(\d+)\s*[x×]\s*(\d+)/i.exec(sizes);
+  if (!m) return {};
+  return { width: Number(m[1]), height: Number(m[2]) };
+}
+function extractLogos(html, base) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const push = (c) => {
+    if (seen.has(c.url)) return;
+    seen.add(c.url);
+    out.push(c);
+  };
+  for (const tag of matchTags(html, "link")) {
+    const rel = attr(tag, "rel")?.toLowerCase() ?? "";
+    const href = attr(tag, "href");
+    if (!href) continue;
+    const url = absolutize(href, base);
+    if (!url) continue;
+    const { width, height } = parseSizes(attr(tag, "sizes"));
+    if (rel.includes("apple-touch-icon")) {
+      push({ url, source: "apple-touch-icon", confidence: 0.7, width, height, mimeType: mimeFromUrl(url) });
+    } else if (rel.split(/\s+/).includes("icon") || rel.includes("shortcut icon")) {
+      push({ url, source: "favicon", confidence: 0.5, width, height, mimeType: mimeFromUrl(url) });
+    }
+  }
+  for (const tag of matchTags(html, "meta")) {
+    const prop = (attr(tag, "property") ?? attr(tag, "name"))?.toLowerCase();
+    if (prop === "og:image" || prop === "og:image:url") {
+      const href = attr(tag, "content");
+      const url = href ? absolutize(href, base) : null;
+      if (url) push({ url, source: "og:image", confidence: 0.55, mimeType: mimeFromUrl(url) });
+    }
+  }
+  for (const tag of matchTags(html, "img")) {
+    const src = attr(tag, "src") ?? attr(tag, "data-src");
+    if (!src) continue;
+    const alt = attr(tag, "alt");
+    const cls = attr(tag, "class") ?? "";
+    const id = attr(tag, "id") ?? "";
+    const looksLikeLogo = /logo|brand|wordmark/i.test(`${src} ${alt ?? ""} ${cls} ${id}`);
+    if (!looksLikeLogo) continue;
+    const url = absolutize(src, base);
+    if (!url) continue;
+    const w = attr(tag, "width");
+    const h = attr(tag, "height");
+    push({
+      url,
+      source: "img-logo",
+      confidence: 0.85,
+      alt,
+      width: w ? Number(w) || void 0 : void 0,
+      height: h ? Number(h) || void 0 : void 0,
+      mimeType: mimeFromUrl(url)
+    });
+  }
+  if (!out.some((l) => l.source === "favicon" || l.source === "apple-touch-icon")) {
+    const fav = absolutize("/favicon.ico", base);
+    if (fav) push({ url: fav, source: "favicon", confidence: 0.3, mimeType: "image/x-icon" });
+  }
+  return out.sort((a, b) => b.confidence - a.confidence);
+}
+function normalizeColor(raw) {
+  const v = raw.trim().toLowerCase();
+  const hex = /^#([0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})$/i.exec(v);
+  if (hex) {
+    const h = hex[1] ?? "";
+    if (h.length === 3 || h.length === 4) {
+      return `#${h.split("").map((c) => c + c).join("")}`;
+    }
+    return `#${h}`;
+  }
+  const rgb = /^rgba?\(\s*([\d.]+)[\s,]+([\d.]+)[\s,]+([\d.]+)(?:[\s,/]+([\d.%]+))?\s*\)$/.exec(v);
+  if (rgb) {
+    const to255 = (n) => Math.max(0, Math.min(255, Math.round(Number(n))));
+    const r = to255(rgb[1]).toString(16).padStart(2, "0");
+    const g = to255(rgb[2]).toString(16).padStart(2, "0");
+    const b = to255(rgb[3]).toString(16).padStart(2, "0");
+    let a = "";
+    if (rgb[4] !== void 0) {
+      const av = rgb[4].endsWith("%") ? Number(rgb[4].slice(0, -1)) / 100 : Number(rgb[4]);
+      const ai = Math.max(0, Math.min(255, Math.round(av * 255)));
+      if (ai < 255) a = ai.toString(16).padStart(2, "0");
+    }
+    return `#${r}${g}${b}${a}`;
+  }
+  return null;
+}
+var COLOR_LITERAL_RE = /#[0-9a-fA-F]{3,8}\b|rgba?\([^)]*\)/g;
+var ROOT_VAR_RE = /(--[a-z0-9-]*(?:color|colour|bg|background|accent|brand|primary|secondary|surface|text|fg|ink)[a-z0-9-]*)\s*:\s*([^;}{]+)/gi;
+function extractPalette(html) {
+  const byHex = /* @__PURE__ */ new Map();
+  const bump = (hex, fromToken, tokenName) => {
+    const existing = byHex.get(hex);
+    if (existing) {
+      existing.occurrences += 1;
+      if (fromToken && !existing.fromToken) {
+        existing.fromToken = true;
+        existing.tokenName = tokenName;
+      }
+    } else {
+      byHex.set(hex, { hex, occurrences: 1, fromToken, ...tokenName ? { tokenName } : {} });
+    }
+  };
+  for (const m of html.matchAll(ROOT_VAR_RE)) {
+    const tokenName = m[1];
+    const value = m[2];
+    if (!value) continue;
+    const lit = value.match(COLOR_LITERAL_RE)?.[0];
+    if (!lit) continue;
+    const hex = normalizeColor(lit);
+    if (hex) bump(hex, true, tokenName);
+  }
+  for (const m of html.matchAll(COLOR_LITERAL_RE)) {
+    const hex = normalizeColor(m[0]);
+    if (hex) bump(hex, false);
+  }
+  const isNeutral = (h) => /^#(0{6}|f{6})(ff)?$/i.test(h);
+  return [...byHex.values()].sort((a, b) => {
+    if (a.fromToken !== b.fromToken) return a.fromToken ? -1 : 1;
+    const an = isNeutral(a.hex) ? 1 : 0;
+    const bn = isNeutral(b.hex) ? 1 : 0;
+    if (an !== bn) return an - bn;
+    return b.occurrences - a.occurrences;
+  });
+}
+var GENERIC_FAMILIES = /* @__PURE__ */ new Set([
+  "serif",
+  "sans-serif",
+  "monospace",
+  "cursive",
+  "fantasy",
+  "system-ui",
+  "ui-sans-serif",
+  "ui-serif",
+  "ui-monospace",
+  "ui-rounded",
+  "inherit",
+  "initial",
+  "unset"
+]);
+var FONT_DECL_RE = /([^{}]*)\{[^{}]*font-family\s*:\s*([^;}{]+)[;}]/gi;
+function parseFontStack(raw) {
+  if (!raw) return [];
+  return raw.split(",").map((s) => s.trim().replace(/^["']|["']$/g, "")).filter(Boolean);
+}
+function roleFromSelector(selector) {
+  const s = selector.toLowerCase();
+  if (/\b(h[1-3]|\.h[1-3]|heading|title|display|hero)\b/.test(s)) return "display";
+  if (/\b(body|p|html|\.text|\.content|root|:root|\*)\b/.test(s)) return "body";
+  return "unknown";
+}
+function extractFonts(html) {
+  const byFamily = /* @__PURE__ */ new Map();
+  const consider = (family, stack, role) => {
+    const key = family.toLowerCase();
+    if (!family || GENERIC_FAMILIES.has(key)) return;
+    const existing = byFamily.get(key);
+    if (existing) {
+      existing.occurrences += 1;
+      if (existing.role === "unknown" && role !== "unknown") existing.role = role;
+    } else {
+      byFamily.set(key, { family, stack, role, occurrences: 1 });
+    }
+  };
+  for (const m of html.matchAll(FONT_DECL_RE)) {
+    const selector = m[1] ?? "";
+    const stack = parseFontStack(m[2]);
+    const primary = stack[0];
+    if (!primary) continue;
+    consider(primary, stack, roleFromSelector(selector));
+  }
+  const BARE_RE = /font-family\s*:\s*([^;"'}{]+)/gi;
+  for (const m of html.matchAll(BARE_RE)) {
+    const stack = parseFontStack(m[1]);
+    const primary = stack[0];
+    if (!primary) continue;
+    consider(primary, stack, "unknown");
+  }
+  for (const tag of matchTags(html, "link")) {
+    const href = attr(tag, "href") ?? "";
+    if (!/fonts\.googleapis\.com/i.test(href)) continue;
+    for (const fam of href.matchAll(/family=([^:&]+)/gi)) {
+      const captured = fam[1];
+      if (!captured) continue;
+      const family = decodeURIComponent(captured.replace(/\+/g, " ")).trim();
+      consider(family, [family], "display");
+    }
+  }
+  return [...byFamily.values()].sort((a, b) => {
+    const rank = (r) => r === "display" ? 0 : r === "body" ? 1 : 2;
+    const rr = rank(a.role) - rank(b.role);
+    if (rr !== 0) return rr;
+    return b.occurrences - a.occurrences;
+  });
+}
+function extractImages(html, base) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const push = (img) => {
+    if (seen.has(img.url)) return;
+    seen.add(img.url);
+    out.push(img);
+  };
+  for (const tag of matchTags(html, "meta")) {
+    const prop = (attr(tag, "property") ?? attr(tag, "name"))?.toLowerCase();
+    const href = attr(tag, "content");
+    const url = href ? absolutize(href, base) : null;
+    if (!url) continue;
+    if (prop === "og:image" || prop === "og:image:url") push({ url, source: "og:image" });
+    else if (prop === "twitter:image" || prop === "twitter:image:src") push({ url, source: "twitter:image" });
+  }
+  for (const tag of matchTags(html, "img")) {
+    const src = attr(tag, "src") ?? attr(tag, "data-src");
+    if (!src) continue;
+    const url = absolutize(src, base);
+    if (!url) continue;
+    const cls = `${attr(tag, "class") ?? ""} ${attr(tag, "id") ?? ""}`;
+    if (/logo|icon|favicon|wordmark/i.test(`${url} ${cls}`)) continue;
+    const isHero = /hero|banner|cover|feature|splash/i.test(cls);
+    const w = attr(tag, "width");
+    const h = attr(tag, "height");
+    push({
+      url,
+      source: isHero ? "img-hero" : "img-content",
+      alt: attr(tag, "alt"),
+      width: w ? Number(w) || void 0 : void 0,
+      height: h ? Number(h) || void 0 : void 0
+    });
+  }
+  const rank = (s) => s === "og:image" ? 0 : s === "twitter:image" ? 1 : s === "img-hero" ? 2 : 3;
+  return out.sort((a, b) => rank(a.source) - rank(b.source));
+}
+function parseBrandKit(html, sourceUrl, maxPerList = DEFAULT_MAX_PER_LIST) {
+  const logos = extractLogos(html, sourceUrl).slice(0, maxPerList);
+  const palette = extractPalette(html).slice(0, maxPerList);
+  const fonts = extractFonts(html).slice(0, maxPerList);
+  const images = extractImages(html, sourceUrl).slice(0, maxPerList);
+  const name = extractName(html);
+  const description = extractDescription(html);
+  return {
+    sourceUrl,
+    ...name ? { name } : {},
+    ...description ? { description } : {},
+    logos,
+    palette,
+    fonts,
+    images,
+    extractedFrom: [sourceUrl]
+  };
+}
+async function extractBrandKit(url, options = {}) {
+  const { html: providedHtml, fetchImpl, timeoutMs = DEFAULT_TIMEOUT_MS, maxPerList = DEFAULT_MAX_PER_LIST } = options;
+  const warnings = [];
+  const sourceUrl = normalizeSiteUrl(url);
+  if (!sourceUrl) {
+    return { succeeded: false, error: `Not a valid http(s) URL: ${JSON.stringify(url)}`, stage: "input" };
+  }
+  let html = providedHtml;
+  if (html === void 0) {
+    const doFetch = fetchImpl ?? (typeof globalThis.fetch === "function" ? (u, init) => globalThis.fetch(u, init) : void 0);
+    if (!doFetch) {
+      return { succeeded: false, error: "No html provided and no fetch implementation available", stage: "input" };
+    }
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      const res = await doFetch(sourceUrl, {
+        signal: controller.signal,
+        headers: { "user-agent": "TangleBrandExtractor/1.0 (+https://tangle.tools)" }
+      });
+      if (!res.ok) {
+        return { succeeded: false, error: `Fetch failed: HTTP ${res.status} for ${sourceUrl}`, stage: "fetch" };
+      }
+      html = await res.text();
+    } catch (err) {
+      const reason = err instanceof Error ? err.message : String(err);
+      return { succeeded: false, error: `Fetch error for ${sourceUrl}: ${reason}`, stage: "fetch" };
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  if (!html.trim()) {
+    return { succeeded: false, error: `Empty document for ${sourceUrl}`, stage: "parse" };
+  }
+  const kit = parseBrandKit(html, sourceUrl, maxPerList);
+  if (kit.logos.length === 0) warnings.push("No logo candidates found.");
+  if (kit.palette.length === 0) warnings.push("No colors extracted \u2014 page has no inline CSS or design tokens.");
+  if (kit.fonts.length === 0) warnings.push("No custom fonts found \u2014 site likely uses system defaults.");
+  if (kit.images.length === 0) warnings.push("No prominent images found.");
+  return { succeeded: true, kit, warnings };
+}
+
+// src/brand-extraction/map.ts
+function luminance(hex) {
+  const h = hex.replace("#", "").slice(0, 6);
+  const r = parseInt(h.slice(0, 2), 16) / 255;
+  const g = parseInt(h.slice(2, 4), 16) / 255;
+  const b = parseInt(h.slice(4, 6), 16) / 255;
+  const lin = (c) => c <= 0.03928 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4;
+  return 0.2126 * lin(r) + 0.7152 * lin(g) + 0.0722 * lin(b);
+}
+function isGreyish(hex) {
+  const h = hex.replace("#", "").slice(0, 6);
+  const r = parseInt(h.slice(0, 2), 16);
+  const g = parseInt(h.slice(2, 4), 16);
+  const b = parseInt(h.slice(4, 6), 16);
+  const max = Math.max(r, g, b);
+  const min = Math.min(r, g, b);
+  return max - min < 18;
+}
+function decidePalette(palette) {
+  if (palette.length === 0) return {};
+  const hexes = palette.map((c) => c.hex);
+  const greys = hexes.filter(isGreyish).sort((a, b) => luminance(b) - luminance(a));
+  const colored = hexes.filter((h) => !isGreyish(h));
+  const accent = colored[0];
+  const sortedLight = [...hexes].sort((a, b) => luminance(b) - luminance(a));
+  const background = greys[0] ?? sortedLight[0];
+  const surface = greys[1] ?? sortedLight.find((h) => h !== background);
+  const textPrimary = [...hexes].sort((a, b) => luminance(a) - luminance(b))[0];
+  const textSecondary = greys.find((h) => h !== background && h !== surface && h !== textPrimary);
+  const result = {};
+  if (background) result.background = background;
+  if (surface) result.surface = surface;
+  if (textPrimary) result.textPrimary = textPrimary;
+  if (textSecondary) result.textSecondary = textSecondary;
+  if (accent) {
+    result.accent = accent;
+    result.accentText = luminance(accent) > 0.45 ? "#000000" : "#ffffff";
+  }
+  return result;
+}
+function decideFonts(fonts) {
+  if (fonts.length === 0) return {};
+  const display = fonts.find((f) => f.role === "display") ?? fonts[0];
+  const body = fonts.find((f) => f.role === "body") ?? fonts.find((f) => f !== display) ?? display;
+  return { display, body };
+}
+function decideBrandKit(kit) {
+  const palette = decidePalette(kit.palette);
+  const fonts = decideFonts(kit.fonts);
+  const logoUrls = kit.logos.map((l) => l.url);
+  const result = {
+    sourceUrl: kit.sourceUrl,
+    palette,
+    fonts,
+    logoUrls,
+    imageUrls: kit.images.map((i) => i.url),
+    extractedFrom: kit.extractedFrom
+  };
+  if (kit.name) result.name = kit.name;
+  if (kit.description) result.description = kit.description;
+  if (logoUrls[0]) result.primaryLogoUrl = logoUrls[0];
+  return result;
+}
+export {
+  decideBrandKit,
+  decideFonts,
+  decidePalette,
+  extractBrandKit,
+  luminance,
+  normalizeColor,
+  normalizeSiteUrl,
+  parseBrandKit
+};
+//# sourceMappingURL=index.js.map