@mintplayer/ng-spark 22.22.0 → 22.24.0

package/fesm2022/mintplayer-ng-spark-models.mjs

@@ -1,826 +1,438 @@
-import { signal } from '@angular/core';
-
-/** Global reactive language state — shared across library boundaries via globalThis */
-const currentLanguage = (globalThis.__sparkCurrentLanguage ??= signal('en'));
+import { signal } from "@angular/core";
+const currentLanguage = globalThis.__sparkCurrentLanguage ??= signal("en");
 function resolveTranslation(ts, lang) {
-    if (!ts)
-        return '';
-    const language = lang ?? currentLanguage();
-    return ts[language] ?? ts['en'] ?? Object.values(ts)[0] ?? '';
+	if (!ts) return "";
+	return ts[lang ?? currentLanguage()] ?? ts["en"] ?? Object.values(ts)[0] ?? "";
 }
-
-/**
- * Flags enum controlling on which pages an attribute should be displayed.
- * Values can be combined: ShowedOn.Query | ShowedOn.PersistentObject
- */
 var ShowedOn;
-(function (ShowedOn) {
-    ShowedOn[ShowedOn["Query"] = 1] = "Query";
-    ShowedOn[ShowedOn["PersistentObject"] = 2] = "PersistentObject";
+(function(ShowedOn) {
+	ShowedOn[ShowedOn["Query"] = 1] = "Query";
+	ShowedOn[ShowedOn["PersistentObject"] = 2] = "PersistentObject";
 })(ShowedOn || (ShowedOn = {}));
-/**
- * Helper function to check if a ShowedOn value includes a specific flag.
- */
 function hasShowedOnFlag(value, flag) {
-    if (value === undefined)
-        return true; // Default: show on all pages
-    // Handle string values from JSON (e.g., "Query, PersistentObject")
-    if (typeof value === 'string') {
-        const parts = value.split(',').map(s => s.trim());
-        const flagName = ShowedOn[flag];
-        return parts.includes(flagName);
-    }
-    // Handle numeric flag values
-    return (value & flag) === flag;
+	if (value === void 0) return true;
+	if (typeof value === "string") {
+		const parts = value.split(",").map((s) => s.trim());
+		const flagName = ShowedOn[flag];
+		return parts.includes(flagName);
+	}
+	return (value & flag) === flag;
 }
-
-/**
- * Controls how a Reference attribute is picked in the PO-edit form.
- * Serialized as a string by the server (mirrors the .NET EReferenceDisplayType).
- */
 var EReferenceDisplayType;
-(function (EReferenceDisplayType) {
-    /** Renders as a `<bs-select>` listing every referenced item. */
-    EReferenceDisplayType["Dropdown"] = "Dropdown";
-    /** Renders a readonly textbox + "…" button that opens a searchable modal grid picker. */
-    EReferenceDisplayType["Modal"] = "Modal";
+(function(EReferenceDisplayType) {
+	EReferenceDisplayType["Dropdown"] = "Dropdown";
+	EReferenceDisplayType["Modal"] = "Modal";
 })(EReferenceDisplayType || (EReferenceDisplayType = {}));
-
-/**
- * Conversions between the wire format for a timestamp and what an `<input type="datetime-local">`
- * or `<input type="date">` will accept.
- *
- * A `DateTimeOffset` in Spark means an **instant**. The wire carries a full ISO-8601 string with an
- * offset (`2026-12-31T23:59:00-08:00`); an HTML date/time control speaks only bare local wall clock
- * (`2026-12-31T23:59`). Neither end can consume the other's format, so both directions need
- * converting, and the browser is deliberately the side that does it: its timezone rules are kept
- * fresh by the operating system, while a container's are frozen at image build time.
- *
- * Assigning a wire value straight to a `datetime-local` input does not throw and does not warn -- the
- * control simply renders **blank**, and saving the untouched form then writes that blank back.
- */
 function pad(n) {
-    return String(n).padStart(2, '0');
+	return String(n).padStart(2, "0");
 }
-/** Formats a UTC offset in minutes as `+HH:mm` / `-HH:mm`. */
 function formatOffset(offsetMinutes) {
-    const sign = offsetMinutes >= 0 ? '+' : '-';
-    const abs = Math.abs(offsetMinutes);
-    return `${sign}${pad(Math.floor(abs / 60))}:${pad(abs % 60)}`;
-}
-/**
- * Parses a wire timestamp. Returns `null` for anything unusable, matching the contract of
- * `parsedDate` / `queryCellValue` -- a bad value renders as empty rather than as `Invalid Date`.
- */
+	const sign = offsetMinutes >= 0 ? "+" : "-";
+	const abs = Math.abs(offsetMinutes);
+	return `${sign}${pad(Math.floor(abs / 60))}:${pad(abs % 60)}`;
+}
 function parseWireDate(value) {
-    if (value === null || value === undefined || value === '')
-        return null;
-    if (value instanceof Date)
-        return isNaN(value.getTime()) ? null : value;
-    if (typeof value !== 'string' && typeof value !== 'number')
-        return null;
-    const parsed = new Date(value);
-    return isNaN(parsed.getTime()) ? null : parsed;
-}
-/**
- * Wire value -> the `yyyy-MM-ddTHH:mm` a `datetime-local` input needs, in the **viewer's** zone.
- *
- * The conversion is date-sensitive, not a fixed shift: a value is rendered using the zone's offset
- * *on that value's own date*, so a timestamp in July and one in January convert differently in a
- * zone that observes DST.
- */
+	if (value === null || value === void 0 || value === "") return null;
+	if (value instanceof Date) return isNaN(value.getTime()) ? null : value;
+	if (typeof value !== "string" && typeof value !== "number") return null;
+	const parsed = new Date(value);
+	return isNaN(parsed.getTime()) ? null : parsed;
+}
 function toDateTimeLocalInput(value) {
-    const d = parseWireDate(value);
-    if (!d)
-        return '';
-    return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}T${pad(d.getHours())}:${pad(d.getMinutes())}`;
+	const d = parseWireDate(value);
+	if (!d) return "";
+	return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}T${pad(d.getHours())}:${pad(d.getMinutes())}`;
 }
-/** Wire value -> the `yyyy-MM-dd` a `date` input needs, in the viewer's zone. */
 function toDateInput(value) {
-    const d = parseWireDate(value);
-    if (!d)
-        return '';
-    return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`;
-}
-/**
- * `yyyy-MM-ddTHH:mm` from the control -> a complete ISO-8601 string carrying the viewer's offset
- * **for the entered date**.
- *
- * Building the `Date` from its parts rather than parsing the string is what makes this correct: it
- * lets the browser apply its own timezone rules for that date, including DST. Using the *current*
- * offset instead would be wrong for any value outside the present season -- entering a January date
- * during summer would record an offset an hour off, and the stored instant would be an hour wrong.
- *
- * Across a DST discontinuity the browser resolves the wall clock itself, taking the offset in force
- * before a fall-back and after a spring-forward. That is specified ECMAScript behaviour, and the
- * server's conversion helper deliberately reproduces the same choice so the two cannot drift.
- */
+	const d = parseWireDate(value);
+	if (!d) return "";
+	return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`;
+}
 function fromDateTimeLocalInput(local) {
-    if (typeof local !== 'string' || local === '')
-        return null;
-    const match = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})(?::(\d{2}))?/.exec(local);
-    if (!match)
-        return null;
-    const [, y, mo, d, h, mi, s] = match;
-    const date = new Date(+y, +mo - 1, +d, +h, +mi, s ? +s : 0);
-    if (isNaN(date.getTime()))
-        return null;
-    // getTimezoneOffset() is minutes to ADD to local to reach UTC, so it is the negation of the offset
-    // an ISO string carries.
-    return `${y}-${mo}-${d}T${h}:${mi}:${pad(s ? +s : 0)}${formatOffset(-date.getTimezoneOffset())}`;
-}
-/** `yyyy-MM-dd` from a `date` control -> an ISO string at local midnight with the viewer's offset. */
+	if (typeof local !== "string" || local === "") return null;
+	const match = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})(?::(\d{2}))?/.exec(local);
+	if (!match) return null;
+	const [, y, mo, d, h, mi, s] = match;
+	const date = new Date(+y, +mo - 1, +d, +h, +mi, s ? +s : 0);
+	if (isNaN(date.getTime())) return null;
+	return `${y}-${mo}-${d}T${h}:${mi}:${pad(s ? +s : 0)}${formatOffset(-date.getTimezoneOffset())}`;
+}
 function fromDateInput(local) {
-    if (typeof local !== 'string' || local === '')
-        return null;
-    const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(local);
-    if (!match)
-        return null;
-    return fromDateTimeLocalInput(`${local}T00:00`);
-}
-/**
- * Compares two wire timestamps **by instant**, which is what a `DateTimeOffset` means in Spark.
- *
- * Round-tripping a value through a date control legitimately rewrites its text -- a document holding
- * `2026-12-31T23:59:00-08:00` comes back as `2027-01-01T08:59:00+01:00` from a viewer in Brussels --
- * so a string comparison would mark every untouched date as edited and send a needless write on every
- * save. Both of those name the same moment.
- *
- * Note this is the *opposite* of the trap on the server side, where `DateTimeOffset.Equals` compares
- * the instant and silently hides a destroyed offset. Here comparing by instant is the correct thing:
- * we are asking "did the user change this value", not "is the offset intact".
- */
+	if (typeof local !== "string" || local === "") return null;
+	if (!/^(\d{4})-(\d{2})-(\d{2})$/.exec(local)) return null;
+	return fromDateTimeLocalInput(`${local}T00:00`);
+}
 function wireDatesEqual(a, b) {
-    const da = parseWireDate(a);
-    const db = parseWireDate(b);
-    if (da === null || db === null)
-        return da === db;
-    return da.getTime() === db.getTime();
+	const da = parseWireDate(a);
+	const db = parseWireDate(b);
+	if (da === null || db === null) return da === db;
+	return da.getTime() === db.getTime();
 }
-/** True for the attribute data types that are edited through a native date/time control. */
 function isDateDataType(dataType) {
-    return dataType === 'date' || dataType === 'datetime';
+	return dataType === "date" || dataType === "datetime";
 }
-/** Wire -> control, picking the right shape for the data type. */
 function toDateInputValue(dataType, value) {
-    return dataType === 'date' ? toDateInput(value) : toDateTimeLocalInput(value);
+	return dataType === "date" ? toDateInput(value) : toDateTimeLocalInput(value);
 }
-/** Control -> wire, picking the right shape for the data type. */
 function fromDateInputValue(dataType, value) {
-    return dataType === 'date' ? fromDateInput(value) : fromDateTimeLocalInput(value);
+	return dataType === "date" ? fromDateInput(value) : fromDateTimeLocalInput(value);
 }
-
-/**
- * Flattens a nested `PersistentObject` into the plain `Record<string, any>` shape the
- * form state uses throughout ng-spark. Primitive / reference attributes contribute their
- * `value`; nested AsDetail attributes recurse — single becomes an inner dict, array
- * becomes an array of inner dicts. Returns `{}` for `null` / `undefined` input.
- *
- * This is the ONE place that reads the server's new AsDetail wire shape and collapses it
- * back to the flat dict the form components already handle.
- */
 function nestedPoToDict(po) {
-    if (!po)
-        return {};
-    const dict = {};
-    for (const attr of po.attributes ?? []) {
-        dict[attr.name] = attributeValueForForm(attr);
-    }
-    // The object's own server-resolved breadcrumb, kept under a reserved key so the form can label
-    // it without re-deriving a template it may be structurally unable to resolve. Safe to carry
-    // through save: `dictToNestedPo` walks the entity type's attributes, never the dict's keys, so
-    // a reserved key is never sent to the server. Attached only when it resolved, which keeps the
-    // common case byte-for-byte identical to the plain flat dict.
-    if (typeof po.breadcrumb === 'string' && po.breadcrumb !== '') {
-        dict[AS_DETAIL_SELF_BREADCRUMB_KEY] = po.breadcrumb;
-    }
-    // The row's own key, same reserved-key mechanism and for a sharper reason: without it the key
-    // never returns, and a save cannot tell an edited row from a deleted one plus a new one. See
-    // AS_DETAIL_ROW_KEY.
-    if (typeof po.id === 'string' && po.id !== '') {
-        dict[AS_DETAIL_ROW_KEY] = po.id;
-    }
-    // The wire values of any date cells, kept so the save side can tell an untouched cell from an
-    // edited one. Without it, flattening to a wall clock and converting back rewrites the stored
-    // offset to the viewer's on every save, even for rows nobody touched.
-    const originalDates = originalDatesOf(po);
-    if (originalDates)
-        dict[AS_DETAIL_ORIGINAL_DATES_KEY] = originalDates;
-    return dict;
+	if (!po) return {};
+	const dict = {};
+	for (const attr of po.attributes ?? []) dict[attr.name] = attributeValueForForm(attr);
+	if (typeof po.breadcrumb === "string" && po.breadcrumb !== "") dict[AS_DETAIL_SELF_BREADCRUMB_KEY] = po.breadcrumb;
+	if (typeof po.id === "string" && po.id !== "") dict[AS_DETAIL_ROW_KEY] = po.id;
+	const originalDates = originalDatesOf(po);
+	if (originalDates) dict[AS_DETAIL_ORIGINAL_DATES_KEY] = originalDates;
+	return dict;
 }
 function originalDatesOf(po) {
-    let originals;
-    for (const attr of po.attributes ?? []) {
-        if (isDateDataType(attr.dataType))
-            (originals ??= {})[attr.name] = attr.value;
-    }
-    return originals;
+	let originals;
+	for (const attr of po.attributes ?? []) if (isDateDataType(attr.dataType)) (originals ??= {})[attr.name] = attr.value;
+	return originals;
 }
 function attributeValueForForm(attr) {
-    if (attr.dataType === 'AsDetail') {
-        if (attr.isArray)
-            return (attr.objects ?? []).map(po => nestedPoToDict(po));
-        return attr.object ? nestedPoToDict(attr.object) : null;
-    }
-    // An embedded row's date cells are edited through the same native controls as a root object's,
-    // so they need the same wire -> wall-clock conversion. This is the FORM path only;
-    // `nestedPoToDisplayRow` deliberately keeps the wire value, because the display path formats
-    // through `parsedDate` rather than feeding an input.
-    if (isDateDataType(attr.dataType))
-        return toDateInputValue(attr.dataType, attr.value);
-    return attr.value;
-}
-/**
- * Reserved key under which a flattened nested object keeps the breadcrumb the SERVER resolved for
- * that object itself (as opposed to {@link AS_DETAIL_BREADCRUMBS_KEY}, which keys the breadcrumbs
- * of its reference attributes by attribute name).
- *
- * This exists because a breadcrumb template can name a property the model does not carry. HR's
- * `Address` declares `[Breadcrumb, IgnoreProperty] string Crumb`, and `Address.json` renders it as
- * `"{Crumb}"` — the server resolves that by reflecting over the CLR property, which no client can
- * do, because `[IgnoreProperty]` is exactly the instruction to keep it out of the model. Flattening
- * used to discard the resolved string, leaving the form to substitute `{Crumb}` against a dict that
- * can never contain it.
- */
-const AS_DETAIL_SELF_BREADCRUMB_KEY = '__sparkBreadcrumb';
-/**
- * Reserved key under which a flattened nested object keeps its own row key — the value of whatever
- * property the server registered as that type's `[ValueKey]`.
- *
- * A value object's key is not a model attribute (nothing declares `Id` in its model file), so it
- * travels as the nested `PersistentObject`'s `id` and has to be carried across the flat-dict form
- * state by hand. Before this existed, flattening dropped it and `dictToNestedPo` rebuilt `id` from
- * `dict['Id']`, which is never present — so **every** embedded row reached the server with an empty
- * id, and the fresh instance the mapper builds kept the guid its own field initializer had just
- * minted.
- *
- * That is not cosmetic. Stored keys and incoming keys were then both plausible and never equal, so
- * a save could not match rows: an edit was indistinguishable from a delete plus a create. Every
- * per-row rule — preserving read-only fields, and the `New`/`Edit`/`Delete` rights of the row type —
- * rests on this key surviving the round trip.
- *
- * Safe to carry, for the same reason the breadcrumb is: `dictToNestedPo` walks the entity type's
- * attributes and never the dict's keys, so a reserved key is never sent back as an attribute.
- */
-const AS_DETAIL_ROW_KEY = '__sparkRowKey';
-/**
- * The breadcrumb the server resolved for a flattened object, or null when it resolved to nothing.
- *
- * `EntityMapper` never emits an empty breadcrumb: when the template renders blank it substitutes
- * the CLR type name, so an unset `Address` arrives as the literal string `"Address"`
- * (EntityMapper.cs:209-211). That is a placeholder, not data, and rendering it would be worse than
- * rendering nothing — it reads as a real value. `typeName` lets a caller filter it back out.
- */
+	if (attr.dataType === "AsDetail") {
+		if (attr.isArray) return (attr.objects ?? []).map((po) => nestedPoToDict(po));
+		return attr.object ? nestedPoToDict(attr.object) : null;
+	}
+	if (isDateDataType(attr.dataType)) return toDateInputValue(attr.dataType, attr.value);
+	return attr.value;
+}
+const AS_DETAIL_SELF_BREADCRUMB_KEY = "__sparkBreadcrumb";
+const AS_DETAIL_ROW_KEY = "__sparkRowKey";
 function selfBreadcrumb(row, typeName) {
-    return resolvedBreadcrumb(row?.[AS_DETAIL_SELF_BREADCRUMB_KEY], typeName);
-}
-/**
- * The same filter as {@link selfBreadcrumb}, for a caller holding the server's breadcrumb string
- * directly rather than a flattened row dict — `attr.object.breadcrumb` on a detail page, or a query
- * cell's `breadcrumb`.
- *
- * Split out so there is exactly one answer to "is this the type-name placeholder?". The first
- * implementation lived inside `selfBreadcrumb` and so covered only the two pipes that flatten a row
- * first; the two that read the string straight off the wire kept printing `BuildFeedback` and
- * `GateSettings` at users (#384). A second copy of the comparison is how that happens again.
- */
+	return resolvedBreadcrumb(row?.[AS_DETAIL_SELF_BREADCRUMB_KEY], typeName);
+}
 function resolvedBreadcrumb(value, typeName) {
-    if (typeof value !== 'string' || value.trim() === '')
-        return null;
-    // Callers hold the type name in two shapes — `EntityType.name` is the short model name, while an
-    // attribute's `asDetailType` is the full CLR name — and the server's placeholder is always the
-    // short one. Compare on the last dotted segment so either shape filters it.
-    if (typeName) {
-        const shortName = typeName.slice(typeName.lastIndexOf('.') + 1);
-        if (value === shortName)
-            return null;
-    }
-    return value;
-}
-/**
- * Reserved key under which {@link nestedPoToDisplayRow} stashes the server-resolved breadcrumb of
- * each reference attribute (keyed by attribute name). Lets an AsDetail reference cell render the
- * label the server already resolved by id — page-independent — instead of guessing from a single
- * reference-query options page. Prefixed to avoid colliding with a real attribute name.
- */
-const AS_DETAIL_BREADCRUMBS_KEY = '__sparkBreadcrumbs';
-/**
- * Reserved key under which a flattened row keeps the **wire** values of its date cells, keyed by
- * attribute name.
- *
- * A date cell is edited through a native control that speaks only a bare local wall clock, so
- * flattening converts the stored instant into the viewer's zone and saving converts it back. That
- * round trip preserves the instant but necessarily rewrites the **offset** to the viewer's. For a
- * cell the user actually edited that is correct — the offset is not business data. For one nobody
- * touched it is pure loss: merely opening a row and saving would relabel a Seattle timestamp as a
- * Brussels one.
- *
- * Keeping the original lets {@link dictToNestedPo} send back exactly what it was given whenever the
- * instant is unchanged. Safe to carry for the same reason as the other reserved keys: the rebuild
- * walks the entity type's attributes, never the dict's keys.
- */
-const AS_DETAIL_ORIGINAL_DATES_KEY = '__sparkOriginalDates';
-/**
- * Whether a flattened-row key is one this module reserved rather than a model attribute.
- *
- * `nestedPoToDict` and `nestedPoToDisplayRow` stash the row key and the resolved breadcrumbs
- * alongside the real values, which is safe on the way back — `dictToNestedPo` walks the entity
- * type's attributes and never the dict's keys. It is *not* safe for anything that enumerates the
- * dict to build display text: a caller joining `Object.values(dict)` prints the row's guid and its
- * own breadcrumb as though they were fields.
- */
+	if (typeof value !== "string" || value.trim() === "") return null;
+	if (typeName) {
+		if (value === typeName.slice(typeName.lastIndexOf(".") + 1)) return null;
+	}
+	return value;
+}
+const AS_DETAIL_BREADCRUMBS_KEY = "__sparkBreadcrumbs";
+const AS_DETAIL_ORIGINAL_DATES_KEY = "__sparkOriginalDates";
 function isReservedAsDetailKey(key) {
-    return key === AS_DETAIL_ROW_KEY
-        || key === AS_DETAIL_SELF_BREADCRUMB_KEY
-        || key === AS_DETAIL_BREADCRUMBS_KEY
-        || key === AS_DETAIL_ORIGINAL_DATES_KEY;
-}
-/**
- * Like {@link nestedPoToDict}, but for the read-only detail display path. In addition to each
- * attribute's value it preserves the server-resolved per-reference `breadcrumb` under
- * {@link AS_DETAIL_BREADCRUMBS_KEY}, so an AsDetail reference cell can render the label by id
- * regardless of whether the referenced document fits on the reference query's first options page.
- * The form/edit path keeps using {@link nestedPoToDict}, which never carries breadcrumbs.
- */
+	return key === "__sparkRowKey" || key === "__sparkBreadcrumb" || key === "__sparkBreadcrumbs" || key === "__sparkOriginalDates";
+}
 function nestedPoToDisplayRow(po) {
-    if (!po)
-        return {};
-    const dict = {};
-    let breadcrumbs;
-    for (const attr of po.attributes ?? []) {
-        dict[attr.name] = displayValueForAttribute(attr);
-        if (attr.dataType === 'Reference' && !attr.isArray && typeof attr.breadcrumb === 'string' && attr.breadcrumb !== '') {
-            (breadcrumbs ??= {})[attr.name] = attr.breadcrumb;
-        }
-    }
-    // Only attach the side channel when something resolved — keeps reference-free rows (the common
-    // case) byte-for-byte identical to the plain flat dict.
-    if (breadcrumbs)
-        dict[AS_DETAIL_BREADCRUMBS_KEY] = breadcrumbs;
-    // Same self-breadcrumb the form path carries: a nested-AsDetail COLUMN in a detail table has an
-    // inner dict as its value, which used to stringify to "[object Object]".
-    if (typeof po.breadcrumb === 'string' && po.breadcrumb !== '') {
-        dict[AS_DETAIL_SELF_BREADCRUMB_KEY] = po.breadcrumb;
-    }
-    // And the row key, for the same reason as the form path — a display row can be handed back for
-    // saving, and a row that loses its key on that trip is indistinguishable from a new one.
-    if (typeof po.id === 'string' && po.id !== '') {
-        dict[AS_DETAIL_ROW_KEY] = po.id;
-    }
-    return dict;
+	if (!po) return {};
+	const dict = {};
+	let breadcrumbs;
+	for (const attr of po.attributes ?? []) {
+		dict[attr.name] = displayValueForAttribute(attr);
+		if (attr.dataType === "Reference" && !attr.isArray && typeof attr.breadcrumb === "string" && attr.breadcrumb !== "") (breadcrumbs ??= {})[attr.name] = attr.breadcrumb;
+	}
+	if (breadcrumbs) dict[AS_DETAIL_BREADCRUMBS_KEY] = breadcrumbs;
+	if (typeof po.breadcrumb === "string" && po.breadcrumb !== "") dict[AS_DETAIL_SELF_BREADCRUMB_KEY] = po.breadcrumb;
+	if (typeof po.id === "string" && po.id !== "") dict[AS_DETAIL_ROW_KEY] = po.id;
+	return dict;
 }
 function displayValueForAttribute(attr) {
-    if (attr.dataType === 'AsDetail') {
-        if (attr.isArray)
-            return (attr.objects ?? []).map(po => nestedPoToDisplayRow(po));
-        return attr.object ? nestedPoToDisplayRow(attr.object) : null;
-    }
-    return attr.value;
-}
-/**
- * Builds a nested `PersistentObject` from a flat dict against the schema in
- * <paramref name="entityType"/>. Used when the form is about to save — AsDetail attributes
- * are no longer sent as flat dicts in `attribute.value`; the server now requires
- * `attribute.object` / `attribute.objects` with fully scaffolded nested POs.
- *
- * `resolve` walks through AsDetail types registered elsewhere (usually the full
- * `getEntityTypes()` list, keyed by CLR type name). Nested AsDetail inside AsDetail is
- * handled recursively.
- */
+	if (attr.dataType === "AsDetail") {
+		if (attr.isArray) return (attr.objects ?? []).map((po) => nestedPoToDisplayRow(po));
+		return attr.object ? nestedPoToDisplayRow(attr.object) : null;
+	}
+	return attr.value;
+}
 function dictToNestedPo(dict, entityType, resolve) {
-    const originalDates = (dict?.[AS_DETAIL_ORIGINAL_DATES_KEY] ?? {});
-    const attributes = (entityType.attributes ?? [])
-        .map(attrDef => buildAttribute(attrDef, dict?.[attrDef.name], resolve, originalDates[attrDef.name]));
-    return {
-        // The reserved key first: it is the only one that is always present for a stored row, because
-        // a value object's key is not a model attribute. `Id`/`id` remain as fallbacks for a root
-        // object, whose id genuinely is part of the dict.
-        id: dict?.[AS_DETAIL_ROW_KEY] ?? dict?.['Id'] ?? dict?.['id'] ?? '',
-        name: entityType.name,
-        objectTypeId: entityType.id,
-        attributes,
-    };
+	const originalDates = dict?.["__sparkOriginalDates"] ?? {};
+	const attributes = (entityType.attributes ?? []).map((attrDef) => buildAttribute(attrDef, dict?.[attrDef.name], resolve, originalDates[attrDef.name]));
+	return {
+		id: dict?.["__sparkRowKey"] ?? dict?.["Id"] ?? dict?.["id"] ?? "",
+		name: entityType.name,
+		objectTypeId: entityType.id,
+		attributes
+	};
 }
 function buildAttribute(attrDef, raw, resolve, originalDate) {
-    const attr = {
-        id: attrDef.id,
-        name: attrDef.name,
-        label: attrDef.label,
-        dataType: attrDef.dataType,
-        isArray: attrDef.isArray,
-        isRequired: attrDef.isRequired,
-        isVisible: attrDef.isVisible,
-        isReadOnly: attrDef.isReadOnly,
-        order: attrDef.order,
-        rules: attrDef.rules ?? [],
-        isValueChanged: true,
-    };
-    if (attrDef.dataType === 'AsDetail') {
-        // Server expects attr.value null for AsDetail; the nested PO carries the data.
-        attr.value = null;
-        attr.asDetailType = attrDef.asDetailType;
-        const nestedType = attrDef.asDetailType ? resolve(attrDef.asDetailType) : undefined;
-        if (!nestedType) {
-            attr.object = null;
-            attr.objects = attrDef.isArray ? [] : null;
-            return attr;
-        }
-        if (attrDef.isArray) {
-            const items = Array.isArray(raw) ? raw : [];
-            attr.objects = items.map(item => dictToNestedPo(item ?? {}, nestedType, resolve));
-        }
-        else {
-            attr.object = raw ? dictToNestedPo(raw, nestedType, resolve) : null;
-        }
-        return attr;
-    }
-    if (isDateDataType(attrDef.dataType)) {
-        // The mirror of the conversion in `attributeValueForForm`: back from the control's bare wall
-        // clock to a complete ISO-8601 instant carrying the viewer's offset for that date. When the
-        // instant is unchanged, send back exactly what was loaded instead, so an untouched row keeps
-        // its stored offset. See AS_DETAIL_ORIGINAL_DATES_KEY.
-        const converted = fromDateInputValue(attrDef.dataType, raw);
-        attr.value = wireDatesEqual(converted, originalDate) ? originalDate : converted;
-        return attr;
-    }
-    attr.value = raw;
-    return attr;
+	const attr = {
+		id: attrDef.id,
+		name: attrDef.name,
+		label: attrDef.label,
+		dataType: attrDef.dataType,
+		isArray: attrDef.isArray,
+		isRequired: attrDef.isRequired,
+		isVisible: attrDef.isVisible,
+		isReadOnly: attrDef.isReadOnly,
+		order: attrDef.order,
+		rules: attrDef.rules ?? [],
+		isValueChanged: true
+	};
+	if (attrDef.dataType === "AsDetail") {
+		attr.value = null;
+		attr.asDetailType = attrDef.asDetailType;
+		const nestedType = attrDef.asDetailType ? resolve(attrDef.asDetailType) : void 0;
+		if (!nestedType) {
+			attr.object = null;
+			attr.objects = attrDef.isArray ? [] : null;
+			return attr;
+		}
+		if (attrDef.isArray) attr.objects = (Array.isArray(raw) ? raw : []).map((item) => dictToNestedPo(item ?? {}, nestedType, resolve));
+		else attr.object = raw ? dictToNestedPo(raw, nestedType, resolve) : null;
+		return attr;
+	}
+	if (isDateDataType(attrDef.dataType)) {
+		const converted = fromDateInputValue(attrDef.dataType, raw);
+		attr.value = wireDatesEqual(converted, originalDate) ? originalDate : converted;
+		return attr;
+	}
+	attr.value = raw;
+	return attr;
 }
-
-/**
- * The value a row carries for a column, whatever shape the row is in — or `undefined` when it
- * carries none.
- *
- * ```ts
- * const isPrivate = valueFor(this.item(), 'IsPrivate')?.value === true;
- * ```
- *
- * Always returns the **cell** rather than the bare value, because a reference cell is worth as much
- * for its `objectId` as for its text, and a helper that discarded it would have to be replaced the
- * first time a renderer wanted to link somewhere. `?.value` is the cost, once per call site.
- *
- * ⚠️ A value only reaches a grid row if its attribute is on the **query surface**. To read a sibling
- * the grid does not draw, mark it `"showedOn": "Query", "isVisible": false` — shipped, not drawn. An
- * attribute marked `"showedOn": "PersistentObject"` is absent from a row by design, and this returns
- * `undefined` for it; that is the first thing to check when a sibling read comes back empty.
- */
 function valueFor(item, columnName) {
-    if (!item)
-        return undefined;
-    if (isQueryRow(item)) {
-        return item.values.find(v => v.key === columnName);
-    }
-    if (isPersistentObject(item)) {
-        const attribute = item.attributes.find(a => a.name === columnName);
-        if (!attribute)
-            return undefined;
-        return {
-            key: attribute.name,
-            value: attribute.value,
-            // A single reference's value IS the target's id, which is what the row shape carries
-            // separately. Deriving it here keeps a renderer from having to know that.
-            objectId: attribute.dataType === 'Reference' && !attribute.isArray && attribute.value != null
-                ? String(attribute.value)
-                : undefined,
-            breadcrumb: attribute.breadcrumb,
-            breadcrumbs: attribute.breadcrumbs,
-        };
-    }
-    const record = item;
-    if (!(columnName in record))
-        return undefined;
-    const value = record[columnName];
-    // The flat row's side channel is populated only for single references, so its presence for this
-    // key is what identifies one — the record itself carries no dataType to ask.
-    const breadcrumb = record[AS_DETAIL_BREADCRUMBS_KEY]?.[columnName];
-    return {
-        key: columnName,
-        value,
-        objectId: breadcrumb !== undefined && value != null ? String(value) : undefined,
-        breadcrumb,
-    };
-}
-/**
- * Whether this row is a query result item.
- *
- * Discriminated on the *elements*, not just on `Array.isArray(values)`: a flat AsDetail record may
- * legitimately have a column named `values` holding an array, and mistaking one for the other would
- * silently read the wrong thing.
- */
+	if (!item) return void 0;
+	if (isQueryRow(item)) return item.values.find((v) => v.key === columnName);
+	if (isPersistentObject(item)) {
+		const attribute = item.attributes.find((a) => a.name === columnName);
+		if (!attribute) return void 0;
+		return {
+			key: attribute.name,
+			value: attribute.value,
+			objectId: attribute.dataType === "Reference" && !attribute.isArray && attribute.value != null ? String(attribute.value) : void 0,
+			breadcrumb: attribute.breadcrumb,
+			breadcrumbs: attribute.breadcrumbs
+		};
+	}
+	const record = item;
+	if (!(columnName in record)) return void 0;
+	const value = record[columnName];
+	const breadcrumb = record[AS_DETAIL_BREADCRUMBS_KEY]?.[columnName];
+	return {
+		key: columnName,
+		value,
+		objectId: breadcrumb !== void 0 && value != null ? String(value) : void 0,
+		breadcrumb
+	};
+}
 function isQueryRow(row) {
-    const values = row?.values;
-    return Array.isArray(values) && (values.length === 0 || typeof values[0]?.key === 'string');
+	const values = row?.values;
+	return Array.isArray(values) && (values.length === 0 || typeof values[0]?.key === "string");
 }
-/** Whether this row is a full persistent object. Discriminated on elements, as above. */
 function isPersistentObject(row) {
-    const attributes = row?.attributes;
-    return Array.isArray(attributes) && (attributes.length === 0 || typeof attributes[0]?.name === 'string');
+	const attributes = row?.attributes;
+	return Array.isArray(attributes) && (attributes.length === 0 || typeof attributes[0]?.name === "string");
 }
-
 var ELookupDisplayType;
-(function (ELookupDisplayType) {
-    ELookupDisplayType[ELookupDisplayType["Dropdown"] = 0] = "Dropdown";
-    ELookupDisplayType[ELookupDisplayType["Modal"] = 1] = "Modal";
+(function(ELookupDisplayType) {
+	ELookupDisplayType[ELookupDisplayType["Dropdown"] = 0] = "Dropdown";
+	ELookupDisplayType[ELookupDisplayType["Modal"] = 1] = "Modal";
 })(ELookupDisplayType || (ELookupDisplayType = {}));
-
-/**
- * The custom actions a query should offer, from the entity type's full set.
- *
- * `showedOn` must include the query side. The accepted values are `"detail"`, `"query"`
- * and `"both"` — as the server model and the custom-actions guide have always
- * documented. Both grids previously tested for `"list"`, a value nothing emits, so an
- * action authored per the documentation rendered nowhere at all.
- *
- * ⚠️ This narrows what is DISPLAYED. It is NOT an authorization boundary: the grant
- * is, and it is enforced independently in `ExecuteCustomAction` regardless of which
- * query the caller clicked from — a caller can always POST directly.
- */
+function isShowedOnQuery(showedOn) {
+	const value = (showedOn ?? "").trim().toLowerCase();
+	return value === "query" || value === "both";
+}
+function isShowedOnDetail(showedOn) {
+	const value = (showedOn ?? "").trim().toLowerCase();
+	return value === "detail" || value === "both";
+}
 function filterQueryActions(actions) {
-    return actions.filter(a => a.showedOn === 'query' || a.showedOn === 'both');
+	return actions.filter((a) => !a.isDefault && isShowedOnQuery(a.showedOn));
+}
+function filterDetailActions(actions) {
+	return actions.filter((a) => !a.isDefault && isShowedOnDetail(a.showedOn));
+}
+function defaultQueryActions(actions) {
+	return actions.filter((a) => !!a.isDefault && isShowedOnQuery(a.showedOn));
 }
-
-/**
- * Parses a custom action's `selectionRule` — a cardinality expression over the number
- * of selected rows — into a predicate.
- *
- * A port of the server's `SelectionRuleParser`, and the two MUST agree: they are tested
- * against one shared fixture (`selection-rule.fixture.json`) for exactly this reason.
- * Vidyano, where this grammar comes from, has the same algorithm in C# and JavaScript and
- * the two have already drifted — one throws on a non-numeric operand where the other
- * silently permits everything.
- *
- * Grammar: `X` is the count placeholder, whitespace is insignificant, terms split on `X`
- * are AND-combined (`1<X<5` is a range), operators are `<= >= < > != =` matched in that
- * order so `>=` is never read as `>`, and a number-first term is mirrored (`0<X` is `>0`).
- *
- * Client-side this only drives whether a button is disabled. The server enforces the same
- * rule independently — and neither is an authorization boundary: the action's grant is.
- */
 function parseSelectionRule(rule) {
-    if (!rule || !rule.trim())
-        return () => true;
-    try {
-        return compile(rule);
-    }
-    catch {
-        // Unlike the server, which refuses to start on a malformed rule, the client cannot
-        // usefully fail: the rule arrived over the wire from a server that already validated
-        // it. Disabling the button is the safe direction — it never permits an action the
-        // server would refuse.
-        return () => false;
-    }
-}
-const OPERATORS = ['<=', '>=', '<', '>', '!=', '='];
+	if (!rule || !rule.trim()) return () => true;
+	try {
+		return compile(rule);
+	} catch {
+		return () => false;
+	}
+}
+const OPERATORS = [
+	"<=",
+	">=",
+	"<",
+	">",
+	"!=",
+	"="
+];
 function compile(rule) {
-    const normalized = rule.replace(/ /g, '').toUpperCase();
-    const terms = normalized.split('X').filter(t => t.length > 0);
-    if (terms.length === 0)
-        throw new Error(`Selection rule '${rule}' has no condition.`);
-    const numberFirst = !normalized.startsWith('X') && normalized.includes('X');
-    const predicates = terms.map((term, i) => compileTerm(term, rule, numberFirst && i === 0));
-    return count => predicates.every(p => p(count));
+	const normalized = rule.replace(/ /g, "").toUpperCase();
+	const terms = normalized.split("X").filter((t) => t.length > 0);
+	if (terms.length === 0) throw new Error(`Selection rule '${rule}' has no condition.`);
+	const numberFirst = !normalized.startsWith("X") && normalized.includes("X");
+	const predicates = terms.map((term, i) => compileTerm(term, rule, numberFirst && i === 0));
+	return (count) => predicates.every((p) => p(count));
 }
 function compileTerm(term, rule, mirrored) {
-    const op = OPERATORS.find(o => (mirrored ? term.endsWith(o) : term.startsWith(o)));
-    if (!op)
-        throw new Error(`Selection rule '${rule}' has no recognised operator in '${term}'.`);
-    const numberPart = mirrored ? term.slice(0, term.length - op.length) : term.slice(op.length);
-    // Number(' ') is 0 and Number('1.5') is 1.5 — neither is a valid operand here.
-    if (!/^-?\d+$/.test(numberPart)) {
-        throw new Error(`Selection rule '${rule}' has a non-numeric operand in '${term}'.`);
-    }
-    const value = Number(numberPart);
-    const effective = mirrored ? mirror(op) : op;
-    switch (effective) {
-        case '<=': return count => count <= value;
-        case '>=': return count => count >= value;
-        case '<': return count => count < value;
-        case '>': return count => count > value;
-        case '!=': return count => count !== value;
-        case '=': return count => count === value;
-        default: throw new Error(`Selection rule '${rule}' has an unsupported operator '${effective}'.`);
-    }
+	const op = OPERATORS.find((o) => mirrored ? term.endsWith(o) : term.startsWith(o));
+	if (!op) throw new Error(`Selection rule '${rule}' has no recognised operator in '${term}'.`);
+	const numberPart = mirrored ? term.slice(0, term.length - op.length) : term.slice(op.length);
+	if (!/^-?\d+$/.test(numberPart)) throw new Error(`Selection rule '${rule}' has a non-numeric operand in '${term}'.`);
+	const value = Number(numberPart);
+	const effective = mirrored ? mirror(op) : op;
+	switch (effective) {
+		case "<=": return (count) => count <= value;
+		case ">=": return (count) => count >= value;
+		case "<": return (count) => count < value;
+		case ">": return (count) => count > value;
+		case "!=": return (count) => count !== value;
+		case "=": return (count) => count === value;
+		default: throw new Error(`Selection rule '${rule}' has an unsupported operator '${effective}'.`);
+	}
 }
 function mirror(op) {
-    switch (op) {
-        case '<': return '>';
-        case '>': return '<';
-        case '<=': return '>=';
-        case '>=': return '<=';
-        default: return op;
-    }
-}
-
-/**
- * The selection mode a grid needs in order to satisfy the actions offered on it.
- *
- * Derived rather than configured, so a grid gains a checkbox column exactly when an
- * action needs one and is otherwise pixel-identical to a grid with no selection at all.
- * Vidyano's query grid does the same thing — it renders the checkbox column only if some
- * action is selection-gated.
- *
- * `'single'` when every gated action is satisfied by one row and refused by two; anything
- * else that cares about the count gets `'multiple'`.
- */
-function selectionModeFor(actions) {
-    // An action with no rule is not selection-gated: it acts on the query, not on rows.
-    const gated = actions.filter(a => !!a.selectionRule?.trim());
-    if (gated.length === 0)
-        return 'none';
-    const everyRuleWantsExactlyOne = gated.every(a => {
-        const rule = parseSelectionRule(a.selectionRule);
-        return rule(1) && !rule(2);
-    });
-    return everyRuleWantsExactlyOne ? 'single' : 'multiple';
+	switch (op) {
+		case "<": return ">";
+		case ">": return "<";
+		case "<=": return ">=";
+		case ">=": return "<=";
+		default: return op;
+	}
+}
+function selectionModeFor(actions, declared) {
+	if (declared && declared !== "auto") return declared;
+	const gated = actions.filter((a) => !!a.selectionRule?.trim());
+	if (gated.length === 0) return "none";
+	return gated.every((a) => {
+		const rule = parseSelectionRule(a.selectionRule);
+		return rule(1) && !rule(2);
+	}) ? "single" : "multiple";
+}
+function normalizeSubQuery(entry) {
+	return typeof entry === "string" ? { query: entry } : entry;
+}
+function subQueriesOf(type) {
+	return (type?.queries ?? []).map(normalizeSubQuery).filter((entry) => !!entry.query);
 }
-
-/** Applies an overlay to one attribute definition, returning a new object when anything changed. */
 function applyOverlay(attr, overlay) {
-    if (!overlay)
-        return attr;
-    return {
-        ...attr,
-        isRequired: overlay.isRequired ?? attr.isRequired,
-        isReadOnly: overlay.isReadOnly ?? attr.isReadOnly,
-        isVisible: overlay.isVisible ?? attr.isVisible,
-        rules: overlay.rules ?? attr.rules,
-        query: overlay.query ?? attr.query,
-    };
-}
-/**
- * Reads a refresh response into an overlay.
- *
- * Everything here is presentation the server owns outright, so it is taken verbatim — there is no
- * merging to do on this half, only on values.
- */
+	if (!overlay) return attr;
+	return {
+		...attr,
+		isRequired: overlay.isRequired ?? attr.isRequired,
+		isReadOnly: overlay.isReadOnly ?? attr.isReadOnly,
+		isVisible: overlay.isVisible ?? attr.isVisible,
+		rules: overlay.rules ?? attr.rules,
+		query: overlay.query ?? attr.query
+	};
+}
 function overlayFromResponse(response) {
-    const overlay = {};
-    for (const attr of response.attributes ?? []) {
-        overlay[attr.name] = {
-            isRequired: attr.isRequired,
-            isReadOnly: attr.isReadOnly,
-            isVisible: attr.isVisible,
-            rules: attr.rules ?? [],
-            query: attr.query,
-            options: attr.options ?? undefined,
-        };
-    }
-    return overlay;
-}
-/**
- * Merges a refresh response's values into the live form.
- *
- * The rule, and the reason for it: a refresh is not instant, and the user keeps typing during it —
- * the form is deliberately never frozen. So for each attribute we ask whether the *server* changed
- * it, by comparing the response against the values that were **sent**, not against what is on
- * screen now.
- *
- * - server value equals what we sent → the hook did not touch it, so whatever is in the form now
- *   wins, including anything typed while the request was in flight;
- * - server value differs → the hook deliberately changed it, and it wins over a concurrent edit.
- *
- * Comparing against the displayed value instead is the classic "refresh eats my typing" bug;
- * refusing to overwrite anything the user touched is the equally wrong opposite, where a dependent
- * field the hook computed never appears.
- *
- * @param sent      values as they were POSTed, captured before the request left
- * @param current   values as they are now, which may have moved on
- * @param response  the reshaped object
- */
+	const overlay = {};
+	for (const attr of response.attributes ?? []) overlay[attr.name] = {
+		isRequired: attr.isRequired,
+		isReadOnly: attr.isReadOnly,
+		isVisible: attr.isVisible,
+		rules: attr.rules ?? [],
+		query: attr.query,
+		options: attr.options ?? void 0
+	};
+	return overlay;
+}
 function mergeRefreshValues(sent, current, response) {
-    const merged = { ...current };
-    for (const attr of response.attributes ?? []) {
-        const serverValue = attr.value ?? null;
-        const sentValue = sent[attr.name] ?? null;
-        if (!valuesEqual(serverValue, sentValue)) {
-            merged[attr.name] = attr.value;
-        }
-    }
-    return merged;
-}
-/**
- * Structural for arrays, `===` otherwise.
- *
- * Multi-reference attributes hold `string[]`, and a fresh array of the same ids is a different
- * object — so reference equality would report every one of them as "changed by the server" on
- * every refresh, and clobber in-flight edits to them.
- */
+	const merged = { ...current };
+	for (const attr of response.attributes ?? []) if (!valuesEqual(attr.value ?? null, sent[attr.name] ?? null)) merged[attr.name] = attr.value;
+	return merged;
+}
 function valuesEqual(a, b) {
-    if (a === b)
-        return true;
-    if (Array.isArray(a) && Array.isArray(b)) {
-        return a.length === b.length && a.every((item, i) => valuesEqual(item, b[i]));
-    }
-    // Values arrive off the wire as JSON scalars; anything else compares by JSON shape rather than
-    // by identity, which is what a caller means by "did this change".
-    if (a !== null && b !== null && typeof a === 'object' && typeof b === 'object') {
-        return JSON.stringify(a) === JSON.stringify(b);
-    }
-    return false;
+	if (a === b) return true;
+	if (Array.isArray(a) && Array.isArray(b)) return a.length === b.length && a.every((item, i) => valuesEqual(item, b[i]));
+	if (a !== null && b !== null && typeof a === "object" && typeof b === "object") return JSON.stringify(a) === JSON.stringify(b);
+	return false;
 }
-
 const EMAIL = /^[^@\s]+@[^@\s]+\.[^@\s]+$/i;
 const URL = /^https?:\/\/[^\s]+$/i;
 function isEmpty(value) {
-    if (value === null || value === undefined)
-        return true;
-    if (typeof value === 'string')
-        return value.trim() === '';
-    if (Array.isArray(value))
-        return value.length === 0;
-    return false;
-}
-/**
- * Evaluates an attribute's rules against a value, mirroring the server's `ValidationService`.
- *
- * ⚠️ **Parity with the server is the point, and disagreement is worse than silence.** A client that
- * rejects something the server would accept blocks legitimate work with no recourse; one that
- * accepts something the server rejects merely defers the error to the round-trip, which is where it
- * used to live anyway. So the rule set here is deliberately limited to the types the server
- * implements, and an unrecognised rule type is ignored rather than guessed at.
- *
- * This exists because a refresh hook that imposes a rule needs it to bite before Save — previously
- * `rules` was carried on the wire and never evaluated in the browser at all.
- */
+	if (value === null || value === void 0) return true;
+	if (typeof value === "string") return value.trim() === "";
+	if (Array.isArray(value)) return value.length === 0;
+	return false;
+}
 function evaluateRules(attr, value) {
-    const failures = [];
-    const label = attr.label?.['en'] ?? attr.name;
-    if (attr.isRequired && isEmpty(value)) {
-        return [{ attributeName: attr.name, ruleType: 'required', message: `${label} is required` }];
-    }
-    // A rule other than "required" says nothing about an absent value — that is what required is for.
-    if (isEmpty(value))
-        return failures;
-    const text = value?.toString() ?? '';
-    for (const rule of attr.rules ?? []) {
-        const failure = evaluateRule(attr.name, label, rule, value, text);
-        if (failure)
-            failures.push(failure);
-    }
-    return failures;
+	const failures = [];
+	const label = attr.label?.["en"] ?? attr.name;
+	if (attr.isRequired && isEmpty(value)) return [{
+		attributeName: attr.name,
+		ruleType: "required",
+		message: `${label} is required`
+	}];
+	if (isEmpty(value)) return failures;
+	const text = value?.toString() ?? "";
+	for (const rule of attr.rules ?? []) {
+		const failure = evaluateRule(attr.name, label, rule, value, text);
+		if (failure) failures.push(failure);
+	}
+	return failures;
 }
 function evaluateRule(name, label, rule, value, text) {
-    const message = rule.message?.['en'];
-    switch (rule.type?.toLowerCase()) {
-        case 'maxlength': {
-            const max = toInt(rule.value);
-            if (max === null || text.length <= max)
-                return null;
-            return { attributeName: name, ruleType: 'maxLength', message: message ?? `${label} must be at most ${max} characters` };
-        }
-        case 'minlength': {
-            const min = toInt(rule.value);
-            if (min === null || text.length >= min)
-                return null;
-            return { attributeName: name, ruleType: 'minLength', message: message ?? `${label} must be at least ${min} characters` };
-        }
-        case 'range': {
-            const numeric = toNumber(value);
-            if (numeric === null)
-                return null;
-            if (rule.min !== undefined && rule.min !== null && numeric < rule.min) {
-                return { attributeName: name, ruleType: 'range', message: message ?? `${label} must be at least ${rule.min}` };
-            }
-            if (rule.max !== undefined && rule.max !== null && numeric > rule.max) {
-                return { attributeName: name, ruleType: 'range', message: message ?? `${label} must be at most ${rule.max}` };
-            }
-            return null;
-        }
-        case 'regex': {
-            const pattern = rule.value?.toString();
-            if (!pattern)
-                return null;
-            let re;
-            try {
-                re = new RegExp(pattern);
-            }
-            catch {
-                // An unparseable pattern is a server-side authoring bug. Staying silent leaves the server to
-                // report it, which is strictly better than blocking the user over a rule nobody can evaluate.
-                return null;
-            }
-            return re.test(text) ? null : { attributeName: name, ruleType: 'regex', message: message ?? `${label} is not in the expected format` };
-        }
-        case 'email':
-            return EMAIL.test(text) ? null : { attributeName: name, ruleType: 'email', message: message ?? `${label} must be a valid email address` };
-        case 'url':
-            return URL.test(text) ? null : { attributeName: name, ruleType: 'url', message: message ?? `${label} must be a valid URL` };
-        default:
-            return null;
-    }
+	const message = rule.message?.["en"];
+	switch (rule.type?.toLowerCase()) {
+		case "maxlength": {
+			const max = toInt(rule.value);
+			if (max === null || text.length <= max) return null;
+			return {
+				attributeName: name,
+				ruleType: "maxLength",
+				message: message ?? `${label} must be at most ${max} characters`
+			};
+		}
+		case "minlength": {
+			const min = toInt(rule.value);
+			if (min === null || text.length >= min) return null;
+			return {
+				attributeName: name,
+				ruleType: "minLength",
+				message: message ?? `${label} must be at least ${min} characters`
+			};
+		}
+		case "range": {
+			const numeric = toNumber(value);
+			if (numeric === null) return null;
+			if (rule.min !== void 0 && rule.min !== null && numeric < rule.min) return {
+				attributeName: name,
+				ruleType: "range",
+				message: message ?? `${label} must be at least ${rule.min}`
+			};
+			if (rule.max !== void 0 && rule.max !== null && numeric > rule.max) return {
+				attributeName: name,
+				ruleType: "range",
+				message: message ?? `${label} must be at most ${rule.max}`
+			};
+			return null;
+		}
+		case "regex": {
+			const pattern = rule.value?.toString();
+			if (!pattern) return null;
+			let re;
+			try {
+				re = new RegExp(pattern);
+			} catch {
+				return null;
+			}
+			return re.test(text) ? null : {
+				attributeName: name,
+				ruleType: "regex",
+				message: message ?? `${label} is not in the expected format`
+			};
+		}
+		case "email": return EMAIL.test(text) ? null : {
+			attributeName: name,
+			ruleType: "email",
+			message: message ?? `${label} must be a valid email address`
+		};
+		case "url": return URL.test(text) ? null : {
+			attributeName: name,
+			ruleType: "url",
+			message: message ?? `${label} must be a valid URL`
+		};
+		default: return null;
+	}
 }
 function toInt(value) {
-    const n = Number(value);
-    return Number.isFinite(n) ? Math.trunc(n) : null;
+	if (typeof value === "number") return Number.isInteger(value) ? value : null;
+	if (typeof value === "string" && /^\s*[+-]?\d+\s*$/.test(value)) return parseInt(value, 10);
+	return null;
 }
 function toNumber(value) {
-    const n = Number(value);
-    return Number.isFinite(n) ? n : null;
+	const n = Number(value);
+	return Number.isFinite(n) ? n : null;
 }
+export { AS_DETAIL_BREADCRUMBS_KEY, AS_DETAIL_ORIGINAL_DATES_KEY, AS_DETAIL_ROW_KEY, AS_DETAIL_SELF_BREADCRUMB_KEY, ELookupDisplayType, EReferenceDisplayType, ShowedOn, applyOverlay, currentLanguage, defaultQueryActions, dictToNestedPo, evaluateRules, filterDetailActions, filterQueryActions, fromDateInput, fromDateInputValue, fromDateTimeLocalInput, hasShowedOnFlag, isDateDataType, isPersistentObject, isQueryRow, isReservedAsDetailKey, isShowedOnDetail, isShowedOnQuery, mergeRefreshValues, nestedPoToDict, nestedPoToDisplayRow, normalizeSubQuery, overlayFromResponse, parseSelectionRule, parseWireDate, resolveTranslation, resolvedBreadcrumb, selectionModeFor, selfBreadcrumb, subQueriesOf, toDateInput, toDateInputValue, toDateTimeLocalInput, valueFor, wireDatesEqual };
 
-/**
- * Generated bundle index. Do not edit.
- */
-
-export { AS_DETAIL_BREADCRUMBS_KEY, AS_DETAIL_ORIGINAL_DATES_KEY, AS_DETAIL_ROW_KEY, AS_DETAIL_SELF_BREADCRUMB_KEY, ELookupDisplayType, EReferenceDisplayType, ShowedOn, applyOverlay, currentLanguage, dictToNestedPo, evaluateRules, filterQueryActions, fromDateInput, fromDateInputValue, fromDateTimeLocalInput, hasShowedOnFlag, isDateDataType, isPersistentObject, isQueryRow, isReservedAsDetailKey, mergeRefreshValues, nestedPoToDict, nestedPoToDisplayRow, overlayFromResponse, parseSelectionRule, parseWireDate, resolveTranslation, resolvedBreadcrumb, selectionModeFor, selfBreadcrumb, toDateInput, toDateInputValue, toDateTimeLocalInput, valueFor, wireDatesEqual };
-//# sourceMappingURL=mintplayer-ng-spark-models.mjs.map
+//# sourceMappingURL=mintplayer-ng-spark-models.mjs.map