@sonata-innovations/fiber-types 1.0.5 → 2.0.0

package/dist/component-accessors.d.ts

@@ -0,0 +1,12 @@
+import type { Component } from "./flow";
+import type { FlowValidationConfig } from "./validation";
+/** Returns the component's validation config if its property shape carries
+ *  one. Returns `undefined` for display-only types (header/text/divider/
+ *  callout/table/computed) and for `toggleSwitch`/`group`/`repeater`. */
+export declare const getValidationConfig: (component: Component) => FlowValidationConfig | undefined;
+/** Best human-readable identifier for a component, falling back from `label`
+ *  to `title` to `value`. Returns `undefined` when no display string is set.
+ *  Used by FBT/FBTL surfaces that need to name a component (stage cards, drag
+ *  overlays, condition pickers, validation messages). */
+export declare const getComponentDisplayLabel: (component: Component) => string | undefined;
+//# sourceMappingURL=component-accessors.d.ts.map

package/dist/component-accessors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"component-accessors.d.ts","sourceRoot":"","sources":["../src/component-accessors.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAC;AACxC,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AAEzD;;yEAEyE;AACzE,eAAO,MAAM,mBAAmB,GAC9B,WAAW,SAAS,KACnB,oBAAoB,GAAG,SAIzB,CAAC;AAEF;;;yDAGyD;AACzD,eAAO,MAAM,wBAAwB,GACnC,WAAW,SAAS,KACnB,MAAM,GAAG,SAYX,CAAC"}

package/dist/component-accessors.js

@@ -0,0 +1,39 @@
+/* ==========================================================================
+   Component accessors — narrow-access helpers across the discriminated union.
+
+   With `Component.properties` keyed on `type`, accessing a field that only
+   some variants carry (e.g. `validation`, `options`) requires narrowing. The
+   helpers here are the canonical narrowing patterns expressed once, so call
+   sites don't repeat the `"x" in props` boilerplate.
+
+   Add a new helper here only if the access pattern appears in multiple
+   packages and the narrowing rule is the same for every component type that
+   exposes the field. One-off accesses inside a single file should narrow
+   inline (`"options" in c.properties ? c.properties.options : undefined`)
+   rather than spawning a helper.
+   ========================================================================== */
+/** Returns the component's validation config if its property shape carries
+ *  one. Returns `undefined` for display-only types (header/text/divider/
+ *  callout/table/computed) and for `toggleSwitch`/`group`/`repeater`. */
+export const getValidationConfig = (component) => {
+    return "validation" in component.properties
+        ? component.properties.validation
+        : undefined;
+};
+/** Best human-readable identifier for a component, falling back from `label`
+ *  to `title` to `value`. Returns `undefined` when no display string is set.
+ *  Used by FBT/FBTL surfaces that need to name a component (stage cards, drag
+ *  overlays, condition pickers, validation messages). */
+export const getComponentDisplayLabel = (component) => {
+    const props = component.properties;
+    if ("label" in props && typeof props.label === "string" && props.label) {
+        return props.label;
+    }
+    if ("title" in props && typeof props.title === "string" && props.title) {
+        return props.title;
+    }
+    if ("value" in props && typeof props.value === "string" && props.value) {
+        return props.value;
+    }
+    return undefined;
+};

package/dist/component-manifest.d.ts

@@ -0,0 +1,39 @@
+import type { ValidationRuleType } from "./validation";
+export type ComponentCategory = "display" | "input" | "selection" | "datetime" | "interactive" | "container";
+export type ComponentManifestEntry = {
+    /** Stable type id used everywhere — Flow JSON, registry keys, props.type. */
+    type: string;
+    /** Human-readable label shown in the palette and badges. */
+    label: string;
+    /** Icon key used by FBT (resolved via the FBT icon registry). */
+    iconKey: string;
+    /** UI grouping — drives the pool section and the category badge. */
+    category: ComponentCategory;
+    /** True for components that render content but never contribute to FlowData
+     *  and cannot be condition sources or validation targets. */
+    displayOnly: boolean;
+    /** Validation rules the FBT editor offers for this type. An empty array
+     *  means the editor surfaces no validation UI. */
+    validationRules: readonly ValidationRuleType[];
+    /** Doc-only pointer to the TS property type in `properties.ts`.
+     *  Not used at runtime — exists so a reader can jump from manifest entry to
+     *  shape definition without grep. */
+    propertiesTypeName: string;
+};
+/** Frozen, ordered list of every registered component type. The order is the
+ *  canonical pool-section order (display → input → selection → datetime →
+ *  interactive → container) and matches the FBT pool. */
+export declare const COMPONENT_MANIFEST: readonly ComponentManifestEntry[];
+/** Stable, immutable list of all registered component type ids. */
+export declare const COMPONENT_TYPES: readonly string[];
+/** Component types that render content but never contribute to FlowData. */
+export declare const DISPLAY_ONLY_TYPES: ReadonlySet<string>;
+/** Human-readable label for the category badge / pool section header. */
+export declare const CATEGORY_LABELS: Record<ComponentCategory, string>;
+/** Look up a manifest entry by component type id. Returns undefined for
+ *  unrecognized types — callers decide whether that is an error. */
+export declare function getComponentManifestEntry(type: string): ComponentManifestEntry | undefined;
+/** Manifest entries grouped by category, preserving manifest order within
+ *  each group. Drives the FBT pool layout. */
+export declare function getManifestByCategory(): Record<ComponentCategory, readonly ComponentManifestEntry[]>;
+//# sourceMappingURL=component-manifest.d.ts.map

package/dist/component-manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"component-manifest.d.ts","sourceRoot":"","sources":["../src/component-manifest.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAEvD,MAAM,MAAM,iBAAiB,GACzB,SAAS,GACT,OAAO,GACP,WAAW,GACX,UAAU,GACV,aAAa,GACb,WAAW,CAAC;AAEhB,MAAM,MAAM,sBAAsB,GAAG;IACnC,6EAA6E;IAC7E,IAAI,EAAE,MAAM,CAAC;IACb,4DAA4D;IAC5D,KAAK,EAAE,MAAM,CAAC;IACd,iEAAiE;IACjE,OAAO,EAAE,MAAM,CAAC;IAChB,oEAAoE;IACpE,QAAQ,EAAE,iBAAiB,CAAC;IAC5B;iEAC6D;IAC7D,WAAW,EAAE,OAAO,CAAC;IACrB;sDACkD;IAClD,eAAe,EAAE,SAAS,kBAAkB,EAAE,CAAC;IAC/C;;yCAEqC;IACrC,kBAAkB,EAAE,MAAM,CAAC;CAC5B,CAAC;AAuTF;;yDAEyD;AACzD,eAAO,MAAM,kBAAkB,EAAE,SAAS,sBAAsB,EAAY,CAAC;AAE7E,mEAAmE;AACnE,eAAO,MAAM,eAAe,EAAE,SAAS,MAAM,EAA+B,CAAC;AAE7E,4EAA4E;AAC5E,eAAO,MAAM,kBAAkB,EAAE,WAAW,CAAC,MAAM,CAElD,CAAC;AAEF,yEAAyE;AACzE,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,iBAAiB,EAAE,MAAM,CAO7D,CAAC;AAEF;oEACoE;AACpE,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,MAAM,GACX,sBAAsB,GAAG,SAAS,CAEpC;AAED;8CAC8C;AAC9C,wBAAgB,qBAAqB,IAAI,MAAM,CAC7C,iBAAiB,EACjB,SAAS,sBAAsB,EAAE,CAClC,CAaA"}

package/dist/component-manifest.js

@@ -0,0 +1,355 @@
+/* ==========================================================================
+   Component Manifest — single source of truth for the registered component
+   types. Every package that needs per-type metadata (labels, icons,
+   categories, display-only behavior, allowed validation rules) derives that
+   knowledge from this file rather than restating it.
+
+   Adding a new component type means:
+     (1) add an entry here,
+     (2) add the property type in `properties.ts`,
+     (3) register a renderer in FBRE (`registerComponent`),
+     (4) add a field-map entry in FBT (`fbt/src/ui/editor/field-map.tsx`).
+
+   The parity guard in `fbre/src/__tests__/manifest-parity.test.ts` fails if
+   the renderer set drifts from the manifest, and the FBT-side guard fails if
+   the field-map drifts. Silent registry drift was the largest growth-friction
+   item in the 2026-05-19 core libs audit (HIGH-1); this file closes that gap.
+   ========================================================================== */
+const ENTRIES = [
+    // ---------- Display ----------
+    {
+        type: "header",
+        label: "Header",
+        iconKey: "header",
+        category: "display",
+        displayOnly: true,
+        validationRules: [],
+        propertiesTypeName: "ComponentDisplayProperties",
+    },
+    {
+        type: "text",
+        label: "Description Text",
+        iconKey: "descriptionText",
+        category: "display",
+        displayOnly: true,
+        validationRules: [],
+        propertiesTypeName: "ComponentDisplayProperties",
+    },
+    {
+        type: "divider",
+        label: "Divider",
+        iconKey: "divider",
+        category: "display",
+        displayOnly: true,
+        validationRules: [],
+        propertiesTypeName: "ComponentDividerProperties",
+    },
+    {
+        type: "callout",
+        label: "Callout",
+        iconKey: "callout",
+        category: "display",
+        displayOnly: true,
+        validationRules: [],
+        propertiesTypeName: "ComponentCalloutProperties",
+    },
+    {
+        type: "table",
+        label: "Table",
+        iconKey: "table",
+        category: "display",
+        displayOnly: true,
+        validationRules: [],
+        propertiesTypeName: "ComponentTableProperties",
+    },
+    {
+        type: "computed",
+        label: "Calculated Field",
+        iconKey: "calculated",
+        category: "display",
+        displayOnly: false,
+        validationRules: [],
+        propertiesTypeName: "ComponentComputedProperties",
+    },
+    // ---------- Text & Number ----------
+    {
+        type: "inputText",
+        label: "Text Input",
+        iconKey: "textInput",
+        category: "input",
+        displayOnly: false,
+        validationRules: [
+            "required",
+            "email",
+            "phone",
+            "url",
+            "minLength",
+            "maxLength",
+            "exactLength",
+            "pattern",
+            "contains",
+            "excludes",
+            "matchesField",
+        ],
+        propertiesTypeName: "ComponentInputProperties",
+    },
+    {
+        type: "inputTextArea",
+        label: "Text Area",
+        iconKey: "textArea",
+        category: "input",
+        displayOnly: false,
+        validationRules: [
+            "required",
+            "minLength",
+            "maxLength",
+            "exactLength",
+            "pattern",
+            "contains",
+            "excludes",
+            "matchesField",
+        ],
+        propertiesTypeName: "ComponentInputProperties",
+    },
+    {
+        type: "inputNumber",
+        label: "Number Input",
+        iconKey: "numberInput",
+        category: "input",
+        displayOnly: false,
+        validationRules: ["required", "minValue", "maxValue", "matchesField"],
+        propertiesTypeName: "ComponentInputProperties",
+    },
+    // ---------- Selection ----------
+    {
+        type: "dropDown",
+        label: "Select",
+        iconKey: "select",
+        category: "selection",
+        displayOnly: false,
+        validationRules: ["required"],
+        propertiesTypeName: "ComponentOptionProperties",
+    },
+    {
+        type: "dropDownMulti",
+        label: "Multi-select",
+        iconKey: "multiSelect",
+        category: "selection",
+        displayOnly: false,
+        validationRules: ["required", "minSelected", "maxSelected"],
+        propertiesTypeName: "ComponentOptionProperties",
+    },
+    {
+        type: "checkbox",
+        label: "Checkbox",
+        iconKey: "checkbox",
+        category: "selection",
+        displayOnly: false,
+        validationRules: ["required", "minSelected", "maxSelected"],
+        propertiesTypeName: "ComponentOptionProperties",
+    },
+    {
+        type: "radio",
+        label: "Radio",
+        iconKey: "radio",
+        category: "selection",
+        displayOnly: false,
+        validationRules: ["required"],
+        propertiesTypeName: "ComponentOptionProperties",
+    },
+    {
+        type: "toggleSwitch",
+        label: "Toggle Switch",
+        iconKey: "toggleSwitch",
+        category: "selection",
+        displayOnly: false,
+        validationRules: [],
+        propertiesTypeName: "ComponentSwitchProperties",
+    },
+    {
+        type: "yesNo",
+        label: "Yes / No",
+        iconKey: "yesNo",
+        category: "selection",
+        displayOnly: false,
+        validationRules: ["required"],
+        propertiesTypeName: "ComponentYesNoProperties",
+    },
+    {
+        type: "confirm",
+        label: "Confirmation",
+        iconKey: "confirm",
+        category: "selection",
+        displayOnly: false,
+        validationRules: ["required"],
+        propertiesTypeName: "ComponentConfirmProperties",
+    },
+    {
+        type: "cardSelect",
+        label: "Card Select",
+        iconKey: "cardSelect",
+        category: "selection",
+        displayOnly: false,
+        validationRules: ["required"],
+        propertiesTypeName: "ComponentCardSelectProperties",
+    },
+    // ---------- Date & Time ----------
+    {
+        type: "date",
+        label: "Date",
+        iconKey: "date",
+        category: "datetime",
+        displayOnly: false,
+        validationRules: ["required"],
+        propertiesTypeName: "ComponentDateProperties",
+    },
+    {
+        type: "time",
+        label: "Time",
+        iconKey: "time",
+        category: "datetime",
+        displayOnly: false,
+        validationRules: ["required"],
+        propertiesTypeName: "ComponentTimeProperties",
+    },
+    {
+        type: "dateTime",
+        label: "Date & Time",
+        iconKey: "dateTime",
+        category: "datetime",
+        displayOnly: false,
+        validationRules: ["required"],
+        propertiesTypeName: "ComponentDateTimeProperties",
+    },
+    {
+        type: "dateRange",
+        label: "Date Range",
+        iconKey: "dateRange",
+        category: "datetime",
+        displayOnly: false,
+        validationRules: ["required"],
+        propertiesTypeName: "ComponentDateRangeProperties",
+    },
+    {
+        type: "timeRange",
+        label: "Time Range",
+        iconKey: "timeRange",
+        category: "datetime",
+        displayOnly: false,
+        validationRules: ["required"],
+        propertiesTypeName: "ComponentTimeRangeProperties",
+    },
+    {
+        type: "dateTimeRange",
+        label: "Date & Time Range",
+        iconKey: "dateTimeRange",
+        category: "datetime",
+        displayOnly: false,
+        validationRules: ["required"],
+        propertiesTypeName: "ComponentDateTimeRangeProperties",
+    },
+    // ---------- Interactive ----------
+    {
+        type: "fileUpload",
+        label: "File Upload",
+        iconKey: "fileUpload",
+        category: "interactive",
+        displayOnly: false,
+        validationRules: ["required", "fileType", "fileSize"],
+        propertiesTypeName: "ComponentFileUploadProperties",
+    },
+    {
+        type: "rating",
+        label: "Rating",
+        iconKey: "rating",
+        category: "interactive",
+        displayOnly: false,
+        validationRules: ["required"],
+        propertiesTypeName: "ComponentRatingProperties",
+    },
+    {
+        type: "slider",
+        label: "Slider",
+        iconKey: "slider",
+        category: "interactive",
+        displayOnly: false,
+        validationRules: [],
+        propertiesTypeName: "ComponentSliderProperties",
+    },
+    {
+        type: "colorPicker",
+        label: "Color Picker",
+        iconKey: "colorPicker",
+        category: "interactive",
+        displayOnly: false,
+        validationRules: ["required"],
+        propertiesTypeName: "ComponentColorPickerProperties",
+    },
+    {
+        type: "signature",
+        label: "Signature",
+        iconKey: "signature",
+        category: "interactive",
+        displayOnly: false,
+        validationRules: ["required"],
+        propertiesTypeName: "ComponentSignatureProperties",
+    },
+    // ---------- Containers ----------
+    {
+        type: "group",
+        label: "Group",
+        iconKey: "contactInfo",
+        category: "container",
+        displayOnly: false,
+        validationRules: [],
+        propertiesTypeName: "ComponentGroupProperties",
+    },
+    {
+        type: "repeater",
+        label: "Repeater",
+        iconKey: "repeater",
+        category: "container",
+        displayOnly: false,
+        validationRules: [],
+        propertiesTypeName: "ComponentRepeaterProperties",
+    },
+];
+const ENTRY_BY_TYPE = new Map(ENTRIES.map((e) => [e.type, e]));
+/** Frozen, ordered list of every registered component type. The order is the
+ *  canonical pool-section order (display → input → selection → datetime →
+ *  interactive → container) and matches the FBT pool. */
+export const COMPONENT_MANIFEST = ENTRIES;
+/** Stable, immutable list of all registered component type ids. */
+export const COMPONENT_TYPES = ENTRIES.map((e) => e.type);
+/** Component types that render content but never contribute to FlowData. */
+export const DISPLAY_ONLY_TYPES = new Set(ENTRIES.filter((e) => e.displayOnly).map((e) => e.type));
+/** Human-readable label for the category badge / pool section header. */
+export const CATEGORY_LABELS = {
+    display: "Display",
+    input: "Text & Number",
+    selection: "Selection",
+    datetime: "Date & Time",
+    interactive: "Interactive",
+    container: "Containers",
+};
+/** Look up a manifest entry by component type id. Returns undefined for
+ *  unrecognized types — callers decide whether that is an error. */
+export function getComponentManifestEntry(type) {
+    return ENTRY_BY_TYPE.get(type);
+}
+/** Manifest entries grouped by category, preserving manifest order within
+ *  each group. Drives the FBT pool layout. */
+export function getManifestByCategory() {
+    const out = {
+        display: [],
+        input: [],
+        selection: [],
+        datetime: [],
+        interactive: [],
+        container: [],
+    };
+    for (const entry of ENTRIES) {
+        out[entry.category].push(entry);
+    }
+    return out;
+}

package/dist/component-variants.d.ts

@@ -0,0 +1,51 @@
+import type { ComponentCalloutProperties, ComponentCardSelectProperties, ComponentColorPickerProperties, ComponentComputedProperties, ComponentConfirmProperties, ComponentDateProperties, ComponentDateRangeProperties, ComponentDateTimeProperties, ComponentDateTimeRangeProperties, ComponentDisplayProperties, ComponentDividerProperties, ComponentFileUploadProperties, ComponentGroupProperties, ComponentInputProperties, ComponentOptionProperties, ComponentRatingProperties, ComponentRepeaterProperties, ComponentSignatureProperties, ComponentSliderProperties, ComponentSwitchProperties, ComponentTableProperties, ComponentTimeProperties, ComponentTimeRangeProperties, ComponentYesNoProperties } from "./properties";
+/** Per-type property map. Keys here are the canonical `Component.type` ids;
+ *  values are the corresponding property shapes from `properties.ts`. */
+export interface ComponentPropertiesByType {
+    header: ComponentDisplayProperties;
+    text: ComponentDisplayProperties;
+    divider: ComponentDividerProperties;
+    callout: ComponentCalloutProperties;
+    table: ComponentTableProperties;
+    computed: ComponentComputedProperties;
+    inputText: ComponentInputProperties;
+    inputTextArea: ComponentInputProperties;
+    inputNumber: ComponentInputProperties;
+    dropDown: ComponentOptionProperties;
+    dropDownMulti: ComponentOptionProperties;
+    checkbox: ComponentOptionProperties;
+    radio: ComponentOptionProperties;
+    toggleSwitch: ComponentSwitchProperties;
+    yesNo: ComponentYesNoProperties;
+    confirm: ComponentConfirmProperties;
+    cardSelect: ComponentCardSelectProperties;
+    date: ComponentDateProperties;
+    time: ComponentTimeProperties;
+    dateTime: ComponentDateTimeProperties;
+    dateRange: ComponentDateRangeProperties;
+    timeRange: ComponentTimeRangeProperties;
+    dateTimeRange: ComponentDateTimeRangeProperties;
+    fileUpload: ComponentFileUploadProperties;
+    rating: ComponentRatingProperties;
+    slider: ComponentSliderProperties;
+    colorPicker: ComponentColorPickerProperties;
+    signature: ComponentSignatureProperties;
+    group: ComponentGroupProperties;
+    repeater: ComponentRepeaterProperties;
+}
+/** Union of every registered component `type` string. */
+export type ComponentType = keyof ComponentPropertiesByType;
+/** Runtime list of every registered component `type` — sourced from the type
+ *  map so the parity check below can verify it matches the manifest. */
+export declare const COMPONENT_VARIANT_TYPES: readonly ComponentType[];
+/** Asserts at runtime that `ComponentPropertiesByType` keys match the
+ *  COMPONENT_MANIFEST entry set. Pure-function check — call it from a unit
+ *  test to fail the build when the two drift. */
+export declare function assertManifestTypeMapParity(manifestTypes: readonly string[]): {
+    ok: true;
+} | {
+    ok: false;
+    missingFromMap: string[];
+    missingFromManifest: string[];
+};
+//# sourceMappingURL=component-variants.d.ts.map

package/dist/component-variants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"component-variants.d.ts","sourceRoot":"","sources":["../src/component-variants.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EACV,0BAA0B,EAC1B,6BAA6B,EAC7B,8BAA8B,EAC9B,2BAA2B,EAC3B,0BAA0B,EAC1B,uBAAuB,EACvB,4BAA4B,EAC5B,2BAA2B,EAC3B,gCAAgC,EAChC,0BAA0B,EAC1B,0BAA0B,EAC1B,6BAA6B,EAC7B,wBAAwB,EACxB,wBAAwB,EACxB,yBAAyB,EACzB,yBAAyB,EACzB,2BAA2B,EAC3B,4BAA4B,EAC5B,yBAAyB,EACzB,yBAAyB,EACzB,wBAAwB,EACxB,uBAAuB,EACvB,4BAA4B,EAC5B,wBAAwB,EACzB,MAAM,cAAc,CAAC;AAEtB;yEACyE;AACzE,MAAM,WAAW,yBAAyB;IAExC,MAAM,EAAE,0BAA0B,CAAC;IACnC,IAAI,EAAE,0BAA0B,CAAC;IACjC,OAAO,EAAE,0BAA0B,CAAC;IACpC,OAAO,EAAE,0BAA0B,CAAC;IACpC,KAAK,EAAE,wBAAwB,CAAC;IAChC,QAAQ,EAAE,2BAA2B,CAAC;IAGtC,SAAS,EAAE,wBAAwB,CAAC;IACpC,aAAa,EAAE,wBAAwB,CAAC;IACxC,WAAW,EAAE,wBAAwB,CAAC;IAGtC,QAAQ,EAAE,yBAAyB,CAAC;IACpC,aAAa,EAAE,yBAAyB,CAAC;IACzC,QAAQ,EAAE,yBAAyB,CAAC;IACpC,KAAK,EAAE,yBAAyB,CAAC;IACjC,YAAY,EAAE,yBAAyB,CAAC;IACxC,KAAK,EAAE,wBAAwB,CAAC;IAChC,OAAO,EAAE,0BAA0B,CAAC;IACpC,UAAU,EAAE,6BAA6B,CAAC;IAG1C,IAAI,EAAE,uBAAuB,CAAC;IAC9B,IAAI,EAAE,uBAAuB,CAAC;IAC9B,QAAQ,EAAE,2BAA2B,CAAC;IACtC,SAAS,EAAE,4BAA4B,CAAC;IACxC,SAAS,EAAE,4BAA4B,CAAC;IACxC,aAAa,EAAE,gCAAgC,CAAC;IAGhD,UAAU,EAAE,6BAA6B,CAAC;IAC1C,MAAM,EAAE,yBAAyB,CAAC;IAClC,MAAM,EAAE,yBAAyB,CAAC;IAClC,WAAW,EAAE,8BAA8B,CAAC;IAC5C,SAAS,EAAE,4BAA4B,CAAC;IAGxC,KAAK,EAAE,wBAAwB,CAAC;IAChC,QAAQ,EAAE,2BAA2B,CAAC;CACvC;AAED,yDAAyD;AACzD,MAAM,MAAM,aAAa,GAAG,MAAM,yBAAyB,CAAC;AAE5D;wEACwE;AACxE,eAAO,MAAM,uBAAuB,EAAE,SAAS,aAAa,EA+BlD,CAAC;AAEX;;iDAEiD;AACjD,wBAAgB,2BAA2B,CACzC,aAAa,EAAE,SAAS,MAAM,EAAE,GAC/B;IAAE,EAAE,EAAE,IAAI,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,cAAc,EAAE,MAAM,EAAE,CAAC;IAAC,mBAAmB,EAAE,MAAM,EAAE,CAAA;CAAE,CAWvF"}

package/dist/component-variants.js

@@ -0,0 +1,64 @@
+/* ==========================================================================
+   Component variants — type-level mapping from each component `type` to the
+   shape of its `properties`. This is the type-level companion to
+   COMPONENT_MANIFEST: the manifest is runtime data (labels, icons, validation
+   rules), this file is types (per-type property shapes).
+
+   Adding a new component type means:
+     (1) add its property shape in `properties.ts`,
+     (2) add a key here mapping `type` → that shape,
+     (3) add a manifest entry in `component-manifest.ts`,
+     (4) add the renderer in FBRE and the field-map entry in FBT.
+
+   The runtime parity guard inside `assertManifestTypeMapParity` (called from
+   tests in fbre/fbt) fails if step (2) is missed against step (3). The casts
+   in fbre/fbt fall back to the loose union and start firing TS errors at the
+   read sites if step (1) is missed against step (2).
+   ========================================================================== */
+/** Runtime list of every registered component `type` — sourced from the type
+ *  map so the parity check below can verify it matches the manifest. */
+export const COMPONENT_VARIANT_TYPES = [
+    "header",
+    "text",
+    "divider",
+    "callout",
+    "table",
+    "computed",
+    "inputText",
+    "inputTextArea",
+    "inputNumber",
+    "dropDown",
+    "dropDownMulti",
+    "checkbox",
+    "radio",
+    "toggleSwitch",
+    "yesNo",
+    "confirm",
+    "cardSelect",
+    "date",
+    "time",
+    "dateTime",
+    "dateRange",
+    "timeRange",
+    "dateTimeRange",
+    "fileUpload",
+    "rating",
+    "slider",
+    "colorPicker",
+    "signature",
+    "group",
+    "repeater",
+];
+/** Asserts at runtime that `ComponentPropertiesByType` keys match the
+ *  COMPONENT_MANIFEST entry set. Pure-function check — call it from a unit
+ *  test to fail the build when the two drift. */
+export function assertManifestTypeMapParity(manifestTypes) {
+    const mapSet = new Set(COMPONENT_VARIANT_TYPES);
+    const manifestSet = new Set(manifestTypes);
+    const missingFromMap = manifestTypes.filter((t) => !mapSet.has(t));
+    const missingFromManifest = COMPONENT_VARIANT_TYPES.filter((t) => !manifestSet.has(t));
+    if (missingFromMap.length === 0 && missingFromManifest.length === 0) {
+        return { ok: true };
+    }
+    return { ok: false, missingFromMap, missingFromManifest };
+}

package/dist/flow.d.ts

@@ -1,5 +1,6 @@
 import type { FlowConditionConfig } from "./conditions";
 import type { FlowCalculation } from "./calculation";
+import type { ComponentPropertiesByType, ComponentType } from "./component-variants";
 export type ScreenTransitionType = "none" | "slide" | "fade" | "slideFade" | "rise" | "scaleFade";
 export type FlowStyleType = "clean" | "outlined" | "refined-clean" | "airy-clean" | "soft-outlined" | "defined-outlined" | "centered-minimal" | "stacked-cards" | "soft-float" | "bold-statement";
 export type ControlsLayout = "default" | "centered" | "inline-full" | "stacked";
@@ -31,10 +32,9 @@ export type FlowConfiguration = {
     controls?: ControlsConfig;
     summary?: boolean;
 };
-export type Component = {
+/** Fields every component variant carries regardless of `type`. */
+type ComponentCommon = {
     uuid: string;
-    type: string;
-    properties: ComponentProperties;
     conditions?: FlowConditionConfig;
     components?: Component[];
     value?: any;
@@ -42,6 +42,23 @@ export type Component = {
     valid?: boolean;
     display?: Record<string, any>;
 };
+/** A component with a specific known `type`. Useful for helpers that want to
+ *  accept only the matching variant (e.g. `ComponentOfType<"inputText">`). */
+export type ComponentOfType<K extends ComponentType> = ComponentCommon & {
+    type: K;
+    properties: ComponentPropertiesByType[K];
+};
+/** Component is a discriminated union keyed on `type`. Switching or guarding
+ *  on `component.type === "..."` narrows `component.properties` to the
+ *  matching `Component*Properties` shape from `properties.ts`. */
+export type Component = {
+    [K in ComponentType]: ComponentOfType<K>;
+}[ComponentType];
+/** Union of every registered properties shape. Replaces the prior
+ *  `Record<string, any>` alias — consumers that previously typed a value as
+ *  `ComponentProperties` now get the union and must narrow (most often via
+ *  `component.type` on the enclosing `Component`). */
+export type ComponentProperties = ComponentPropertiesByType[ComponentType];
 export type FlowScreen = {
     uuid: string;
     label?: string;
@@ -58,5 +75,5 @@ export type Flow = {
     screens: FlowScreen[];
     calculations?: FlowCalculation[];
 };
-export type ComponentProperties = Record<string, any>;
+export {};
 //# sourceMappingURL=flow.d.ts.map

package/dist/flow.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"flow.d.ts","sourceRoot":"","sources":["../src/flow.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AACxD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAErD,MAAM,MAAM,oBAAoB,GAC5B,MAAM,GACN,OAAO,GACP,MAAM,GACN,WAAW,GACX,MAAM,GACN,WAAW,CAAC;AAEhB,MAAM,MAAM,aAAa,GACrB,OAAO,GACP,UAAU,GACV,eAAe,GACf,YAAY,GACZ,eAAe,GACf,kBAAkB,GAClB,kBAAkB,GAClB,eAAe,GACf,YAAY,GACZ,gBAAgB,CAAC;AAErB,MAAM,MAAM,cAAc,GAAG,SAAS,GAAG,UAAU,GAAG,aAAa,GAAG,SAAS,CAAC;AAEhF,MAAM,MAAM,YAAY,GAAG,SAAS,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,KAAK,GAAG,MAAM,CAAC;AAEjF,MAAM,MAAM,YAAY,GAAG,UAAU,GAAG,gBAAgB,CAAC;AAEzD,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG;IAClD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,KAAK,CAAC,EAAE,aAAa,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,UAAU,CAAC,EAAE,oBAAoB,CAAC;IAClC,sBAAsB,CAAC,EAAE,OAAO,CAAC;CAClC,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,MAAM,CAAC,EAAE,cAAc,CAAC;IACxB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,YAAY,CAAC,EAAE,YAAY,CAAC;CAC7B,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,CAAC,EAAE,YAAY,CAAC;IACpB,KAAK,CAAC,EAAE,WAAW,CAAC;IACpB,UAAU,CAAC,EAAE,gBAAgB,CAAC;IAC9B,QAAQ,CAAC,EAAE,cAAc,CAAC;IAC1B,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,mBAAmB,CAAC;IAChC,UAAU,CAAC,EAAE,mBAAmB,CAAC;IACjC,UAAU,CAAC,EAAE,SAAS,EAAE,CAAC;IACzB,KAAK,CAAC,EAAE,GAAG,CAAC;IACZ,eAAe,CAAC,EAAE,SAAS,EAAE,EAAE,CAAC;IAChC,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAC/B,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,SAAS,EAAE,CAAC;IACxB,UAAU,CAAC,EAAE,mBAAmB,GAAG,EAAE,CAAC;IACtC,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,IAAI,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,iBAAiB,CAAC;IAC3B,QAAQ,EAAE,YAAY,CAAC;IACvB,OAAO,EAAE,UAAU,EAAE,CAAC;IACtB,YAAY,CAAC,EAAE,eAAe,EAAE,CAAC;CAClC,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC"}
+{"version":3,"file":"flow.d.ts","sourceRoot":"","sources":["../src/flow.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -1,10 +1,17 @@
-export type { Flow, FlowScreen, FlowConfiguration, ThemeConfig, NavigationConfig, ControlsConfig, FlowMetadata, Component, ComponentProperties, ScreenTransitionType, FlowStyleType, ControlsLayout, StepperStyle, FlowModeType, } from "./flow";
+export type { Flow, FlowScreen, FlowConfiguration, ThemeConfig, NavigationConfig, ControlsConfig, FlowMetadata, Component, ComponentOfType, ComponentProperties, ScreenTransitionType, FlowStyleType, ControlsLayout, StepperStyle, FlowModeType, } from "./flow";
+export type { ComponentType, ComponentPropertiesByType, } from "./component-variants";
+export { COMPONENT_VARIANT_TYPES, assertManifestTypeMapParity, } from "./component-variants";
 export type { ConditionAction, ConditionLogic, ConditionOperator, ConditionRule, ConditionRuleSource, ConditionGroup, FlowConditionConfig, } from "./conditions";
 export type { ValidationRuleType, ValidationRule, FlowValidationConfig, } from "./validation";
+export { generateUUID } from "./uuid";
 export { normalizeOptions } from "./normalize-options";
 export type { FlowData, ScreenData, ComponentData, CalculationData, FileUploadData, FileUploadBase64Data, FileUploadS3Data, RangeValue, } from "./flow-data";
 export { regenerateComponentUUIDs, regenerateFlowUUIDs, } from "./uuid-regeneration";
+export { normalizeConditionalOrder } from "./normalize-conditional-order";
+export { getValidationConfig, getComponentDisplayLabel, } from "./component-accessors";
 export type { PresetData, TemplateData } from "./preset-template-data";
 export type { CalculationFormat, FlowCalculation, } from "./calculation";
-export type { ComponentWidth, DateFormat, ComponentInputType, ComponentDisplayProperties, ComponentDividerProperties, ComponentInputProperties, OptionItem, ComponentOptionProperties, ComponentSliderProperties, ComponentSwitchProperties, ComponentRatingProperties, ComponentFileUploadProperties, ComponentGroupProperties, ComponentRepeaterProperties, ComponentDateProperties, ComponentTimeProperties, ComponentDateTimeProperties, ComponentDateRangeProperties, ComponentTimeRangeProperties, ComponentDateTimeRangeProperties, ComponentYesNoProperties, ComponentConfirmProperties, ComponentColorPickerProperties, CardSelectOption, ComponentCardSelectProperties, ComponentCalloutVariant, ComponentCalloutProperties, TableColumn, TableRow, ComponentTableProperties, SignatureMode, ComponentSignatureProperties, ComponentComputedProperties, } from "./properties";
+export type { ComponentCategory, ComponentManifestEntry, } from "./component-manifest";
+export { COMPONENT_MANIFEST, COMPONENT_TYPES, DISPLAY_ONLY_TYPES, CATEGORY_LABELS, getComponentManifestEntry, getManifestByCategory, } from "./component-manifest";
+export type { ComponentWidth, DateFormat, ComponentDisplayProperties, ComponentDividerProperties, ComponentInputProperties, OptionItem, ComponentOptionProperties, ComponentSliderProperties, ComponentSwitchProperties, ComponentRatingProperties, ComponentFileUploadProperties, ComponentGroupProperties, ComponentRepeaterProperties, ComponentDateProperties, ComponentTimeProperties, ComponentDateTimeProperties, ComponentDateRangeProperties, ComponentTimeRangeProperties, ComponentDateTimeRangeProperties, ComponentYesNoProperties, ComponentConfirmProperties, ComponentColorPickerProperties, CardSelectOption, ComponentCardSelectProperties, ComponentCalloutVariant, ComponentCalloutProperties, TableColumn, TableRow, ComponentTableProperties, SignatureMode, ComponentSignatureProperties, ComponentComputedProperties, } from "./properties";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,IAAI,EACJ,UAAU,EACV,iBAAiB,EACjB,WAAW,EACX,gBAAgB,EAChB,cAAc,EACd,YAAY,EACZ,SAAS,EACT,mBAAmB,EACnB,oBAAoB,EACpB,aAAa,EACb,cAAc,EACd,YAAY,EACZ,YAAY,GACb,MAAM,QAAQ,CAAC;AAEhB,YAAY,EACV,eAAe,EACf,cAAc,EACd,iBAAiB,EACjB,aAAa,EACb,mBAAmB,EACnB,cAAc,EACd,mBAAmB,GACpB,MAAM,cAAc,CAAC;AAEtB,YAAY,EACV,kBAAkB,EAClB,cAAc,EACd,oBAAoB,GACrB,MAAM,cAAc,CAAC;AAEtB,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAEvD,YAAY,EACV,QAAQ,EACR,UAAU,EACV,aAAa,EACb,eAAe,EACf,cAAc,EACd,oBAAoB,EACpB,gBAAgB,EAChB,UAAU,GACX,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,wBAAwB,EACxB,mBAAmB,GACpB,MAAM,qBAAqB,CAAC;AAE7B,YAAY,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAEvE,YAAY,EACV,iBAAiB,EACjB,eAAe,GAChB,MAAM,eAAe,CAAC;AAEvB,YAAY,EACV,cAAc,EACd,UAAU,EACV,kBAAkB,EAClB,0BAA0B,EAC1B,0BAA0B,EAC1B,wBAAwB,EACxB,UAAU,EACV,yBAAyB,EACzB,yBAAyB,EACzB,yBAAyB,EACzB,yBAAyB,EACzB,6BAA6B,EAC7B,wBAAwB,EACxB,2BAA2B,EAC3B,uBAAuB,EACvB,uBAAuB,EACvB,2BAA2B,EAC3B,4BAA4B,EAC5B,4BAA4B,EAC5B,gCAAgC,EAChC,wBAAwB,EACxB,0BAA0B,EAC1B,8BAA8B,EAC9B,gBAAgB,EAChB,6BAA6B,EAC7B,uBAAuB,EACvB,0BAA0B,EAC1B,WAAW,EACX,QAAQ,EACR,wBAAwB,EACxB,aAAa,EACb,4BAA4B,EAC5B,2BAA2B,GAC5B,MAAM,cAAc,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,IAAI,EACJ,UAAU,EACV,iBAAiB,EACjB,WAAW,EACX,gBAAgB,EAChB,cAAc,EACd,YAAY,EACZ,SAAS,EACT,eAAe,EACf,mBAAmB,EACnB,oBAAoB,EACpB,aAAa,EACb,cAAc,EACd,YAAY,EACZ,YAAY,GACb,MAAM,QAAQ,CAAC;AAEhB,YAAY,EACV,aAAa,EACb,yBAAyB,GAC1B,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EACL,uBAAuB,EACvB,2BAA2B,GAC5B,MAAM,sBAAsB,CAAC;AAE9B,YAAY,EACV,eAAe,EACf,cAAc,EACd,iBAAiB,EACjB,aAAa,EACb,mBAAmB,EACnB,cAAc,EACd,mBAAmB,GACpB,MAAM,cAAc,CAAC;AAEtB,YAAY,EACV,kBAAkB,EAClB,cAAc,EACd,oBAAoB,GACrB,MAAM,cAAc,CAAC;AAEtB,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAEtC,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAEvD,YAAY,EACV,QAAQ,EACR,UAAU,EACV,aAAa,EACb,eAAe,EACf,cAAc,EACd,oBAAoB,EACpB,gBAAgB,EAChB,UAAU,GACX,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,wBAAwB,EACxB,mBAAmB,GACpB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,yBAAyB,EAAE,MAAM,+BAA+B,CAAC;AAE1E,OAAO,EACL,mBAAmB,EACnB,wBAAwB,GACzB,MAAM,uBAAuB,CAAC;AAE/B,YAAY,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAEvE,YAAY,EACV,iBAAiB,EACjB,eAAe,GAChB,MAAM,eAAe,CAAC;AAEvB,YAAY,EACV,iBAAiB,EACjB,sBAAsB,GACvB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EACL,kBAAkB,EAClB,eAAe,EACf,kBAAkB,EAClB,eAAe,EACf,yBAAyB,EACzB,qBAAqB,GACtB,MAAM,sBAAsB,CAAC;AAE9B,YAAY,EACV,cAAc,EACd,UAAU,EACV,0BAA0B,EAC1B,0BAA0B,EAC1B,wBAAwB,EACxB,UAAU,EACV,yBAAyB,EACzB,yBAAyB,EACzB,yBAAyB,EACzB,yBAAyB,EACzB,6BAA6B,EAC7B,wBAAwB,EACxB,2BAA2B,EAC3B,uBAAuB,EACvB,uBAAuB,EACvB,2BAA2B,EAC3B,4BAA4B,EAC5B,4BAA4B,EAC5B,gCAAgC,EAChC,wBAAwB,EACxB,0BAA0B,EAC1B,8BAA8B,EAC9B,gBAAgB,EAChB,6BAA6B,EAC7B,uBAAuB,EACvB,0BAA0B,EAC1B,WAAW,EACX,QAAQ,EACR,wBAAwB,EACxB,aAAa,EACb,4BAA4B,EAC5B,2BAA2B,GAC5B,MAAM,cAAc,CAAC"}

package/dist/index.js

@@ -1,2 +1,7 @@
+export { COMPONENT_VARIANT_TYPES, assertManifestTypeMapParity, } from "./component-variants";
+export { generateUUID } from "./uuid";
 export { normalizeOptions } from "./normalize-options";
 export { regenerateComponentUUIDs, regenerateFlowUUIDs, } from "./uuid-regeneration";
+export { normalizeConditionalOrder } from "./normalize-conditional-order";
+export { getValidationConfig, getComponentDisplayLabel, } from "./component-accessors";
+export { COMPONENT_MANIFEST, COMPONENT_TYPES, DISPLAY_ONLY_TYPES, CATEGORY_LABELS, getComponentManifestEntry, getManifestByCategory, } from "./component-manifest";

package/dist/normalize-conditional-order.d.ts

@@ -0,0 +1,8 @@
+import type { Flow } from "./flow";
+/**
+ * Returns a new Flow in which every top-level conditional component is moved
+ * to immediately follow the component it depends on. Pure: the input Flow is
+ * not mutated and component objects are reused by reference.
+ */
+export declare function normalizeConditionalOrder(flow: Flow): Flow;
+//# sourceMappingURL=normalize-conditional-order.d.ts.map

package/dist/normalize-conditional-order.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize-conditional-order.d.ts","sourceRoot":"","sources":["../src/normalize-conditional-order.ts"],"names":[],"mappings":"AAgCA,OAAO,KAAK,EAAE,IAAI,EAAyB,MAAM,QAAQ,CAAC;AAgB1D;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,CAqL1D"}

package/dist/normalize-conditional-order.js

@@ -0,0 +1,230 @@
+/* ==========================================================================
+   Conditional-order normalization — relocate each conditional component so it
+   sits immediately after the component it depends on.
+
+   Why: FBTL groups a conditional with its trigger ONLY when the conditional
+   immediately follows that trigger in document order. Generators (e.g. an AI
+   authoring step) often emit a conditional after an unrelated non-conditional
+   sibling, so FBTL can't group them and the conditional becomes a detached
+   downstream screen. Run a Flow through this BEFORE loading it into FBTL and
+   the adjacency FBTL expects is guaranteed.
+
+   Scope and guarantees:
+   - Operates on TOP-LEVEL screen components only. Nested children (inside
+     groups/repeaters) already share their parent's screen and are untouched.
+   - Only REORDERS. No condition, property, uuid, label, or screen-level
+     condition is ever rewritten. Component object references are preserved.
+   - A condition source pointing at a question nested inside a group/repeater
+     resolves to that nested question's top-level ancestor card, so the
+     conditional anchors on the card that actually carries the trigger.
+   - A conditional with multiple component sources is anchored after the
+     LATEST of its (resolved) sources, so every dependency precedes it.
+   - Dependency chains (A → C → D) are resolved trigger-before-dependent.
+   - Cycles and dangling sources are left in place (never relocated, never
+     loops).
+   - Every empty screen is dropped — both those emptied by relocation and any
+     the generator emitted empty. Original screen order, uuids, labels, and
+     screen-level conditions of surviving screens are preserved.
+   - First-screen identity is preserved: if relocation drops the original
+     first screen, its uuid is transplanted onto the new first screen so
+     FBTL's stable round-trip screenUUID does not shift.
+   ========================================================================== */
+/** All component-type source UUIDs referenced by a condition config.
+ *  `sourceType` undefined is treated as "component" (matches FBTL). */
+function conditionSourceUUIDs(config) {
+    const rules = config?.when?.rules;
+    if (!rules || rules.length === 0)
+        return [];
+    const out = [];
+    for (const rule of rules) {
+        if (rule.sourceType && rule.sourceType !== "component")
+            continue;
+        if (rule.source)
+            out.push(rule.source);
+    }
+    return out;
+}
+/**
+ * Returns a new Flow in which every top-level conditional component is moved
+ * to immediately follow the component it depends on. Pure: the input Flow is
+ * not mutated and component objects are reused by reference.
+ */
+export function normalizeConditionalOrder(flow) {
+    const screens = flow.screens ?? [];
+    const flat = [];
+    screens.forEach((screen, screenIndex) => {
+        for (const comp of screen.components ?? []) {
+            flat.push({ comp, screenIndex });
+        }
+    });
+    const byUUID = new Map();
+    for (const e of flat)
+        byUUID.set(e.comp.uuid, e);
+    const originalIndex = new Map();
+    flat.forEach((e, i) => originalIndex.set(e.comp.uuid, i));
+    // Map every component UUID — including ones nested inside group/repeater
+    // children — to its TOP-LEVEL ancestor. Lets a condition that points at a
+    // nested question anchor on the top-level card that contains it instead of
+    // being treated as dangling.
+    const topAncestor = new Map();
+    function indexSubtree(comp, rootUUID) {
+        topAncestor.set(comp.uuid, rootUUID);
+        for (const child of comp.components ?? []) {
+            indexSubtree(child, rootUUID);
+        }
+    }
+    for (const e of flat)
+        indexSubtree(e.comp, e.comp.uuid);
+    // Resolve each component's anchor: the source it should follow. Each source
+    // UUID is mapped to its top-level ancestor; the anchor is the resolved
+    // ancestor that appears LAST in original document order, so every dependency
+    // of a multi-source condition ends up before it. Returns null when there is
+    // no condition, no component source, or the source resolves to nothing /
+    // back to this component itself.
+    function anchorUUID(comp) {
+        const resolved = conditionSourceUUIDs(comp.conditions)
+            .map((uuid) => topAncestor.get(uuid))
+            .filter((uuid) => uuid !== undefined && uuid !== comp.uuid && byUUID.has(uuid));
+        if (resolved.length === 0)
+            return null;
+        let best = null;
+        let bestIdx = -1;
+        for (const uuid of resolved) {
+            const idx = originalIndex.get(uuid) ?? -1;
+            if (idx > bestIdx) {
+                bestIdx = idx;
+                best = uuid;
+            }
+        }
+        return best;
+    }
+    // Dependency depth, with cycle detection. Cyclic components report depth 0
+    // so they are treated as un-anchored (left in place, never looped on).
+    const depthCache = new Map();
+    function depthOf(uuid, seen) {
+        const cached = depthCache.get(uuid);
+        if (cached !== undefined)
+            return cached;
+        if (seen.has(uuid))
+            return 0; // cycle — break
+        const entry = byUUID.get(uuid);
+        if (!entry)
+            return 0;
+        const anchor = anchorUUID(entry.comp);
+        if (!anchor) {
+            depthCache.set(uuid, 0);
+            return 0;
+        }
+        seen.add(uuid);
+        const d = depthOf(anchor, seen) + 1;
+        seen.delete(uuid);
+        depthCache.set(uuid, d);
+        return d;
+    }
+    function isCyclic(uuid) {
+        // Walk anchors; if we revisit a node before hitting a root, it's a cycle.
+        const path = new Set();
+        let cur = uuid;
+        while (cur) {
+            if (path.has(cur))
+                return true;
+            path.add(cur);
+            const entry = byUUID.get(cur);
+            if (!entry)
+                return false;
+            cur = anchorUUID(entry.comp);
+        }
+        return false;
+    }
+    // Working order starts as original document order; relocations splice in.
+    const order = flat.map((e) => e.comp);
+    // Process relocatable conditionals trigger-before-dependent (depth asc),
+    // tie-broken by original index for stable sibling ordering.
+    const movable = flat
+        .map((e) => e.comp)
+        .filter((c) => anchorUUID(c) !== null && !isCyclic(c.uuid))
+        .sort((a, b) => {
+        const da = depthOf(a.uuid, new Set());
+        const db = depthOf(b.uuid, new Set());
+        if (da !== db)
+            return da - db;
+        return (originalIndex.get(a.uuid) ?? 0) - (originalIndex.get(b.uuid) ?? 0);
+    });
+    for (const comp of movable) {
+        const anchor = anchorUUID(comp);
+        if (!anchor)
+            continue;
+        const from = order.indexOf(comp);
+        if (from === -1)
+            continue;
+        order.splice(from, 1);
+        let at = order.findIndex((c) => c.uuid === anchor);
+        if (at === -1) {
+            // Anchor vanished (shouldn't happen) — restore original slot.
+            order.splice(Math.min(from, order.length), 0, comp);
+            continue;
+        }
+        // Skip past any conditionals already attached to this anchor so multiple
+        // dependents of one trigger keep their original relative order.
+        let insertAt = at + 1;
+        while (insertAt < order.length && anchorUUID(order[insertAt]) === anchor) {
+            insertAt++;
+        }
+        order.splice(insertAt, 0, comp);
+    }
+    // Resolve the screen a component lands on: follow anchors to the root
+    // (non-conditional / cyclic) component and use that screen.
+    const screenCache = new Map();
+    function targetScreen(uuid, seen) {
+        const cached = screenCache.get(uuid);
+        if (cached !== undefined)
+            return cached;
+        const entry = byUUID.get(uuid);
+        if (!entry)
+            return 0;
+        if (seen.has(uuid))
+            return entry.screenIndex; // cycle — own screen
+        if (isCyclic(uuid))
+            return entry.screenIndex;
+        const anchor = anchorUUID(entry.comp);
+        if (!anchor) {
+            screenCache.set(uuid, entry.screenIndex);
+            return entry.screenIndex;
+        }
+        seen.add(uuid);
+        const s = targetScreen(anchor, seen);
+        seen.delete(uuid);
+        screenCache.set(uuid, s);
+        return s;
+    }
+    // Re-emit screens in original order; components in final relocated order
+    // filtered to their target screen. Drop every empty screen — both those
+    // emptied by relocation and any that arrived empty from the generator.
+    const buckets = screens.map(() => []);
+    for (const comp of order) {
+        buckets[targetScreen(comp.uuid, new Set())].push(comp);
+    }
+    const newScreens = [];
+    screens.forEach((screen, i) => {
+        const comps = buckets[i];
+        if (comps.length === 0)
+            return; // empty — drop
+        newScreens.push({ ...screen, components: comps });
+    });
+    // Preserve first-screen identity: FBTL pins screens[0]'s uuid as its stable
+    // round-trip screenUUID. If relocation dropped the original first screen,
+    // transplant its uuid onto the new first screen so that anchor doesn't
+    // shift. The surviving screen keeps its own label — it carries meaning the
+    // dropped screen's would not.
+    const originalFirst = screens[0];
+    if (originalFirst && newScreens.length > 0) {
+        if (newScreens[0].uuid !== originalFirst.uuid) {
+            newScreens[0] = { ...newScreens[0], uuid: originalFirst.uuid };
+        }
+    }
+    else if (originalFirst && newScreens.length === 0) {
+        // Whole flow had no components — keep one well-formed empty screen.
+        newScreens.push({ ...originalFirst, components: [] });
+    }
+    return { ...flow, screens: newScreens };
+}

package/dist/uuid-regeneration.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"uuid-regeneration.d.ts","sourceRoot":"","sources":["../src/uuid-regeneration.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAE9C;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,UAAU,EAAE,SAAS,EAAE,GAAG,SAAS,EAAE,CAe7E;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,CAYpD"}
+{"version":3,"file":"uuid-regeneration.d.ts","sourceRoot":"","sources":["../src/uuid-regeneration.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAG9C;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,UAAU,EAAE,SAAS,EAAE,GAAG,SAAS,EAAE,CAkB7E;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,CAYpD"}

package/dist/uuid-regeneration.js

@@ -2,15 +2,19 @@
    UUID regeneration — deep-clone components/flows and replace all UUIDs.
    Used when dropping stored presets/templates onto the stage.
    ========================================================================== */
+import { generateUUID } from "./uuid";
 /**
  * Deep-clones an array of components and replaces every `uuid`
  * (including recursively within group `components`).
  */
 export function regenerateComponentUUIDs(components) {
     return components.map((comp) => {
+        // Cast through the union because the spread breaks TS's correlation
+        // between `type` and `properties`. At runtime the spread preserves both
+        // verbatim and structuredClone preserves the matching shape.
         const cloned = {
             ...comp,
-            uuid: crypto.randomUUID(),
+            uuid: generateUUID(),
             properties: structuredClone(comp.properties),
         };
         // Recurse into group children
@@ -27,12 +31,12 @@ export function regenerateComponentUUIDs(components) {
 export function regenerateFlowUUIDs(flow) {
     return {
         ...flow,
-        uuid: crypto.randomUUID(),
+        uuid: generateUUID(),
         metadata: { ...flow.metadata },
         config: flow.config ? { ...flow.config } : undefined,
         screens: flow.screens.map((screen) => ({
             ...screen,
-            uuid: crypto.randomUUID(),
+            uuid: generateUUID(),
             components: regenerateComponentUUIDs(screen.components),
         })),
     };

package/dist/uuid.d.ts

@@ -0,0 +1,2 @@
+export declare const generateUUID: () => string;
+//# sourceMappingURL=uuid.d.ts.map

package/dist/uuid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uuid.d.ts","sourceRoot":"","sources":["../src/uuid.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,YAAY,QAAO,MAA6B,CAAC"}

package/dist/uuid.js

@@ -0,0 +1,5 @@
+/* ==========================================================================
+   UUID generator — thin wrapper around crypto.randomUUID.
+   Single source for fbt/fbtl (which re-export this) and uuid-regeneration.
+   ========================================================================== */
+export const generateUUID = () => crypto.randomUUID();

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@sonata-innovations/fiber-types",
-	"version": "1.0.5",
+	"version": "2.0.0",
 	"description": "TypeScript type definitions for the Fiber form builder system",
 	"keywords": ["fiber", "form-builder", "types", "typescript", "flow-json"],
 	"license": "MIT",
@@ -25,7 +25,9 @@
 	],
 	"sideEffects": false,
 	"scripts": {
-		"build": "tsc"
+		"clean": "node -e \"fs.rmSync('dist',{recursive:true,force:true})\"",
+		"prebuild": "node scripts/check-variant-parity.mjs",
+		"build": "npm run clean && tsc"
 	},
 	"publishConfig": {
 		"access": "public"