@contrail/cli 3.5.0-alpha.dd20a19 → 3.5.1-alpha.68d57e0

package/README.md

@@ -17,7 +17,7 @@ $ npm install -g @contrail/cli
 $ contrail COMMAND
 running command...
 $ contrail (--version)
-@contrail/cli/3.5.0-alpha.dd20a19 linux-x64 node-v24.14.1
+@contrail/cli/3.5.1-alpha.68d57e0 linux-x64 node-v24.14.1
 $ contrail --help [COMMAND]
 USAGE
   $ contrail COMMAND
@@ -51,7 +51,6 @@ To get instructions on how to set up autocomplete for your shell, run `contrail
 * [`contrail config list`](#contrail-config-list)
 * [`contrail config set`](#contrail-config-set)
 * [`contrail config use [NAME]`](#contrail-config-use-name)
-* [`contrail event-workflows assess-impact IDENTIFIER`](#contrail-event-workflows-assess-impact-identifier)
 * [`contrail file upload FILELOCATION CONTENTTYPE`](#contrail-file-upload-filelocation-contenttype)
 * [`contrail groups export`](#contrail-groups-export)
 * [`contrail groups import GROUPSFILE`](#contrail-groups-import-groupsfile)
@@ -537,37 +536,6 @@ EXAMPLES
   $ contrail config use demo-org
 ```
 
-## `contrail event-workflows assess-impact IDENTIFIER`
-
-Sample Dash0 traces of an event-workflow action and report per-invocation downstream impact.
-
-```
-USAGE
-  $ contrail event-workflows assess-impact IDENTIFIER [-l error|warn|info|debug] [-e true|false] [-s <value>] [--lookback <value>]
-    [--dataset <value>] [-j]
-
-ARGUMENTS
-  IDENTIFIER  Action identifier (contrail.event_workflow.action.identifier).
-
-FLAGS
-  -e, --alwaysConfirmEnv=<option>  [default: true] The Environment variables
-                                   <options: true|false>
-  -j, --json                       JSON output (not yet implemented; flag reserved).
-  -l, --logLevel=<option>          The Log Level
-                                   <options: error|warn|info|debug>
-  -s, --samples=<value>            [default: 50] Number of distinct traces to sample (10-100).
-  --dataset=<value>                [default: prod] Dash0 dataset.
-  --lookback=<value>               [default: 2d] How far back to search. Format: 30m | 6h | 2d.
-
-DESCRIPTION
-  Sample Dash0 traces of an event-workflow action and report per-invocation downstream impact.
-
-EXAMPLES
-  $ contrail event-workflows assess-impact @gap-automations:bomCcCostUpdate
-
-  $ contrail event-workflows assess-impact @gap-automations:bomCcCostUpdate --samples 25 --lookback 6h
-```
-
 ## `contrail file upload FILELOCATION CONTENTTYPE`
 
 Uploads a file to the VibeIQ platform

package/node_modules/@contrail/loader/lib/color-processor.js

@@ -5,14 +5,7 @@ const entity_types_1 = require("@contrail/entity-types");
 const base_processor_1 = require("./base-processor");
 const entity_processor_1 = require("./entity-processor");
 const constants_1 = require("./constants");
-function removeHexHash(data) {
-    for (const row of data ?? []) {
-        if (row.hex?.startsWith('#')) {
-            row.hex = row.hex.slice(1);
-        }
-    }
-    return data;
-}
+const color_validation_1 = require("./common/color-validation");
 class ColorProcessor extends base_processor_1.BaseProcessor {
     static typesToTransformBy = ['color'];
     static requiredProperties = ['typePath', 'typeId', 'federatedId', 'name', 'hex', 'red', 'green', 'blue'];
@@ -20,7 +13,7 @@ class ColorProcessor extends base_processor_1.BaseProcessor {
         if (!data) {
             return [];
         }
-        return removeHexHash(data);
+        return (0, color_validation_1.applyHexPriorityToRows)(data);
     }
     static validateTypePath(data, config, csvHeaders, generalErrors) {
         const typePathSource = {
@@ -56,20 +49,13 @@ class ColorProcessor extends base_processor_1.BaseProcessor {
     static validateLoadFile(data, config) {
         const { errors, warnings, generalErrors, generalWarnings, csvHeaders } = entity_processor_1.EntityProcessor.validateLoadFile(data, config, entity_types_1.LoadType.COLOR);
         this.validateTypePath(data, config, csvHeaders, generalErrors);
-        const redColumn = config?.federatedMappings?.red || 'red';
-        const blueColumn = config?.federatedMappings?.blue || 'blue';
-        const greenColumn = config?.federatedMappings?.green || 'green';
-        const hexColumn = config?.federatedMappings?.hex || 'hex';
-        const hasRedColumn = csvHeaders.includes(redColumn);
-        const hasBlueColumn = csvHeaders.includes(blueColumn);
-        const hasGreenColumn = csvHeaders.includes(greenColumn);
-        const hasHexColumn = csvHeaders.includes(hexColumn);
-        if (hasHexColumn && hasRedColumn && hasGreenColumn && hasBlueColumn) {
-            generalWarnings.push({
-                message: constants_1.COLOR_PROCESSOR_WARNINGS.HEX_IGNORED_WARNING,
-                issueType: entity_types_1.IssueType.CONFIG,
-            });
-        }
+        data.forEach((row, index) => {
+            const { rowErrors, rowWarnings } = (0, color_validation_1.buildColorRowIssues)(row, index + 2, config?.federatedMappings);
+            if (rowErrors)
+                errors.push(rowErrors);
+            if (rowWarnings)
+                warnings.push(rowWarnings);
+        });
         return { errors, warnings, generalErrors, generalWarnings };
     }
 }

package/node_modules/@contrail/loader/lib/color-processor.spec.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const color_processor_1 = require("./color-processor");
 const entity_types_1 = require("@contrail/entity-types");
 const constants_1 = require("./constants");
+const color_validation_1 = require("./common/color-validation");
 describe('ColorProcessor', () => {
     const loaderProcess = {
         id: 'mock-loader-process-id',
@@ -219,72 +220,38 @@ describe('ColorProcessor', () => {
             });
         });
         describe('color column validation', () => {
-            it('should warn when both hex and RGB columns are present', () => {
+            it('warns per-row when both hex and RGB are populated (hex prioritized)', () => {
                 const data = [
-                    {
-                        name: 'test-color',
-                        red: '255',
-                        green: '0',
-                        blue: '0',
-                        hex: '#ff0000',
-                    },
+                    { name: 'test-color', red: '255', green: '0', blue: '0', hex: '#ff0000' },
                 ];
-                const config = {
-                    ...loaderProcess,
-                    federatedMappings: {
-                        ...loaderProcess.federatedMappings,
-                        red: 'red',
-                        green: 'green',
-                        blue: 'blue',
-                        hex: 'hex',
-                    },
-                };
-                const result = color_processor_1.ColorProcessor.validateLoadFile(data, config);
-                expect(result.generalWarnings).toContainEqual({
-                    message: constants_1.COLOR_PROCESSOR_WARNINGS.HEX_IGNORED_WARNING,
-                    issueType: entity_types_1.IssueType.CONFIG,
-                });
-            });
-            it('should not warn when only RGB columns are present', () => {
-                const data = [
+                const result = color_processor_1.ColorProcessor.validateLoadFile(data, loaderProcess);
+                expect(result.warnings).toEqual([
                     {
-                        name: 'test-color',
-                        red: '255',
-                        green: '0',
-                        blue: '0',
-                    },
-                ];
-                const config = {
-                    ...loaderProcess,
-                    federatedMappings: {
-                        ...loaderProcess.federatedMappings,
-                        red: 'red',
-                        green: 'green',
-                        blue: 'blue',
+                        rowNumber: 2,
+                        columnIssues: [
+                            {
+                                columnName: 'hex',
+                                message: color_validation_1.COLOR_VALIDATION_MESSAGES.HEX_PRIORITIZED_OVER_RGB,
+                                issueType: entity_types_1.IssueType.INVALID_DATA,
+                                data: JSON.stringify(data[0]),
+                            },
+                        ],
                     },
-                };
-                const result = color_processor_1.ColorProcessor.validateLoadFile(data, config);
-                expect(result.generalWarnings).not.toContainEqual({
-                    message: constants_1.COLOR_PROCESSOR_WARNINGS.HEX_IGNORED_WARNING,
-                    issueType: entity_types_1.IssueType.CONFIG,
-                });
+                ]);
             });
-            it('should not warn when only hex column is present', () => {
+            it('does not warn when only RGB is populated and all components are valid', () => {
+                const data = [{ name: 'test-color', red: '255', green: '0', blue: '0' }];
+                const result = color_processor_1.ColorProcessor.validateLoadFile(data, loaderProcess);
+                expect(result.warnings).toEqual([]);
+                expect(result.errors).toEqual([]);
+            });
+            it('does not warn when only a valid hex is populated', () => {
                 const data = [{ name: 'test-color', hex: '#ff0000' }];
-                const config = {
-                    ...loaderProcess,
-                    federatedMappings: {
-                        ...loaderProcess.federatedMappings,
-                        hex: 'hex',
-                    },
-                };
-                const result = color_processor_1.ColorProcessor.validateLoadFile(data, config);
-                expect(result.generalWarnings).not.toContainEqual({
-                    message: constants_1.COLOR_PROCESSOR_WARNINGS.HEX_IGNORED_WARNING,
-                    issueType: entity_types_1.IssueType.CONFIG,
-                });
+                const result = color_processor_1.ColorProcessor.validateLoadFile(data, loaderProcess);
+                expect(result.warnings).toEqual([]);
+                expect(result.errors).toEqual([]);
             });
-            it('should handle custom column names from federatedMappings', () => {
+            it('warns per-row when both hex and RGB are populated under federatedMappings', () => {
                 const data = [{ name: 'test-color', r: '255', g: '0', b: '0', hexcode: '#ff0000' }];
                 const config = {
                     ...loaderProcess,
@@ -297,11 +264,94 @@ describe('ColorProcessor', () => {
                     },
                 };
                 const result = color_processor_1.ColorProcessor.validateLoadFile(data, config);
-                expect(result.generalWarnings).toContainEqual({
-                    message: constants_1.COLOR_PROCESSOR_WARNINGS.HEX_IGNORED_WARNING,
-                    issueType: entity_types_1.IssueType.CONFIG,
+                expect(result.warnings).toEqual([
+                    {
+                        rowNumber: 2,
+                        columnIssues: [
+                            {
+                                columnName: 'hex',
+                                message: color_validation_1.COLOR_VALIDATION_MESSAGES.HEX_PRIORITIZED_OVER_RGB,
+                                issueType: entity_types_1.IssueType.INVALID_DATA,
+                                data: JSON.stringify(data[0]),
+                            },
+                        ],
+                    },
+                ]);
+            });
+            it('errors when hex is invalid', () => {
+                const data = [{ name: 'bad', hex: 'notahex' }];
+                const result = color_processor_1.ColorProcessor.validateLoadFile(data, loaderProcess);
+                expect(result.errors).toHaveLength(1);
+                expect(result.errors[0]).toMatchObject({
+                    rowNumber: 2,
+                    columnIssues: [
+                        {
+                            columnName: 'hex',
+                            message: color_validation_1.COLOR_VALIDATION_MESSAGES.HEX_INVALID('notahex'),
+                            issueType: entity_types_1.IssueType.INVALID_DATA,
+                        },
+                    ],
+                });
+            });
+            it('errors when RGB is partially populated and hex is missing', () => {
+                const data = [{ name: 'partial', red: '255', green: '128' }];
+                const result = color_processor_1.ColorProcessor.validateLoadFile(data, loaderProcess);
+                expect(result.errors).toHaveLength(1);
+                expect(result.errors[0].rowNumber).toBe(2);
+                expect(result.errors[0].columnIssues).toEqual([
+                    {
+                        columnName: 'blue',
+                        message: color_validation_1.COLOR_VALIDATION_MESSAGES.RGB_INCOMPLETE(['blue']),
+                        issueType: entity_types_1.IssueType.INVALID_DATA,
+                        data: JSON.stringify(data[0]),
+                    },
+                ]);
+            });
+            it('errors when an RGB component is out of range or non-numeric', () => {
+                const data = [
+                    { name: 'bad-red', red: '300', green: '0', blue: '0' },
+                    { name: 'nan-green', red: '10', green: 'foo', blue: '0' },
+                ];
+                const result = color_processor_1.ColorProcessor.validateLoadFile(data, loaderProcess);
+                expect(result.errors).toHaveLength(2);
+                expect(result.errors[0]).toMatchObject({
+                    rowNumber: 2,
+                    columnIssues: [
+                        { columnName: 'red', message: color_validation_1.COLOR_VALIDATION_MESSAGES.RGB_OUT_OF_RANGE('red', '300') },
+                    ],
+                });
+                expect(result.errors[1]).toMatchObject({
+                    rowNumber: 3,
+                    columnIssues: [
+                        { columnName: 'green', message: color_validation_1.COLOR_VALIDATION_MESSAGES.RGB_OUT_OF_RANGE('green', 'foo') },
+                    ],
                 });
             });
+            it('does not error when neither hex nor RGB are populated (defaults to black)', () => {
+                const data = [{ name: 'no-color' }];
+                const result = color_processor_1.ColorProcessor.validateLoadFile(data, loaderProcess);
+                expect(result.errors).toEqual([]);
+                expect(result.warnings).toEqual([]);
+            });
+        });
+    });
+    describe('transformData (hex priority)', () => {
+        it('strips red/green/blue when hex is valid', () => {
+            const data = [
+                { hex: '#ff0000', red: '255', green: '0', blue: '0', name: 'red' },
+            ];
+            const result = color_processor_1.ColorProcessor.transformData(data);
+            expect(result).toEqual([{ hex: 'ff0000', name: 'red' }]);
+        });
+        it('keeps red/green/blue and removes empty hex when hex is missing', () => {
+            const data = [{ red: '255', green: '0', blue: '0', name: 'red' }];
+            const result = color_processor_1.ColorProcessor.transformData(data);
+            expect(result).toEqual([{ red: '255', green: '0', blue: '0', name: 'red' }]);
+        });
+        it('defaults to #000000 (without hash) when neither hex nor full RGB is provided', () => {
+            const data = [{ name: 'fallback' }];
+            const result = color_processor_1.ColorProcessor.transformData(data);
+            expect(result).toEqual([{ name: 'fallback', hex: color_validation_1.DEFAULT_HEX }]);
         });
     });
 });

package/node_modules/@contrail/loader/lib/common/chunk-by-url-length.d.ts

@@ -2,5 +2,5 @@ interface ChunkByUrlLengthOptions {
     maxBytes?: number;
     maxCount?: number;
 }
-export declare function chunkByUrlLength(ids: string[], options?: ChunkByUrlLengthOptions): string[][];
+export declare function chunkByUrlLength(ids: readonly string[] | null | undefined, options?: ChunkByUrlLengthOptions): string[][];
 export {};

package/node_modules/@contrail/loader/lib/common/chunk-by-url-length.js

@@ -6,6 +6,8 @@ function wireEncodedLength(id) {
     return encodeURIComponent(id.replace(/,/g, '_COMMA_')).length;
 }
 function chunkByUrlLength(ids, options = {}) {
+    if (!ids?.length)
+        return [];
     const maxBytes = options.maxBytes ?? constants_1.FEDERATED_ID_FETCH_MAX_URL_BYTES;
     const maxCount = options.maxCount ?? constants_1.FEDERATED_ID_FETCH_MAX_COUNT;
     const result = [];

package/node_modules/@contrail/loader/lib/common/chunk-by-url-length.spec.js

@@ -5,6 +5,10 @@ describe('chunkByUrlLength', () => {
     it('returns an empty array for empty input', () => {
         expect((0, chunk_by_url_length_1.chunkByUrlLength)([])).toEqual([]);
     });
+    it('returns an empty array for null/undefined input (matches lodash.chunk behavior)', () => {
+        expect((0, chunk_by_url_length_1.chunkByUrlLength)(undefined)).toEqual([]);
+        expect((0, chunk_by_url_length_1.chunkByUrlLength)(null)).toEqual([]);
+    });
     it('packs short ids into a single chunk up to maxCount', () => {
         const ids = Array.from({ length: 50 }, (_, i) => `id-${i}`);
         const chunks = (0, chunk_by_url_length_1.chunkByUrlLength)(ids, { maxCount: 200, maxBytes: 10000 });

package/node_modules/@contrail/loader/lib/common/color-validation.d.ts

@@ -0,0 +1,26 @@
+import { ProcessingIssues } from '@contrail/entity-types';
+export declare const COLOR_VALIDATION_MESSAGES: {
+    readonly HEX_INVALID: (hex: string) => string;
+    readonly RGB_INCOMPLETE: (missingColumns: string[]) => string;
+    readonly RGB_OUT_OF_RANGE: (column: string, value: string) => string;
+    readonly HEX_PRIORITIZED_OVER_RGB: "Both \"hex\" and red/green/blue values are provided — \"hex\" will be used and red/green/blue will be ignored for this row.";
+};
+export declare const DEFAULT_HEX = "000000";
+export declare function isValidHex(hex: string): boolean;
+export declare function parseRgbComponent(value: any): number | null;
+export interface ColorRowValidationResult {
+    errors: {
+        columnName: string;
+        message: string;
+    }[];
+    warnings: {
+        columnName: string;
+        message: string;
+    }[];
+}
+export declare function validateColorRow(row: Record<string, any>, federatedMappings?: Record<string, string>): ColorRowValidationResult;
+export declare function buildColorRowIssues(row: Record<string, any>, rowNumber: number, federatedMappings?: Record<string, string>): {
+    rowErrors: ProcessingIssues | null;
+    rowWarnings: ProcessingIssues | null;
+};
+export declare function applyHexPriorityToRows<T extends Record<string, any>>(rows: T[]): T[];

package/node_modules/@contrail/loader/lib/common/color-validation.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyHexPriorityToRows = exports.buildColorRowIssues = exports.validateColorRow = exports.parseRgbComponent = exports.isValidHex = exports.DEFAULT_HEX = exports.COLOR_VALIDATION_MESSAGES = void 0;
+const entity_types_1 = require("@contrail/entity-types");
+const validate_color_1 = require("validate-color");
+exports.COLOR_VALIDATION_MESSAGES = {
+    HEX_INVALID: (hex) => `"hex" value "${hex}" is not a valid hex color code (expected 3, 4, 6, or 8 hex digits, optionally prefixed with #).`,
+    RGB_INCOMPLETE: (missingColumns) => `Row has partial RGB data — "${missingColumns.join('", "')}" must also be provided when using RGB. Provide all of red/green/blue, or use "hex" instead.`,
+    RGB_OUT_OF_RANGE: (column, value) => `"${column}" value "${value}" is not a valid RGB component (must be a whole number between 0 and 255).`,
+    HEX_PRIORITIZED_OVER_RGB: 'Both "hex" and red/green/blue values are provided — "hex" will be used and red/green/blue will be ignored for this row.',
+};
+exports.DEFAULT_HEX = '000000';
+const RGB_TARGET_KEYS = ['red', 'green', 'blue'];
+const HEX_TARGET_KEY = 'hex';
+function getColorValue(row, federatedMappings, targetKey) {
+    const target = row[targetKey];
+    if (!isEmpty(target))
+        return target;
+    const sourceColumn = federatedMappings?.[targetKey];
+    if (sourceColumn && sourceColumn !== targetKey)
+        return row[sourceColumn];
+    return target;
+}
+function isEmpty(value) {
+    return value === null || value === undefined || value === '';
+}
+function isValidHex(hex) {
+    if (typeof hex !== 'string' || hex.length === 0)
+        return false;
+    const normalized = hex.startsWith('#') ? hex : `#${hex}`;
+    return (0, validate_color_1.validateHTMLColorHex)(normalized);
+}
+exports.isValidHex = isValidHex;
+function parseRgbComponent(value) {
+    if (isEmpty(value))
+        return null;
+    if (typeof value === 'number' && Number.isInteger(value) && value >= 0 && value <= 255)
+        return value;
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        if (trimmed === '' || !/^-?\d+$/.test(trimmed))
+            return null;
+        const n = Number(trimmed);
+        if (!Number.isInteger(n) || n < 0 || n > 255)
+            return null;
+        return n;
+    }
+    return null;
+}
+exports.parseRgbComponent = parseRgbComponent;
+function validateColorRow(row, federatedMappings) {
+    const errors = [];
+    const warnings = [];
+    const hexValue = getColorValue(row, federatedMappings, HEX_TARGET_KEY);
+    const rgbValues = {
+        red: getColorValue(row, federatedMappings, 'red'),
+        green: getColorValue(row, federatedMappings, 'green'),
+        blue: getColorValue(row, federatedMappings, 'blue'),
+    };
+    const rgbProvided = RGB_TARGET_KEYS.filter((k) => !isEmpty(rgbValues[k]));
+    const hexProvided = !isEmpty(hexValue);
+    if (hexProvided) {
+        if (!isValidHex(String(hexValue))) {
+            errors.push({
+                columnName: HEX_TARGET_KEY,
+                message: exports.COLOR_VALIDATION_MESSAGES.HEX_INVALID(String(hexValue)),
+            });
+        }
+        if (rgbProvided.length > 0) {
+            warnings.push({
+                columnName: HEX_TARGET_KEY,
+                message: exports.COLOR_VALIDATION_MESSAGES.HEX_PRIORITIZED_OVER_RGB,
+            });
+        }
+        return { errors, warnings };
+    }
+    if (rgbProvided.length === 0) {
+        return { errors, warnings };
+    }
+    if (rgbProvided.length < RGB_TARGET_KEYS.length) {
+        const missing = RGB_TARGET_KEYS.filter((k) => isEmpty(rgbValues[k]));
+        for (const k of missing) {
+            errors.push({
+                columnName: k,
+                message: exports.COLOR_VALIDATION_MESSAGES.RGB_INCOMPLETE([...missing]),
+            });
+        }
+        return { errors, warnings };
+    }
+    for (const k of RGB_TARGET_KEYS) {
+        if (parseRgbComponent(rgbValues[k]) === null) {
+            errors.push({
+                columnName: k,
+                message: exports.COLOR_VALIDATION_MESSAGES.RGB_OUT_OF_RANGE(k, String(rgbValues[k])),
+            });
+        }
+    }
+    return { errors, warnings };
+}
+exports.validateColorRow = validateColorRow;
+function buildColorRowIssues(row, rowNumber, federatedMappings) {
+    const { errors, warnings } = validateColorRow(row, federatedMappings);
+    const rowJson = JSON.stringify(row);
+    const rowErrors = errors.length
+        ? {
+            rowNumber,
+            columnIssues: errors.map((e) => ({
+                columnName: e.columnName,
+                message: e.message,
+                issueType: entity_types_1.IssueType.INVALID_DATA,
+                data: rowJson,
+            })),
+        }
+        : null;
+    const rowWarnings = warnings.length
+        ? {
+            rowNumber,
+            columnIssues: warnings.map((w) => ({
+                columnName: w.columnName,
+                message: w.message,
+                issueType: entity_types_1.IssueType.INVALID_DATA,
+                data: rowJson,
+            })),
+        }
+        : null;
+    return { rowErrors, rowWarnings };
+}
+exports.buildColorRowIssues = buildColorRowIssues;
+function applyHexPriorityToRows(rows) {
+    for (const r of rows ?? []) {
+        if (!r)
+            continue;
+        const row = r;
+        const hexRaw = row.hex;
+        const hexNormalized = typeof hexRaw === 'string' && hexRaw.startsWith('#') ? hexRaw.slice(1) : hexRaw;
+        const hexValid = !isEmpty(hexNormalized) && isValidHex(String(hexNormalized));
+        if (hexValid) {
+            row.hex = hexNormalized;
+            delete row.red;
+            delete row.green;
+            delete row.blue;
+            continue;
+        }
+        const rgbAllValid = parseRgbComponent(row.red) !== null &&
+            parseRgbComponent(row.green) !== null &&
+            parseRgbComponent(row.blue) !== null;
+        if (rgbAllValid) {
+            if (!isEmpty(hexNormalized)) {
+                row.hex = hexNormalized;
+            }
+            else if ('hex' in row) {
+                delete row.hex;
+            }
+            continue;
+        }
+        row.hex = exports.DEFAULT_HEX;
+        delete row.red;
+        delete row.green;
+        delete row.blue;
+    }
+    return rows;
+}
+exports.applyHexPriorityToRows = applyHexPriorityToRows;

package/node_modules/@contrail/loader/lib/common/color-validation.spec.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const color_validation_1 = require("./color-validation");
+describe('isValidHex', () => {
+    it.each(['#ff0000', 'ff0000', '#FFF', 'fff', '#1a2b3c', '#FFFFFFFF'])('accepts %s', (hex) => {
+        expect((0, color_validation_1.isValidHex)(hex)).toBe(true);
+    });
+    it.each(['', 'notahex', 'gggggg', '#12345', '#1234567', '   ', '#'])('rejects %s', (hex) => {
+        expect((0, color_validation_1.isValidHex)(hex)).toBe(false);
+    });
+});
+describe('parseRgbComponent', () => {
+    it('parses valid integers in range', () => {
+        expect((0, color_validation_1.parseRgbComponent)('0')).toBe(0);
+        expect((0, color_validation_1.parseRgbComponent)('255')).toBe(255);
+        expect((0, color_validation_1.parseRgbComponent)(128)).toBe(128);
+    });
+    it('rejects out-of-range, non-integer, and empty values', () => {
+        expect((0, color_validation_1.parseRgbComponent)('-1')).toBe(null);
+        expect((0, color_validation_1.parseRgbComponent)('256')).toBe(null);
+        expect((0, color_validation_1.parseRgbComponent)('1.5')).toBe(null);
+        expect((0, color_validation_1.parseRgbComponent)('foo')).toBe(null);
+        expect((0, color_validation_1.parseRgbComponent)('')).toBe(null);
+        expect((0, color_validation_1.parseRgbComponent)(null)).toBe(null);
+        expect((0, color_validation_1.parseRgbComponent)(undefined)).toBe(null);
+    });
+});
+describe('validateColorRow', () => {
+    it('returns no errors when only valid hex is present', () => {
+        expect((0, color_validation_1.validateColorRow)({ hex: '#ff0000' })).toEqual({ errors: [], warnings: [] });
+    });
+    it('returns no errors when only valid RGB is present', () => {
+        expect((0, color_validation_1.validateColorRow)({ red: '255', green: '0', blue: '0' })).toEqual({
+            errors: [],
+            warnings: [],
+        });
+    });
+    it('errors on invalid hex', () => {
+        const result = (0, color_validation_1.validateColorRow)({ hex: 'zzz' });
+        expect(result.errors).toEqual([
+            { columnName: 'hex', message: color_validation_1.COLOR_VALIDATION_MESSAGES.HEX_INVALID('zzz') },
+        ]);
+    });
+    it('warns when both hex and RGB are populated', () => {
+        const result = (0, color_validation_1.validateColorRow)({ hex: '#fff', red: '1', green: '2', blue: '3' });
+        expect(result.errors).toEqual([]);
+        expect(result.warnings).toEqual([
+            { columnName: 'hex', message: color_validation_1.COLOR_VALIDATION_MESSAGES.HEX_PRIORITIZED_OVER_RGB },
+        ]);
+    });
+    it('errors per-missing-column when RGB is partial and hex is missing', () => {
+        const result = (0, color_validation_1.validateColorRow)({ red: '255' });
+        expect(result.errors).toEqual([
+            { columnName: 'green', message: color_validation_1.COLOR_VALIDATION_MESSAGES.RGB_INCOMPLETE(['green', 'blue']) },
+            { columnName: 'blue', message: color_validation_1.COLOR_VALIDATION_MESSAGES.RGB_INCOMPLETE(['green', 'blue']) },
+        ]);
+    });
+    it('errors when an RGB component is out of range', () => {
+        const result = (0, color_validation_1.validateColorRow)({ red: '999', green: '0', blue: '0' });
+        expect(result.errors).toEqual([
+            { columnName: 'red', message: color_validation_1.COLOR_VALIDATION_MESSAGES.RGB_OUT_OF_RANGE('red', '999') },
+        ]);
+    });
+    it('reports no errors when neither hex nor RGB is present', () => {
+        expect((0, color_validation_1.validateColorRow)({ name: 'foo' })).toEqual({ errors: [], warnings: [] });
+    });
+    it('resolves federatedMappings to source columns', () => {
+        const row = { hexcode: '#fff', r: '255', g: '0', b: '0' };
+        const mappings = { hex: 'hexcode', red: 'r', green: 'g', blue: 'b' };
+        const result = (0, color_validation_1.validateColorRow)(row, mappings);
+        expect(result.errors).toEqual([]);
+        expect(result.warnings).toEqual([
+            { columnName: 'hex', message: color_validation_1.COLOR_VALIDATION_MESSAGES.HEX_PRIORITIZED_OVER_RGB },
+        ]);
+    });
+});
+describe('applyHexPriorityToRows', () => {
+    it('strips RGB columns when hex is valid', () => {
+        const result = (0, color_validation_1.applyHexPriorityToRows)([
+            { hex: '#ff0000', red: '255', green: '0', blue: '0', name: 'foo' },
+        ]);
+        expect(result).toEqual([{ hex: 'ff0000', name: 'foo' }]);
+    });
+    it('keeps RGB and removes empty hex when hex is absent', () => {
+        const result = (0, color_validation_1.applyHexPriorityToRows)([{ red: '1', green: '2', blue: '3', name: 'foo' }]);
+        expect(result).toEqual([{ red: '1', green: '2', blue: '3', name: 'foo' }]);
+    });
+    it('defaults to DEFAULT_HEX when neither valid hex nor full RGB is present', () => {
+        const result = (0, color_validation_1.applyHexPriorityToRows)([{ name: 'foo' }]);
+        expect(result).toEqual([{ name: 'foo', hex: color_validation_1.DEFAULT_HEX }]);
+    });
+    it('treats invalid hex as missing and falls through to RGB or default', () => {
+        const result = (0, color_validation_1.applyHexPriorityToRows)([
+            { hex: 'zzz', red: '1', green: '2', blue: '3', name: 'with-rgb' },
+            { hex: 'zzz', name: 'no-rgb' },
+        ]);
+        expect(result).toEqual([
+            { hex: 'zzz', red: '1', green: '2', blue: '3', name: 'with-rgb' },
+            { hex: color_validation_1.DEFAULT_HEX, name: 'no-rgb' },
+        ]);
+    });
+});

package/node_modules/@contrail/loader/lib/common/size-range-helpers.js

@@ -53,7 +53,6 @@ class SizeRangeSanitizer {
                 }
                 const typePropertySlugs = type?.typeProperties?.map((x) => x.slug);
                 if ((0, lodash_1.intersection)(typePropertySlugs, [exports.SIZE_RANGE_SLUG, exports.SIZE_RANGE_TEMPLATE_SLUG]).length !== 2) {
-                    console.debug(`No size ranges for type ${JSON.stringify(type, null, 2)}, skipping.`);
                     continue;
                 }
                 validTypePaths.push(typePath);

package/node_modules/@contrail/loader/lib/constants.d.ts

@@ -1,9 +1,6 @@
 export declare const COLOR_PROCESSOR_ERRORS: {
     readonly TYPEPATH_MISSING: "\"typePath\" with value \"color\" is required property but is not found in the federatedMapping config, conditionalColumns config, or as a header in the CSV file. Please add a mapping \"typePath\" mapping with value \"color\" with one of these methods, then try the load again.";
 };
-export declare const COLOR_PROCESSOR_WARNINGS: {
-    readonly HEX_IGNORED_WARNING: "\"Hex\" is ignored when red, green, and blue columns are present";
-};
 export declare const CUSTOM_ENTITY_PROCESSOR_ERRORS: {
     readonly TYPEPATH_MISSING: "\"typePath\" with value \"custom-entity:<subtypepath>\" is required property but is not found in the federatedMapping config, conditionalColumns config, or as a header in the CSV file. Please add a mapping \"typePath\" mapping with value \"custom-entity:<subtypepath>\" with one of these methods, then try the load again.";
 };