@vectoriox/iox-ui 5.54.0 → 5.56.0

package/src/generation-core/site-plan-schema.ts

@@ -0,0 +1,239 @@
+import type { DesignChoices } from '@vectoriox/iox-ui/design-core';
+
+import {
+    jsonAnyOf, jsonBoolean, jsonClosedObject, jsonInteger, jsonListOf, jsonOneOf, JsonSchema, jsonShapedObject, jsonText,
+} from './json-schema';
+import { patternOptionalParts, patternSlots, patternTakesBinding, PatternGlobalPosition, SITE_PATTERNS, SitePattern } from './patterns';
+import {
+    FACT_KEYS, GlobalSlot, PlanDataSourceMode, PlanDataSourceType, RelativeOp, SitePlan, SitePlanSource, SitePlanSourceKind, SITE_PLAN_VERSION,
+} from './site-plan.model';
+import { SPEC_SITE_PLAN_SHAPE } from './site-spec.generated';
+import { isPlainObject, PlainObject, ShapeEntry } from './shape-check';
+
+/**
+ * The structured-output format a model writes a Site Plan in (AI plan §3d step 4, M1-3) — built from the SAME shape
+ * table `validateSitePlan` reads (`SPEC_SITE_PLAN_SHAPE`) and the SAME pattern library, so the plan a model is told
+ * about is the plan the gate refuses. ONE source: a key the table gains breaks this builder until it is written here.
+ *
+ * Two maps of the shape are written as LISTS on the wire, because no strict mode can say "any key": a section's
+ * `slots` (`[{ slot, text }]`, the slot names closed per pattern) and a seed's field values (`values: [{ field,
+ * value }]`). `sitePlanFromWire` turns them back; nothing else differs. Every section is one `anyOf` branch per
+ * pattern — its id, its declared slots, its optional parts, a binding only when it takes one — and the design, the
+ * source and the version are PINNED to the owner's pick and this run (one-value enums), so the provider cannot let
+ * a model change the look. The gate still checks both (`plan.design` deep-equals the pick).
+ */
+
+export const SITE_PLAN_SCHEMA_NAME = 'site_plan';
+
+/** The wire keys of the two maps written as lists. */
+export enum SitePlanWireKey {
+    SlotName = 'slot',
+    SlotText = 'text',
+    SeedValues = 'values',
+    SeedField = 'field',
+    SeedValue = 'value',
+}
+
+const SHAPE: Readonly<Record<string, ShapeEntry>> = SPEC_SITE_PLAN_SHAPE;
+
+export interface SitePlanSchemaPin {
+    /** The owner's pick, verbatim — every design key becomes a one-value enum. */
+    design: DesignChoices;
+    /** This generation. */
+    source: SitePlanSource;
+}
+
+const one = (value: string): JsonSchema => jsonOneOf([value]);
+const oneBoolean = (value: boolean): JsonSchema => ({ type: 'boolean', enum: [value] });
+
+/** The pick, key by key, as one-value enums; an optional key the pick leaves out may only be left out (or empty). */
+function pinnedDesign(design: DesignChoices): JsonSchema {
+    const entry = SHAPE['design'];
+    const values = design as unknown as Record<string, unknown>;
+    const properties: Record<string, JsonSchema> = {};
+    for (const key of Object.keys(entry).map(k => k.replace(/\?$/, ''))) {
+        const v = values[key];
+        if (typeof v === 'string') properties[key] = one(v);
+        else if (typeof v === 'boolean') properties[key] = oneBoolean(v);
+        else if (isPlainObject(v)) properties[key] = jsonClosedObject(
+            Object.fromEntries(Object.entries(v).map(([role, family]) => [role, one(String(family))])), Object.keys(v));
+        else properties[key] = jsonClosedObject({}, []);
+    }
+    const shaped = jsonShapedObject(entry, properties, 'design');
+    // Everything the pick carries is required: a model may not leave a choice out and let a default stand in.
+    const given = Object.keys(values).filter(k => values[k] !== undefined && k in properties);
+    return { ...shaped, required: [...new Set([...(shaped['required'] as string[]), ...given])] };
+}
+
+function sourceSchema(source: SitePlanSource): JsonSchema {
+    if (source.kind === SitePlanSourceKind.Ai) return jsonShapedObject(SHAPE['sourceAi'], { kind: one(source.kind), runId: one(source.runId) }, 'sourceAi');
+    return jsonShapedObject(SHAPE['sourceTemplate'], {
+        kind: one(source.kind), templateId: one(source.templateId), templateVersion: { type: 'integer', enum: [source.templateVersion] },
+    }, 'sourceTemplate');
+}
+
+function businessSchema(): JsonSchema {
+    const facts = jsonClosedObject(Object.fromEntries(FACT_KEYS.map(key => [key, jsonText()])), []);
+    return jsonShapedObject(SHAPE['business'], { name: jsonText(), tagline: jsonText(), facts }, 'business');
+}
+
+/** A content type's field. */
+export function fieldJsonSchema(): JsonSchema {
+    return jsonShapedObject(SHAPE['field'], { name: jsonText(), type: jsonText(), controller: jsonText(), required: jsonBoolean(), note: jsonText() }, 'field');
+}
+
+/** A content type, its seed's field values as a list (`values: [{ field, value }]`). */
+export function contentTypeJsonSchema(): JsonSchema {
+    const value = jsonAnyOf([jsonText(), jsonListOf(jsonText())]);
+    const values = jsonListOf(jsonClosedObject({ [SitePlanWireKey.SeedField]: jsonText(), [SitePlanWireKey.SeedValue]: value }, [SitePlanWireKey.SeedField, SitePlanWireKey.SeedValue]));
+    const seed = jsonShapedObject(SHAPE['seed'], { count: jsonInteger(), sample: jsonBoolean(), isPublished: jsonBoolean() }, 'seed',
+        { key: SitePlanWireKey.SeedValues, schema: values });
+    return jsonShapedObject(SHAPE['contentType'], {
+        name: jsonText(), label: jsonText(), previewTextField: jsonText(), previewImageField: jsonText(), fields: jsonListOf(fieldJsonSchema()), seed,
+    }, 'contentType');
+}
+
+/** A data source: a cms list / single item, or a relative one. */
+export function dataSourceJsonSchema(): JsonSchema {
+    const byRoute = jsonClosedObject({ field: jsonText(), routeParam: jsonText() }, ['field', 'routeParam']);
+    const cms = jsonShapedObject(SHAPE['cmsDataSource'], {
+        alias: jsonText(), type: one(PlanDataSourceType.Cms), mode: jsonOneOf(Object.values(PlanDataSourceMode)),
+        contentType: jsonText(), limit: jsonInteger(), filterByRouteParam: byRoute,
+    }, 'cmsDataSource');
+    const relative = jsonShapedObject(SHAPE['relativeDataSource'], {
+        alias: jsonText(), type: one(PlanDataSourceType.Relative), of: jsonText(), op: jsonOneOf(Object.values(RelativeOp)), within: jsonText(),
+    }, 'relativeDataSource');
+    return jsonAnyOf([cms, relative]);
+}
+
+/** The patterns a page section may use (every non-global one), in library order. */
+export function sectionPatternIds(): string[] {
+    return Object.entries(SITE_PATTERNS).filter(([, p]) => !p.global).map(([id]) => id);
+}
+
+/** A key a pattern has nothing for: only `{}` (or leaving it out) — the decoder drops it. */
+const NOTHING = (): JsonSchema => jsonClosedObject({}, []);
+
+/** One section branch: this pattern's id, its declared slots (a list), its optional parts, a binding when it takes one. */
+function sectionBranch(id: string, pattern: SitePattern): JsonSchema {
+    const slots = patternSlots(pattern);
+    const parts = patternOptionalParts(pattern);
+    const slotList = slots.length
+        ? jsonListOf(jsonClosedObject({ [SitePlanWireKey.SlotName]: jsonOneOf(slots), [SitePlanWireKey.SlotText]: jsonText() }, [SitePlanWireKey.SlotName, SitePlanWireKey.SlotText]))
+        : NOTHING();
+    const branch = jsonShapedObject(SHAPE['section'], {
+        pattern: one(id),
+        slots: slotList,
+        binding: patternTakesBinding(pattern) ? jsonText() : NOTHING(),
+        without: parts.length ? jsonListOf(jsonOneOf(parts)) : NOTHING(),
+    }, 'section');
+    return { ...branch, description: `${id}: ${pattern.label}` };
+}
+
+/** A page section: one branch per pattern. */
+export function sectionJsonSchema(): JsonSchema {
+    return jsonAnyOf(sectionPatternIds().map(id => sectionBranch(id, SITE_PATTERNS[id])));
+}
+
+/** A page. */
+export function pageJsonSchema(): JsonSchema {
+    return jsonShapedObject(SHAPE['page'], {
+        key: jsonText(), name: jsonText(), route: jsonText(), isHome: jsonBoolean(), required: jsonBoolean(), inNav: jsonBoolean(),
+        template: jsonText(), routeSource: jsonText(), sections: jsonListOf(sectionJsonSchema()),
+    }, 'page');
+}
+
+const globalIds = (position: `${PatternGlobalPosition}`) => Object.entries(SITE_PATTERNS).filter(([, p]) => p.global === position).map(([id]) => id);
+
+/** The Site Plan format, pinned to the owner's pick and this run. */
+export function sitePlanJsonSchema(pin: SitePlanSchemaPin): JsonSchema {
+    const globals = jsonShapedObject(SHAPE['globals'], {
+        [GlobalSlot.Header]: jsonOneOf(globalIds(PatternGlobalPosition.Before)),
+        [GlobalSlot.Footer]: jsonOneOf(globalIds(PatternGlobalPosition.After)),
+    }, 'globals');
+    return jsonShapedObject(SHAPE['plan'], {
+        version: one(SITE_PLAN_VERSION),
+        source: sourceSchema(pin.source),
+        business: businessSchema(),
+        design: pinnedDesign(pin.design),
+        contentTypes: jsonListOf(contentTypeJsonSchema()),
+        dataSources: jsonListOf(dataSourceJsonSchema()),
+        pages: jsonListOf(pageJsonSchema()),
+        globals,
+    }, 'plan');
+}
+
+// ── The wire → the plan ─────────────────────────────────────────────────────────────────────────────
+
+const isEmptyObject = (v: unknown) => isPlainObject(v) && Object.keys(v).length === 0;
+
+/** `[{ slot, text }]` → `{ slot: text }`; anything that is not that list is left for the gate to refuse. */
+function slotsFromWire(slots: unknown): unknown {
+    if (!Array.isArray(slots)) return slots;
+    const out: PlainObject = {};
+    for (const entry of slots) {
+        if (!isPlainObject(entry) || typeof entry[SitePlanWireKey.SlotName] !== 'string') return slots;
+        out[entry[SitePlanWireKey.SlotName] as string] = entry[SitePlanWireKey.SlotText];
+    }
+    return out;
+}
+
+/** A section off the wire: its slots back to a map; a key the pattern has nothing for (`{}`) dropped. */
+export function sectionFromWire(section: unknown): unknown {
+    if (!isPlainObject(section)) return section;
+    const out: PlainObject = { ...section };
+    for (const key of ['slots', 'binding', 'without']) if (isEmptyObject(out[key])) delete out[key];
+    if ('slots' in out) out['slots'] = slotsFromWire(out['slots']);
+    return out;
+}
+
+/** A content type off the wire: its seed's `values` list back to field keys. */
+export function contentTypeFromWire(type: unknown): unknown {
+    if (!isPlainObject(type) || !isPlainObject(type['seed'])) return type;
+    const { [SitePlanWireKey.SeedValues]: values, ...seed } = type['seed'] as PlainObject;
+    if (Array.isArray(values)) {
+        for (const entry of values) {
+            if (isPlainObject(entry) && typeof entry[SitePlanWireKey.SeedField] === 'string') seed[entry[SitePlanWireKey.SeedField] as string] = entry[SitePlanWireKey.SeedValue];
+        }
+    } else if (values !== undefined) seed[SitePlanWireKey.SeedValues] = values;
+    return { ...type, seed };
+}
+
+function pageFromWire(page: unknown): unknown {
+    if (!isPlainObject(page) || !Array.isArray(page['sections'])) return page;
+    return { ...page, sections: (page['sections'] as unknown[]).map(sectionFromWire) };
+}
+
+/** The design off the wire: an empty optional object (a choice the pick does not carry) dropped. */
+function designFromWire(design: unknown): unknown {
+    if (!isPlainObject(design)) return design;
+    return Object.fromEntries(Object.entries(design).filter(([, v]) => !isEmptyObject(v)));
+}
+
+/**
+ * A model's answer → a Site Plan: the two listed maps back to maps, nothing else touched. Never repairs — whatever the
+ * answer got wrong is still wrong, for `validateSitePlan` to refuse with a path.
+ */
+export function sitePlanFromWire(wire: unknown): SitePlan | unknown {
+    if (!isPlainObject(wire)) return wire;
+    const out: PlainObject = { ...wire };
+    if (Array.isArray(out['contentTypes'])) out['contentTypes'] = (out['contentTypes'] as unknown[]).map(contentTypeFromWire);
+    if (Array.isArray(out['pages'])) out['pages'] = (out['pages'] as unknown[]).map(pageFromWire);
+    if ('design' in out) out['design'] = designFromWire(out['design']);
+    return out;
+}
+
+/** The plan → the wire (what a re-ask shows the model, and what the plan edits' prompt carries). */
+export function sitePlanToWire(plan: SitePlan): PlainObject {
+    const slotsToWire = (slots: Readonly<Record<string, string>> | undefined) =>
+        Object.entries(slots ?? {}).map(([slot, text]) => ({ [SitePlanWireKey.SlotName]: slot, [SitePlanWireKey.SlotText]: text }));
+    return {
+        ...plan,
+        contentTypes: plan.contentTypes.map(t => {
+            if (!t.seed) return t;
+            const { count, sample, isPublished, ...values } = t.seed;
+            return { ...t, seed: { count, sample, isPublished, [SitePlanWireKey.SeedValues]: Object.entries(values).map(([field, value]) => ({ [SitePlanWireKey.SeedField]: field, [SitePlanWireKey.SeedValue]: value })) } };
+        }),
+        pages: plan.pages.map(p => ({ ...p, sections: p.sections.map(s => (s.slots ? { ...s, slots: slotsToWire(s.slots) } : s)) })),
+    };
+}

package/src/generation-core/stock-photos.ts

@@ -0,0 +1,137 @@
+import { ComposedSite, PlaceholderKind } from './compose-site';
+import { patternById } from './patterns';
+import { createSerializedNode, SerializedNode, walkSerialized } from './serialized-node';
+import { SitePlan } from './site-plan.model';
+
+/**
+ * Stock photos in a built site (AI plan §3g / §3m, I2): a FREE picture from the platform's curated library, copied
+ * into the studio's own storage (never hot-linked), placed only in an EMPTY picture slot of a section that may show
+ * one — never the owner's work (a collection, a detail page, a gallery: what the nine portfolio types sell is theirs),
+ * never a person (testimonials, the team), never anywhere when the business type says `stock: false`. Its alt text is
+ * the provider's description of what it shows (never a claim), and the credit line its licence requires is placed in
+ * the footer. Pure: the build step does the copying.
+ */
+
+/** Where a stock photo comes from (the library's provider). */
+export enum StockProviderId {
+    Magnific = 'magnific',
+}
+
+/** What a picture's licence asks of the site that shows it. */
+export interface StockCredit {
+    provider: `${StockProviderId}`;
+    /** The provider's id of the picture. */
+    resourceId: string;
+    /** The provider's page for it. */
+    sourceUrl: string;
+    /** The provider's own title — what the picture shows. */
+    title: string;
+    author: string;
+    /** `freemium` — the free licence (premium pictures never enter the library). */
+    licence: string;
+    licenceUrl: string;
+    /** The words the licence requires, and where they link. */
+    line: string;
+    lineUrl: string;
+}
+
+/** One picture of the platform library (`iox-stock/<type>/`), as its manifest lists it. */
+export interface StockPhoto {
+    /** The library key (`spa/12345.jpg`) — the copy's file name is derived from it. */
+    key: string;
+    /** Where the build downloads it from (the platform bucket). */
+    url: string;
+    /** What it shows, in the provider's words — the alt text. Never a claim. */
+    alt: string;
+    width?: number;
+    height?: number;
+    credit: StockCredit;
+}
+
+/** The section families a stock photo may stand in for a picture in. */
+export const STOCK_FAMILIES: ReadonlySet<string> = new Set(['hero', 'feature', 'content', 'story', 'cta', 'contact', 'header']);
+
+export interface StockSlot {
+    /** The Image node the photo goes into. */
+    nodeId: string;
+    /** The page key it lives on. */
+    owner: string;
+    pattern: string;
+}
+
+/** The empty picture slots of a composed site a stock photo may fill, in page and section order. */
+export function stockSlots(plan: SitePlan, composed: Pick<ComposedSite, 'pages' | 'placeholders'>): StockSlot[] {
+    const empty = new Set(composed.placeholders.filter(p => p.kind === PlaceholderKind.Image).map(p => p.nodeId));
+    const out: StockSlot[] = [];
+    composed.pages.forEach((page, p) => {
+        page.layout.forEach((root, s) => {
+            const pattern = plan.pages[p]?.sections[s]?.pattern;
+            const family = patternById(pattern)?.family;
+            if (!pattern || !family || !STOCK_FAMILIES.has(family)) return;
+            walkSerialized([root], n => {
+                if (n.type === 'Image' && empty.has(n.id) && !n.bindings.length) out.push({ nodeId: n.id, owner: page.key, pattern });
+            });
+        });
+    });
+    return out;
+}
+
+export interface StockPlacement extends StockSlot {
+    photo: StockPhoto;
+}
+
+/** Which photo goes where: the library's photos in order, one per slot, never twice; none when the type says no stock. */
+export function planStockPhotos(slots: ReadonlyArray<StockSlot>, photos: ReadonlyArray<StockPhoto>, stockAllowed: boolean): StockPlacement[] {
+    if (!stockAllowed) return [];
+    return slots.slice(0, photos.length).map((slot, i) => ({ ...slot, photo: photos[i] }));
+}
+
+/** A placed photo's copy in the studio's storage: the key the build writes it under. */
+export function stockCopyKey(photo: Pick<StockPhoto, 'key'>): string {
+    return `media/stock/${photo.key.replace(/[^a-zA-Z0-9._-]+/g, '-')}`;
+}
+
+/** Put the studio's copy of each photo into its slot (src + the provider's alt). Returns the nodes changed. */
+export function applyStockPhotos(trees: ReadonlyArray<SerializedNode>, placed: ReadonlyArray<{ nodeId: string; url: string; alt: string }>): number {
+    const byId = new Map(placed.map(p => [p.nodeId, p]));
+    let changed = 0;
+    walkSerialized(trees, n => {
+        const p = byId.get(n.id);
+        if (!p || n.type !== 'Image') return;
+        n.props['src'] = p.url;
+        n.props['alt'] = p.alt;
+        changed++;
+    });
+    return changed;
+}
+
+/** The credit lines a set of photos needs — one per distinct line (a free Magnific photo: "Designed by Magnific"). */
+export function stockCreditLines(photos: ReadonlyArray<Pick<StockPhoto, 'credit'>>): Array<{ line: string; url: string }> {
+    const seen = new Map<string, string>();
+    for (const p of photos) if (!seen.has(p.credit.line)) seen.set(p.credit.line, p.credit.lineUrl);
+    return [...seen.entries()].map(([line, url]) => ({ line, url }));
+}
+
+/** The footer node id of a credit line (stable — a build that runs twice finds it). */
+export const stockCreditNodeId = (index: number) => `stock-credit-${index + 1}`;
+
+/**
+ * The credit line, as the builder would create a Link (a plain node the owner may move or restyle): the licence's words,
+ * linking where it asks, opening in a new tab. Placed at the end of the footer — the place the licence names for a site.
+ */
+export function stockCreditNode(index: number, credit: { line: string; url: string }): SerializedNode {
+    return createSerializedNode(stockCreditNodeId(index), 'Link', { label: credit.line, linkType: 'external', url: credit.url, target: '_blank' }, 'link');
+}
+
+/** Append the credit lines to the footer root (once each). Returns how many it added. */
+export function addStockCredits(footer: SerializedNode, credits: ReadonlyArray<{ line: string; url: string }>): number {
+    footer.children ??= [];
+    let added = 0;
+    credits.forEach((credit, i) => {
+        const id = stockCreditNodeId(i);
+        if (footer.children!.some(c => c.id === id)) return;
+        footer.children!.push(stockCreditNode(i, credit));
+        added++;
+    });
+    return added;
+}

package/src/harness-core/generation-view.ts

@@ -0,0 +1,115 @@
+import type { DesignChoices } from '@vectoriox/iox-ui/design-core';
+import type { AiGenerationStage, AiStep, PlanChange, PlanEdit, SitePlan } from '@vectoriox/iox-ui/generation-core';
+
+import type { StyleRead } from './rank';
+import type { SiteAnalysis } from './site-analysis';
+import type { PictureRole } from './site-reading';
+
+/**
+ * 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). */
+export enum ReaderState {
+    Wait = 'wait',
+    Run = 'run',
+    Done = 'done',
+    /** Nothing to read (no pictures, no address). */
+    Skipped = 'skipped',
+    /** Refused on purpose (robots.txt, a private address…) — said in one plain line, never blocks the reading. */
+    Refused = 'refused',
+    Failed = 'failed',
+}
+
+/** Why a website address was not read (the screens' i18n `ai.siteRead.<reason>`). */
+export enum SiteReadRefusal {
+    /** robots.txt disallows our user agent (`IOX-Import`). */
+    Robots = 'robots',
+    InvalidAddress = 'invalid-address',
+    PrivateAddress = 'private-address',
+    Unreachable = 'unreachable',
+    Timeout = 'timeout',
+    TooLarge = 'too-large',
+    NotHtml = 'not-html',
+    HttpError = 'http-error',
+    TooManyRedirects = 'redirects',
+}
+
+/** What a sentence in the Plan prompt box did. */
+export enum PlanChangeOutcome {
+    Applied = 'applied',
+    /** The closed operations cannot say it — one line, the map unchanged (the call still cost). */
+    Cannot = 'cannot',
+    /** Its edits did not make a valid plan, twice — the map unchanged. */
+    Invalid = 'invalid',
+}
+
+export interface GenerationFileView {
+    key: string;
+    url: string;
+    role: `${PictureRole}`;
+}
+
+export interface SiteReaderView {
+    address: string;
+    state: `${ReaderState}`;
+    reason?: `${SiteReadRefusal}`;
+}
+
+export interface GenerationReadersView {
+    words: { state: `${ReaderState}` };
+    pictures: { state: `${ReaderState}`; count: number };
+    site: { state: `${ReaderState}`; addresses: SiteReaderView[] };
+}
+
+export interface PlanRevisionView {
+    plan: SitePlan;
+    at: string;
+    sentence?: string;
+    edits?: PlanEdit[];
+    changed?: PlanChange[];
+}
+
+export interface AiGenerationView {
+    _id: string;
+    organization: string;
+    stage: `${AiGenerationStage}`;
+    /** The model step the runner is working on; null = the owner's move. */
+    task: `${AiStep}` | null;
+    intake: { prompt: string; files: GenerationFileView[]; addresses: string[]; auto: boolean };
+    readers: GenerationReadersView;
+    reads: { analysis?: { value: SiteAnalysis; model: string; usageIds: string[] }; style?: StyleRead | null };
+    /** What Design and Plan use: the owner's edit, else the reading. */
+    analysis: SiteAnalysis | null;
+    analysisRevision: number;
+    design?: { presetId?: string; design: DesignChoices; auto?: boolean };
+    plan?: {
+        revisions: PlanRevisionView[];
+        model: string;
+        lastChange?: { sentence: string; outcome: `${PlanChangeOutcome}`; message?: string; at: string };
+    };
+    siteBuildId?: string;
+    models: Partial<Record<`${AiStep}`, string>>;
+    estimate: number;
+    cap: number;
+    /** Derived from the ledger — the running credit total. */
+    spent: number;
+    error?: { code: string; detail: string; providerMessage?: string; issues?: Array<{ code: string; path: string }> };
+}
+
+/** `POST …/ai/generations`. */
+export interface GenerationStartRequest {
+    prompt: string;
+    files?: Array<{ key: string; role?: `${PictureRole}` }>;
+    addresses?: string[];
+}
+
+/** The longest message, the most files and addresses a generation starts from (Start's limits). */
+export const GENERATION_LIMITS = {
+    promptChars: 4_000,
+    files: 12,
+    addresses: 3,
+    sentenceChars: 500,
+} as const;