@celigo/api-specs 0.2.28 → 0.2.30

package/dist/ai-agent.yml

@@ -2119,9 +2119,11 @@ components:
             This field supports THREE DISTINCT PATTERNS that are easily distinguished:
 
             **1. json Path Syntax**
-            - MUST start with '$.' prefix
+            - MUST start with '$' — the record root. An object record is addressed as
+              '$.field'; a grouped (array) record as '$[0].field' / '$[*].field'
             - Used for precisely targeting data in structured JSON objects
-            - Examples: '$.customer.firstName', '$.items[0].price', '$.addresses[*].street'
+            - Examples: '$.customer.firstName', '$.items[0].price', '$.addresses[*].street',
+              '$[*].Tax' (every row of a grouped record)
             - Wildcards like [*] extract multiple values/objects
 
             ```json
@@ -2132,7 +2134,8 @@ components:
             - Contains '{{' and '}}' pattern
             - Evaluated by the AFE 2.0 handlebars template engine
             - Can include logic, formatting, and computation
-            - Access input record fields with {{record.fieldName}} notation
+            - Access input record fields with {{record.fieldName}} notation; a grouped
+              (array) record binds as `rows` instead — {{rows.0.fieldName}} / {{#each rows}}
             - Examples: "{{record.firstName}} {{record.lastName}}", "{{#if record.isActive}}Active{{else}}Inactive{{/if}}"
             - Valid on `object`, `objectarray`, and primitive-array dataTypes as
               well as scalars — the rendered template output must parse into the
@@ -2143,7 +2146,7 @@ components:
             ```
 
             **3. Hard-Coded Value (literal string)**
-            - Does NOT start with '$.'
+            - Does NOT start with '$'
             - Does NOT contain handlebars '{{' syntax
             - System treats it as a literal string value
             - VERY COMMON for setting static/constant values
@@ -2165,10 +2168,38 @@ components:
             - The system maintains this context even in deeply nested mappings
             - For object mappings without child mappings, extract should return a complete object
             - When both extract and mappings are defined for objects, extract is applied first
+            - The root is the record as it arrives: an object record roots at `$.field`; a
+              grouped record (an array of rows — grouped exports, file key columns, NetSuite
+              grouped saved searches) roots at the array, so its rows are addressed as
+              `$[0].field` (one row) or `$[*].field` (every row). A root that contradicts the
+              record's shape resolves to nothing without an error.
 
             For most simple field-to-field mappings, prefer JSON path syntax for its clarity and performance.
             For hard-coded values, simply use the literal string as the extract value.
           x-celigo-ai-guidance:
+            - |-
+              ## GROUPED (ARRAY) RECORDS
+              Decide the JSONPath root from the record's shape before writing
+              any extract. When the record is an array of rows, `$.field`,
+              `$.properties.field` and `$.rows[*].field` all resolve to
+              nothing — the processor still reports success and the request
+              body ships as `{}`. Address rows as `$[0].field` (that row's
+              value, typed) or `$[*].field` (every row: joined with commas
+              into a `string` destination; rejected with
+              `incompatible_destination_conversion` into a `number`
+              destination). Column labels with spaces work as
+              `$[*][Order Number]`, `$[*].[Order Number]`, or
+              `$[*]['Order Number']`. For one destination element per row
+              the two array kinds take different helper forms: a primitive
+              array (`stringarray` / `numberarray`) uses `buildArrayHelper:
+              [{"extract": "$[*].field"}]`; an `objectarray` uses
+              `buildArrayHelper: [{"extract": "$[*]", "mappings": [...]}]`
+              with the children addressing the row relatively (`$.field`,
+              `{{rows.field}}`). An `extract` placed directly on the
+              array-typed field yields nothing. Handlebars
+              extracts bind the array record as `rows` (`{{rows.0.field}}`),
+              an object record as `record`. The reverse holds too: `$[*]` on
+              an object record iterates the object's values, not rows.
             - |-
               ## SIZE LIMIT
               The platform's import save validator caps this field at **1024
@@ -2426,7 +2457,11 @@ components:
               (`$.items[*]`), `"$"` (the record root), or omission — a
               constructed entry (child `mappings` with the extract omitted or
               `"$"`; the two spellings are equivalent) contributes exactly one
-              element, and entries append in order. Indexed or comma-joined
+              element, and entries append in order. On a grouped (array)
+              record the record itself is the array to iterate: `"$[*]"`
+              yields one `objectarray` element per row (children address the
+              row as `$.field`), and `"$[*].field"` yields one primitive-array
+              value per row. Indexed or comma-joined
               entry extracts (`"$[0]"`, `"$[0],$[0]"`) are not valid: the
               processor renders the entire destination array as null with no
               validation error. To emit a fixed number of static elements, add
@@ -2447,7 +2482,9 @@ components:
 
             **For Simple Arrays (stringarray, numberarray, booleanarray)**
             - Only the 'extract' field is used to pull values
-            - JSON path with wildcards (e.g., $.items[*].name) returns multiple values
+            - JSON path with wildcards (e.g., $.items[*].name) returns multiple values;
+              on a grouped (array) record the record itself is the array, so the
+              path roots at it ($[*].name — one value per row)
             - Each result is converted to the appropriate primitive type
             ```json
             {
@@ -2549,11 +2586,13 @@ components:
             - When both extract and mappings are provided, the system creates special composite objects
               that maintain hierarchical context during processing
             - This enables accessing both the current array element AND its parent context
-            - An ITERATING entry's extract MUST use JSON path syntax starting with '$.'
-              (e.g. '$.items[*]'). A CONSTRUCTED entry (child mappings building one element)
-              instead omits extract or sets it to exactly "$" — never rewrite "$" into a
-              '$.'-prefixed, indexed, or comma-joined form ('$[0]', '$[0],$[0]'): those render
-              the entire destination array as null without raising a validation error
+            - An ITERATING entry's extract MUST be a JSON path that iterates an array:
+              '$.items[*]' when the array is a field of an object record, or '$[*]'
+              (objectarray) / '$[*].field' (primitive arrays) when the record itself is a
+              grouped array of rows. A CONSTRUCTED entry (child mappings building one
+              element) instead omits extract or sets it to exactly "$" — never rewrite "$"
+              into an indexed or comma-joined form ('$[0]', '$[0],$[0]'): those render the
+              entire destination array as null without raising a validation error
             - Each array helper entry acts independently, potentially adding multiple elements
 
             The buildArrayHelper is the most complex part of the mappings system - always analyze the
@@ -2967,9 +3006,11 @@ components:
               This field supports THREE DISTINCT PATTERNS that are easily distinguished:
 
               **1. json Path Syntax**
-              - MUST start with '$.' prefix
+              - MUST start with '$' — the record root. An object record is addressed as
+                '$.field'; a grouped (array) record as '$[0].field' / '$[*].field'
               - Used for precisely targeting data in structured JSON objects
-              - Examples: '$.customer.firstName', '$.items[0].price', '$.addresses[*].street'
+              - Examples: '$.customer.firstName', '$.items[0].price', '$.addresses[*].street',
+                '$[*].Tax' (every row of a grouped record)
               - Wildcards like [*] extract multiple values/objects
 
               ```json
@@ -2980,7 +3021,8 @@ components:
               - Contains '{{' and '}}' pattern
               - Evaluated by the AFE 2.0 handlebars template engine
               - Can include logic, formatting, and computation
-              - Access input record fields with {{record.fieldName}} notation
+              - Access input record fields with {{record.fieldName}} notation; a grouped
+                (array) record binds as `rows` instead — {{rows.0.fieldName}} / {{#each rows}}
               - Examples: "{{record.firstName}} {{record.lastName}}", "{{#if record.isActive}}Active{{else}}Inactive{{/if}}"
               - Valid on `object`, `objectarray`, and primitive-array dataTypes as
                 well as scalars — the rendered template output must parse into the
@@ -2991,7 +3033,7 @@ components:
               ```
 
               **3. Hard-Coded Value (literal string)**
-              - Does NOT start with '$.'
+              - Does NOT start with '$'
               - Does NOT contain handlebars '{{' syntax
               - System treats it as a literal string value
               - VERY COMMON for setting static/constant values
@@ -3013,10 +3055,38 @@ components:
               - The system maintains this context even in deeply nested mappings
               - For object mappings without child mappings, extract should return a complete object
               - When both extract and mappings are defined for objects, extract is applied first
+              - The root is the record as it arrives: an object record roots at `$.field`; a
+                grouped record (an array of rows — grouped exports, file key columns, NetSuite
+                grouped saved searches) roots at the array, so its rows are addressed as
+                `$[0].field` (one row) or `$[*].field` (every row). A root that contradicts the
+                record's shape resolves to nothing without an error.
 
               For most simple field-to-field mappings, prefer JSON path syntax for its clarity and performance.
               For hard-coded values, simply use the literal string as the extract value.
             x-celigo-ai-guidance:
+              - |-
+                ## GROUPED (ARRAY) RECORDS
+                Decide the JSONPath root from the record's shape before writing
+                any extract. When the record is an array of rows, `$.field`,
+                `$.properties.field` and `$.rows[*].field` all resolve to
+                nothing — the processor still reports success and the request
+                body ships as `{}`. Address rows as `$[0].field` (that row's
+                value, typed) or `$[*].field` (every row: joined with commas
+                into a `string` destination; rejected with
+                `incompatible_destination_conversion` into a `number`
+                destination). Column labels with spaces work as
+                `$[*][Order Number]`, `$[*].[Order Number]`, or
+                `$[*]['Order Number']`. For one destination element per row
+                the two array kinds take different helper forms: a primitive
+                array (`stringarray` / `numberarray`) uses `buildArrayHelper:
+                [{"extract": "$[*].field"}]`; an `objectarray` uses
+                `buildArrayHelper: [{"extract": "$[*]", "mappings": [...]}]`
+                with the children addressing the row relatively (`$.field`,
+                `{{rows.field}}`). An `extract` placed directly on the
+                array-typed field yields nothing. Handlebars
+                extracts bind the array record as `rows` (`{{rows.0.field}}`),
+                an object record as `record`. The reverse holds too: `$[*]` on
+                an object record iterates the object's values, not rows.
               - |-
                 ## SIZE LIMIT
                 The platform's import save validator caps this field at **1024
@@ -3274,7 +3344,11 @@ components:
                 (`$.items[*]`), `"$"` (the record root), or omission — a
                 constructed entry (child `mappings` with the extract omitted or
                 `"$"`; the two spellings are equivalent) contributes exactly one
-                element, and entries append in order. Indexed or comma-joined
+                element, and entries append in order. On a grouped (array)
+                record the record itself is the array to iterate: `"$[*]"`
+                yields one `objectarray` element per row (children address the
+                row as `$.field`), and `"$[*].field"` yields one primitive-array
+                value per row. Indexed or comma-joined
                 entry extracts (`"$[0]"`, `"$[0],$[0]"`) are not valid: the
                 processor renders the entire destination array as null with no
                 validation error. To emit a fixed number of static elements, add
@@ -3295,7 +3369,9 @@ components:
 
               **For Simple Arrays (stringarray, numberarray, booleanarray)**
               - Only the 'extract' field is used to pull values
-              - JSON path with wildcards (e.g., $.items[*].name) returns multiple values
+              - JSON path with wildcards (e.g., $.items[*].name) returns multiple values;
+                on a grouped (array) record the record itself is the array, so the
+                path roots at it ($[*].name — one value per row)
               - Each result is converted to the appropriate primitive type
               ```json
               {
@@ -3397,11 +3473,13 @@ components:
               - When both extract and mappings are provided, the system creates special composite objects
                 that maintain hierarchical context during processing
               - This enables accessing both the current array element AND its parent context
-              - An ITERATING entry's extract MUST use JSON path syntax starting with '$.'
-                (e.g. '$.items[*]'). A CONSTRUCTED entry (child mappings building one element)
-                instead omits extract or sets it to exactly "$" — never rewrite "$" into a
-                '$.'-prefixed, indexed, or comma-joined form ('$[0]', '$[0],$[0]'): those render
-                the entire destination array as null without raising a validation error
+              - An ITERATING entry's extract MUST be a JSON path that iterates an array:
+                '$.items[*]' when the array is a field of an object record, or '$[*]'
+                (objectarray) / '$[*].field' (primitive arrays) when the record itself is a
+                grouped array of rows. A CONSTRUCTED entry (child mappings building one
+                element) instead omits extract or sets it to exactly "$" — never rewrite "$"
+                into an indexed or comma-joined form ('$[0]', '$[0],$[0]'): those render the
+                entire destination array as null without raising a validation error
               - Each array helper entry acts independently, potentially adding multiple elements
 
               The buildArrayHelper is the most complex part of the mappings system - always analyze the
@@ -4689,6 +4767,16 @@ components:
                   x-enumDescriptions:
                     create: Builds entirely new output records from inputs, ignoring unmapped fields.
                     modify: Makes targeted edits to existing records, preserving unmapped fields.
+                  x-celigo-ai-guidance:
+                    - |-
+                      On a grouped record (the export groups rows, so the record is an
+                      array) only `create` can author output — build it from the rows with
+                      `$[0].field`, `$[*].field`, or a `buildArrayHelper` over `$[*]`.
+                      `modify` has no object to overlay onto an array: the record passes
+                      through untouched and the processor reports success. Either mode
+                      reshapes the inside of one record; neither changes how many records
+                      the page carries (that is the export's `preSavePage` hook) or whether
+                      the export groups at all (that is its grouping setting).
                   examples:
                     - create
                     - modify

package/dist/asynchelper.yml

@@ -607,9 +607,11 @@ components:
             This field supports THREE DISTINCT PATTERNS that are easily distinguished:
 
             **1. json Path Syntax**
-            - MUST start with '$.' prefix
+            - MUST start with '$' — the record root. An object record is addressed as
+              '$.field'; a grouped (array) record as '$[0].field' / '$[*].field'
             - Used for precisely targeting data in structured JSON objects
-            - Examples: '$.customer.firstName', '$.items[0].price', '$.addresses[*].street'
+            - Examples: '$.customer.firstName', '$.items[0].price', '$.addresses[*].street',
+              '$[*].Tax' (every row of a grouped record)
             - Wildcards like [*] extract multiple values/objects
 
             ```json
@@ -620,7 +622,8 @@ components:
             - Contains '{{' and '}}' pattern
             - Evaluated by the AFE 2.0 handlebars template engine
             - Can include logic, formatting, and computation
-            - Access input record fields with {{record.fieldName}} notation
+            - Access input record fields with {{record.fieldName}} notation; a grouped
+              (array) record binds as `rows` instead — {{rows.0.fieldName}} / {{#each rows}}
             - Examples: "{{record.firstName}} {{record.lastName}}", "{{#if record.isActive}}Active{{else}}Inactive{{/if}}"
             - Valid on `object`, `objectarray`, and primitive-array dataTypes as
               well as scalars — the rendered template output must parse into the
@@ -631,7 +634,7 @@ components:
             ```
 
             **3. Hard-Coded Value (literal string)**
-            - Does NOT start with '$.'
+            - Does NOT start with '$'
             - Does NOT contain handlebars '{{' syntax
             - System treats it as a literal string value
             - VERY COMMON for setting static/constant values
@@ -653,10 +656,38 @@ components:
             - The system maintains this context even in deeply nested mappings
             - For object mappings without child mappings, extract should return a complete object
             - When both extract and mappings are defined for objects, extract is applied first
+            - The root is the record as it arrives: an object record roots at `$.field`; a
+              grouped record (an array of rows — grouped exports, file key columns, NetSuite
+              grouped saved searches) roots at the array, so its rows are addressed as
+              `$[0].field` (one row) or `$[*].field` (every row). A root that contradicts the
+              record's shape resolves to nothing without an error.
 
             For most simple field-to-field mappings, prefer JSON path syntax for its clarity and performance.
             For hard-coded values, simply use the literal string as the extract value.
           x-celigo-ai-guidance:
+            - |-
+              ## GROUPED (ARRAY) RECORDS
+              Decide the JSONPath root from the record's shape before writing
+              any extract. When the record is an array of rows, `$.field`,
+              `$.properties.field` and `$.rows[*].field` all resolve to
+              nothing — the processor still reports success and the request
+              body ships as `{}`. Address rows as `$[0].field` (that row's
+              value, typed) or `$[*].field` (every row: joined with commas
+              into a `string` destination; rejected with
+              `incompatible_destination_conversion` into a `number`
+              destination). Column labels with spaces work as
+              `$[*][Order Number]`, `$[*].[Order Number]`, or
+              `$[*]['Order Number']`. For one destination element per row
+              the two array kinds take different helper forms: a primitive
+              array (`stringarray` / `numberarray`) uses `buildArrayHelper:
+              [{"extract": "$[*].field"}]`; an `objectarray` uses
+              `buildArrayHelper: [{"extract": "$[*]", "mappings": [...]}]`
+              with the children addressing the row relatively (`$.field`,
+              `{{rows.field}}`). An `extract` placed directly on the
+              array-typed field yields nothing. Handlebars
+              extracts bind the array record as `rows` (`{{rows.0.field}}`),
+              an object record as `record`. The reverse holds too: `$[*]` on
+              an object record iterates the object's values, not rows.
             - |-
               ## SIZE LIMIT
               The platform's import save validator caps this field at **1024
@@ -914,7 +945,11 @@ components:
               (`$.items[*]`), `"$"` (the record root), or omission — a
               constructed entry (child `mappings` with the extract omitted or
               `"$"`; the two spellings are equivalent) contributes exactly one
-              element, and entries append in order. Indexed or comma-joined
+              element, and entries append in order. On a grouped (array)
+              record the record itself is the array to iterate: `"$[*]"`
+              yields one `objectarray` element per row (children address the
+              row as `$.field`), and `"$[*].field"` yields one primitive-array
+              value per row. Indexed or comma-joined
               entry extracts (`"$[0]"`, `"$[0],$[0]"`) are not valid: the
               processor renders the entire destination array as null with no
               validation error. To emit a fixed number of static elements, add
@@ -935,7 +970,9 @@ components:
 
             **For Simple Arrays (stringarray, numberarray, booleanarray)**
             - Only the 'extract' field is used to pull values
-            - JSON path with wildcards (e.g., $.items[*].name) returns multiple values
+            - JSON path with wildcards (e.g., $.items[*].name) returns multiple values;
+              on a grouped (array) record the record itself is the array, so the
+              path roots at it ($[*].name — one value per row)
             - Each result is converted to the appropriate primitive type
             ```json
             {
@@ -1037,11 +1074,13 @@ components:
             - When both extract and mappings are provided, the system creates special composite objects
               that maintain hierarchical context during processing
             - This enables accessing both the current array element AND its parent context
-            - An ITERATING entry's extract MUST use JSON path syntax starting with '$.'
-              (e.g. '$.items[*]'). A CONSTRUCTED entry (child mappings building one element)
-              instead omits extract or sets it to exactly "$" — never rewrite "$" into a
-              '$.'-prefixed, indexed, or comma-joined form ('$[0]', '$[0],$[0]'): those render
-              the entire destination array as null without raising a validation error
+            - An ITERATING entry's extract MUST be a JSON path that iterates an array:
+              '$.items[*]' when the array is a field of an object record, or '$[*]'
+              (objectarray) / '$[*].field' (primitive arrays) when the record itself is a
+              grouped array of rows. A CONSTRUCTED entry (child mappings building one
+              element) instead omits extract or sets it to exactly "$" — never rewrite "$"
+              into an indexed or comma-joined form ('$[0]', '$[0],$[0]'): those render the
+              entire destination array as null without raising a validation error
             - Each array helper entry acts independently, potentially adding multiple elements
 
             The buildArrayHelper is the most complex part of the mappings system - always analyze the
@@ -1455,9 +1494,11 @@ components:
               This field supports THREE DISTINCT PATTERNS that are easily distinguished:
 
               **1. json Path Syntax**
-              - MUST start with '$.' prefix
+              - MUST start with '$' — the record root. An object record is addressed as
+                '$.field'; a grouped (array) record as '$[0].field' / '$[*].field'
               - Used for precisely targeting data in structured JSON objects
-              - Examples: '$.customer.firstName', '$.items[0].price', '$.addresses[*].street'
+              - Examples: '$.customer.firstName', '$.items[0].price', '$.addresses[*].street',
+                '$[*].Tax' (every row of a grouped record)
               - Wildcards like [*] extract multiple values/objects
 
               ```json
@@ -1468,7 +1509,8 @@ components:
               - Contains '{{' and '}}' pattern
               - Evaluated by the AFE 2.0 handlebars template engine
               - Can include logic, formatting, and computation
-              - Access input record fields with {{record.fieldName}} notation
+              - Access input record fields with {{record.fieldName}} notation; a grouped
+                (array) record binds as `rows` instead — {{rows.0.fieldName}} / {{#each rows}}
               - Examples: "{{record.firstName}} {{record.lastName}}", "{{#if record.isActive}}Active{{else}}Inactive{{/if}}"
               - Valid on `object`, `objectarray`, and primitive-array dataTypes as
                 well as scalars — the rendered template output must parse into the
@@ -1479,7 +1521,7 @@ components:
               ```
 
               **3. Hard-Coded Value (literal string)**
-              - Does NOT start with '$.'
+              - Does NOT start with '$'
               - Does NOT contain handlebars '{{' syntax
               - System treats it as a literal string value
               - VERY COMMON for setting static/constant values
@@ -1501,10 +1543,38 @@ components:
               - The system maintains this context even in deeply nested mappings
               - For object mappings without child mappings, extract should return a complete object
               - When both extract and mappings are defined for objects, extract is applied first
+              - The root is the record as it arrives: an object record roots at `$.field`; a
+                grouped record (an array of rows — grouped exports, file key columns, NetSuite
+                grouped saved searches) roots at the array, so its rows are addressed as
+                `$[0].field` (one row) or `$[*].field` (every row). A root that contradicts the
+                record's shape resolves to nothing without an error.
 
               For most simple field-to-field mappings, prefer JSON path syntax for its clarity and performance.
               For hard-coded values, simply use the literal string as the extract value.
             x-celigo-ai-guidance:
+              - |-
+                ## GROUPED (ARRAY) RECORDS
+                Decide the JSONPath root from the record's shape before writing
+                any extract. When the record is an array of rows, `$.field`,
+                `$.properties.field` and `$.rows[*].field` all resolve to
+                nothing — the processor still reports success and the request
+                body ships as `{}`. Address rows as `$[0].field` (that row's
+                value, typed) or `$[*].field` (every row: joined with commas
+                into a `string` destination; rejected with
+                `incompatible_destination_conversion` into a `number`
+                destination). Column labels with spaces work as
+                `$[*][Order Number]`, `$[*].[Order Number]`, or
+                `$[*]['Order Number']`. For one destination element per row
+                the two array kinds take different helper forms: a primitive
+                array (`stringarray` / `numberarray`) uses `buildArrayHelper:
+                [{"extract": "$[*].field"}]`; an `objectarray` uses
+                `buildArrayHelper: [{"extract": "$[*]", "mappings": [...]}]`
+                with the children addressing the row relatively (`$.field`,
+                `{{rows.field}}`). An `extract` placed directly on the
+                array-typed field yields nothing. Handlebars
+                extracts bind the array record as `rows` (`{{rows.0.field}}`),
+                an object record as `record`. The reverse holds too: `$[*]` on
+                an object record iterates the object's values, not rows.
               - |-
                 ## SIZE LIMIT
                 The platform's import save validator caps this field at **1024
@@ -1762,7 +1832,11 @@ components:
                 (`$.items[*]`), `"$"` (the record root), or omission — a
                 constructed entry (child `mappings` with the extract omitted or
                 `"$"`; the two spellings are equivalent) contributes exactly one
-                element, and entries append in order. Indexed or comma-joined
+                element, and entries append in order. On a grouped (array)
+                record the record itself is the array to iterate: `"$[*]"`
+                yields one `objectarray` element per row (children address the
+                row as `$.field`), and `"$[*].field"` yields one primitive-array
+                value per row. Indexed or comma-joined
                 entry extracts (`"$[0]"`, `"$[0],$[0]"`) are not valid: the
                 processor renders the entire destination array as null with no
                 validation error. To emit a fixed number of static elements, add
@@ -1783,7 +1857,9 @@ components:
 
               **For Simple Arrays (stringarray, numberarray, booleanarray)**
               - Only the 'extract' field is used to pull values
-              - JSON path with wildcards (e.g., $.items[*].name) returns multiple values
+              - JSON path with wildcards (e.g., $.items[*].name) returns multiple values;
+                on a grouped (array) record the record itself is the array, so the
+                path roots at it ($[*].name — one value per row)
               - Each result is converted to the appropriate primitive type
               ```json
               {
@@ -1885,11 +1961,13 @@ components:
               - When both extract and mappings are provided, the system creates special composite objects
                 that maintain hierarchical context during processing
               - This enables accessing both the current array element AND its parent context
-              - An ITERATING entry's extract MUST use JSON path syntax starting with '$.'
-                (e.g. '$.items[*]'). A CONSTRUCTED entry (child mappings building one element)
-                instead omits extract or sets it to exactly "$" — never rewrite "$" into a
-                '$.'-prefixed, indexed, or comma-joined form ('$[0]', '$[0],$[0]'): those render
-                the entire destination array as null without raising a validation error
+              - An ITERATING entry's extract MUST be a JSON path that iterates an array:
+                '$.items[*]' when the array is a field of an object record, or '$[*]'
+                (objectarray) / '$[*].field' (primitive arrays) when the record itself is a
+                grouped array of rows. A CONSTRUCTED entry (child mappings building one
+                element) instead omits extract or sets it to exactly "$" — never rewrite "$"
+                into an indexed or comma-joined form ('$[0]', '$[0],$[0]'): those render the
+                entire destination array as null without raising a validation error
               - Each array helper entry acts independently, potentially adding multiple elements
 
               The buildArrayHelper is the most complex part of the mappings system - always analyze the
@@ -2615,6 +2693,16 @@ components:
                   x-enumDescriptions:
                     create: Builds entirely new output records from inputs, ignoring unmapped fields.
                     modify: Makes targeted edits to existing records, preserving unmapped fields.
+                  x-celigo-ai-guidance:
+                    - |-
+                      On a grouped record (the export groups rows, so the record is an
+                      array) only `create` can author output — build it from the rows with
+                      `$[0].field`, `$[*].field`, or a `buildArrayHelper` over `$[*]`.
+                      `modify` has no object to overlay onto an array: the record passes
+                      through untouched and the processor reports success. Either mode
+                      reshapes the inside of one record; neither changes how many records
+                      the page carries (that is the export's `preSavePage` hook) or whether
+                      the export groups at all (that is its grouping setting).
                   examples:
                     - create
                     - modify

package/dist/connection.yml

@@ -1828,6 +1828,91 @@ paths:
                             - 64ff4b21612a134bd2f45534
         '401':
           $ref: '#/components/responses/401-unauthorized'
+  /v1/connections/{_id}/distributedApps:
+    get:
+      x-internal: false
+      summary: Check the Celigo SuiteApp and bundle on a NetSuite connection
+      description: |-
+        Reports, live from the connected NetSuite account, whether the Celigo integrator.io SuiteApp
+        (SuiteScript 2.x) and the legacy Celigo bundle are installed — the check the UI runs before
+        offering a NetSuite API version that depends on either. Round-trips to NetSuite, so expect a
+        few seconds. Only connections of type `netsuite` are accepted.
+
+        Use this instead of the connection's `netsuite.suiteAppInstalled`, which reflects only the
+        SuiteApp as detected the last time the connection authenticated.
+      operationId: getConnectionDistributedApps
+      tags:
+        - Connections
+      parameters:
+        - in: path
+          name: _id
+          required: true
+          schema:
+            type: string
+            format: objectId
+            x-celigo-refModel: connections
+          description: NetSuite connection to check.
+      responses:
+        '200':
+          description: Installation state of each component.
+          content:
+            application/json:
+              schema:
+                type: object
+                required:
+                  - bundle
+                  - suiteapp
+                properties:
+                  bundle:
+                    description: The legacy Celigo integrator.io bundle (SuiteScript 1.0).
+                    allOf:
+                      - $ref: '#/components/schemas/DistributedAppStatus'
+                  suiteapp:
+                    description: The Celigo integrator.io SuiteApp (SuiteScript 2.x).
+                    allOf:
+                      - $ref: '#/components/schemas/DistributedAppStatus'
+              examples:
+                both_installed:
+                  summary: SuiteApp and bundle both present
+                  value:
+                    bundle:
+                      success: true
+                    suiteapp:
+                      success: true
+        '401':
+          $ref: '#/components/responses/401-unauthorized'
+        '404':
+          description: No connection found for the given `_id`.
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/Error'
+              examples:
+                invalid_ref:
+                  value:
+                    errors:
+                      - code: invalid_ref
+                        message: Connection not found for the given id.
+        '422':
+          description: The connection exists but is not a NetSuite connection.
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/Error'
+              examples:
+                invalid_connection_type:
+                  value:
+                    errors:
+                      - message: 'invalid connection type: http'
+      x-celigo-ai-guidance:
+        - |-
+          Decides the NetSuite import adaptor: when `suiteapp.success` or `bundle.success` is true,
+          author a NetSuiteDistributedImport (netsuite_da) — Celigo RESTlets; when both are false,
+          author a NetSuiteHTTPImport (NetSuite REST APIs). Exports and lookups do not depend on this
+          check — NetSuiteHTTPExport needs neither component.
+        - |-
+          A non-NetSuite connection answers 422 with the message "invalid connection type: <type>"
+          and no `code`; an unknown `_id` answers 404 `invalid_ref`.
   /v1/salesforce/metadata/connections/{_id}/sObjectTypes:
     get:
       x-internal: false
@@ -7315,7 +7400,11 @@ components:
                     suiteAppInstalled:
                       type: boolean
                       readOnly: true
-                      description: When true, the Celigo SuiteApp bundle is installed in the connected NetSuite account. Detected by the server when the connection authenticates to NetSuite.
+                      description: |-
+                        When true, the Celigo integrator.io SuiteApp (SuiteScript 2.x) was detected in
+                        the connected NetSuite account the last time the connection authenticated. It
+                        says nothing about the legacy Celigo bundle; for a live check of both, use
+                        `GET /v1/connections/{_id}/distributedApps`.
             salesforce:
               description: Present when `type` is `salesforce`.
               allOf:
@@ -8463,6 +8552,19 @@ components:
             dependencyIds:
               export:
                 - 64ff4b21612a134bd2f45534
+    DistributedAppStatus:
+      type: object
+      required:
+        - success
+      properties:
+        success:
+          type: boolean
+          description: When true, the component is installed in the connected NetSuite account.
+        URL:
+          type: string
+          description: |-
+            Install link for the component. Absent when `success` is true; the integrator.io UI
+            reads it to render its install prompt when the component is missing.
     SObjectType:
       type: object
       description: |