@coffer-org/sdk 1.1.0 → 1.2.0

package/dist/fields.js

@@ -1,42 +1,31 @@
-/**
- * Система типів полів — серце платформи. Чистий, ізоморфний модуль.
- * Один опис поля → три споживачі:
- *   1. `zod`    — валідація (однакова на сервері й клієнті)
- *   2. `column` — тип колонки в БД
- *   3. `prim`/`kind` — ключі для резолву рендера (див. web/render/registry)
- */
 import { z } from 'zod';
-import ISO6391 from 'iso-639-1';
-import { resolveUnits } from './units.js';
-import { isCurrencyCode } from './currencies.js';
-// Пресети — тонкі обгортки над примітивами нижче. Циклічний імпорт безпечний:
-// преcети викликають фабрики лише в тілі функцій (фабрики — hoisted-декларації).
-import { presets } from './field-presets.js';
+import { resolveUnits } from "./units.js";
+import { isCurrencyCode } from "./currencies.js";
+import { vmsg, reqErr, typeErr, reqTypeErr, jsonRefined, optionalize, jsonValue } from "./fields/validation.js";
+export { vmsg, reqErr, typeErr, reqTypeErr, jsonRefined, optionalize, jsonValue, decodeVmsg, validateField } from "./fields/validation.js";
+export { normalizeOpts } from "./fields/normalize.js";
+import { normalizeOpts } from "./fields/normalize.js";
+import { presets } from "./field-presets.js";
 export const isField = (x) => 'key' in x && !('el' in x);
 export const isStatic = (x) => 'el' in x && x.el === 'static';
 export const isGroup = (x) => 'el' in x && x.el === 'group';
 export const isDivider = (x) => 'el' in x && x.el === 'divider';
 export const isInfo = (x) => 'el' in x && x.el === 'info';
 export const isButton = (x) => 'el' in x && x.el === 'button';
-// ─── Layout-фабрики ──────────────────────────────────────────────────────────
-/**
- * Візуальна або storage-група полів (один рівень вкладеності — груп усередині груп нема).
- * Без `key` → layout-група (не зберігається). З `key` → storage:
- *   - embedded (key, без multiple): зберігається як колонка або вкладений об'єкт.
- *   - collection (key + multiple): child-таблиця (масив рядків).
- * Storage-група вимагає `label` і лише `FieldItem`-нащадків (зі storage key).
- */
+export const isBreak = (x) => 'el' in x && x.el === 'break';
 export function group(o) {
+    const r = o.rules ?? {};
+    const v = o.view ?? {};
     if (o.key) {
         if (!o.label)
-            throw new Error(`[field.group] storage-група '${o.key}' потребує label`);
+            throw new Error(`[field.group] storage group '${o.key}' requires a label`);
         for (const f of o.fields) {
             if (!('key' in f))
-                throw new Error(`[field.group] storage-група '${o.key}': діти мусять бути FieldItem (мати key)`);
+                throw new Error(`[field.group] storage group '${o.key}': children must be FieldItem (have a key)`);
         }
-        for (const k of o.unique ?? []) {
+        for (const k of r.unique ?? []) {
             if (!o.fields.some((f) => 'key' in f && f.key === k))
-                throw new Error(`[field.group] '${o.key}': unique-ключ '${k}' не є сабфілдом`);
+                throw new Error(`[field.group] '${o.key}': unique key '${k}' is not a subfield`);
         }
     }
     return {
@@ -44,120 +33,143 @@ export function group(o) {
         key: o.key,
         multiple: o.multiple,
         required: o.required,
-        unique: o.unique,
+        unique: r.unique,
         label: o.label,
-        icon: o.icon,
+        icon: v.icon,
+        display: v.display ?? 'wrap',
+        kind: v.kind,
+        fixed: r.fixed,
         fields: o.fields,
     };
 }
+export function row(o) {
+    return group({ label: o.label, fields: o.fields, view: { ...o.view, display: 'scroll' } });
+}
+export function table(o) {
+    return group({
+        key: o.key,
+        label: o.label,
+        fields: o.fields,
+        multiple: true,
+        required: o.required,
+        rules: o.rules,
+        view: { ...o.view, display: 'table' },
+    });
+}
+export function sheet(o) {
+    const flat = [];
+    o.fields.forEach((rowFields, i) => {
+        if (i > 0)
+            flat.push(brk());
+        flat.push(...rowFields);
+    });
+    return group({ label: o.label, fields: flat, view: { ...o.view, display: 'sheet' } });
+}
+export function url(o) {
+    return group({
+        key: o.key,
+        label: o.label ?? o.key,
+        required: o.required,
+        view: { kind: 'url' },
+        fields: [
+            string({ key: 'scheme' }),
+            string({ key: 'username' }),
+            string({ key: 'password' }),
+            string({ key: 'host' }),
+            int({ key: 'port' }),
+            string({ key: 'path' }),
+            string({ key: 'query' }),
+            string({ key: 'hash' }),
+        ],
+    });
+}
+export function keyed(o) {
+    if (o.fixed && o.by.type.prim !== 'select')
+        throw new Error(`[field.keyed] fixed requires by=select (enumerated), got '${o.by.type.prim}'`);
+    const make = (o.container ?? group);
+    const g = make({ label: o.label, fields: [o.by, ...o.fields], view: o.view });
+    return {
+        ...g,
+        key: o.key,
+        multiple: true,
+        required: o.required,
+        unique: o.unique ?? [o.by.key],
+        fixed: o.fixed,
+    };
+}
 export const isStorageGroup = (g) => g.key != null;
 export const isCollectionGroup = (g) => g.key != null && g.multiple === true;
 export const isEmbeddedGroup = (g) => g.key != null && g.multiple !== true;
-/** Горизонтальний розділювач. */
 export function divider() {
     return { el: 'divider' };
 }
-/** Довідковий markdown-блок за i18n-ключем. */
+export function brk() {
+    return { el: 'break' };
+}
 export function info(textKey) {
     return { el: 'info', text: textKey };
 }
-/** Кнопка-дія: викликає обробник, зареєстрований у actionRegistry під ключем `value`. */
 export function button(o) {
     return { el: 'button', label: o.label, value: o.value, icon: o.icon, variant: o.variant };
 }
-/** Обгортає FieldMeta у FieldItem/StaticEl залежно від opts.key/opts.value. */
 export function wrapKey(opts, meta) {
-    // Бренд (phantom) існує лише в типі — у runtime повертаємо чистий { key, type }.
-    let m = opts.span != null ? { ...meta, span: opts.span } : meta;
+    let m = meta;
     if (opts.noEditControl)
         m = { ...m, hints: { ...m.hints, noEditControl: true } };
+    if (opts.default !== undefined)
+        m = { ...m, default: opts.default };
+    if (opts.hidden !== undefined)
+        m = { ...m, hidden: opts.hidden };
     if (opts.key)
         return { key: opts.key, type: m };
     if ('value' in opts && opts.value !== undefined)
         return { el: 'static', type: m, value: opts.value };
     return m;
 }
-// ─── Константи ────────────────────────────────────────────────────────────────
-/** Усі мови ISO 639-1 (native-назви як label). Джерело — пакет `iso-639-1`. */
-export const LANGUAGES = ISO6391.getAllCodes()
-    .map((code) => ({ code, name: ISO6391.getNativeName(code) }))
-    .sort((a, b) => a.name.localeCompare(b.name));
-/** Стать — спільний optionList 'sex' (реєструє plugin-core). i18n: core.sex.*. */
-export const SEX_OPTIONS = [
-    { value: 'M', title: 'core.sex.M' },
-    { value: 'F', title: 'core.sex.F' },
-    { value: 'other', title: 'core.sex.other' },
-];
-// ─── Helpers ──────────────────────────────────────────────────────────────────
-/** Структуроване повідомлення для zod: JSON {code, params}. Декодує mutate.ts. */
-export function vmsg(code, params) {
-    return JSON.stringify(params ? { code, params } : { code });
-}
-/** v4 error-map: повідомлення для відсутнього значення (колишній required_error). */
-export function reqErr(code = 'required') {
-    return { error: (iss) => (iss.input === undefined ? vmsg(code) : undefined) };
-}
-/** v4 error-map: повідомлення для невалідного типу (колишній invalid_type_error). */
-export function typeErr(code = 'invalid_type') {
-    return { error: (iss) => (iss.code === 'invalid_type' ? vmsg(code) : undefined) };
-}
-/** v4 error-map: required + invalid_type разом (колишні required_error + invalid_type_error). */
-export function reqTypeErr() {
-    return {
-        error: (iss) => iss.code === 'invalid_type' ? (iss.input === undefined ? vmsg('required') : vmsg('invalid_type')) : undefined,
-    };
-}
-/**
- * Спільна фабрика для полів, що зберігають JSON-рядок і валідуються вкладеною
- * zod-схемою: parse → inner.safeParse → при невдачі issue з кодом `code`,
- * при невалідному JSON — код 'json'. Уникає дублювання try/parse/superRefine.
- */
-export function jsonRefined(inner, code) {
-    return z.string(reqErr()).superRefine((val, ctx) => {
-        try {
-            const r = inner.safeParse(JSON.parse(val));
-            if (!r.success)
-                ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg(code) });
-        }
-        catch {
-            ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('json') });
-        }
-    });
-}
-export function optionalize(schema, required) {
-    return z.preprocess((v) => (v === '' || v === null ? undefined : v), required ? schema : schema.optional());
+export function isJsonStored(field) {
+    return field.json === true || field.hints['multiple'] === true;
 }
+export { LANGUAGES, SEX_OPTIONS, WEEKDAY_OPTIONS } from "./fields/constants.js";
+export { parseUrl, buildUrl, hrefOf } from "./fields/url.js";
 function resolveDate(v) {
     return v === 'today' ? new Date().toISOString().slice(0, 10) : v;
 }
-const uuidRe = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
-// ─── Модифікатори ───────────────────────────────────────────────────────────
-/**
- * Обгортає поле у JSON-масив значень (storage: TEXT). Внутрішній zod — `base.zod`.
- * Порядок модифікаторів: base → applyMultiple.
- *
- * Виняток: kind 'image'/'media' обробляє multiple сам у рендері (галерея) —
- * MultipleField*-обгортки на вебі їх пропускають.
- */
-/** Zod «JSON-масив значень inner» — спільне для applyMultiple і bindSelectSourceZod. */
+function safeJsonParse(s) {
+    try {
+        return JSON.parse(s);
+    }
+    catch {
+        return undefined;
+    }
+}
 function multipleZod(inner) {
-    return z.string(reqErr()).superRefine((val, ctx) => {
-        try {
-            const arr = JSON.parse(val);
-            if (!Array.isArray(arr)) {
-                ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('array') });
-                return;
+    return z.unknown().superRefine((raw, ctx) => {
+        let arr;
+        if (Array.isArray(raw)) {
+            arr = raw;
+        }
+        else if (typeof raw === 'string') {
+            try {
+                arr = JSON.parse(raw);
             }
-            for (const item of arr) {
-                const r = inner.safeParse(item);
-                if (!r.success) {
-                    ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('array_item') });
-                    return;
-                }
+            catch {
+                ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('json') });
+                return;
             }
         }
-        catch {
-            ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('json') });
+        else {
+            ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('array') });
+            return;
+        }
+        if (!Array.isArray(arr)) {
+            ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('array') });
+            return;
+        }
+        for (const item of arr) {
+            if (!inner.safeParse(item).success) {
+                ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('array_item') });
+                return;
+            }
         }
     });
 }
@@ -165,12 +177,13 @@ export function applyMultiple(base, multiple) {
     if (!multiple)
         return base;
     const s = multipleZod(base.zod);
-    return { ...base, column: 'text', hints: { ...base.hints, multiple: true }, zod: optionalize(s, base.required) };
+    return { ...base, column: 'text', hints: { ...base.hints, multiple: true }, json: true, zod: optionalize(s, base.required) };
 }
-export function string(o) {
+export function string(raw) {
+    const o = normalizeOpts(raw);
     const required = o.required ?? false;
-    const cfg = o.config ?? {};
-    const min = cfg.min ?? (required ? 1 : 0);
+    const cfg = (o.config ?? {});
+    const min = cfg.min ?? (o.required === true ? 1 : 0);
     let s = z.string(reqTypeErr());
     if (min > 0)
         s = s.min(min, { message: vmsg('min_length', { min }) });
@@ -195,20 +208,50 @@ export function string(o) {
     const meta = applyMultiple(base, o.multiple ?? false);
     return wrapKey(o, meta);
 }
-export function text(o) {
-    // Support legacy min/max at top-level (used internally by presets)
-    const mergedConfig = { ...o.config };
-    if (o.min != null && mergedConfig.min == null)
-        mergedConfig.min = o.min;
-    if (o.max != null && mergedConfig.max == null)
-        mergedConfig.max = o.max;
-    const meta = string({ ...o, key: undefined, value: undefined, config: mergedConfig });
+function pathField(o, kind, exts) {
+    const required = o.required ?? false;
+    let s = z.string(reqTypeErr());
+    if (o.required === true)
+        s = s.min(1, { message: vmsg('min_length', { min: 1 }) });
+    const base = {
+        kind,
+        label: o.label ?? '',
+        required,
+        prim: 'text',
+        column: 'text',
+        hints: exts && exts.length ? { exts } : {},
+        zod: optionalize(s, required),
+        ...(o.default !== undefined ? { default: o.default } : {}),
+    };
+    return wrapKey(o, base);
+}
+export function localDir(raw) {
+    return pathField(normalizeOpts(raw), 'localDir');
+}
+export function localFile(raw) {
+    const o = normalizeOpts(raw);
+    return pathField(o, 'localFile', o.exts);
+}
+export function text(raw) {
+    const o = normalizeOpts(raw);
+    const meta = string({ ...raw, key: undefined, value: undefined });
     const textMeta = { ...meta, prim: 'text', kind: 'textarea' };
     return wrapKey(o, textMeta);
 }
-export function real(o) {
+export function i18n(raw) {
+    const o = normalizeOpts(raw);
+    const meta = text({ ...raw, key: undefined, value: undefined });
+    return wrapKey(o, { ...meta, kind: 'i18n' });
+}
+export function smallText(raw) {
+    const o = normalizeOpts(raw);
+    const meta = text({ ...raw, key: undefined, value: undefined });
+    return wrapKey(o, { ...meta, kind: 'smalltext' });
+}
+export function real(raw) {
+    const o = normalizeOpts(raw);
     const required = o.required ?? false;
-    const cfg = o.config ?? {};
+    const cfg = (o.config ?? {});
     let s = z.coerce.number(typeErr());
     if (cfg.min != null)
         s = s.min(cfg.min, { message: vmsg('min', { min: cfg.min }) });
@@ -226,9 +269,10 @@ export function real(o) {
     const meta = applyMultiple(base, o.multiple ?? false);
     return wrapKey(o, meta);
 }
-export function int(o) {
+export function int(raw) {
+    const o = normalizeOpts(raw);
     const required = o.required ?? false;
-    const cfg = o.config ?? {};
+    const cfg = (o.config ?? {});
     let s = z.coerce.number(typeErr()).int({ message: vmsg('int') });
     if (cfg.min != null)
         s = s.min(cfg.min, { message: vmsg('min', { min: cfg.min }) });
@@ -246,12 +290,12 @@ export function int(o) {
     const meta = applyMultiple(base, o.multiple ?? false);
     return wrapKey(o, meta);
 }
-export function date(o) {
+export function date(raw) {
+    const o = normalizeOpts(raw);
     const required = o.required ?? false;
     const granularity = o.config?.granularity ?? 'day';
     let s;
     if (granularity === 'year') {
-        // year/month: min/max порівнюються лексикографічно як рядки (без resolveDate, на відміну від day)
         s = z
             .string(reqErr())
             .regex(/^\d{4}$/, { message: vmsg('date_format') })
@@ -296,7 +340,8 @@ export function date(o) {
     const meta = applyMultiple(base, o.multiple ?? false);
     return wrapKey(o, meta);
 }
-export function time(o) {
+export function time(raw) {
+    const o = normalizeOpts(raw);
     const required = o.required ?? false;
     const granularity = o.config?.granularity ?? 'second';
     const timeRegex = {
@@ -317,7 +362,8 @@ export function time(o) {
     const meta = applyMultiple(base, o.multiple ?? false);
     return wrapKey(o, meta);
 }
-export function datetime(o) {
+export function datetime(raw) {
+    const o = normalizeOpts(raw);
     const required = o.required ?? false;
     const granularity = o.config?.granularity ?? 'minute';
     const dtRegex = {
@@ -338,8 +384,9 @@ export function datetime(o) {
     const meta = applyMultiple(base, o.multiple ?? false);
     return wrapKey(o, meta);
 }
-export function boolean(o) {
-    const s = z.preprocess((v) => (v === 'true' || v === 1 || v === '1' ? true : v === 'false' || v === 0 || v === '0' ? false : v), z.boolean().default(false));
+export function boolean(raw) {
+    const o = normalizeOpts(raw);
+    const s = z.preprocess((v) => (v === 'true' || v === 1 || v === '1' ? true : v === 'false' || v === 0 || v === '0' ? false : v), z.boolean().default(false).nullable());
     const meta = {
         kind: 'boolean',
         label: o.label ?? '',
@@ -351,7 +398,8 @@ export function boolean(o) {
     };
     return wrapKey(o, meta);
 }
-export function triState(o) {
+export function triState(raw) {
+    const o = normalizeOpts(raw);
     const required = o.required ?? false;
     const s = z.enum(['yes', 'no', 'unknown'], { error: () => vmsg('enum') });
     const meta = {
@@ -365,9 +413,9 @@ export function triState(o) {
     };
     return wrapKey(o, meta);
 }
-export function select(o) {
+export function select(raw) {
+    const o = normalizeOpts(raw);
     const required = o.required ?? false;
-    // ── статичне джерело: NamedOptionList (string) або inline OptionItem[] ──
     const source = typeof o.options === 'string' ? o.options : null;
     const inlineOpts = Array.isArray(o.options) ? o.options : [];
     const s = inlineOpts.length > 0
@@ -386,63 +434,54 @@ export function select(o) {
     const meta = applyMultiple(base, o.multiple ?? false);
     return wrapKey(o, meta);
 }
-export function relation(o) {
+export function relation(raw) {
+    const o = normalizeOpts(raw);
     const required = o.required ?? false;
     const multi = o.multiple ?? false;
     let s;
     if (multi) {
-        s = z.string().superRefine((val, ctx) => {
-            try {
-                const arr = JSON.parse(val);
-                if (!Array.isArray(arr) || !arr.every((id) => uuidRe.test(id)))
-                    ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('uuid_list') });
-            }
-            catch {
-                ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('uuid_list') });
-            }
+        s = z.unknown().superRefine((raw, ctx) => {
+            const arr = jsonValue(raw);
+            if (!Array.isArray(arr) || !arr.every((id) => Number.isInteger(id) && id > 0))
+                ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('int_list') });
         });
     }
     else {
-        s = z.string().regex(uuidRe, { message: vmsg('uuid') });
+        s = z.coerce.number().int().positive({ message: vmsg('int') });
     }
     const meta = {
         kind: 'relation',
         label: o.label ?? '',
         required,
         prim: 'relation',
-        column: 'text',
+        column: multi ? 'text' : 'integer',
         hints: { multi, displayKey: o.displayKey ?? 'name' },
-        relation: { vault: o.vault, type: o.module },
+        relation: { vault: raw.options.vault, type: raw.options.module },
+        ...(multi && { json: true }),
         zod: optionalize(s, required),
     };
     return wrapKey(o, meta);
 }
-/**
- * Compose-time: підв'язати enum-валідацію source-селекту до значень списку.
- * Factory не знає вмісту optionList (списки збираються лише в composeRegistry),
- * тому zod source-полів спочатку z.string(); реєстр викликає це для кожного
- * такого поля, щоб сервер відхиляв значення поза списком.
- * Відтворює повний ланцюг модифікаторів: enum → multiple.
- */
 export function bindSelectSourceZod(field, values) {
     if (!values.length)
         return;
     const enumS = z.enum(values, { error: () => vmsg('enum') });
-    // Точне відтворення ланцюга factory: кожен крок обгортається в optionalize,
-    // як у select → applyMultiple.
     let s = optionalize(enumS, field.required);
     if (field.hints['multiple'] === true)
         s = optionalize(multipleZod(s), field.required);
     field.zod = s;
 }
-export function json(o) {
+export function json(raw) {
+    const o = normalizeOpts(raw);
     const required = o.required ?? false;
-    const s = z.string().superRefine((val, ctx) => {
-        try {
-            JSON.parse(val);
-        }
-        catch {
-            ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('json') });
+    const s = z.unknown().superRefine((raw, ctx) => {
+        if (typeof raw === 'string') {
+            try {
+                JSON.parse(raw);
+            }
+            catch {
+                ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('json') });
+            }
         }
     });
     const meta = {
@@ -452,35 +491,58 @@ export function json(o) {
         prim: 'json',
         column: 'text',
         hints: {},
+        json: true,
         zod: optionalize(s, required),
     };
     return wrapKey(o, meta);
 }
-export function checklist(o) {
+export function check(raw) {
+    const o = normalizeOpts(raw);
     const required = o.required ?? false;
-    const itemSchema = z.object({ done: z.boolean(), text: z.string().min(1) });
-    const s = jsonRefined(z.array(itemSchema), 'checklist_structure');
-    const base = {
-        kind: 'checklist',
+    const multiple = o.multiple ?? false;
+    const slots = o.slots && o.slots.length > 0 ? o.slots : [''];
+    if (multiple) {
+        const fields = [string({ key: 'text', label: 'core.fields.text' })];
+        slots.forEach((label, i) => fields.push(boolean({ key: `check${i}`, label: label || 'core.fields.check' })));
+        return group({ key: o.key, label: o.label ?? o.key, multiple: true, required: required, fields });
+    }
+    const shape = { text: z.string() };
+    const columns = { text: 'text' };
+    slots.forEach((_, i) => {
+        shape[`check${i}`] = z.boolean();
+        columns[`check${i}`] = 'boolean';
+    });
+    const rowSchema = z.object(shape).passthrough();
+    const s = z.unknown().superRefine((raw, ctx) => {
+        const parsed = typeof raw === 'string' ? safeJsonParse(raw) : raw;
+        if (parsed === undefined) {
+            ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('json') });
+            return;
+        }
+        if (!rowSchema.safeParse(parsed).success)
+            ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('check_structure') });
+    });
+    const meta = {
+        kind: 'check',
         label: o.label ?? '',
         required,
-        prim: 'checklist',
+        prim: 'check',
         column: 'text',
-        hints: {},
+        hints: { slots },
+        columns,
         zod: optionalize(s, required),
     };
-    const meta = applyMultiple(base, o.multiple ?? false);
     return wrapKey(o, meta);
 }
-export function measured(o) {
+export function measured(raw) {
+    const o = normalizeOpts(raw);
     const required = o.required ?? false;
     const cfg = o.config ?? {};
-    // Resolve units: string preset name or inline array
     const unitsSpec = (typeof o.options === 'string' ? o.options : o.options);
     const units = resolveUnits(unitsSpec);
     let numSchema = z.number().finite();
     if (cfg.step === 1)
-        numSchema = numSchema.int({ message: vmsg('int') }); // int via step:1 is not used, kept for compat
+        numSchema = numSchema.int({ message: vmsg('int') });
     if (cfg.min != null)
         numSchema = numSchema.min(cfg.min);
     if (cfg.max != null)
@@ -489,46 +551,47 @@ export function measured(o) {
         value: numSchema,
         unit: z.string().refine((v) => units.some((u) => u.value === v), { message: vmsg('measured_unit') }),
     });
-    const s = z.string().superRefine((val, ctx) => {
-        try {
-            const r = rowSchema.safeParse(JSON.parse(val));
-            if (!r.success) {
-                const vmsgIssue = r.error.issues.find((iss) => {
-                    try {
-                        return typeof JSON.parse(iss.message).code === 'string';
-                    }
-                    catch {
-                        return false;
-                    }
-                });
-                ctx.addIssue({
-                    code: z.ZodIssueCode.custom,
-                    message: vmsgIssue ? vmsgIssue.message : vmsg('measured_structure'),
-                });
-            }
-        }
-        catch {
+    const s = z.unknown().superRefine((raw, ctx) => {
+        const parsed = jsonValue(raw);
+        if (typeof parsed === 'string') {
             ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('json') });
+            return;
+        }
+        const r = rowSchema.safeParse(parsed);
+        if (!r.success) {
+            const vmsgIssue = r.error.issues.find((iss) => {
+                try {
+                    return typeof JSON.parse(iss.message).code === 'string';
+                }
+                catch {
+                    return false;
+                }
+            });
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: vmsgIssue ? vmsgIssue.message : vmsg('measured_structure'),
+            });
         }
     });
-    const base = {
+    const meta = {
         kind: 'measured',
         label: o.label ?? '',
         required,
         prim: 'measured',
         column: 'text',
         hints: {
-            units: o.options, // рядок або масив — як є
+            units: o.options,
             ...(cfg.min != null && { min: cfg.min }),
             ...(cfg.max != null && { max: cfg.max }),
             ...(cfg.step != null && { step: cfg.step }),
         },
+        columns: { value: 'real', unit: 'text' },
         zod: optionalize(s, required),
     };
-    const meta = applyMultiple(base, o.multiple ?? false);
     return wrapKey(o, meta);
 }
-export function money(o) {
+export function money(raw) {
+    const o = normalizeOpts(raw);
     const required = o.required ?? false;
     const cfg = o.config ?? {};
     let numSchema = z.number().finite();
@@ -540,17 +603,17 @@ export function money(o) {
         value: numSchema,
         currency: z.string().refine(isCurrencyCode, { message: vmsg('money_currency') }),
     });
-    const s = z.string().superRefine((val, ctx) => {
-        try {
-            const r = rowSchema.safeParse(JSON.parse(val));
-            if (!r.success)
-                ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('money_structure') });
-        }
-        catch {
+    const s = z.unknown().superRefine((raw, ctx) => {
+        const parsed = jsonValue(raw);
+        if (typeof parsed === 'string') {
             ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('json') });
+            return;
         }
+        const r = rowSchema.safeParse(parsed);
+        if (!r.success)
+            ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('money_structure') });
     });
-    const base = {
+    const meta = {
         kind: 'money',
         label: o.label ?? '',
         required,
@@ -561,23 +624,24 @@ export function money(o) {
             ...(cfg.min != null && { min: cfg.min }),
             ...(cfg.max != null && { max: cfg.max }),
         },
+        columns: { value: 'real', currency: 'text' },
         zod: optionalize(s, required),
     };
-    const meta = applyMultiple(base, o.multiple ?? false);
     return wrapKey(o, meta);
 }
-export function code(o) {
+export function code(raw) {
+    const o = normalizeOpts(raw);
     const required = o.required ?? false;
     const cfg = o.config ?? {};
     const rowSchema = z.object({ code: z.string(), lang: z.string() });
-    const s = z.string().superRefine((val, ctx) => {
-        try {
-            if (!rowSchema.safeParse(JSON.parse(val)).success)
-                ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('code_structure') });
-        }
-        catch {
+    const s = z.unknown().superRefine((raw, ctx) => {
+        const parsed = jsonValue(raw);
+        if (typeof parsed === 'string') {
             ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('json') });
+            return;
         }
+        if (!rowSchema.safeParse(parsed).success)
+            ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('code_structure') });
     });
     const base = {
         kind: 'code',
@@ -586,25 +650,27 @@ export function code(o) {
         prim: 'code',
         column: 'text',
         hints: { ...(cfg.defaultLang && { defaultLang: cfg.defaultLang }) },
+        columns: { code: 'text', lang: 'text' },
         zod: optionalize(s, required),
     };
     return wrapKey(o, base);
 }
-export function geo(o) {
+export function geo(raw) {
+    const o = normalizeOpts(raw);
     const required = o.required ?? false;
     const rowSchema = z.object({
         lat: z.number().min(-90).max(90),
         lng: z.number().min(-180).max(180),
         label: z.string().optional(),
     });
-    const s = z.string().superRefine((val, ctx) => {
-        try {
-            if (!rowSchema.safeParse(JSON.parse(val)).success)
-                ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('geo_structure') });
-        }
-        catch {
+    const s = z.unknown().superRefine((raw, ctx) => {
+        const parsed = jsonValue(raw);
+        if (typeof parsed === 'string') {
             ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('json') });
+            return;
         }
+        if (!rowSchema.safeParse(parsed).success)
+            ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('geo_structure') });
     });
     const base = {
         kind: 'geo',
@@ -613,45 +679,25 @@ export function geo(o) {
         prim: 'geo',
         column: 'text',
         hints: {},
+        columns: { lat: 'real', lng: 'real', label: 'text' },
         zod: optionalize(s, required),
     };
     return wrapKey(o, base);
 }
 export function perWeekday(o) {
-    const required = o.required ?? false;
-    const cfg = o.config ?? {};
-    let num = z.number(typeErr('per_weekday'));
-    if (cfg.min != null)
-        num = num.min(cfg.min, { message: vmsg('per_weekday') });
-    if (cfg.max != null)
-        num = num.max(cfg.max, { message: vmsg('per_weekday') });
-    const arrSchema = z.array(num).length(7);
-    const s = z.string().superRefine((val, ctx) => {
-        try {
-            const r = arrSchema.safeParse(JSON.parse(val));
-            if (!r.success)
-                ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('per_weekday') });
-        }
-        catch {
-            ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('json') });
-        }
-    });
-    const base = {
-        kind: 'perWeekday',
-        label: o.label ?? '',
-        required,
-        prim: 'per-weekday',
-        column: 'text',
-        hints: {
-            ...(cfg.min != null && { min: cfg.min }),
-            ...(cfg.max != null && { max: cfg.max }),
-            ...(cfg.step != null && { step: cfg.step }),
-        },
-        zod: optionalize(s, required),
+    return {
+        ...keyed({
+            key: o.key,
+            label: o.label,
+            by: select({ key: 'day', label: 'core.fields.weekday', options: 'weekdays' }),
+            fixed: true,
+            fields: [real({ key: 'value', label: 'core.fields.value', rules: o.rules })],
+        }),
+        kind: 'per-weekday',
     };
-    return wrapKey(o, base);
 }
-export function lookup(o) {
+export function lookup(raw) {
+    const o = normalizeOpts(raw);
     const meta = {
         kind: 'lookup',
         label: o.label ?? '',
@@ -664,62 +710,71 @@ export function lookup(o) {
     };
     return wrapKey(o, meta);
 }
-/**
- * Відновлює FieldMeta з клієнтського FieldClient (для рекурсивного рендеру
- * сабфілдів групових полів через FieldInput/FieldValue). zod тут не потрібен —
- * валідація відбувається на рівні схеми батьківського поля.
- */
 export function clientToMeta(fc) {
     return { ...fc, column: 'text', zod: z.any() };
 }
-export function period(o) {
-    const granularity = o.granularity ?? 'day';
-    const fromField = granularity === 'datetime'
-        ? datetime({ label: 'core.period.from' })
-        : date({ label: 'core.period.from', config: { granularity: granularity === 'month' ? 'month' : 'day' } });
-    const untilField = granularity === 'datetime'
-        ? datetime({ label: 'core.period.until' })
-        : date({ label: 'core.period.until', config: { granularity: granularity === 'month' ? 'month' : 'day' } });
-    // Самодостатній JSON-композит {from,until} (раніше будувався на field.row).
-    // Відчеплено від row, щоб row можна було видалити. Storage: JSON {from,until}
-    // (single) або [{from,until}] (multiple), як measured/keyValue.
+export function period(raw) {
+    const o = normalizeOpts(raw);
+    const granularity = (o.config?.granularity ?? 'day');
     const required = o.required ?? false;
     const multiple = o.multiple ?? false;
-    const subDefs = { from: fromField, until: untilField };
+    const mkSub = (key, label) => granularity === 'datetime'
+        ? datetime({ key, label })
+        : date({ key, label, rules: { granularity: granularity === 'month' ? 'month' : 'day' } });
+    if (multiple) {
+        return group({
+            key: o.key,
+            label: o.label ?? o.key,
+            multiple: true,
+            required: required,
+            fields: [mkSub('from', 'core.period.from'), mkSub('until', 'core.period.until')],
+        });
+    }
+    const fromField = mkSub('from', 'core.period.from');
+    const untilField = mkSub('until', 'core.period.until');
+    const subDefs = { from: fromField.type, until: untilField.type };
     const rowShape = {};
     for (const [key, fm] of Object.entries(subDefs))
         rowShape[key] = fm.zod.optional();
-    const rowSchema = z.object(rowShape).passthrough();
-    let s = jsonRefined(multiple ? z.array(rowSchema) : rowSchema, 'row_structure');
+    let s = z.object(rowShape).passthrough();
     s = s.superRefine((val, ctx) => {
-        if (val == null || typeof val !== 'string')
+        if (val == null)
             return;
-        try {
-            const parsed = JSON.parse(val);
-            const items = Array.isArray(parsed) ? parsed : [parsed];
-            for (const item of items) {
-                const r = item;
-                if (r?.from && r?.until && String(r.from) > String(r.until))
-                    ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('period_order') });
+        let parsed = val;
+        if (typeof val === 'string') {
+            try {
+                parsed = JSON.parse(val);
+            }
+            catch {
+                return;
             }
         }
-        catch {
-            /* already handled by jsonRefined */
+        const items = Array.isArray(parsed) ? parsed : [parsed];
+        for (const item of items) {
+            const r = item;
+            if (r?.from && r?.until && String(r.from) > String(r.until))
+                ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('period_order') });
         }
     });
-    const subFields = Object.entries(subDefs).map(([key, fm]) => ({ key, ...toClient(fm) }));
+    const colType = granularity === 'datetime' ? 'datetime' : granularity === 'day' ? 'date' : 'text';
+    const subFields = [
+        { key: 'from', ...toClient(fromField.type) },
+        { key: 'until', ...toClient(untilField.type) },
+    ];
     const meta = {
         kind: 'period',
         label: o.label ?? '',
         required,
         prim: 'period',
         column: 'text',
-        hints: { fields: subFields, rowMultiple: multiple, unique: [], granularity },
+        hints: { fields: subFields, rowMultiple: false, unique: [], granularity },
+        columns: { from: colType, until: colType },
         zod: optionalize(s, required),
     };
     return wrapKey(o, meta);
 }
-function makeFile(kind, o) {
+function makeFile(kind, raw) {
+    const o = normalizeOpts(raw);
     const required = o.required ?? false;
     const multiple = o.multiple ?? false;
     const rowSchema = z.object({
@@ -727,21 +782,23 @@ function makeFile(kind, o) {
         mime: z.string().optional(),
         size: z.number().optional(),
     });
-    // Schema accepts both single {name,...} and array [{name,...},...] stored as JSON.
-    // multiple=true expects an array; single accepts a single object or array.
-    const s = z.string().superRefine((val, ctx) => {
-        try {
-            const parsed = JSON.parse(val);
-            const items = Array.isArray(parsed) ? parsed : [parsed];
-            for (const it of items) {
-                if (!rowSchema.safeParse(it).success) {
-                    ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('file_structure') });
-                    return;
-                }
+    const s = z.unknown().superRefine((raw, ctx) => {
+        if (typeof raw === 'string') {
+            try {
+                JSON.parse(raw);
+            }
+            catch {
+                ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('json') });
+                return;
             }
         }
-        catch {
-            ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('json') });
+        const parsed = jsonValue(raw);
+        const items = Array.isArray(parsed) ? parsed : [parsed];
+        for (const it of items) {
+            if (!rowSchema.safeParse(it).success) {
+                ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('file_structure') });
+                return;
+            }
         }
     });
     const meta = {
@@ -751,6 +808,7 @@ function makeFile(kind, o) {
         prim: 'file',
         column: 'text',
         hints: multiple ? { multiple: true } : {},
+        json: true,
         zod: optionalize(s, required),
     };
     return wrapKey(o, meta);
@@ -773,41 +831,26 @@ export function image(o) {
 export function media(o) {
     return makeFile('media', o);
 }
-const kvItemSchema = z.object({ key: z.string().min(1), value: z.string() });
-export function keyValue(o) {
-    const required = o.required ?? false;
-    const multiple = o.multiple ?? true;
-    const s = z.string().superRefine((val, ctx) => {
-        try {
-            const r = z.array(kvItemSchema).safeParse(JSON.parse(val));
-            if (!r.success)
-                return ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('structure') });
-            if (!multiple && r.data.length > 1)
-                ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('kv_single') });
-        }
-        catch {
-            ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('json') });
-        }
-    });
-    const meta = {
-        kind: 'keyValue',
+export function avatar(o) {
+    return makeFile('avatar', o);
+}
+export function cover(o) {
+    return makeFile('cover', o);
+}
+export function keyValue(raw) {
+    const o = normalizeOpts(raw);
+    const valueType = { ...(o.option ?? string({ label: '' })), label: o.valueLabel ?? '' };
+    return keyed({
+        key: o.key,
         label: o.label ?? '',
-        required,
-        prim: 'key-value',
-        column: 'text',
-        // kvMultiple (НЕ multiple): «кілька пар» — внутрішня семантика віджету,
-        // не applyMultiple-обгортка. Інакше display/form гейти multiple ловлять його помилково.
-        hints: {
-            kvMultiple: multiple,
-            option: o.option ?? string({ label: '' }),
-            keyLabel: o.keyLabel,
-            valueLabel: o.valueLabel,
-        },
-        zod: optionalize(s, required),
-    };
-    return wrapKey(o, meta);
+        container: o.container ?? table,
+        by: string({ key: 'key', label: o.keyLabel ?? '' }),
+        fields: [{ key: 'value', type: valueType }],
+        required: o.required,
+    });
 }
-function makeRange(kind, int, o) {
+function makeRange(kind, int, raw) {
+    const o = normalizeOpts(raw);
     const required = o.required ?? false;
     const cfg = o.config ?? {};
     let n = z.number().finite();
@@ -818,19 +861,23 @@ function makeRange(kind, int, o) {
     if (cfg.max != null)
         n = n.max(cfg.max);
     const rowSchema = z.object({ from: n, to: n });
-    const s = z.string().superRefine((val, ctx) => {
-        try {
-            const r = rowSchema.safeParse(JSON.parse(val));
-            if (!r.success) {
-                ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('range_structure') });
+    const s = z.unknown().superRefine((raw, ctx) => {
+        if (typeof raw === 'string') {
+            try {
+                JSON.parse(raw);
+            }
+            catch {
+                ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('json') });
                 return;
             }
-            if (r.data.from > r.data.to)
-                ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('range_order') });
         }
-        catch {
-            ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('json') });
+        const r = rowSchema.safeParse(jsonValue(raw));
+        if (!r.success) {
+            ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('range_structure') });
+            return;
         }
+        if (r.data.from > r.data.to)
+            ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('range_order') });
     });
     const base = {
         kind,
@@ -843,6 +890,7 @@ function makeRange(kind, int, o) {
             ...(cfg.max != null && { max: cfg.max }),
             ...(cfg.step != null && { step: cfg.step }),
         },
+        columns: int ? { from: 'integer', to: 'integer' } : { from: 'real', to: 'real' },
         zod: optionalize(s, required),
     };
     return wrapKey(o, base);
@@ -853,17 +901,41 @@ export function numberRange(o) {
 export function realRange(o) {
     return makeRange('realRange', false, o);
 }
-// ─────────────────────────────────────────────────────────────────────────────
-//  f — єдина точка входу для визначення полів у типах
-// ─────────────────────────────────────────────────────────────────────────────
-/**
- * Базові примітиви (storage-aligned) + структурні типи. Пресети (тонкі обгортки
- * над цими примітивами) додаються нижче з field-presets.ts і НЕ можуть перебивати
- * жоден ключ звідси (guard у composeF).
- */
+export function embed(raw) {
+    const o = normalizeOpts(raw);
+    const required = o.required ?? false;
+    const multiple = o.multiple ?? false;
+    const recSchema = z.object({
+        url: z.string().min(1),
+        title: z.string().optional(),
+        description: z.string().optional(),
+        thumbnail: z.string().optional(),
+        provider: z.string().optional(),
+        type: z.enum(['video', 'rich', 'photo', 'link']).optional(),
+        html: z.string().optional(),
+        width: z.number().optional(),
+        height: z.number().optional(),
+    });
+    const s = jsonRefined(multiple ? z.array(recSchema) : z.union([recSchema, z.array(recSchema).max(1)]), 'embed_structure');
+    const meta = {
+        kind: 'embed',
+        label: o.label ?? '',
+        required,
+        prim: 'embed',
+        column: 'text',
+        hints: multiple ? { multiple: true } : {},
+        json: true,
+        zod: optionalize(s, required),
+    };
+    return wrapKey(o, meta);
+}
 const PRIMITIVES = {
     string,
     text,
+    i18n,
+    smallText,
+    localDir,
+    localFile,
     real,
     int,
     date,
@@ -874,7 +946,7 @@ const PRIMITIVES = {
     select,
     relation,
     json,
-    checklist,
+    check,
     measured,
     money,
     code,
@@ -888,24 +960,36 @@ const PRIMITIVES = {
     video,
     image,
     media,
+    avatar,
+    cover,
+    embed,
     keyValue,
     numberRange,
     realRange,
     group,
+    row,
+    table,
+    sheet,
+    keyed,
+    url,
     divider,
+    break: brk,
     info,
     button,
 };
-/** Збирає `f`, гарантуючи, що жоден пресет не затіняє примітив. */
 function composeF(presets) {
     for (const k of Object.keys(presets))
         if (k in PRIMITIVES)
-            throw new Error(`[f] пресет '${k}' перебиває примітив`);
+            throw new Error(`[f] preset '${k}' overrides a primitive`);
     return { ...PRIMITIVES, ...presets };
 }
-export const field = composeF(presets);
+let _composed;
+const composedField = () => (_composed ??= composeF(presets));
+export const field = new Proxy({}, {
+    get: (_t, k) => composedField()[k],
+    has: (_t, k) => k in composedField(),
+});
 export function toClient(field) {
-    const { kind, label, required, prim, hints, options, relation, virtual } = field;
-    return { kind, label, required, prim, hints, options, relation, virtual };
+    const { kind, label, required, prim, hints, options, relation, virtual, json, hidden } = field;
+    return { kind, label, required, prim, hints, options, relation, virtual, json, hidden };
 }
-//# sourceMappingURL=fields.js.map