@aglyn/plugins-ai 1.0.0-beta.143

package/src/lib/jobs/ai-product-image.js

@@ -0,0 +1,113 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ import { aiMediaAssetLocation, loadAiMediaSharp, readAiMediaAssetBytes } from "./ai-media-asset.js";
+/**
+ * A PRODUCT'S PHOTO, as a `products` job shows it to the model (AGL-2916).
+ *
+ * Exactly one picture is read for a product: its FIRST media item, the photo
+ * the storefront leads with. Nothing else of the media library is read or
+ * sent — no other photo of the product, no other asset, no folder, no file
+ * name and no alt text.
+ *
+ * The photo is read the way the media CDN would serve it
+ * (`readAiMediaAssetBytes`): only an asset of this site's own library or its
+ * org's, live, not private, visible to the site, not locked or quarantined.
+ * A photo that is a link to somewhere else, or a raw storage URL, is not an
+ * asset of the library and is not read at all; nothing is ever fetched from a
+ * URL.
+ *
+ * What is sent is a new JPEG made from it: turned upright by its own
+ * orientation, shrunk to fit inside `AI_PRODUCT_IMAGE_MAX_EDGE_PX` on its
+ * longer edge (never enlarged), laid on white where it was transparent, and
+ * encoded at `AI_PRODUCT_IMAGE_JPEG_QUALITY`. Encoding a new image carries none
+ * of the original's metadata, so no camera, date or location embedded in the
+ * file leaves with it. An animated image sends its first frame.
+ */ /** The longer edge of the picture sent, in pixels. */ export const AI_PRODUCT_IMAGE_MAX_EDGE_PX = 768;
+/** The JPEG quality the picture is sent at. */ export const AI_PRODUCT_IMAGE_JPEG_QUALITY = 80;
+/** The largest original read, in bytes. */ export const AI_PRODUCT_IMAGE_MAX_SOURCE_BYTES = 15 * 1024 * 1024;
+/** The formats read; a vector drawing is not a product photo, and is not decoded. */ export const AI_PRODUCT_IMAGE_TYPES = /^image\/(png|jpeg|webp|gif|avif)$/;
+/**
+ * ASSUMED: how long the photo read takes — the media document, the CDN's
+ * block, the storage download and the resize — which a pass's least time
+ * counts (AGL-3035).
+ */ export const AI_PRODUCT_IMAGE_READ_MS = 6000;
+/** The JPEG the model is shown, made from the original's bytes. */ export async function encodeAiProductImage(bytes) {
+    const sharp = await loadAiMediaSharp();
+    return sharp(bytes, {
+        limitInputPixels: 64000000,
+        animated: false
+    }).rotate().resize({
+        width: AI_PRODUCT_IMAGE_MAX_EDGE_PX,
+        height: AI_PRODUCT_IMAGE_MAX_EDGE_PX,
+        fit: 'inside',
+        withoutEnlargement: true
+    })// White, as channels: a transparent product shot reads on a white page.
+    .flatten({
+        background: {
+            r: 255,
+            g: 255,
+            b: 255
+        }
+    }).jpeg({
+        quality: AI_PRODUCT_IMAGE_JPEG_QUALITY
+    }).toBuffer();
+}
+/**
+ * The product's first photo as a picture part, or what kept it from being
+ * one. Never throws: a photo that cannot be read leaves the copy to be written
+ * from the product's words, and says so.
+ */ export async function readAiProductImage(firestore, input, seams = {}) {
+    if (!input.value) return {
+        status: 'none'
+    };
+    const location = aiMediaAssetLocation(input.value, input.hostId, input.orgId);
+    if (!location) return {
+        status: 'not-in-library'
+    };
+    try {
+        var _seams_readBytes, _seams_encode;
+        const read = (_seams_readBytes = seams.readBytes) != null ? _seams_readBytes : (store, where, hostId)=>readAiMediaAssetBytes(store, where, hostId, {
+                maxBytes: AI_PRODUCT_IMAGE_MAX_SOURCE_BYTES,
+                types: AI_PRODUCT_IMAGE_TYPES
+            });
+        const asset = await read(firestore, location, input.hostId);
+        if (!asset) return {
+            status: 'unreadable'
+        };
+        const jpeg = await ((_seams_encode = seams.encode) != null ? _seams_encode : encodeAiProductImage)(asset.buffer);
+        if (!jpeg.length) return {
+            status: 'unreadable'
+        };
+        return {
+            status: 'read',
+            image: {
+                type: 'image',
+                mediaType: 'image/jpeg',
+                data: jpeg.toString('base64')
+            }
+        };
+    } catch (error) {
+        console.error('ai product image read failed', {
+            hostId: input.hostId,
+            error
+        });
+        return {
+            status: 'unreadable'
+        };
+    }
+}
+
+//# sourceMappingURL=ai-product-image.js.map

package/src/lib/jobs/ai-product-image.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../libs/plugins/ai/src/lib/jobs/ai-product-image.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2026 Aglyn LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport type { AiProductPhotoRead } from '../model/ai-products'\nimport type { AiImagePart } from '../providers/contract'\nimport {\n  aiMediaAssetLocation,\n  loadAiMediaSharp,\n  readAiMediaAssetBytes,\n  type AiMediaAssetBytes,\n  type AiMediaAssetLocation,\n} from './ai-media-asset'\n\n/**\n * A PRODUCT'S PHOTO, as a `products` job shows it to the model (AGL-2916).\n *\n * Exactly one picture is read for a product: its FIRST media item, the photo\n * the storefront leads with. Nothing else of the media library is read or\n * sent — no other photo of the product, no other asset, no folder, no file\n * name and no alt text.\n *\n * The photo is read the way the media CDN would serve it\n * (`readAiMediaAssetBytes`): only an asset of this site's own library or its\n * org's, live, not private, visible to the site, not locked or quarantined.\n * A photo that is a link to somewhere else, or a raw storage URL, is not an\n * asset of the library and is not read at all; nothing is ever fetched from a\n * URL.\n *\n * What is sent is a new JPEG made from it: turned upright by its own\n * orientation, shrunk to fit inside `AI_PRODUCT_IMAGE_MAX_EDGE_PX` on its\n * longer edge (never enlarged), laid on white where it was transparent, and\n * encoded at `AI_PRODUCT_IMAGE_JPEG_QUALITY`. Encoding a new image carries none\n * of the original's metadata, so no camera, date or location embedded in the\n * file leaves with it. An animated image sends its first frame.\n */\n\n/** The longer edge of the picture sent, in pixels. */\nexport const AI_PRODUCT_IMAGE_MAX_EDGE_PX = 768\n\n/** The JPEG quality the picture is sent at. */\nexport const AI_PRODUCT_IMAGE_JPEG_QUALITY = 80\n\n/** The largest original read, in bytes. */\nexport const AI_PRODUCT_IMAGE_MAX_SOURCE_BYTES = 15 * 1024 * 1024\n\n/** The formats read; a vector drawing is not a product photo, and is not decoded. */\nexport const AI_PRODUCT_IMAGE_TYPES = /^image\\/(png|jpeg|webp|gif|avif)$/\n\n/**\n * ASSUMED: how long the photo read takes — the media document, the CDN's\n * block, the storage download and the resize — which a pass's least time\n * counts (AGL-3035).\n */\nexport const AI_PRODUCT_IMAGE_READ_MS = 6_000\n\n/** The part of `sharp` the photo read uses. */\ninterface SharpJpegPipeline {\n  rotate(): SharpJpegPipeline\n  resize(options: { width: number; height: number; fit: 'inside'; withoutEnlargement: true }): SharpJpegPipeline\n  flatten(options: { background: { r: number; g: number; b: number } }): SharpJpegPipeline\n  jpeg(options: { quality: number }): SharpJpegPipeline\n  toBuffer(): Promise<Buffer>\n}\ntype SharpJpeg = (input: Buffer, options?: { limitInputPixels?: number; animated?: boolean }) => SharpJpegPipeline\n\n/** The reads that leave the process, replaceable where a spec needs to. */\nexport interface AiProductImageSeams {\n  readBytes?: (\n    firestore: FirebaseFirestore.Firestore,\n    location: AiMediaAssetLocation,\n    hostId: string,\n  ) => Promise<AiMediaAssetBytes | null>\n  encode?: (bytes: Buffer) => Promise<Buffer>\n}\n\nexport type AiProductImage =\n  | { status: 'read'; image: AiImagePart }\n  | { status: Exclude<AiProductPhotoRead, 'read' | 'model'> }\n\n/** The JPEG the model is shown, made from the original's bytes. */\nexport async function encodeAiProductImage(bytes: Buffer): Promise<Buffer> {\n  const sharp = (await loadAiMediaSharp()) as SharpJpeg\n  return sharp(bytes, { limitInputPixels: 64_000_000, animated: false })\n    .rotate()\n    .resize({\n      width: AI_PRODUCT_IMAGE_MAX_EDGE_PX,\n      height: AI_PRODUCT_IMAGE_MAX_EDGE_PX,\n      fit: 'inside',\n      withoutEnlargement: true,\n    })\n    // White, as channels: a transparent product shot reads on a white page.\n    .flatten({ background: { r: 255, g: 255, b: 255 } })\n    .jpeg({ quality: AI_PRODUCT_IMAGE_JPEG_QUALITY })\n    .toBuffer()\n}\n\n/**\n * The product's first photo as a picture part, or what kept it from being\n * one. Never throws: a photo that cannot be read leaves the copy to be written\n * from the product's words, and says so.\n */\nexport async function readAiProductImage(\n  firestore: FirebaseFirestore.Firestore,\n  input: { value: string | null | undefined; hostId: string; orgId: string },\n  seams: AiProductImageSeams = {},\n): Promise<AiProductImage> {\n  if (!input.value) return { status: 'none' }\n  const location = aiMediaAssetLocation(input.value, input.hostId, input.orgId)\n  if (!location) return { status: 'not-in-library' }\n  try {\n    const read =\n      seams.readBytes ??\n      ((store, where, hostId) =>\n        readAiMediaAssetBytes(store, where, hostId, {\n          maxBytes: AI_PRODUCT_IMAGE_MAX_SOURCE_BYTES,\n          types: AI_PRODUCT_IMAGE_TYPES,\n        }))\n    const asset = await read(firestore, location, input.hostId)\n    if (!asset) return { status: 'unreadable' }\n    const jpeg = await (seams.encode ?? encodeAiProductImage)(asset.buffer)\n    if (!jpeg.length) return { status: 'unreadable' }\n    return { status: 'read', image: { type: 'image', mediaType: 'image/jpeg', data: jpeg.toString('base64') } }\n  } catch (error) {\n    console.error('ai product image read failed', { hostId: input.hostId, error })\n    return { status: 'unreadable' }\n  }\n}\n"],"names":["aiMediaAssetLocation","loadAiMediaSharp","readAiMediaAssetBytes","AI_PRODUCT_IMAGE_MAX_EDGE_PX","AI_PRODUCT_IMAGE_JPEG_QUALITY","AI_PRODUCT_IMAGE_MAX_SOURCE_BYTES","AI_PRODUCT_IMAGE_TYPES","AI_PRODUCT_IMAGE_READ_MS","encodeAiProductImage","bytes","sharp","limitInputPixels","animated","rotate","resize","width","height","fit","withoutEnlargement","flatten","background","r","g","b","jpeg","quality","toBuffer","readAiProductImage","firestore","input","seams","value","status","location","hostId","orgId","read","readBytes","store","where","maxBytes","types","asset","encode","buffer","length","image","type","mediaType","data","toString","error","console"],"mappings":"AAAA;;;;;;;;;;;;;;;CAeC,GAID,SACEA,oBAAoB,EACpBC,gBAAgB,EAChBC,qBAAqB,QAGhB,sBAAkB;AAEzB;;;;;;;;;;;;;;;;;;;;;CAqBC,GAED,oDAAoD,GACpD,OAAO,MAAMC,+BAA+B,IAAG;AAE/C,6CAA6C,GAC7C,OAAO,MAAMC,gCAAgC,GAAE;AAE/C,yCAAyC,GACzC,OAAO,MAAMC,oCAAoC,KAAK,OAAO,KAAI;AAEjE,mFAAmF,GACnF,OAAO,MAAMC,yBAAyB,oCAAmC;AAEzE;;;;CAIC,GACD,OAAO,MAAMC,2BAA2B,KAAK;AA0B7C,iEAAiE,GACjE,OAAO,eAAeC,qBAAqBC,KAAa;IACtD,MAAMC,QAAS,MAAMT;IACrB,OAAOS,MAAMD,OAAO;QAAEE,kBAAkB;QAAYC,UAAU;IAAM,GACjEC,MAAM,GACNC,MAAM,CAAC;QACNC,OAAOZ;QACPa,QAAQb;QACRc,KAAK;QACLC,oBAAoB;IACtB,EACA,wEAAwE;KACvEC,OAAO,CAAC;QAAEC,YAAY;YAAEC,GAAG;YAAKC,GAAG;YAAKC,GAAG;QAAI;IAAE,GACjDC,IAAI,CAAC;QAAEC,SAASrB;IAA8B,GAC9CsB,QAAQ;AACb;AAEA;;;;CAIC,GACD,OAAO,eAAeC,mBACpBC,SAAsC,EACtCC,KAA0E,EAC1EC,QAA6B,CAAC,CAAC;IAE/B,IAAI,CAACD,MAAME,KAAK,EAAE,OAAO;QAAEC,QAAQ;IAAO;IAC1C,MAAMC,WAAWjC,qBAAqB6B,MAAME,KAAK,EAAEF,MAAMK,MAAM,EAAEL,MAAMM,KAAK;IAC5E,IAAI,CAACF,UAAU,OAAO;QAAED,QAAQ;IAAiB;IACjD,IAAI;YAEAF,kBAQkBA;QATpB,MAAMM,QACJN,mBAAAA,MAAMO,SAAS,YAAfP,mBACC,CAACQ,OAAOC,OAAOL,SACdhC,sBAAsBoC,OAAOC,OAAOL,QAAQ;gBAC1CM,UAAUnC;gBACVoC,OAAOnC;YACT;QACJ,MAAMoC,QAAQ,MAAMN,KAAKR,WAAWK,UAAUJ,MAAMK,MAAM;QAC1D,IAAI,CAACQ,OAAO,OAAO;YAAEV,QAAQ;QAAa;QAC1C,MAAMR,OAAO,MAAM,EAACM,gBAAAA,MAAMa,MAAM,YAAZb,gBAAgBtB,sBAAsBkC,MAAME,MAAM;QACtE,IAAI,CAACpB,KAAKqB,MAAM,EAAE,OAAO;YAAEb,QAAQ;QAAa;QAChD,OAAO;YAAEA,QAAQ;YAAQc,OAAO;gBAAEC,MAAM;gBAASC,WAAW;gBAAcC,MAAMzB,KAAK0B,QAAQ,CAAC;YAAU;QAAE;IAC5G,EAAE,OAAOC,OAAO;QACdC,QAAQD,KAAK,CAAC,gCAAgC;YAAEjB,QAAQL,MAAMK,MAAM;YAAEiB;QAAM;QAC5E,OAAO;YAAEnB,QAAQ;QAAa;IAChC;AACF"}

package/src/lib/jobs/ai-theme-brand-inputs.d.ts

@@ -0,0 +1,125 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import type { AglynOrgBilling } from '@aglyn/aglyn/foundation/definitions/org-billing.types';
+import { AI_THEME_BRAND_BUDGET_MS } from './ai-job-theme-budget';
+import { aiMediaAssetLocation, type AiMediaAssetLocation } from './ai-media-asset';
+/**
+ * The brand a theme job builds on (AGL-2938): the colors that belong to the
+ * site before anyone describes them.
+ *
+ * - **The workspace's brand color** — a white-label workspace's, and only
+ *   theirs: without the entitlement the resolved profile is the platform's,
+ *   which is no customer's brand.
+ * - **The site logo** — when the logo is an asset of the site's own media
+ *   library or its org's, read from storage and reduced to its dominant
+ *   colors. Never fetched from a URL: a logo that is not a library asset is
+ *   left alone.
+ * - **A page the brief links to** — fetched through the same SSRF guard the
+ *   plugin fetch proxy uses (a public address, pinned; https only; every
+ *   redirect re-validated), capped in bytes and time, and reduced to the
+ *   colors its markup and stylesheets use.
+ *
+ * Only hex colors leave this module. Nothing a page or a logo SAYS reaches a
+ * prompt, so there is nothing in them to follow. Each source is best effort:
+ * one that cannot be read is named in a note and the proposal is made
+ * without it.
+ */
+export type AiThemeBrandSource = 'organization' | 'logo' | 'reference';
+/** How the prompt names where each brand color came from. */
+export declare const AI_THEME_BRAND_SOURCE_WORDS: Record<AiThemeBrandSource, string>;
+export interface AiThemeBrandColor {
+    hex: string;
+    source: AiThemeBrandSource;
+}
+export interface AiThemeBrandInputs {
+    colors: AiThemeBrandColor[];
+    /** A source that could not be read, in customer-safe words. */
+    notes: string[];
+}
+/** The most colors one source contributes. */
+export declare const AI_THEME_BRAND_COLORS_PER_SOURCE = 4;
+/** The largest logo decoded for its colors. */
+export declare const AI_THEME_LOGO_MAX_BYTES: number;
+/** The most of a linked page, and of each of its stylesheets, that is read. */
+export declare const AI_THEME_REFERENCE_MAX_BYTES: number;
+export declare const AI_THEME_STYLESHEET_MAX_BYTES: number;
+/** The stylesheets of a linked page that are read beside it. */
+export declare const AI_THEME_REFERENCE_STYLESHEETS = 2;
+/**
+ * The wall clock brand colors may take, declared with the theme step's time
+ * (`ai-job-theme-budget.ts`), which counts it (AGL-3035).
+ */
+export { AI_THEME_BRAND_BUDGET_MS };
+/** A white-label workspace's own brand color; nothing for any other workspace. */
+export declare function organizationBrandColors(org: Partial<AglynOrgBilling> | null | undefined): AiThemeBrandColor[];
+export type AiThemeLogoLocation = AiMediaAssetLocation;
+/**
+ * Where a site's logo lives in a media library: a media reference or a CDN
+ * path naming this site's library, or its org's. Anything else — an external
+ * URL, an asset of some other site or org — has no location, and the logo is
+ * left alone. The media library's own rule, shared with every job that reads
+ * an asset (`ai-media-asset.ts`).
+ */
+export declare const logoMediaLocation: typeof aiMediaAssetLocation;
+/**
+ * The dominant colors of an image's pixels: transparent pixels skipped, the
+ * rest grouped into coarse buckets, the busiest distinct buckets first, and
+ * the near-white and near-black edges a logo sits on dropped while anything
+ * else is there.
+ */
+export declare function dominantColorsFromPixels(data: ArrayLike<number>, channels: number, count?: number): string[];
+/** The first https link in a brief, or `null` — an http link is not followed. */
+export declare function referenceUrlOf(brief: string): URL | null;
+/** How much a page's declared `theme-color` counts beside one use of a color. */
+export declare const AI_THEME_THEME_COLOR_WEIGHT = 25;
+/** Every color a page's markup or a stylesheet uses, weighted by how often. */
+export declare function colorsFromMarkup(text: string): Map<string, number>;
+/** The https stylesheets a page links, resolved against it, at most a few. */
+export declare function stylesheetUrlsOf(html: string, pageUrl: string): string[];
+/** The most used distinct colors, the colorful before the greys. */
+export declare function rankBrandColors(weights: ReadonlyMap<string, number>, count?: number): string[];
+/**
+ * A public https resource as text, through the plugin fetch proxy's SSRF
+ * guard: the host must resolve only to public addresses and the socket is
+ * pinned to the address checked; no credentials in the URL and no port but
+ * the default; every redirect re-enters the same checks; the body is read to
+ * a byte cap under a clock, and only a content type the caller accepts is
+ * read at all. `null` for anything that does not hold.
+ */
+export declare function fetchPublicText(url: string, options: {
+    maxBytes: number;
+    accept: RegExp;
+    signal?: AbortSignal;
+    timeoutMs?: number;
+}): Promise<{
+    text: string;
+    url: string;
+} | null>;
+/** The two reads that leave the process, replaceable where a spec needs to. */
+export interface AiThemeBrandSeams {
+    logoColors?: (firestore: FirebaseFirestore.Firestore, location: AiThemeLogoLocation, hostId: string) => Promise<string[] | null>;
+    referenceColors?: (url: URL, signal: AbortSignal) => Promise<string[] | null>;
+}
+export declare function gatherAiThemeBrandInputs(input: {
+    firestore: FirebaseFirestore.Firestore;
+    org: Partial<AglynOrgBilling> | null;
+    hostId: string;
+    /** The site's host document. */
+    host: Record<string, unknown>;
+    brief: string;
+    signal?: AbortSignal;
+}, seams?: AiThemeBrandSeams): Promise<AiThemeBrandInputs>;

package/src/lib/jobs/ai-theme-brand-inputs.js

@@ -0,0 +1,378 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ import { checkEntitlement } from "@aglyn/aglyn/app-utils/plan-entitlements";
+import { normalizeThemeHex } from "../tools/ai-theme-tool.js";
+import { AI_THEME_BRAND_BUDGET_MS } from "./ai-job-theme-budget.js";
+import { aiMediaAssetLocation, loadAiMediaSharp, readAiMediaAssetBytes } from "./ai-media-asset.js";
+/** How the prompt names where each brand color came from. */ export const AI_THEME_BRAND_SOURCE_WORDS = {
+    organization: 'the workspace brand color',
+    logo: 'from the site logo',
+    reference: 'from the page the brief links to'
+};
+/** The most colors one source contributes. */ export const AI_THEME_BRAND_COLORS_PER_SOURCE = 4;
+/** The largest logo decoded for its colors. */ export const AI_THEME_LOGO_MAX_BYTES = 5 * 1024 * 1024;
+/** The most of a linked page, and of each of its stylesheets, that is read. */ export const AI_THEME_REFERENCE_MAX_BYTES = 512 * 1024;
+export const AI_THEME_STYLESHEET_MAX_BYTES = 256 * 1024;
+/** The stylesheets of a linked page that are read beside it. */ export const AI_THEME_REFERENCE_STYLESHEETS = 2;
+/**
+ * The wall clock brand colors may take, declared with the theme step's time
+ * (`ai-job-theme-budget.ts`), which counts it (AGL-3035).
+ */ export { AI_THEME_BRAND_BUDGET_MS };
+const FETCH_TIMEOUT_MS = 4000;
+const MAX_REDIRECT_HOPS = 3;
+const REDIRECT_STATUSES = new Set([
+    301,
+    302,
+    303,
+    307,
+    308
+]);
+const toHex = ([red, green, blue])=>`#${[
+        red,
+        green,
+        blue
+    ].map((channel)=>Math.round(Math.min(255, Math.max(0, channel))).toString(16).padStart(2, '0')).join('')}`;
+const channelsOf = (hex)=>[
+        parseInt(hex.slice(1, 3), 16),
+        parseInt(hex.slice(3, 5), 16),
+        parseInt(hex.slice(5, 7), 16)
+    ];
+const distance = (a, b)=>Math.hypot(a[0] - b[0], a[1] - b[1], a[2] - b[2]);
+/** How far a color is from grey: the spread of its channels. */ const chroma = ([red, green, blue])=>Math.max(red, green, blue) - Math.min(red, green, blue);
+/** Colors closer than this read as the same color in a palette. */ const SAME_COLOR_DISTANCE = 40;
+/** A spread under this reads as a grey, which says little about a brand. */ const GREY_CHROMA = 38;
+/** The distinct colors of a ranked list, colorful ones first when there are any. */ function distinctColors(ranked, count) {
+    const colorful = ranked.filter((color)=>chroma(color) > GREY_CHROMA);
+    const chosen = [];
+    for (const color of colorful.length ? colorful : ranked){
+        if (chosen.some((other)=>distance(other, color) < SAME_COLOR_DISTANCE)) continue;
+        chosen.push(color);
+        if (chosen.length === count) break;
+    }
+    return chosen.map(toHex);
+}
+/* ------------------------------------------------------------------------ *
+ * The workspace's brand color
+ * ------------------------------------------------------------------------ */ /** A white-label workspace's own brand color; nothing for any other workspace. */ export function organizationBrandColors(org) {
+    var _org_brandingProfile;
+    if (!checkEntitlement(org, 'whiteLabel')) return [];
+    const raw = org == null ? void 0 : (_org_brandingProfile = org.brandingProfile) == null ? void 0 : _org_brandingProfile.primaryColor;
+    const hex = typeof raw === 'string' ? normalizeThemeHex(raw) : null;
+    return hex ? [
+        {
+            hex,
+            source: 'organization'
+        }
+    ] : [];
+}
+/**
+ * Where a site's logo lives in a media library: a media reference or a CDN
+ * path naming this site's library, or its org's. Anything else — an external
+ * URL, an asset of some other site or org — has no location, and the logo is
+ * left alone. The media library's own rule, shared with every job that reads
+ * an asset (`ai-media-asset.ts`).
+ */ export const logoMediaLocation = aiMediaAssetLocation;
+/**
+ * The dominant colors of an image's pixels: transparent pixels skipped, the
+ * rest grouped into coarse buckets, the busiest distinct buckets first, and
+ * the near-white and near-black edges a logo sits on dropped while anything
+ * else is there.
+ */ export function dominantColorsFromPixels(data, channels, count = AI_THEME_BRAND_COLORS_PER_SOURCE) {
+    const buckets = new Map();
+    for(let index = 0; index + channels <= data.length; index += channels){
+        var _buckets_get;
+        if (channels >= 4 && data[index + 3] < 128) continue;
+        const pixel = [
+            data[index],
+            data[index + 1],
+            data[index + 2]
+        ];
+        const key = pixel[0] >> 4 << 8 | pixel[1] >> 4 << 4 | pixel[2] >> 4;
+        const bucket = (_buckets_get = buckets.get(key)) != null ? _buckets_get : {
+            sum: [
+                0,
+                0,
+                0
+            ],
+            pixels: 0
+        };
+        bucket.sum = [
+            bucket.sum[0] + pixel[0],
+            bucket.sum[1] + pixel[1],
+            bucket.sum[2] + pixel[2]
+        ];
+        bucket.pixels += 1;
+        buckets.set(key, bucket);
+    }
+    const ranked = [
+        ...buckets.values()
+    ].sort((a, b)=>b.pixels - a.pixels).map(({ sum, pixels })=>[
+            sum[0] / pixels,
+            sum[1] / pixels,
+            sum[2] / pixels
+        ]);
+    const edge = (color)=>Math.min(...color) > 235 || Math.max(...color) < 20;
+    const inside = ranked.filter((color)=>!edge(color));
+    return distinctColors(inside.length ? inside : ranked, count);
+}
+const LOGO_TYPES = /^image\/(png|jpeg|webp|gif|avif|svg\+xml)$/;
+/**
+ * A library logo's colors, read the way the media CDN would serve it
+ * (`readAiMediaAssetBytes`). `null` when the asset may not be read or the bytes
+ * cannot be decoded.
+ */ async function readLogoColors(firestore, location, hostId) {
+    const asset = await readAiMediaAssetBytes(firestore, location, hostId, {
+        maxBytes: AI_THEME_LOGO_MAX_BYTES,
+        types: LOGO_TYPES
+    });
+    if (!asset) return null;
+    const sharp = await loadAiMediaSharp();
+    const { data, info } = await sharp(asset.buffer, {
+        limitInputPixels: 64000000
+    }).resize(48, 48, {
+        fit: 'inside'
+    }).ensureAlpha().raw().toBuffer({
+        resolveWithObject: true
+    });
+    return dominantColorsFromPixels(data, info.channels);
+}
+/* ------------------------------------------------------------------------ *
+ * A page the brief links to
+ * ------------------------------------------------------------------------ */ const URL_IN_BRIEF = /\bhttps?:\/\/[^\s<>"'`)\]]+/i;
+/** The first https link in a brief, or `null` — an http link is not followed. */ export function referenceUrlOf(brief) {
+    const match = URL_IN_BRIEF.exec(brief);
+    if (!match) return null;
+    try {
+        const url = new URL(match[0].replace(/[.,;:!?]+$/, ''));
+        return url.protocol === 'https:' ? url : null;
+    } catch (unused) {
+        return null;
+    }
+}
+/** How much a page's declared `theme-color` counts beside one use of a color. */ export const AI_THEME_THEME_COLOR_WEIGHT = 25;
+const THEME_COLOR_META = /<meta\b[^>]*\bname\s*=\s*["']?theme-color\b[^>]*>/gi;
+const CONTENT_ATTRIBUTE = /\bcontent\s*=\s*["']?\s*([^"'\s>]+)/i;
+// A `#` after `&` is a character reference (`&#039;`), not a color.
+const HEX_LITERAL = /(?<!&)#(?:[0-9a-f]{6}|[0-9a-f]{3})(?![0-9a-z])/gi;
+const RGB_LITERAL = /rgba?\(\s*(\d{1,3})\s*[,\s]\s*(\d{1,3})\s*[,\s]\s*(\d{1,3})/gi;
+/** Every color a page's markup or a stylesheet uses, weighted by how often. */ export function colorsFromMarkup(text) {
+    var _text_match;
+    const weights = new Map();
+    const add = (hex, weight)=>{
+        var _weights_get;
+        if (hex) weights.set(hex, ((_weights_get = weights.get(hex)) != null ? _weights_get : 0) + weight);
+    };
+    for (const tag of (_text_match = text.match(THEME_COLOR_META)) != null ? _text_match : []){
+        var _ref;
+        var _CONTENT_ATTRIBUTE_exec;
+        add(normalizeThemeHex((_ref = (_CONTENT_ATTRIBUTE_exec = CONTENT_ATTRIBUTE.exec(tag)) == null ? void 0 : _CONTENT_ATTRIBUTE_exec[1]) != null ? _ref : ''), AI_THEME_THEME_COLOR_WEIGHT);
+    }
+    for (const match of text.matchAll(HEX_LITERAL))add(normalizeThemeHex(match[0]), 1);
+    for (const match of text.matchAll(RGB_LITERAL)){
+        add(toHex([
+            Number(match[1]),
+            Number(match[2]),
+            Number(match[3])
+        ]), 1);
+    }
+    return weights;
+}
+const STYLESHEET_LINK = /<link\b[^>]*\brel\s*=\s*["']?stylesheet\b[^>]*>/gi;
+const HREF_ATTRIBUTE = /\bhref\s*=\s*["']?\s*([^"'\s>]+)/i;
+/** The https stylesheets a page links, resolved against it, at most a few. */ export function stylesheetUrlsOf(html, pageUrl) {
+    var _html_match;
+    const urls = [];
+    for (const tag of (_html_match = html.match(STYLESHEET_LINK)) != null ? _html_match : []){
+        var _HREF_ATTRIBUTE_exec;
+        const href = (_HREF_ATTRIBUTE_exec = HREF_ATTRIBUTE.exec(tag)) == null ? void 0 : _HREF_ATTRIBUTE_exec[1];
+        if (!href) continue;
+        try {
+            const url = new URL(href, pageUrl);
+            if (url.protocol === 'https:' && !urls.includes(url.toString())) urls.push(url.toString());
+        } catch (unused) {
+            continue;
+        }
+        if (urls.length === AI_THEME_REFERENCE_STYLESHEETS) break;
+    }
+    return urls;
+}
+/** The most used distinct colors, the colorful before the greys. */ export function rankBrandColors(weights, count = AI_THEME_BRAND_COLORS_PER_SOURCE) {
+    const ranked = [
+        ...weights.entries()
+    ].sort((a, b)=>b[1] - a[1]).map(([hex])=>channelsOf(hex));
+    return distinctColors(ranked, count);
+}
+/** One abort for the caller's signal and a clock, whichever ends first. */ function deadline(signal, ms) {
+    const controller = new AbortController();
+    const timer = setTimeout(()=>controller.abort(), ms);
+    const onAbort = ()=>controller.abort();
+    if (signal == null ? void 0 : signal.aborted) controller.abort();
+    signal == null ? void 0 : signal.addEventListener('abort', onAbort);
+    return {
+        signal: controller.signal,
+        done: ()=>{
+            clearTimeout(timer);
+            signal == null ? void 0 : signal.removeEventListener('abort', onAbort);
+        }
+    };
+}
+async function readCapped(body, maxBytes) {
+    const reader = body.getReader();
+    const chunks = [];
+    let total = 0;
+    for(;;){
+        const { done, value } = await reader.read();
+        if (done || !value) break;
+        const room = maxBytes - total;
+        if (value.byteLength >= room) {
+            chunks.push(value.subarray(0, room));
+            await reader.cancel().catch(()=>undefined);
+            break;
+        }
+        chunks.push(value);
+        total += value.byteLength;
+    }
+    const joined = new Uint8Array(chunks.reduce((sum, chunk)=>sum + chunk.byteLength, 0));
+    let offset = 0;
+    for (const chunk of chunks){
+        joined.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return new TextDecoder().decode(joined);
+}
+/**
+ * A public https resource as text, through the plugin fetch proxy's SSRF
+ * guard: the host must resolve only to public addresses and the socket is
+ * pinned to the address checked; no credentials in the URL and no port but
+ * the default; every redirect re-enters the same checks; the body is read to
+ * a byte cap under a clock, and only a content type the caller accepts is
+ * read at all. `null` for anything that does not hold.
+ */ export async function fetchPublicText(url, options) {
+    const { createPinnedDispatcher, resolvePublicIp } = await import("./ai-theme-brand-server.js");
+    let current = url;
+    for(let hop = 0; hop <= MAX_REDIRECT_HOPS; hop += 1){
+        var _options_timeoutMs;
+        let parsed;
+        try {
+            parsed = new URL(current);
+        } catch (unused) {
+            return null;
+        }
+        if (parsed.protocol !== 'https:' || parsed.username || parsed.password) return null;
+        if (parsed.port && parsed.port !== '443') return null;
+        const pinned = await resolvePublicIp(parsed.hostname);
+        if (!pinned) return null;
+        const dispatcher = createPinnedDispatcher(pinned);
+        const clock = deadline(options.signal, (_options_timeoutMs = options.timeoutMs) != null ? _options_timeoutMs : FETCH_TIMEOUT_MS);
+        try {
+            var _response_headers_get;
+            // `dispatcher` is undici's, which the global fetch honors; a variable
+            // rather than a literal keeps the DOM `RequestInit` check off it.
+            const init = {
+                method: 'GET',
+                redirect: 'manual',
+                signal: clock.signal,
+                dispatcher,
+                headers: {
+                    Accept: 'text/html, text/css;q=0.9'
+                }
+            };
+            const response = await fetch(parsed.toString(), init);
+            if (REDIRECT_STATUSES.has(response.status)) {
+                const location = response.headers.get('location');
+                if (!location) return null;
+                current = new URL(location, parsed).toString();
+                continue;
+            }
+            if (!response.ok || !response.body) return null;
+            if (!options.accept.test((_response_headers_get = response.headers.get('content-type')) != null ? _response_headers_get : '')) return null;
+            return {
+                text: await readCapped(response.body, options.maxBytes),
+                url: parsed.toString()
+            };
+        } catch (unused) {
+            return null;
+        } finally{
+            clock.done();
+            await dispatcher.close().catch(()=>undefined);
+        }
+    }
+    return null;
+}
+/** A linked page's colors, from its markup and its first stylesheets. */ async function readReferenceColors(url, signal) {
+    const page = await fetchPublicText(url.toString(), {
+        maxBytes: AI_THEME_REFERENCE_MAX_BYTES,
+        accept: /text\/html|application\/xhtml\+xml/i,
+        signal
+    });
+    if (!page) return null;
+    const weights = colorsFromMarkup(page.text);
+    for (const sheet of stylesheetUrlsOf(page.text, page.url)){
+        const css = await fetchPublicText(sheet, {
+            maxBytes: AI_THEME_STYLESHEET_MAX_BYTES,
+            accept: /text\/css/i,
+            signal
+        });
+        if (!css) continue;
+        for (const [hex, weight] of colorsFromMarkup(css.text)){
+            var _weights_get;
+            weights.set(hex, ((_weights_get = weights.get(hex)) != null ? _weights_get : 0) + weight);
+        }
+    }
+    return rankBrandColors(weights);
+}
+export async function gatherAiThemeBrandInputs(input, seams = {}) {
+    const colors = [
+        ...organizationBrandColors(input.org)
+    ];
+    const notes = [];
+    const clock = deadline(input.signal, AI_THEME_BRAND_BUDGET_MS);
+    const add = (found, source)=>{
+        for (const hex of found.slice(0, AI_THEME_BRAND_COLORS_PER_SOURCE)){
+            if (!colors.some((color)=>color.hex === hex)) colors.push({
+                hex,
+                source
+            });
+        }
+    };
+    try {
+        var _input_host_orgId;
+        const location = logoMediaLocation(input.host['logoUrl'], input.hostId, String((_input_host_orgId = input.host['orgId']) != null ? _input_host_orgId : ''));
+        if (location) {
+            var _seams_logoColors;
+            const found = await ((_seams_logoColors = seams.logoColors) != null ? _seams_logoColors : readLogoColors)(input.firestore, location, input.hostId).catch(()=>null);
+            if (found) add(found, 'logo');
+            else notes.push("The site logo's colors could not be read, so the proposal does not use them.");
+        }
+        const reference = referenceUrlOf(input.brief);
+        if (reference) {
+            var _seams_referenceColors;
+            const found = clock.signal.aborted ? null : await ((_seams_referenceColors = seams.referenceColors) != null ? _seams_referenceColors : readReferenceColors)(reference, clock.signal).catch(()=>null);
+            if (found == null ? void 0 : found.length) add(found, 'reference');
+            else {
+                notes.push(`The page at ${reference.hostname} could not be read for its colors, so the proposal does not use them.`);
+            }
+        }
+    } finally{
+        clock.done();
+    }
+    return {
+        colors,
+        notes
+    };
+}
+
+//# sourceMappingURL=ai-theme-brand-inputs.js.map