@uides/stepwise 2.2.1 → 2.2.3

package/src/schemas/field/radio-choice/index.ts

@@ -1,5 +1,9 @@
 import * as v from 'valibot';
-import { createFieldDisplay } from '@uides/stepwise/schemas/field/common';
+import {
+  createComponentParams,
+  createFieldDisplay,
+  createFieldSchema,
+} from '@uides/stepwise/schemas/field/common';
 
 const RadioChoiceDisplaySchema = createFieldDisplay(
   v.strictObject({
@@ -12,20 +16,18 @@ const RadioChoiceDisplaySchema = createFieldDisplay(
     ),
     'choices-order': v.nullish(v.string()),
     'component-params': v.nullish(
-      v.strictObject({
+      createComponentParams({
         'legacy-mode': v.boolean(),
       })
     ),
   })
 );
 
-const RadioChoiceSchema = v.strictObject({
+const RadioChoiceSchema = createFieldSchema({
   'user-input-mode': v.picklist(['noinput', 'optional', 'required']),
   display: RadioChoiceDisplaySchema,
   'default-value': v.nullish(v.string()),
   'choices-source-fn': v.nullish(v.string()),
-  datatype: v.nullish(v.picklist(['document_id', 'radio-choice', 'string'])),
-  attribute: v.nullish(v.string()),
 });
 
 export type RadioChoiceType = v.InferOutput<typeof RadioChoiceSchema>;

package/src/schemas/field/rate/index.ts

@@ -1,19 +1,18 @@
 import * as v from 'valibot';
-import { createFieldDisplay } from '@uides/stepwise/schemas/field/common';
+import {
+  createComponentParams,
+  createFieldDisplay,
+  createFieldSchema,
+} from '@uides/stepwise/schemas/field/common';
 
 const RateDisplaySchema = createFieldDisplay(
   v.strictObject({
     component: v.literal('rate'),
-    'component-params': v.nullish(
-      v.strictObject({
-        dependencies: v.array(v.string()),
-        'dependencies-error-message': v.string(),
-      })
-    ),
+    'component-params': v.nullish(createComponentParams({})),
   })
 );
 
-const RateSchema = v.strictObject({
+const RateSchema = createFieldSchema({
   'user-input-mode': v.picklist(['noinput', 'optional']),
   display: RateDisplaySchema,
 });

package/src/schemas/field/recipient/index.ts

@@ -1,18 +1,21 @@
 import * as v from 'valibot';
-import { createFieldDisplay } from '@uides/stepwise/schemas/field/common';
+import {
+  createComponentParams,
+  createFieldDisplay,
+  createFieldSchema,
+} from '@uides/stepwise/schemas/field/common';
 
 const RecipientDisplaySchema = createFieldDisplay(
   v.strictObject({
     component: v.literal('recipient'),
+    'component-params': v.nullish(createComponentParams({})),
   })
 );
 
-const RecipientSchema = v.strictObject({
+const RecipientSchema = createFieldSchema({
   display: RecipientDisplaySchema,
   'user-input-mode': v.picklist(['noinput', 'required']),
-  datatype: v.nullish(v.picklist(['recipient', 'entity_recipient'])),
   'default-value': v.nullish(v.string()),
-  attribute: v.nullish(v.string()),
 });
 
 export type RecipientType = v.InferOutput<typeof RecipientSchema>;

package/src/schemas/field/redirect/index.ts

@@ -1,19 +1,20 @@
 import * as v from 'valibot';
-import { createFieldDisplay } from '@uides/stepwise/schemas/field/common';
+import {
+  createComponentParams,
+  createFieldDisplay,
+  createFieldSchema,
+} from '@uides/stepwise/schemas/field/common';
 
 const RedirectDisplaySchema = createFieldDisplay(
   v.strictObject({
     component: v.literal('redirect'),
+    'component-params': v.nullish(createComponentParams({})),
   })
 );
 
-const RedirectSchema = v.strictObject({
+const RedirectSchema = createFieldSchema({
   'user-input-mode': v.literal('noinput'),
   display: RedirectDisplaySchema,
-  sources: v.nullish(v.string()),
-  'value-constructor': v.nullish(v.string()),
-  attribute: v.nullish(v.string()),
-  datatype: v.nullish(v.literal('string')),
 });
 
 export type RedirectType = v.InferOutput<typeof RedirectSchema>;

package/src/schemas/field/refcode/index.ts

@@ -1,39 +1,25 @@
 import * as v from 'valibot';
-import { createFieldDisplay } from '@uides/stepwise/schemas/field/common';
+import {
+  createComponentParams,
+  createFieldDisplay,
+  createFieldSchema,
+} from '@uides/stepwise/schemas/field/common';
 
 const RefcodeDisplaySchema = createFieldDisplay(
   v.strictObject({
     component: v.literal('refcode'),
     'component-params': v.nullish(
-      v.strictObject({
-        'later-pages': v.nullish(v.boolean()),
+      createComponentParams({
         label: v.nullish(v.string()),
-        coordinates: v.nullish(v.array(v.nullable(v.number()))),
-      })
-    ),
-  }),
-  v.strictObject({
-    component: v.literal('refcode'),
-    // TODO: Make pdf component-params also inherit default component-params
-    'component-params': v.nullish(
-      v.strictObject({
-        'later-pages': v.nullish(v.boolean()),
-        label: v.nullish(v.string()),
-        coordinates: v.nullish(v.array(v.nullable(v.number()))),
-        fontName: v.nullish(v.literal('Font-Mono')),
       })
     ),
   })
 );
 
-const RefcodeSchema = v.strictObject({
+const RefcodeSchema = createFieldSchema({
   display: RefcodeDisplaySchema,
-  sources: v.nullish(v.string()),
-  'value-constructor': v.nullish(v.string()),
   'user-input-mode': v.literal('noinput'),
-  'is-display-field': v.nullish(v.boolean()),
   value: v.nullish(v.string()),
-  datatype: v.nullish(v.literal('string')),
 });
 
 export type RefcodeType = v.InferOutput<typeof RefcodeSchema>;

package/src/schemas/field/string/index.ts

@@ -1,12 +1,15 @@
 import * as v from 'valibot';
-import { createFieldDisplay } from '@uides/stepwise/schemas/field/common';
+import {
+  createComponentParams,
+  createFieldDisplay,
+  createFieldSchema,
+} from '@uides/stepwise/schemas/field/common';
 
 const StringFieldDisplaySchema = createFieldDisplay(
   v.strictObject({
     component: v.nullish(v.literal('string')),
     'component-params': v.nullish(
-      v.strictObject({
-        position: v.nullish(v.picklist(['center', 'justify', 'left', 'right'])),
+      createComponentParams({
         enforceUppercase: v.nullish(v.boolean()),
         multiplicity: v.nullish(v.number()),
         multiplicityLabels: v.nullish(
@@ -18,57 +21,19 @@ const StringFieldDisplaySchema = createFieldDisplay(
             emptyValueDisplay: v.nullish(v.string()),
           })
         ),
-        format: v.nullish(v.literal('plaintext')),
-        textColor: v.nullish(v.string()),
         'format-title': v.nullish(v.boolean()),
-        emph: v.nullish(v.boolean()),
-        bold: v.nullish(v.boolean()),
-        cell_valign: v.nullish(v.picklist(['BOTTOM', 'MIDDLE', 'TOP'])),
-        coordinates: v.nullish(v.array(v.nullable(v.number()))),
-        fontSize: v.nullish(v.number()),
-        leading: v.nullish(v.number()),
-        fontName: v.nullish(v.string()),
-        ignore_emph: v.nullish(v.boolean()),
-        'later-pages': v.nullish(v.boolean()),
-        attachment_retrieval: v.nullish(v.literal('no-content')),
-        backColor: v.nullish(v.string()),
       })
     ),
-  }),
-  v.strictObject({
-    component: v.nullish(v.literal('string')),
-    emph: v.nullish(v.boolean()),
-    bold: v.nullish(v.boolean()),
-    fontSize: v.nullish(v.number()),
-    position: v.nullish(v.picklist(['center', 'justify', 'left', 'right'])),
   })
 );
 
-const StringDatatypeSchema = v.nullish(
-  v.picklist([
-    'amka',
-    'attachment',
-    'blood_group',
-    'document_id',
-    'idnumber',
-    'string',
-    'date',
-  ])
-);
-
-const StringSchema = v.strictObject({
+const StringSchema = createFieldSchema({
   display: v.nullish(StringFieldDisplaySchema),
   'user-input-mode': v.nullish(
     v.picklist(['display', 'noinput', 'optional', 'required'])
   ),
-  attribute: v.nullish(v.string()),
   value: v.nullish(v.string()),
   'default-value': v.nullish(v.string()),
-  sources: v.nullish(v.string()),
-  'value-constructor': v.nullish(v.string()),
-  'is-display-field': v.nullish(v.boolean()),
-  datatype: StringDatatypeSchema,
-  'default-on-empty': v.nullish(v.string()),
   safe: v.nullish(v.boolean()),
 });
 

package/src/schemas/field/text/index.ts

@@ -1,34 +1,26 @@
 import * as v from 'valibot';
-import { createFieldDisplay } from '@uides/stepwise/schemas/field/common';
+import {
+  createComponentParams,
+  createFieldDisplay,
+  createFieldSchema,
+} from '@uides/stepwise/schemas/field/common';
 
 const TextDisplaySchema = createFieldDisplay(
   v.strictObject({
     component: v.literal('text'),
     'component-params': v.nullish(
-      v.strictObject({
-        format: v.nullish(v.literal('plaintext')),
-        fontSize: v.nullish(v.number()),
-        leading: v.nullish(v.number()),
-        bold: v.nullish(v.boolean()),
-        textColor: v.nullish(v.string()),
-        position: v.nullish(v.picklist(['center', 'justify', 'left', 'right'])),
-        cell_valign: v.nullish(v.picklist(['BOTTOM', 'MIDDLE', 'TOP'])),
+      createComponentParams({
         enforceUppercase: v.nullish(v.boolean()),
       })
     ),
   })
 );
 
-const TextSchema = v.strictObject({
-  'user-input-mode': v.picklist(['display', 'noinput', 'optional', 'required']),
+const TextSchema = createFieldSchema({
+  'user-input-mode': v.picklist(['noinput', 'optional', 'required']),
   display: TextDisplaySchema,
   value: v.nullish(v.string()),
   'default-value': v.nullish(v.string()),
-  attribute: v.nullish(v.string()),
-  datatype: v.nullish(v.picklist(['text', 'string'])),
-  sources: v.nullish(v.string()),
-  'value-constructor': v.nullish(v.string()),
-  safe: v.nullish(v.boolean()),
 });
 
 export type TextType = v.InferOutput<typeof TextSchema>;

package/src/schemas/field/three-block-date/index.ts

@@ -1,11 +1,15 @@
 import * as v from 'valibot';
-import { createFieldDisplay } from '@uides/stepwise/schemas/field/common';
+import {
+  createComponentParams,
+  createFieldDisplay,
+  createFieldSchema,
+} from '@uides/stepwise/schemas/field/common';
 
 const ThreeBlockDateDisplaySchema = createFieldDisplay(
   v.strictObject({
     component: v.literal('three-block-date'),
     'component-params': v.nullish(
-      v.strictObject({
+      createComponentParams({
         max: v.literal('now'),
         min: v.nullish(v.string()),
       })
@@ -13,13 +17,10 @@ const ThreeBlockDateDisplaySchema = createFieldDisplay(
   })
 );
 
-const ThreeBlockDateSchema = v.strictObject({
+const ThreeBlockDateSchema = createFieldSchema({
   'user-input-mode': v.picklist(['noinput', 'optional', 'required']),
-  attribute: v.nullish(v.string()),
   display: ThreeBlockDateDisplaySchema,
-  'default-on-empty': v.nullish(v.string()),
   'default-value': v.nullish(v.string()),
-  datatype: v.nullish(v.picklist(['date', 'string'])),
 });
 
 export type ThreeBlockDateType = v.InferOutput<typeof ThreeBlockDateSchema>;

package/src/schemas/field/url/index.ts

@@ -0,0 +1,24 @@
+import * as v from 'valibot';
+import {
+  createComponentParams,
+  createFieldDisplay,
+  createFieldSchema,
+} from '@uides/stepwise/schemas/field/common';
+
+const UrlDisplaySchema = createFieldDisplay(
+  v.strictObject({
+    component: v.literal('url'),
+    'component-params': v.nullish(createComponentParams({})),
+  })
+);
+
+const UrlSchema = createFieldSchema({
+  'user-input-mode': v.picklist(['optional', 'noinput']),
+  display: UrlDisplaySchema,
+  'default-value': v.nullish(v.string()),
+});
+
+export type UrlType = v.InferOutput<typeof UrlSchema>;
+export type UrlSchemaType = v.GenericSchema<UrlType>;
+
+export default UrlSchema as UrlSchemaType;

package/src/schemas/fieldset/component-params.ts

@@ -3,35 +3,27 @@ import * as v from 'valibot';
 export const MultiplicityLabelsSchema = v.strictObject({
   /** add dialog title */
   addTitle: v.nullish(v.string()),
+  /** add dialog hint */
+  addHint: v.nullish(v.string()),
   /** edit dialog title */
   editTitle: v.nullish(v.string()),
   /** add action */
   addItem: v.nullish(v.string()),
-  /** remove item action */
-  removeItem: v.nullish(v.string()),
   /** edit item action */
   editItem: v.nullish(v.string()),
-  /** submit form action (add case) */
-  submitAdd: v.nullish(v.string()),
-  /** submit form action (edit case) */
-  submitEdit: v.nullish(v.string()),
-  /** cancel action */
-  cancel: v.nullish(v.string()),
   /** empty selection message (form field) */
   empty: v.nullish(v.string()),
-  /** empty selection message (field display) */
-  emptyValueDisplay: v.nullish(v.string()),
 });
 export type MultiplicityLabels = v.InferOutput<typeof MultiplicityLabelsSchema>;
 
 export const OtherComponentParamsSchema = v.strictObject({
-  page_break: v.nullish(v.boolean()),
   sticky_title: v.nullish(v.boolean()),
   multiplicity: v.nullish(v.number()),
   multiplicityLabels: v.nullish(MultiplicityLabelsSchema),
   required: v.nullish(v.boolean()),
   fixed: v.nullish(v.boolean()),
   layout: v.nullish(v.picklist(['entry', 'card'])),
+  page_break: v.nullish(v.boolean()),
 });
 export type OtherComponentParams = v.InferOutput<
   typeof OtherComponentParamsSchema
@@ -41,21 +33,13 @@ export const TableComponentParamsSchema = v.strictObject({
   lines: v.optional(
     v.nullable(v.picklist(['no', 'grid', 'outer', 'grid-round', 'outer-round']))
   ),
-  table_halign: v.optional(v.nullable(v.picklist(['LEFT', 'CENTER', 'RIGHT']))),
-  table_width_ratio: v.nullish(v.number()),
-  cell_halign: v.optional(v.nullable(v.picklist(['left', 'center', 'right']))),
-  cell_valign: v.optional(v.nullable(v.picklist(['BOTTOM', 'MIDDLE', 'TOP']))),
+  fontSize: v.nullish(v.number()),
   cell_height: v.nullish(v.number()),
   auto_columns: v.nullish(v.boolean()),
-  fontSize: v.nullish(v.number()),
-  no_split: v.nullish(v.boolean()),
   spaceBefore: v.nullish(v.number()),
   spaceAfter: v.nullish(v.number()),
   omit_empty_values: v.nullish(v.boolean()),
-  background: v.nullish(v.string()),
   coordinates: v.nullish(v.array(v.number())),
-  mirrored: v.nullish(v.boolean()),
-  handler: v.nullish(v.string()),
   ...OtherComponentParamsSchema.entries,
 });
 export type TableComponentParams = v.InferOutput<

package/src/schemas/fieldset/display-components.ts

@@ -3,51 +3,20 @@ import {
   ComponentLayoutSchema,
   DisplayLangSchema,
 } from '@uides/stepwise/schemas/common';
-import {
-  OtherComponentParamsSchema,
-  TableComponentParamsSchema,
-} from '@uides/stepwise/schemas/fieldset/component-params';
-import {
-  PdfOtherComponentSchema,
-  PdfTableBasedComponentSchema,
-  WebComponentSchema,
-} from '@uides/stepwise/schemas/fieldset/enums';
+import { TableComponentParamsSchema } from '@uides/stepwise/schemas/fieldset/component-params';
+import { WebComponentSchema } from '@uides/stepwise/schemas/fieldset/enums';
 
 export const FieldsetWebDisplaySchema = v.strictObject({
   /** The explanatory title of the fieldset */
   title: v.nullish(v.string()),
+  /** The explanatory hint of the fieldset */
+  hint: v.nullish(v.string()),
   component: WebComponentSchema,
   'component-params': v.nullish(TableComponentParamsSchema),
   layout: v.nullish(ComponentLayoutSchema),
 });
 export type FieldsetWebDisplay = v.InferOutput<typeof FieldsetWebDisplaySchema>;
 
-export const FieldsetPdfDisplayTableSchema = v.strictObject({
-  /** The explanatory title of the fieldset */
-  title: v.nullish(v.string()),
-  component: PdfTableBasedComponentSchema,
-  'component-params': v.nullish(TableComponentParamsSchema),
-});
-export type FieldsetPdfDisplayTable = v.InferOutput<
-  typeof FieldsetPdfDisplayTableSchema
->;
-
-export const FieldsetPdfDisplayOtherSchema = v.strictObject({
-  /** The explanatory title of the fieldset */
-  title: v.nullish(v.string()),
-  component: PdfOtherComponentSchema,
-  'component-params': v.nullish(OtherComponentParamsSchema),
-});
-export type FieldsetPdfDisplayOther = v.InferOutput<
-  typeof FieldsetPdfDisplayOtherSchema
->;
-
-export const FieldsetPdfDisplaySchema = v.variant('component', [
-  FieldsetPdfDisplayTableSchema,
-  FieldsetPdfDisplayOtherSchema,
-]);
-export type FieldsetPdfDisplay = v.InferOutput<typeof FieldsetPdfDisplaySchema>;
-
 export const FieldsetDisplaySchema = v.union([
   v.looseObject({
     default: v.record(DisplayLangSchema, FieldsetWebDisplaySchema),
@@ -56,7 +25,7 @@ export const FieldsetDisplaySchema = v.union([
     web: v.record(DisplayLangSchema, FieldsetWebDisplaySchema),
   }),
   v.looseObject({
-    pdf: v.record(DisplayLangSchema, FieldsetPdfDisplaySchema),
+    pdf: v.record(DisplayLangSchema, v.any()),
   }),
 ]);
 

package/src/schemas/fieldset/enums.ts

@@ -9,41 +9,3 @@ import * as v from 'valibot';
  */
 export const WebComponentSchema = v.picklist(['values-list', 'hidden', 'form']);
 export type WebComponent = v.InferOutput<typeof WebComponentSchema>;
-
-/**
- * Pdf table-based component type.
- *
- * @value 'values-list' Used for displaying values.
- * @value 'table' Table. Ideal for displaying multiple fields, by showing both the field title and value. By using the field attributes 'title_md' and 'value_md', it is possible to align the fields in a custom way.
- * @value 'one-liner-table' One-liner table. Ideal for displaying a single row per value.
- * @value 'signature' Signature.
- * @value 'footnotes' Footnotes.
- * @value 'hidden' Hidden.
- * @value 'custom' Custom.
- */
-export const PdfTableBasedComponentSchema = v.picklist([
-  'values-list',
-  'table',
-  'one-liner-table',
-  'signature',
-  'footnotes',
-  'hidden',
-  'custom',
-]);
-export type PdfTableBasedComponent = v.InferOutput<
-  typeof PdfTableBasedComponentSchema
->;
-
-/**
- * Pdf component type.
- *
- * @value 'header' Header.
- * @value 'common' Common.
- * @value 'plain-text' Plain text. Ideal for displaying fields with values that are large texts. It helps in displaying the text across multiple pages.
- */
-export const PdfOtherComponentSchema = v.picklist([
-  'header',
-  'common',
-  'plain-text',
-]);
-export type PdfOtherComponent = v.InferOutput<typeof PdfOtherComponentSchema>;

package/src/schemas/step.ts

@@ -116,6 +116,7 @@ export const StepSchema = v.pipe(
     'has-display-fields': v.nullish(v.boolean()),
     targets: v.nullish(v.array(v.record(v.string(), v.any()))),
     'post-step-claims': v.nullish(v.array(v.string())),
+    'pre-step-claims': v.nullish(v.array(v.string())),
   }),
 
   validateField('fieldsets', (fieldsets, step) => {

package/src/schemas/{template/template-base.ts → template.ts}

@@ -5,12 +5,12 @@ import {
 } from '@uides/stepwise/schemas/step';
 
 /**
- * Describes a template
+ * Describes a template.
  *
  * A template is a set of steps that the user must complete in order to complete a process
  * in the system, whether that is the issuance of a document or the entry of a request.
  */
-export const TemplateBaseSchema = v.strictObject({
+export const TemplateSchema = v.strictObject({
   /**
    * Template's creation date
    */
@@ -39,7 +39,7 @@ export const TemplateBaseSchema = v.strictObject({
    * An entity's gate can be the owner of a template. If not specified, the template is considered
    * to be owned by the "System".
    */
-  owner: v.string(),
+  owner: v.nullish(v.string()),
   /** The template's unique identifier */
   refname: v.string(),
   /**
@@ -52,8 +52,32 @@ export const TemplateBaseSchema = v.strictObject({
    * Specification of the steps of the template.
    */
   steps_spec: v.nullish(StepsSpecSchema as unknown as StepsSpecSchemaType),
+  /**
+   * Whether the template is enabled or not.
+   */
+  enabled: v.nullish(v.boolean()),
+  template_type: v.strictObject({
+    /** @default 'application' */
+    refname: v.string(),
+    /** @default [] */
+    fields: v.array(v.any()),
+  }),
+  consent_method: v.literal('login'),
+  /**
+   * Recipient's business title
+   * @deprecated
+   */
+  recipient_hint: v.nullish(v.string()),
+  /**
+   * Claims that the application checks for in the user's session.
+   *
+   * @default ['mobile_certified_login','is_citizen_user','govgr_login']
+   */
+  required_claims: v.array(v.string()),
+  login_endpoint: v.nullish(v.string()),
+  fields: v.nullish(v.array(v.any())),
+  'ui:legacy_renderer': v.nullish(v.boolean()),
 });
+export type Template = v.InferOutput<typeof TemplateSchema>;
 
-export type TemplateBase = v.InferOutput<typeof TemplateBaseSchema>;
-
-export default TemplateBase;
+export default Template;

package/src/utils/index.ts

@@ -27,7 +27,7 @@ export function collectIssues(
     if (!issue?.issues) {
       formattedIssues[path] = {
         ...formattedIssues[path],
-        [nestedPath]: issue.message.replace(/invalid type: /i, ''),
+        [nestedPath]: formatMessage(issue),
       };
     } else {
       const nestedIssues: Record<string, string> = {};
@@ -60,10 +60,77 @@ function getNestedIssueMessage(
     });
     return nestedIssues;
   } else {
-    return { [path]: issue.message.replace(/invalid type: /i, '') };
+    return { [path]: formatMessage(issue) };
   }
 }
 
+/**
+ * Format a valibot issue into a clearer, actionable message.
+ *
+ * Handles common-but-noisy cases:
+ * - `strict_object` with `expected: 'never'` → unknown key
+ * - `variant` with no sub-issues → no matching schema, with component hint
+ * - `picklist` / `literal` mismatch → expected vs received with values
+ * - same `expected`/`received` labels (e.g. `Object` vs `Object`) → drop the
+ *   useless "Expected X but received X" wording
+ */
+function formatMessage(issue: BaseIssue<unknown>): string {
+  const { type, expected, received, message, input } = issue;
+
+  if (type === 'strict_object' && expected === 'never') {
+    return `Unknown key ${received} not allowed`;
+  }
+
+  if (type === 'variant') {
+    const components = extractDisplayComponents(input);
+    if (components.length > 0) {
+      const list = components.map((c) => `"${c}"`).join(', ');
+      return `No schema variant matches display component ${list}`;
+    }
+    return `No matching schema variant`;
+  }
+
+  if (
+    (type === 'picklist' || type === 'literal') &&
+    expected != null &&
+    received != null
+  ) {
+    return `Expected one of ${expected} but received ${received}`;
+  }
+
+  // valibot's literal/picklist can surface inside a `raw_check` when the
+  // schema author misuses the message-override arg; expected/received are
+  // still correct, so prefer those over the bare message.
+  if (
+    type === 'raw_check' &&
+    expected != null &&
+    received != null &&
+    message !== `Expected ${expected} but received ${received}`
+  ) {
+    return `Expected ${expected} but received ${received}`;
+  }
+
+  if (expected != null && received != null && expected === received) {
+    return `Value does not match expected ${expected} shape`;
+  }
+
+  return message.replace(/^Invalid type: /i, '');
+}
+
+function extractDisplayComponents(input: unknown): string[] {
+  if (!input || typeof input !== 'object' || Array.isArray(input)) return [];
+  const components = new Set<string>();
+  for (const modeVal of Object.values(input as Record<string, unknown>)) {
+    if (!modeVal || typeof modeVal !== 'object') continue;
+    for (const langVal of Object.values(modeVal as Record<string, unknown>)) {
+      if (!langVal || typeof langVal !== 'object') continue;
+      const c = (langVal as Record<string, unknown>)['component'];
+      if (typeof c === 'string') components.add(c);
+    }
+  }
+  return Array.from(components);
+}
+
 /**
  * Type guard to check if previous pipeline step resulted in a failure dataset.
  */