@vectoriox/iox-ui 5.54.0 → 5.55.0

package/fesm2022/vectoriox-iox-ui-harness-core.mjs

@@ -1,5 +1,5 @@
-import { MOOD_IDS, MOOD_LABELS, STYLE_PRESETS, flavorPackById, parseFontFamilies, SPEC_AXES, parseHexColor, rgbToOklab, presetChoices } from '@vectoriox/iox-ui/design-core';
-import { shapeKeys, requiredShapeKeys, PathIssueCollector, isPlainObject, pathAt, FACT_KEYS, SPEC_SITE_LIBRARY, patternById, SITE_FACT_LABELS, SITE_TEMPLATES, STUDIO_TEMPLATE } from '@vectoriox/iox-ui/generation-core';
+import { MOOD_IDS, MOOD_LABELS, STYLE_PRESETS, flavorPackById, parseFontFamilies, SPEC_AXES, parseHexColor, rgbToOklab, presetChoices, toHexColor, stylePresetById, auditDesignContrast, designTokenRows } from '@vectoriox/iox-ui/design-core';
+import { shapeKeys, requiredShapeKeys, PathIssueCollector, isPlainObject, pathAt, FACT_KEYS, jsonText, jsonOneOf, jsonListOf, jsonShapedObject, jsonClosedObject, describeShapeKey, SPEC_SITE_LIBRARY, patternById, SITE_FACT_LABELS, SITE_TEMPLATES, STUDIO_TEMPLATE, jsonInteger } from '@vectoriox/iox-ui/generation-core';
 
 // GENERATED from iox-ai-guidance flavor-spec.v1.json — do not edit; re-run scripts/gen-flavor-spec.mjs
 // (npm run gen:flavor-spec). The JSON is itself generated by iox-ai-guidance
@@ -3794,7 +3794,7 @@ const ALTERNATIVES = 2;
 const SHAPE = SPEC_ANALYSIS_SHAPE;
 const KEYS = Object.fromEntries(Object.keys(SHAPE).map(k => [k, shapeKeys(SHAPE[k])]));
 const REQUIRED = Object.fromEntries(Object.keys(SHAPE).map(k => [k, requiredShapeKeys(SHAPE[k])]));
-class Collector extends PathIssueCollector {
+let Collector$1 = class Collector extends PathIssueCollector {
     constructor() {
         super('analysis', { shape: AnalysisIssueCode.Shape, unknownKey: AnalysisIssueCode.UnknownKey, duplicate: AnalysisIssueCode.Duplicate });
     }
@@ -3821,11 +3821,11 @@ class Collector extends PathIssueCollector {
             this.add(AnalysisIssueCode.Shape, `${pathAt(path, key)}[${i}]`, 'must be a string'); });
         return list.filter((v) => typeof v === 'string');
     }
-}
+};
 /** Whitespace and case never decide whether words are the prompt's. */
 const normalise = (s) => s.toLowerCase().replace(/\s+/g, ' ').trim();
 function validateSiteAnalysis(value, ctx) {
-    const c = new Collector();
+    const c = new Collector$1();
     const a = c.object(value, 'analysis', '');
     if (!a)
         return { valid: false, issues: c.issues };
@@ -3907,33 +3907,14 @@ function validateSiteAnalysis(value, ctx) {
 }
 /** The name a provider shows the format under (`json_schema.name`). */
 const SITE_ANALYSIS_SCHEMA_NAME = 'site_analysis';
-const OPTIONAL_MARK = '?';
-const text = () => ({ type: 'string' });
-const oneOf = (values) => ({ type: 'string', enum: [...values] });
-const listOf = (items) => ({ type: 'array', items });
-/** The shape table's own words for a key — the description the model reads. */
-function describe(shape, key) {
-    const entry = SHAPE[shape];
-    return String(entry[key] ?? entry[`${key}${OPTIONAL_MARK}`] ?? '');
-}
+const text = jsonText;
+const oneOf = jsonOneOf;
+const listOf = jsonListOf;
 /** An object of `shape`: exactly its keys, its required ones required, each described by the table. */
-function shaped(shape, properties) {
-    return {
-        type: 'object',
-        properties: Object.fromEntries(Object.entries(properties).map(([key, schema]) => [key, { ...schema, description: describe(shape, key) }])),
-        required: requiredShapeKeys(SHAPE[shape]),
-        additionalProperties: false,
-    };
-}
+const shaped = (shape, properties) => jsonShapedObject(SHAPE[shape], properties, shape);
 /** `{ [fact]: factRead }`: the closed fact keys, each optional — a fact the prompt does not state is left out. */
 function factsSchema(factRead) {
-    return {
-        type: 'object',
-        properties: Object.fromEntries(FACT_KEYS.map(key => [key, factRead])),
-        required: [],
-        additionalProperties: false,
-        description: describe('analysis', 'facts'),
-    };
+    return jsonClosedObject(Object.fromEntries(FACT_KEYS.map(key => [key, factRead])), [], describeShapeKey(SHAPE['analysis'], 'facts'));
 }
 function siteAnalysisJsonSchema() {
     const factRead = shaped('factRead', { value: text(), quote: text() });
@@ -4368,6 +4349,445 @@ function structureFor(typeId) {
     return { structure, template: own ?? STUDIO_TEMPLATE, fallback: !own };
 }
 
+/** At most this many colours (the StyleRead's palette). */
+const PALETTE_SIZE = 6;
+/** Channels are bucketed to this many bits before the cut, so noise never decides a colour. */
+const BUCKET_BITS = 5;
+const BUCKET_SHIFT = 8 - BUCKET_BITS;
+/** The sampling ceiling for a picture — every n-th pixel, so a 12 MP photo costs what a thumbnail does. */
+const MAX_PIXEL_SAMPLES = 20_000;
+/** A pixel under this alpha is not part of the picture. */
+const MIN_ALPHA = 128;
+/** OKLab lightness / chroma thresholds the reading speaks in. */
+const PALETTE_THRESHOLDS = {
+    /** Above: a light colour. */
+    light: 0.72,
+    /** Below: a dark colour. */
+    dark: 0.38,
+    /** At least this share of light (or dark) makes the ground light (or dark); otherwise mixed. */
+    groundShare: 0.55,
+    /** A brand candidate is at least this colourful… */
+    brandChroma: 0.08,
+    /** …and neither near-white nor near-black. */
+    brandMinL: 0.25,
+    brandMaxL: 0.92,
+    /** Two palette colours closer than this (OKLab distance) are one colour. */
+    mergeDistance: 0.035,
+};
+/** Every n-th opaque pixel of an RGBA buffer (canvas `ImageData.data`, a decoder's pixels), weight 1 each. */
+function pixelSamples(rgba, width, height, max = MAX_PIXEL_SAMPLES) {
+    const pixels = Math.max(0, Math.floor(width) * Math.floor(height));
+    const step = Math.max(1, Math.ceil(pixels / max));
+    const out = [];
+    for (let p = 0; p < pixels; p += step) {
+        const i = p * 4;
+        if (rgba[i + 3] < MIN_ALPHA)
+            continue;
+        out.push({ r: rgba[i], g: rgba[i + 1], b: rgba[i + 2], weight: 1 });
+    }
+    return out;
+}
+/** A palette (hex + share) back to samples — what merging two readings measures. */
+function paletteSamples(palette, weight = 1) {
+    return palette.flatMap(c => {
+        const rgb = parseHexColor(c.hex);
+        return rgb ? [{ r: Math.round(rgb.r * 255), g: Math.round(rgb.g * 255), b: Math.round(rgb.b * 255), weight: c.share * weight }] : [];
+    });
+}
+const CHANNELS = ['r', 'g', 'b'];
+const boxOf = (colours) => ({ colours, weight: colours.reduce((s, c) => s + c.weight, 0) });
+function range(box, ch) {
+    let lo = 255;
+    let hi = 0;
+    for (const c of box.colours) {
+        lo = Math.min(lo, c[ch]);
+        hi = Math.max(hi, c[ch]);
+    }
+    return hi - lo;
+}
+/** The channel a box is widest in (ties: r, then g, then b). */
+function widest(box) {
+    return CHANNELS.reduce((best, ch) => {
+        const span = range(box, ch);
+        return span > best.span ? { ch, span } : best;
+    }, { ch: 'r', span: -1 });
+}
+/** Split at the weighted median of its widest channel (a stable sort, so ties never depend on the runtime). */
+function split(box) {
+    const { ch, span } = widest(box);
+    if (span <= 0 || box.colours.length < 2)
+        return null;
+    const sorted = [...box.colours].sort((a, b) => a[ch] - b[ch] || a.r - b.r || a.g - b.g || a.b - b.b);
+    let acc = 0;
+    let cut = 1;
+    for (let i = 0; i < sorted.length - 1; i++) {
+        acc += sorted[i].weight;
+        cut = i + 1;
+        if (acc >= box.weight / 2)
+            break;
+    }
+    return [boxOf(sorted.slice(0, cut)), boxOf(sorted.slice(cut))];
+}
+/** Samples bucketed (BUCKET_BITS per channel), each bucket's weighted mean colour kept. */
+function bucket(samples) {
+    const buckets = new Map();
+    for (const s of samples) {
+        if (!(s.weight > 0))
+            continue;
+        const key = ((s.r >> BUCKET_SHIFT) << (2 * BUCKET_BITS)) | ((s.g >> BUCKET_SHIFT) << BUCKET_BITS) | (s.b >> BUCKET_SHIFT);
+        const b = buckets.get(key) ?? { r: 0, g: 0, b: 0, weight: 0 };
+        b.r += s.r * s.weight;
+        b.g += s.g * s.weight;
+        b.b += s.b * s.weight;
+        b.weight += s.weight;
+        buckets.set(key, b);
+    }
+    return [...buckets.entries()].sort(([a], [b]) => a - b).map(([, b]) => ({ r: b.r / b.weight, g: b.g / b.weight, b: b.b / b.weight, weight: b.weight }));
+}
+function meanHex(box) {
+    const sum = box.colours.reduce((s, c) => ({ r: s.r + c.r * c.weight, g: s.g + c.g * c.weight, b: s.b + c.b * c.weight }), { r: 0, g: 0, b: 0 });
+    return toHexColor({ r: sum.r / box.weight / 255, g: sum.g / box.weight / 255, b: sum.b / box.weight / 255 }).toUpperCase();
+}
+const oklabOf = (hex) => rgbToOklab(parseHexColor(hex));
+const distance = (a, b) => { const x = oklabOf(a); const y = oklabOf(b); return Math.hypot(x.L - y.L, x.a - y.a, x.b - y.b); };
+const SHARE_PRECISION = 1e4;
+/** Weighted samples → ≤ 6 colours, largest share first (ties by hex), shares adding up to 1. */
+function measurePalette(samples, size = PALETTE_SIZE) {
+    const colours = bucket(samples);
+    if (!colours.length)
+        return [];
+    let boxes = [boxOf(colours)];
+    while (boxes.length < size) {
+        // The box to cut: the most weight × span (ties: the earlier box).
+        let best = -1;
+        let bestScore = 0;
+        boxes.forEach((box, i) => {
+            const score = box.weight * widest(box).span;
+            if (score > bestScore) {
+                best = i;
+                bestScore = score;
+            }
+        });
+        const halves = best >= 0 ? split(boxes[best]) : null;
+        if (!halves)
+            break;
+        boxes = [...boxes.slice(0, best), ...halves, ...boxes.slice(best + 1)];
+    }
+    const total = boxes.reduce((s, b) => s + b.weight, 0);
+    const merged = [];
+    for (const box of [...boxes].sort((a, b) => b.weight - a.weight)) {
+        const hex = meanHex(box);
+        const near = merged.find(m => distance(m.hex, hex) < PALETTE_THRESHOLDS.mergeDistance);
+        if (near)
+            near.weight += box.weight;
+        else
+            merged.push({ hex, weight: box.weight });
+    }
+    return merged
+        .map(m => ({ hex: m.hex, share: Math.round((m.weight / total) * SHARE_PRECISION) / SHARE_PRECISION }))
+        .sort((a, b) => b.share - a.share || a.hex.localeCompare(b.hex));
+}
+/** Light, dark or mixed: the share of the palette that is light (or dark). */
+function paletteGround(palette) {
+    let light = 0;
+    let dark = 0;
+    for (const c of palette) {
+        const { L } = oklabOf(c.hex);
+        if (L >= PALETTE_THRESHOLDS.light)
+            light += c.share;
+        else if (L <= PALETTE_THRESHOLDS.dark)
+            dark += c.share;
+    }
+    if (light >= PALETTE_THRESHOLDS.groundShare)
+        return StyleReadGround.Light;
+    if (dark >= PALETTE_THRESHOLDS.groundShare)
+        return StyleReadGround.Dark;
+    return StyleReadGround.Mixed;
+}
+/** The most frequent saturated colour that is neither near-white nor near-black, or undefined. */
+function paletteBrand(palette) {
+    return palette.find(c => {
+        const { L, a, b } = oklabOf(c.hex);
+        return Math.hypot(a, b) >= PALETTE_THRESHOLDS.brandChroma && L >= PALETTE_THRESHOLDS.brandMinL && L <= PALETTE_THRESHOLDS.brandMaxL;
+    })?.hex;
+}
+/** The whole reading of a set of samples: the palette, its ground, its brand candidate. */
+function readPalette(samples) {
+    const palette = measurePalette(samples);
+    const brand = paletteBrand(palette);
+    return { palette, ground: paletteGround(palette), ...(brand ? { brand } : {}) };
+}
+
+/** Every mode `presetId` offers passes the audit with `seed`. */
+function seedPassesPreset(presetId, seed) {
+    const preset = stylePresetById(presetId);
+    if (!preset || !parseHexColor(seed))
+        return { passes: false, failsIn: [] };
+    const failsIn = preset.modes.filter(mode => {
+        const choices = presetChoices(preset.id, mode);
+        return auditDesignContrast(designTokenRows({ ...choices, seed }), mode).some(f => !f.pass);
+    });
+    return { passes: failsIn.length === 0, failsIn: [...failsIn] };
+}
+/** The seed a preset starts from, given a reading (or none). Unknown preset → null. */
+function referenceSeed(read, presetId) {
+    const preset = stylePresetById(presetId);
+    if (!preset)
+        return null;
+    const reference = read?.brand && parseHexColor(read.brand) ? read.brand : null;
+    if (!reference)
+        return { seed: preset.seed, reference: null, used: false, failsIn: [] };
+    const { passes, failsIn } = seedPassesPreset(preset.id, reference);
+    return passes ? { seed: reference, reference, used: true, failsIn: [] } : { seed: preset.seed, reference, used: false, failsIn };
+}
+
+/**
+ * The READING call (AI plan §3d step 1, §3k R2, M1-1): ONE `text.fast` call reads the owner's words AND the pictures
+ * they attached (image input) and answers with the SiteAnalysis and — when there are pictures — which ones are the
+ * owner's own (Your photos) and which are pictures they like (references, style only), plus what the liked pictures
+ * FEEL like: moods, the lettering, corners, spacing. Never a colour: the palette is MEASURED (`palette.ts`, R-D2).
+ * The format is built from `READING_SHAPE` (keys + their explanations), the gate reads the same table. Pure.
+ */
+/** Which group a picture belongs to (R-D3: from the words; own when the words don't say). */
+var PictureRole;
+(function (PictureRole) {
+    PictureRole["Own"] = "own";
+    PictureRole["Reference"] = "reference";
+})(PictureRole || (PictureRole = {}));
+/** At most this many pictures go to the reading call as image input (§3d: "up to 6 pictures"). */
+const MAX_READ_PICTURES = 6;
+const READING_SHAPE = {
+    reading: {
+        analysis: 'analysis — the reading of the words',
+        pictures: 'pictures — the pictures attached, in order',
+    },
+    pictures: {
+        files: 'fileRole[] — one per attached picture, in the order given',
+        style: 'pictureStyle — what the pictures the owner LIKES (role reference) feel like; empty moods when there are none',
+    },
+    fileRole: {
+        index: 'integer — the picture, 0-based, in the order given',
+        role: "'own' | 'reference' — own: the owner's work, place, products or people, for the site; reference: a picture they like, for style only (\"a site like these\"); own when the words don't say",
+    },
+    pictureStyle: {
+        moods: 'string[] — ≤ 3 moods the liked pictures feel like',
+        'headings?': "'serif' | 'sans' | 'display' | 'mono' — the lettering they show, when they show some",
+        'shape?': 'string — design axes.shapes: their corners',
+        'density?': 'string — design axes.densities: how much room things have',
+    },
+};
+const SITE_READING_SCHEMA_NAME = 'site_reading';
+/** The reading's format: the analysis alone when no picture was attached, else the analysis + the pictures. */
+function siteReadingJsonSchema(pictureCount) {
+    if (pictureCount <= 0)
+        return siteAnalysisJsonSchema();
+    const fileRole = jsonShapedObject(READING_SHAPE['fileRole'], { index: jsonInteger(), role: jsonOneOf(Object.values(PictureRole)) }, 'fileRole');
+    const style = jsonShapedObject(READING_SHAPE['pictureStyle'], {
+        moods: jsonListOf(jsonOneOf(MOOD_IDS)),
+        headings: jsonOneOf(Object.values(StyleReadHeadings)),
+        shape: jsonOneOf(Object.keys(SPEC_AXES.shapes)),
+        density: jsonOneOf(Object.keys(SPEC_AXES.densities)),
+    }, 'pictureStyle');
+    const pictures = jsonShapedObject(READING_SHAPE['pictures'], { files: jsonListOf(fileRole), style }, 'pictures');
+    return jsonShapedObject(READING_SHAPE['reading'], { analysis: siteAnalysisJsonSchema(), pictures }, 'reading');
+}
+var ReadingIssueCode;
+(function (ReadingIssueCode) {
+    ReadingIssueCode["Shape"] = "shape";
+    ReadingIssueCode["UnknownKey"] = "unknown-key";
+    ReadingIssueCode["Duplicate"] = "duplicate";
+    ReadingIssueCode["InvalidValue"] = "invalid-value";
+    /** A picture named twice, or one left out. */
+    ReadingIssueCode["Pictures"] = "pictures";
+})(ReadingIssueCode || (ReadingIssueCode = {}));
+class Collector extends PathIssueCollector {
+    constructor() {
+        super('reading', { shape: ReadingIssueCode.Shape, unknownKey: ReadingIssueCode.UnknownKey, duplicate: ReadingIssueCode.Duplicate });
+    }
+    object(value, shape, path) {
+        if (!isPlainObject(value)) {
+            this.add(ReadingIssueCode.Shape, path, 'must be an object');
+            return null;
+        }
+        this.keys(value, shapeKeys(READING_SHAPE[shape]), path);
+        for (const key of requiredShapeKeys(READING_SHAPE[shape]))
+            if (value[key] === undefined)
+                this.add(ReadingIssueCode.Shape, pathAt(path, key), 'is required');
+        return value;
+    }
+    oneOf(obj, key, allowed, path) {
+        const v = obj[key];
+        if (v !== undefined && (typeof v !== 'string' || !allowed.includes(v)))
+            this.add(ReadingIssueCode.InvalidValue, pathAt(path, key), `must be one of ${allowed.join(', ')}`);
+    }
+}
+/** The pictures' part: every picture named once, a role each, moods from the closed list. */
+function validatePictures(c, raw, count) {
+    const pictures = c.object(raw, 'pictures', 'pictures');
+    if (!pictures)
+        return;
+    const files = c.array(pictures, 'files', 'pictures');
+    const seen = new Set();
+    files.forEach((f, i) => {
+        const path = `pictures.files[${i}]`;
+        const file = c.object(f, 'fileRole', path);
+        if (!file)
+            return;
+        c.oneOf(file, 'role', Object.values(PictureRole), path);
+        const index = file['index'];
+        if (!Number.isInteger(index) || index < 0 || index >= count)
+            c.add(ReadingIssueCode.Pictures, `${path}.index`, `must be a picture 0–${count - 1}`);
+        else if (seen.has(index))
+            c.add(ReadingIssueCode.Pictures, `${path}.index`, `picture ${index} is named twice`);
+        else
+            seen.add(index);
+    });
+    if (Array.isArray(pictures['files']) && seen.size !== count)
+        c.add(ReadingIssueCode.Pictures, 'pictures.files', `name each of the ${count} pictures once`);
+    const style = c.object(pictures['style'], 'pictureStyle', 'pictures.style');
+    if (!style)
+        return;
+    const moods = c.array(style, 'moods', 'pictures.style');
+    if (moods.length > MAX_ANALYSIS_MOODS)
+        c.add(ReadingIssueCode.InvalidValue, 'pictures.style.moods', `at most ${MAX_ANALYSIS_MOODS}`);
+    moods.forEach((m, i) => { if (!MOOD_IDS.includes(m))
+        c.add(ReadingIssueCode.InvalidValue, `pictures.style.moods[${i}]`, `"${String(m)}" is not a mood`); });
+    c.oneOf(style, 'headings', Object.values(StyleReadHeadings), 'pictures.style');
+    c.oneOf(style, 'shape', Object.keys(SPEC_AXES.shapes), 'pictures.style');
+    c.oneOf(style, 'density', Object.keys(SPEC_AXES.densities), 'pictures.style');
+}
+/** The reading's gate: the analysis by `validateSiteAnalysis` (paths under `analysis.` when pictures came too), the pictures by `READING_SHAPE`. */
+function validateSiteReading(value, ctx) {
+    if (ctx.pictureCount <= 0)
+        return validateSiteAnalysis(value, { prompt: ctx.prompt });
+    const c = new Collector();
+    const reading = c.object(value, 'reading', '');
+    if (!reading)
+        return { valid: false, issues: c.issues };
+    const analysis = validateSiteAnalysis(reading['analysis'], { prompt: ctx.prompt });
+    const issues = analysis.issues.map(i => ({ ...i, path: pathAt('analysis', i.path) }));
+    validatePictures(c, reading['pictures'], ctx.pictureCount);
+    issues.push(...c.issues);
+    return { valid: issues.length === 0, issues };
+}
+/** A valid reading's answer → `SiteReading` (the analysis alone answers `{ analysis }`). */
+function decodeSiteReading(value, pictureCount) {
+    if (pictureCount <= 0)
+        return { analysis: value };
+    return value;
+}
+/** The liked pictures as a StyleRead: their palettes measured together, what the model saw of them. */
+function pictureStyleRead(pictures, style) {
+    if (!pictures.length)
+        return null;
+    const reading = readPalette(pictures.flatMap(p => paletteSamples(p.palette)));
+    return {
+        sources: pictures.map(p => ({ kind: StyleReadSourceKind.Image, ref: p.ref })),
+        palette: reading.palette,
+        ...(reading.brand ? { brand: reading.brand } : {}),
+        ground: reading.ground,
+        moods: [...(style?.moods ?? [])].slice(0, MAX_ANALYSIS_MOODS),
+        ...(style?.headings ? { headings: style.headings } : {}),
+        ...(style?.shape ? { shape: style.shape } : {}),
+        ...(style?.density ? { density: style.density } : {}),
+    };
+}
+/** The most frequent defined value (ties: the first reading's). */
+function mostCommon(values) {
+    const counts = new Map();
+    for (const v of values)
+        if (v !== undefined)
+            counts.set(v, (counts.get(v) ?? 0) + 1);
+    let best;
+    let n = 0;
+    for (const [v, k] of counts)
+        if (k > n) {
+            best = v;
+            n = k;
+        }
+    return best;
+}
+/**
+ * Every reading of one generation (the pictures', each site's) → ONE StyleRead: palettes measured together (each
+ * reading weighs the same), the ground re-read from that palette, moods by how often they were seen (≤ 3), the rest the
+ * most common answer. Null when nothing was read.
+ */
+function mergeStyleReads(reads) {
+    const all = reads.filter((r) => !!r);
+    if (!all.length)
+        return null;
+    if (all.length === 1)
+        return all[0];
+    const reading = readPalette(all.flatMap(r => paletteSamples(r.palette)));
+    const moodCount = new Map();
+    all.forEach(r => r.moods.forEach(m => moodCount.set(m, (moodCount.get(m) ?? 0) + 1)));
+    const moods = [...moodCount.entries()].sort((a, b) => b[1] - a[1]).map(([m]) => m).slice(0, MAX_ANALYSIS_MOODS);
+    const pick = (key) => mostCommon(all.map(r => r[key]));
+    const headings = pick('headings');
+    const shape = pick('shape');
+    const density = pick('density');
+    const motion = pick('motion');
+    return {
+        sources: all.flatMap(r => r.sources),
+        palette: reading.palette,
+        ...(reading.brand ? { brand: reading.brand } : {}),
+        ground: reading.palette.length ? reading.ground : StyleReadGround.Mixed,
+        moods,
+        ...(headings ? { headings } : {}),
+        ...(shape ? { shape } : {}),
+        ...(density ? { density } : {}),
+        ...(motion ? { motion } : {}),
+    };
+}
+
+/**
+ * A generation as the screens read it (AI plan "M1 pipeline — the screens contract"): what iox-cms's
+ * `GET …/ai/generations/:id` answers and the Thinking · Analysis · Design · Plan · Build screens render. ONE
+ * definition: iox-cms builds it, cms-client types its client with it. Types and enums only — no transport.
+ */
+/** Where one reader is (Thinking's three lines). */
+var ReaderState;
+(function (ReaderState) {
+    ReaderState["Wait"] = "wait";
+    ReaderState["Run"] = "run";
+    ReaderState["Done"] = "done";
+    /** Nothing to read (no pictures, no address). */
+    ReaderState["Skipped"] = "skipped";
+    /** Refused on purpose (robots.txt, a private address…) — said in one plain line, never blocks the reading. */
+    ReaderState["Refused"] = "refused";
+    ReaderState["Failed"] = "failed";
+})(ReaderState || (ReaderState = {}));
+/** Why a website address was not read (the screens' i18n `ai.siteRead.<reason>`). */
+var SiteReadRefusal;
+(function (SiteReadRefusal) {
+    /** robots.txt disallows our user agent (`IOX-Import`). */
+    SiteReadRefusal["Robots"] = "robots";
+    SiteReadRefusal["InvalidAddress"] = "invalid-address";
+    SiteReadRefusal["PrivateAddress"] = "private-address";
+    SiteReadRefusal["Unreachable"] = "unreachable";
+    SiteReadRefusal["Timeout"] = "timeout";
+    SiteReadRefusal["TooLarge"] = "too-large";
+    SiteReadRefusal["NotHtml"] = "not-html";
+    SiteReadRefusal["HttpError"] = "http-error";
+    SiteReadRefusal["TooManyRedirects"] = "redirects";
+})(SiteReadRefusal || (SiteReadRefusal = {}));
+/** What a sentence in the Plan prompt box did. */
+var PlanChangeOutcome;
+(function (PlanChangeOutcome) {
+    PlanChangeOutcome["Applied"] = "applied";
+    /** The closed operations cannot say it — one line, the map unchanged (the call still cost). */
+    PlanChangeOutcome["Cannot"] = "cannot";
+    /** Its edits did not make a valid plan, twice — the map unchanged. */
+    PlanChangeOutcome["Invalid"] = "invalid";
+})(PlanChangeOutcome || (PlanChangeOutcome = {}));
+/** The longest message, the most files and addresses a generation starts from (Start's limits). */
+const GENERATION_LIMITS = {
+    promptChars: 4_000,
+    files: 12,
+    addresses: 3,
+    sentenceChars: 500,
+};
+
 /**
  * @vectoriox/iox-ui/harness-core — the design HARNESS (AI plan rev 3 §3f, decision N18), FRAMEWORK-FREE: the 30
  * kinds of business and their rules (generated 1:1 from iox-ai-guidance `flavor-spec.v1.json` `harness`), the
@@ -4382,5 +4802,5 @@ function structureFor(typeId) {
  * Generated bundle index. Do not edit.
  */
 
-export { ANIMATE_ADVICE_STEPS, AnalysisIssueCode, AnalysisLocale, AvoidCheck, BUSINESS_TYPES, BUSINESS_TYPE_IDS, BookingNeed, COPY_LENGTH_ORDER, CopyLength, HARNESS_SOURCE, LITTLE_MOVEMENT_AVOID, LITTLE_MOVEMENT_CAP, LintKind, MAX_ANALYSIS_MOODS, NEEDS, NEED_IDS, NeedSource, PresetFit, RANK_WEIGHTS, READ_ANIMATE, READ_WEIGHTS, RankReason, SITE_ANALYSIS_SCHEMA_NAME, SPEC_ANALYSIS_SHAPE, SPEC_BUSINESS_TYPES, SPEC_HARNESS_EXAMPLES, SPEC_HARNESS_SOURCE, SPEC_NEEDS, SPEC_STRUCTURES, SPEC_USER_AVOIDS, STRUCTURES, StyleReadGround, StyleReadHeadings, StyleReadMotion, StyleReadSourceKind, USER_AVOID_IDS, VoiceFormality, VoicePerson, addressesIn, analysisPromptContext, businessTypeById, calmerChoice, inferNeeds, isLookRule, lintDesign, lookMatches, mapStyleRead, matchBusinessType, matchBusinessTypes, motionAdvice, motionFor, normalizeAddress, oklchHue, presetHasSerifHeadings, presetLook, presetReason, rankStylePresets, rankWithReferences, siteAnalysisJsonSchema, structureFor, userAvoidRule, validateSiteAnalysis, withoutAddress };
+export { ANIMATE_ADVICE_STEPS, AnalysisIssueCode, AnalysisLocale, AvoidCheck, BUSINESS_TYPES, BUSINESS_TYPE_IDS, BookingNeed, COPY_LENGTH_ORDER, CopyLength, GENERATION_LIMITS, HARNESS_SOURCE, LITTLE_MOVEMENT_AVOID, LITTLE_MOVEMENT_CAP, LintKind, MAX_ANALYSIS_MOODS, MAX_PIXEL_SAMPLES, MAX_READ_PICTURES, NEEDS, NEED_IDS, NeedSource, PALETTE_SIZE, PALETTE_THRESHOLDS, PictureRole, PlanChangeOutcome, PresetFit, RANK_WEIGHTS, READING_SHAPE, READ_ANIMATE, READ_WEIGHTS, RankReason, ReaderState, ReadingIssueCode, SITE_ANALYSIS_SCHEMA_NAME, SITE_READING_SCHEMA_NAME, SPEC_ANALYSIS_SHAPE, SPEC_BUSINESS_TYPES, SPEC_HARNESS_EXAMPLES, SPEC_HARNESS_SOURCE, SPEC_NEEDS, SPEC_STRUCTURES, SPEC_USER_AVOIDS, STRUCTURES, SiteReadRefusal, StyleReadGround, StyleReadHeadings, StyleReadMotion, StyleReadSourceKind, USER_AVOID_IDS, VoiceFormality, VoicePerson, addressesIn, analysisPromptContext, businessTypeById, calmerChoice, decodeSiteReading, inferNeeds, isLookRule, lintDesign, lookMatches, mapStyleRead, matchBusinessType, matchBusinessTypes, measurePalette, mergeStyleReads, motionAdvice, motionFor, normalizeAddress, oklchHue, paletteBrand, paletteGround, paletteSamples, pictureStyleRead, pixelSamples, presetHasSerifHeadings, presetLook, presetReason, rankStylePresets, rankWithReferences, readPalette, referenceSeed, seedPassesPreset, siteAnalysisJsonSchema, siteReadingJsonSchema, structureFor, userAvoidRule, validateSiteAnalysis, validateSiteReading, withoutAddress };
 //# sourceMappingURL=vectoriox-iox-ui-harness-core.mjs.map