@antelopejs/dms 0.11.1 → 0.12.1

package/frontend-vue/layers/dms-ui/app/build/composables/data-types/registerFieldTypes.ts

@@ -1,10 +1,11 @@
 import { h } from "vue";
-import type { DataType } from "#dms-core/app/composables/data-types/useDataType";
+import type {
+  DataType,
+  DataTypeFormatter,
+} from "#dms-core/app/composables/data-types/useDataType";
+import { isObject, isString } from "#dms-core/app/utils/type-check";
 import { getAppTranslation } from "../../../../../dms-core/app/composables/translation/useTranslation";
 
-// How the field types made of several values read in a table cell or a
-// read-only form: a count, a masked secret, the first line of the code,
-// the tags as pills.
 const SECRET_TAIL = 4;
 const SECRET_MASK = "••••";
 const TAG_CLASS =
@@ -12,33 +13,33 @@ const TAG_CLASS =
 const TAGS_CLASS = "inline-flex flex-wrap items-center gap-1";
 const CODE_CLASS = "font-mono text-[12px] truncate";
 
-const countOf = (value: unknown): number => {
+const countOf = (value: Parameters<DataTypeFormatter>[0]): number => {
   if (Array.isArray(value)) return value.length;
-  if (value && typeof value === "object") return Object.keys(value).length;
+  if (value && isObject(value)) return Object.keys(value).length;
   return 0;
 };
 
 function renderCount(key: string) {
-  return (value: unknown) => {
+  return (value: Parameters<DataTypeFormatter>[0]) => {
     const { t } = getAppTranslation();
     const count = countOf(value);
     return t(key, { count }, count);
   };
 }
 
-function renderSecret(value: unknown): string {
-  return typeof value === "string" && value
+function renderSecret(value: Parameters<DataTypeFormatter>[0]): string {
+  return isString(value) && value
     ? `${SECRET_MASK}${value.slice(-SECRET_TAIL)}`
     : "";
 }
 
-function renderCode(value: unknown) {
-  if (typeof value !== "string") return "";
+function renderCode(value: Parameters<DataTypeFormatter>[0]) {
+  if (!isString(value)) return "";
   const [firstLine = ""] = value.split("\n");
   return h("span", { class: CODE_CLASS, title: value }, firstLine);
 }
 
-function renderTags(value: unknown) {
+function renderTags(value: Parameters<DataTypeFormatter>[0]) {
   if (!Array.isArray(value)) return "";
   return h(
     "span",

package/frontend-vue/layers/dms-ui/app/build/composables/data-types/relationBadges.ts

@@ -1,3 +1,7 @@
+import type { DataTypeFormatter } from "#dms-core/app/composables/data-types/useDataType";
+import { isObject } from "#dms-core/app/utils/type-check";
+import { DEFAULT_RELATION_VALUE_KEY } from "./relationValue";
+
 /** How many labels a multi-value relation cell shows before collapsing. */
 export const MAX_RELATION_BADGES = 3;
 
@@ -7,12 +11,22 @@ export interface RelationBadges {
   hidden: string[];
 }
 
-function readRelationLabel(item: unknown, labelKey: string): string {
-  if (typeof item === "object" && item !== null) {
-    const label = (item as Record<string, unknown>)[labelKey];
-    return label === undefined || label === null ? "" : String(label);
+const textOf = (value: unknown): string =>
+  value === undefined || value === null ? "" : String(value);
+
+/**
+ * The text a related row shows: its label, or its key when the label is
+ * empty. A raw id (join skipped) is shown as is.
+ */
+export function readRelationLabel(
+  item: Parameters<DataTypeFormatter>[0],
+  labelKey: string,
+  valueKey = DEFAULT_RELATION_VALUE_KEY,
+): string {
+  if (isObject(item) && item !== null) {
+    return textOf(item[labelKey]) || textOf(item[valueKey]);
   }
-  return item === undefined || item === null ? "" : String(item);
+  return textOf(item);
 }
 
 /**
@@ -25,9 +39,10 @@ export function buildRelationBadges(
   values: unknown[],
   labelKey: string,
   maxVisible = MAX_RELATION_BADGES,
+  valueKey = DEFAULT_RELATION_VALUE_KEY,
 ): RelationBadges {
   const labels = values
-    .map((item) => readRelationLabel(item, labelKey))
+    .map((item) => readRelationLabel(item, labelKey, valueKey))
     .filter((label) => label !== "");
   return {
     visible: labels.slice(0, maxVisible),

package/frontend-vue/layers/dms-ui/app/build/composables/data-types/relationFilter.ts

@@ -1,4 +1,5 @@
 import { isEmptyFormValue, sameFormValue } from "../unsaved-changes/formValue";
+import { isBoolean, isNumber, isString } from "#dms-core/app/utils/type-check";
 
 /**
  * A relation picker narrowed by another field of its form: the related
@@ -14,9 +15,11 @@ const FILTER_MODE = "is";
 
 type FilterValue = string | number | boolean;
 
-function isFilterValue(value: unknown): value is FilterValue {
-  if (typeof value === "string") return value !== "";
-  return typeof value === "number" || typeof value === "boolean";
+function isFilterValue(
+  value: RelationPickChange["source"],
+): value is FilterValue {
+  if (isString(value)) return value !== "";
+  return isNumber(value) || isBoolean(value);
 }
 
 /**
@@ -26,8 +29,8 @@ function isFilterValue(value: unknown): value is FilterValue {
  */
 export function relationFilterParams(
   filterBy: RelationFilterBy | undefined,
-  sourceValue: unknown,
-): Record<string, string> {
+  sourceValue: RelationPickChange["source"],
+) {
   if (!filterBy || !isFilterValue(sourceValue)) return {};
   return { [`filter_${filterBy.field}`]: `${FILTER_MODE}:${sourceValue}` };
 }
@@ -49,7 +52,7 @@ export interface RelationPickOutcome {
 }
 
 /** Whether a picker holds a value. */
-function hasRelationPick(value: unknown): boolean {
+function hasRelationPick(value: RelationPickChange["pick"]): boolean {
   return !isEmptyFormValue(value);
 }
 

package/frontend-vue/layers/dms-ui/app/build/composables/data-types/relationRows.ts

@@ -1,4 +1,9 @@
-import type { DataTypeSelectSource } from "#dms-core/app/composables/data-types/useDataType";
+import type {
+  DataType,
+  DataTypeFormatter,
+  DataTypeSelectSource,
+} from "#dms-core/app/composables/data-types/useDataType";
+import { isString } from "#dms-core/app/utils/type-check";
 import { pageRequestUrl } from "../page/pageUrlValues";
 import { relationIdsQuery } from "./relationValue";
 
@@ -6,7 +11,7 @@ import { relationIdsQuery } from "./relationValue";
 export const RELATION_LABEL_KEY = "label";
 export const RELATION_VALUE_KEY = "value";
 
-type RelationRow = Record<string, unknown>;
+type RelationRow = NonNullable<Parameters<DataTypeFormatter>[3]>;
 
 interface RelationSelectResponse {
   results?: RelationRow[];
@@ -22,10 +27,11 @@ interface RelationSourceOptions {
  * mapping: the relation data type's {@link DataTypeSelectSource}.
  */
 export function relationSelectSource(
-  options: unknown,
+  options: Parameters<NonNullable<DataType["selectSource"]>>[0],
 ): DataTypeSelectSource | undefined {
+  // oxlint-disable-next-line anti-slop/require-safety-comment-for-type-assertion -- The plugin contract erases options; only searchUrl is checked below, not keyMapping or the whole asserted shape.
   const opts = options as RelationSourceOptions | undefined;
-  if (typeof opts?.searchUrl !== "string") return undefined;
+  if (!isString(opts?.searchUrl)) return undefined;
   return { searchUrl: opts.searchUrl, keyMapping: opts.keyMapping };
 }
 
@@ -33,7 +39,7 @@ export function relationSelectSource(
 export function relationRowValue(
   source: DataTypeSelectSource,
   row: RelationRow,
-): unknown {
+): RelationRow[string] {
   return row[source.keyMapping?.value || RELATION_VALUE_KEY];
 }
 
@@ -41,7 +47,7 @@ export function relationRowValue(
 export function relationRowLabel(
   source: DataTypeSelectSource,
   row: RelationRow,
-): unknown {
+): RelationRow[string] {
   return row[source.keyMapping?.label || RELATION_LABEL_KEY];
 }
 

package/frontend-vue/layers/dms-ui/app/build/composables/data-types/relationValue.ts

@@ -1,6 +1,12 @@
 import { isEmptyFormValue, sameFormValue } from "../unsaved-changes/formValue";
+import type {
+  BeforeStateMapper,
+  DataTypeValueComparer,
+} from "#dms-core/app/composables/data-types/useDataType";
+import { isNumber, isObject, isString } from "#dms-core/app/utils/type-check";
 
-const DEFAULT_RELATION_VALUE_KEY = "_id";
+/** The key a related row is referenced by when `keyMapping.value` maps none. */
+export const DEFAULT_RELATION_VALUE_KEY = "_id";
 
 interface RelationKeyMapping {
   value?: string;
@@ -15,35 +21,43 @@ interface RelationValueOptions {
  * The form state of a relation value: the id of each row it references, as
  * the picker holds it, whether the server sent the joined rows or their ids.
  */
-export function mapRelationBeforeState(value: unknown, options: unknown) {
+export function mapRelationBeforeState(
+  value: Parameters<BeforeStateMapper>[0],
+  options: Parameters<BeforeStateMapper>[1],
+) {
   if (!value) return value;
 
+  // oxlint-disable-next-line anti-slop/require-safety-comment-for-type-assertion -- BeforeStateMapper erases plugin options; relation options are consumed without validation so malformed inputs retain their existing behavior.
   const opts = options as RelationValueOptions | undefined;
   const valueKey = opts?.keyMapping?.value || DEFAULT_RELATION_VALUE_KEY;
 
-  if (typeof value === "string" || typeof value === "number") return value;
+  if (isString(value) || isNumber(value)) return value;
 
   if (opts?.multiple && Array.isArray(value)) {
     return value.map((item) =>
-      typeof item === "object" && item !== null
-        ? (item as Record<string, unknown>)[valueKey]
-        : item,
+      isObject(item) && item !== null ? item[valueKey] : item,
     );
   }
 
-  if (typeof value === "object" && value !== null) {
-    return (value as Record<string, unknown>)[valueKey];
+  if (isObject(value) && value !== null) {
+    return value[valueKey];
   }
 
   return value;
 }
 
-function relationIds(value: unknown, options: unknown): unknown[] {
+function relationIds(
+  value: Parameters<BeforeStateMapper>[0],
+  options: Parameters<BeforeStateMapper>[1],
+): ReturnType<BeforeStateMapper>[] {
   const ids = mapRelationBeforeState(value, options);
   return isEmptyFormValue(ids) ? [] : [ids].flat();
 }
 
-function compareIdText(left: unknown, right: unknown): number {
+function compareIdText(
+  left: ReturnType<typeof relationIds>[number],
+  right: ReturnType<typeof relationIds>[number],
+): number {
   return String(left).localeCompare(String(right));
 }
 
@@ -53,12 +67,13 @@ function compareIdText(left: unknown, right: unknown): number {
  * picks of a multiple relation are a set: their order does not count.
  */
 export function sameRelationValue(
-  left: unknown,
-  right: unknown,
-  options: unknown,
+  left: Parameters<DataTypeValueComparer>[0],
+  right: Parameters<DataTypeValueComparer>[1],
+  options: Parameters<DataTypeValueComparer>[2],
 ): boolean {
+  // oxlint-disable-next-line anti-slop/require-safety-comment-for-type-assertion -- The comparer shares the mapper's erased options contract; this assertion does not validate multiple.
   const isSet = !!(options as RelationValueOptions | undefined)?.multiple;
-  const comparable = (value: unknown) => {
+  const comparable = (value: Parameters<DataTypeValueComparer>[0]) => {
     const ids = relationIds(value, options);
     return isSet ? ids.sort(compareIdText) : ids;
   };
@@ -77,7 +92,7 @@ export interface RelationIdsQuery {
 }
 
 const isIdValue = (value: unknown): value is string | number =>
-  (typeof value === "string" && value !== "") || typeof value === "number";
+  (isString(value) && value !== "") || isNumber(value);
 
 /**
  * The ids a relation value holds that no known row labels yet — a form whose
@@ -85,7 +100,7 @@ const isIdValue = (value: unknown): value is string | number =>
  * labels itself, so only plain ids are returned, each once.
  */
 export function unlabeledRelationIds(
-  value: unknown,
+  value: Parameters<BeforeStateMapper>[0],
   labeledIds: ReadonlySet<string>,
 ): string[] {
   const ids = [value].flat().filter(isIdValue).map(String);
@@ -99,7 +114,7 @@ export function relationIdsQuery(
 ): RelationIdsQuery {
   return {
     ids,
-    ...(keyMapping?.value ? { idKey: keyMapping.value } : {}),
+    ...(keyMapping?.value ? { idKey: keyMapping.value } : undefined),
     limit: ids.length,
   };
 }

package/frontend-vue/layers/dms-ui/app/build/composables/data-types/twoLineCell.ts

@@ -1,5 +1,8 @@
 import { h, type VNodeChild } from "vue";
-import type { DataType } from "#dms-core/app/composables/data-types/useDataType";
+import type {
+  DataType,
+  DataTypeFormatter,
+} from "#dms-core/app/composables/data-types/useDataType";
 import { getAppComposedText } from "../../../../../dms-core/app/composables/translation/useComposedText";
 import {
   type ComposableText,
@@ -27,12 +30,12 @@ interface TwoLineOptions {
   typeOptions?: unknown;
 }
 
-const isBlank = (value: unknown): boolean =>
+const isBlank = (value: Parameters<DataTypeFormatter>[0]): boolean =>
   value === null || value === undefined || value === "";
 
 /** The column's value written by the column's own data type. */
 function formatColumnValue(
-  value: unknown,
+  value: Parameters<DataTypeFormatter>[0],
   locale: string,
   opts: TwoLineOptions,
   row: Row,
@@ -43,12 +46,13 @@ function formatColumnValue(
     : undefined;
   const format = formatter?.cell ?? formatter?.default;
   if (!format) return String(value);
+  // oxlint-disable-next-line anti-slop/require-safety-comment-for-type-assertion -- DataTypeFormatter returns unknown; the existing cell forwards that result to Vue without checking VNodeChild.
   return format(value, locale, opts.typeOptions, row) as VNodeChild;
 }
 
 /** The primary line, or nothing when the row has none to show. */
 function readPrimary(
-  value: unknown,
+  value: Parameters<DataTypeFormatter>[0],
   locale: string,
   opts: TwoLineOptions,
   row: Row,
@@ -56,6 +60,7 @@ function readPrimary(
   const { processText } = getAppComposedText();
   if (opts.primaryField) {
     const text = processText(
+      // oxlint-disable-next-line anti-slop/require-safety-comment-for-type-assertion -- Row fields are open plugin values; processText receives the same unchecked value rather than a newly filtered or coerced one.
       readRowField(row, opts.primaryField) as ComposableText,
     );
     return text || undefined;
@@ -71,13 +76,13 @@ function readPrimary(
  * else `subTone`, else muted. No avatar.
  */
 function renderTwoLine(
-  value: unknown,
+  value: Parameters<DataTypeFormatter>[0],
   locale: string,
-  options: unknown,
+  options: Parameters<DataTypeFormatter>[2],
   row: Row,
 ) {
   const { processText } = getAppComposedText();
-  const opts = (options ?? {}) as TwoLineOptions;
+  const opts: TwoLineOptions = options ?? {};
   const primary = readPrimary(value, locale, opts, row);
   const sub = readSubline(readRowField(row, opts.subField), {
     processText,

package/frontend-vue/layers/dms-ui/app/build/composables/data-types/useColumnValueRenderer.ts

@@ -1,5 +1,7 @@
 import { h, type VNodeChild } from "vue";
 import { get } from "@nuxt/ui/runtime/utils/index.js";
+import type { DataTypeFormatter } from "#dms-core/app/composables/data-types/useDataType";
+import { isNumber, isString } from "#dms-core/app/utils/type-check";
 
 /**
  * A data type a column borrows for its cells only: the column keeps its own
@@ -8,7 +10,12 @@ import { get } from "@nuxt/ui/runtime/utils/index.js";
  */
 export interface ColumnDisplay {
   type: string;
-  options?: Record<string, unknown>;
+  options?: NonNullable<Parameters<DataTypeFormatter>[3]>;
+}
+
+interface ResolvedColumnRenderer {
+  typeId: string | undefined;
+  options: ColumnDisplay["options"];
 }
 
 /** What a column must carry for its values to be rendered. */
@@ -19,10 +26,6 @@ export interface RenderableColumn {
   display?: ColumnDisplay;
 }
 
-// v2 cell anatomy: amounts are right-aligned mono figures in the ink color,
-// dates 12px muted mono. Where a record is read (the detail surface), amounts
-// keep the form's own font with tabular figures, as its read-only values do. A data type can give cells a shorter rendering
-// through a `cell` formatter (the date type does); others use `default`.
 export const NUMERIC_TYPE_IDS = new Set(["number", "price", "percentage"]);
 const DATE_TYPE_IDS = new Set(["date"]);
 const NUMERIC_CELL_CLASS =
@@ -36,6 +39,20 @@ const DETAIL_FALLBACK = "—";
 /** Where a value is drawn: a grid cell gets the `cell` formatter first. */
 export type ColumnValueSurface = "cell" | "detail";
 
+function renderEmptyFallback(
+  options: ResolvedColumnRenderer["options"],
+  surface: ColumnValueSurface,
+  isNumeric: boolean,
+): VNodeChild {
+  const fallback =
+    // oxlint-disable-next-line anti-slop/require-safety-comment-for-type-assertion -- Plugin options have no fallback schema; this preserves the unchecked value rather than coercing or rejecting malformed inputs.
+    (options?.fallback as string) ??
+    (surface === "detail" ? DETAIL_FALLBACK : DEFAULT_FALLBACK);
+  return isNumeric
+    ? h("span", { class: NUMERIC_EMPTY_CELL_CLASS }, fallback)
+    : fallback;
+}
+
 /**
  * Renders a row's value for a column through the formatter of its data type
  * (or of its `display` data type), the way the grid draws its cells. The row
@@ -46,15 +63,10 @@ export function useColumnValueRenderer() {
   const { getDataType } = useDataTypes();
   const { locale } = useI18n();
 
-  // A display also reads the column's own type options (`typeOptions`): a
-  // select's items name the values it draws; and the column's own type id
-  // (`columnType`), so it can write the value as the column would (an amount
-  // under `two_line`). A display declared without options reads the type
-  // options at the top level, as it always did.
-  const resolveRenderer = (column: RenderableColumn) => {
-    const typeOptions = column.type?.inputComponent?.options as
-      | Record<string, unknown>
-      | undefined;
+  const resolveRenderer = (
+    column: RenderableColumn,
+  ): ResolvedColumnRenderer => {
+    const typeOptions = column.type?.inputComponent?.options;
     if (!column.display)
       return { typeId: column.type?.id, options: typeOptions };
     const displayOptions = column.display.options ?? typeOptions;
@@ -72,8 +84,8 @@ export function useColumnValueRenderer() {
 
   const renderValue = (
     column: RenderableColumn,
-    value: unknown,
-    row: Record<string, unknown> | undefined,
+    value: Parameters<DataTypeFormatter>[0],
+    row: Parameters<DataTypeFormatter>[3],
     surface: ColumnValueSurface = "cell",
   ): VNodeChild => {
     const { typeId, options } = resolveRenderer(column);
@@ -81,16 +93,11 @@ export function useColumnValueRenderer() {
     const formatter = typeId ? getDataType(typeId)?.formatter : undefined;
 
     if (value === null || value === undefined) {
-      // A data type may draw the absence itself ("Never signed in").
       if (formatter?.empty) {
+        // oxlint-disable-next-line anti-slop/require-safety-comment-for-type-assertion -- DataTypeFormatter returns unknown for plugin extensions; the existing render boundary forwards it without VNodeChild validation.
         return formatter.empty(value, locale.value, options, row) as VNodeChild;
       }
-      const fallback =
-        (options?.fallback as string) ??
-        (surface === "detail" ? DETAIL_FALLBACK : DEFAULT_FALLBACK);
-      return isNumeric
-        ? h("span", { class: NUMERIC_EMPTY_CELL_CLASS }, fallback)
-        : fallback;
+      return renderEmptyFallback(options, surface, isNumeric);
     }
 
     const format =
@@ -99,7 +106,8 @@ export function useColumnValueRenderer() {
       ? format(value, locale.value, options, row)
       : value;
 
-    if (typeof formatted !== "string" && typeof formatted !== "number") {
+    if (!isString(formatted) && !isNumber(formatted)) {
+      // oxlint-disable-next-line anti-slop/require-safety-comment-for-type-assertion -- Excluding strings and numbers does not validate a VNodeChild; preserve the existing unchecked plugin result handoff.
       return formatted as VNodeChild;
     }
     if (isNumeric) {
@@ -116,7 +124,7 @@ export function useColumnValueRenderer() {
   /** Renders the column's value read off `row`. */
   const renderColumnValue = (
     column: RenderableColumn,
-    row: Record<string, unknown>,
+    row: NonNullable<Parameters<DataTypeFormatter>[3]>,
     surface: ColumnValueSurface = "cell",
   ): VNodeChild => {
     const key = column.accessorKey ?? column.id;

package/frontend-vue/layers/dms-ui/app/build/composables/files/useFileMetadata.ts

@@ -24,7 +24,7 @@ export interface FileMetadata {
 }
 
 const METADATA_URL = "/api/files/metadata";
-// A read URL is read again this long before it expires.
+
 const URL_REFRESH_LEAD_MS = 5000;
 
 const isExpired = (metadata: FileMetadata): boolean =>
@@ -46,7 +46,7 @@ const isExpired = (metadata: FileMetadata): boolean =>
  */
 export function useFileMetadata(storage?: string) {
   const contentLanguage = inject(FORM_CONTENT_LANGUAGE_KEY, undefined);
-  // Reads resolved past the setup run with the application's context.
+
   const app = getCurrentInstance()?.appContext.app;
   const scope = effectScope();
   const reads = shallowReactive(new Map<string, ApiDataResult<FileMetadata>>());
@@ -134,7 +134,7 @@ export function useFileMetadata(storage?: string) {
    */
   function isUnavailable(key: string): boolean {
     const result = reads.get(key);
-    // A failure stays until the next answer: a retry keeps the file marked.
+
     if (!result?.error.value) return false;
     const known = result.data.value;
     return (

package/frontend-vue/layers/dms-ui/app/build/composables/form/createFormFields.ts

@@ -8,7 +8,10 @@ import { isEmptyFormValue } from "../unsaved-changes/formValue";
  * default, one a rule computed), and a field declaring `showEmptyOnCreate`
  * keeps its place regardless.
  */
-export function isHiddenOnCreate(field: FormField, value: unknown): boolean {
+export function isHiddenOnCreate(
+  field: FormField,
+  value: Parameters<typeof isEmptyFormValue>[0],
+): boolean {
   if (field.showEmptyOnCreate) return false;
   if (!field.disabled && !field.readonly) return false;
   return isEmptyFormValue(value);

package/frontend-vue/layers/dms-ui/app/build/composables/form/fieldSaved.ts

@@ -6,9 +6,9 @@ import type {
 } from "../../../composables/form/types/value";
 import { cloneFormValue } from "../../../composables/form/useForm";
 import type { UseFormDirtyReturn } from "../../../composables/unsaved-changes/useFormDirty";
-import type { InstantForm } from "./useInstantForm";
+import type { InstantForm, InstantFormOptions } from "./useInstantForm";
 
-type FormValues = Record<string, unknown>;
+type FormValues = InstantFormOptions["state"]["value"];
 
 /** What a field the server saved on its own updates in its form. */
 export interface FieldSavedTargets {
@@ -32,6 +32,7 @@ export function fieldSavedMarker(targets: FieldSavedTargets): MarkFieldSaved {
     if (!targets.hasField(id)) return;
     targets.initialValues.value = {
       ...targets.initialValues.value,
+      // oxlint-disable-next-line anti-slop/require-safety-comment-for-type-assertion -- Field-saved values are arbitrary form payloads; JSON cloning does not establish FormFieldValue.
       [id]: cloneFormValue(value as FormFieldValue) as FormFieldValue,
     };
     targets.dirty.markClean({ ...targets.dirty.baseline.value, [id]: value });

package/frontend-vue/layers/dms-ui/app/build/composables/form/fieldValueRule.ts

@@ -1,8 +1,11 @@
+import type { WatchAction } from "#dms-core/app/types/watch";
+import { isString, isNumber, isBoolean } from "#dms-core/app/utils/type-check";
+
 /** What a `SetFieldValue` watch writes, and where. */
 export interface SetFieldValueParams {
   targetField: string;
   value?: unknown;
-  valueMap?: Record<string, unknown>;
+  valueMap?: NonNullable<WatchAction["params"]>;
 }
 
 /** The payload of a form's `FieldChange` event. */
@@ -18,8 +21,8 @@ export type FieldValueWrite = { value: unknown } | undefined;
 
 type MapKey = string | number | boolean;
 
-function isMapKey(value: unknown): value is MapKey {
-  return ["string", "number", "boolean"].includes(typeof value);
+function isMapKey(value: FieldChangePayload["value"]): value is MapKey {
+  return isString(value) || isNumber(value) || isBoolean(value);
 }
 
 /**
@@ -50,8 +53,11 @@ export function resolveFieldValueWrite(
  * coming back to that value is a change too.
  */
 export function createStartingValueTracker(
-  isStartingValue: (fieldId: string, value: unknown) => boolean,
-): (fieldId: string, value: unknown) => boolean {
+  isStartingValue: (
+    fieldId: string,
+    value: FieldChangePayload["value"],
+  ) => boolean,
+): (fieldId: string, value: FieldChangePayload["value"]) => boolean {
   const changedFieldIds = new Set<string>();
   return (fieldId, value) => {
     if (changedFieldIds.has(fieldId)) return false;

package/frontend-vue/layers/dms-ui/app/build/composables/form/floatingSaveBars.ts

@@ -7,7 +7,6 @@ import {
   watch,
 } from "vue";
 
-// Only mounted bars count, so a server render never adds to it.
 const shownBars = shallowReactive(new Set<symbol>());
 
 /**

package/frontend-vue/layers/dms-ui/app/build/composables/form/formComponentCancel.ts

@@ -0,0 +1,49 @@
+import { computed, onMounted, ref } from "vue";
+import { isString } from "#dms-core/app/utils/type-check";
+import type { FormProps } from "../../../composables/form/types/props";
+import type { DmsContainerContext } from "../containers/context";
+
+interface FormCancelSource {
+  inFormContainer: boolean;
+  container: DmsContainerContext | undefined;
+  backTo: () => FormProps["backTo"];
+  isDirty: () => boolean;
+  discardChanges: () => void;
+  back: () => void;
+  navigate: () => void;
+}
+
+function previousAppPage(): string | undefined {
+  const back: unknown = window.history.state?.back;
+  return isString(back) ? back : undefined;
+}
+
+/** Cancels into the container, app history, or configured fallback after discarding. */
+export function formComponentCancel(source: FormCancelSource) {
+  const cameFromAppPage = ref(false);
+  onMounted(() => {
+    cameFromAppPage.value = !!previousAppPage();
+  });
+  const canCancel = computed(
+    () =>
+      source.inFormContainer ||
+      !!source.container ||
+      !!source.backTo() ||
+      cameFromAppPage.value,
+  );
+
+  function cancelForm(): void {
+    if (source.isDirty()) source.discardChanges();
+    if (source.container) {
+      void source.container.close();
+      return;
+    }
+    if (previousAppPage()) {
+      source.back();
+      return;
+    }
+    source.navigate();
+  }
+
+  return { canCancel, cancelForm };
+}