@servicenow/sdk-build-plugins 4.7.2 → 4.8.1

package/src/flow/plugins/flow-instance-plugin.ts

@@ -45,6 +45,7 @@ import {
     ActionSubflowInstanceShape,
     ApprovalDueDateShape,
     ApprovalRulesShape,
+    getRefSysId,
     InlineScriptShape,
 } from '../utils/flow-shapes'
 import { FDInlineScriptCallShape } from './inline-script-plugin'
@@ -68,6 +69,7 @@ import {
     UNSUPPORTED_DATA_TYPES,
     UTC_TIMEZONE_VALUE,
     ELEMENT_MAPPING_FIELD_ALIASES,
+    ELEMENT_MAPPING_FIELD_ALIASES_REVERSE,
 } from '../utils/flow-constants'
 
 import type { ApprovalDueDateType, ApprovalRulesType } from '@servicenow/sdk-core/runtime/flow'
@@ -141,6 +143,119 @@ function parseComplexObjectValues(obj: unknown): unknown {
     return parseValue(obj)
 }
 
+/**
+ * Returns the complex-object payload type ('object' | 'array.object') when the given value is a
+ * serialized FD complex-object JSON string (has both `complexObjectSchema` and `complexObject`).
+ * Returns `undefined` for any other value.
+ */
+export function getComplexObjectPayloadType(value: unknown): 'object' | 'array.object' | undefined {
+    if (typeof value !== 'string') {
+        return undefined
+    }
+    try {
+        const parsed = JSON.parse(value)
+        if (parsed && typeof parsed === 'object' && 'complexObjectSchema' in parsed && 'complexObject' in parsed) {
+            const co = (parsed as { complexObject?: unknown }).complexObject
+            return co && typeof co === 'object' && '$COCollectionField' in co ? 'array.object' : 'object'
+        }
+    } catch {
+        // not JSON / not a complex-object payload
+    }
+    return undefined
+}
+
+/**
+ * Decodes a serialized FD complex-object payload (FlowObject or FlowArray) into a plain
+ * JavaScript object/array by extracting the `$cv.$v` leaf values from `complexObject`.
+ *
+ * Returns `undefined` if the string cannot be decoded (malformed, empty complexObject, etc.).
+ * Falls back gracefully so callers can keep the verbatim string for spoke/snapshot references.
+ *
+ * Exported only for unit testing.
+ */
+type PlainObj = { [key: string]: unknown }
+
+export function decodeComplexObjectPayload(jsonString: string): PlainObj | PlainObj[] | unknown[] | undefined {
+    try {
+        const parsed = JSON.parse(jsonString)
+        if (!parsed || typeof parsed !== 'object' || !('complexObject' in parsed)) {
+            return undefined
+        }
+        return decodeComplexObjectNode(parsed.complexObject as PlainObj)
+    } catch {
+        return undefined
+    }
+}
+
+function decodeComplexObjectNode(co: PlainObj): PlainObj | PlainObj[] | unknown[] {
+    if ('$COCollectionField' in co && Array.isArray(co['$COCollectionField'])) {
+        const arr = co['$COCollectionField'] as unknown[]
+        // Primitive arrays (e.g. FlowArray<StringColumn>, FlowArray<IntegerColumn>) store plain
+        // strings/numbers in $COCollectionField — not $cv-wrapped objects. Return them directly
+        // to avoid decodeComplexObjectItem treating string characters or number properties as fields.
+        if (arr.length === 0 || typeof arr[0] !== 'object' || arr[0] === null) {
+            return arr
+        }
+        return (arr as PlainObj[]).map(decodeComplexObjectItem)
+    }
+    return decodeComplexObjectItem(co)
+}
+
+function decodeComplexObjectItem(item: PlainObj): PlainObj {
+    const result: PlainObj = {}
+    for (const [key, val] of Object.entries(item)) {
+        if (key === 'name$' || key.includes('.$')) {
+            continue
+        }
+        if (Array.isArray(val)) {
+            // Nested FlowArray<primitive> (Array.String, Array.Integer, Array.Boolean, etc.)
+            // within a FlowObject: buildCv stores plain values directly as a bare array —
+            // no $COCollectionField wrapper for primitive element types.
+            // Must check Array.isArray BEFORE typeof object because arrays are objects in JS.
+            if (val.length === 0 || typeof val[0] !== 'object' || val[0] === null) {
+                result[key] = val
+            } else {
+                result[key] = (val as PlainObj[]).map(decodeComplexObjectItem)
+            }
+        } else if (typeof val === 'object' && val !== null) {
+            const v = val as PlainObj
+            if ('$cv' in v) {
+                // ServiceNow UI format: leaf value wrapped in { $cv: { $c, $v } }
+                const cv = v['$cv'] as PlainObj
+                const rawVal = cv?.['$v'] ?? ''
+                const javaClass = cv?.['$c'] as string | undefined
+                // Only coerce to number for known numeric Java types — avoids silently converting
+                // string choice values (e.g. state: '1' stored as java.lang.String) to numbers.
+                const isNumericType =
+                    javaClass === 'java.lang.Integer' ||
+                    javaClass === 'java.lang.Long' ||
+                    javaClass === 'java.lang.Double' ||
+                    javaClass === 'java.lang.Float'
+                result[key] =
+                    isNumericType && typeof rawVal === 'string' && rawVal.trim() !== '' ? Number(rawVal) : rawVal
+            } else if ('$COCollectionField' in v) {
+                // Nested FlowArray<object> (Array.Object) within a FlowObject:
+                // buildCv wraps complex array elements in { $COCollectionField: [...] }.
+                const arr = v['$COCollectionField'] as unknown[]
+                if (arr.length === 0 || typeof arr[0] !== 'object' || arr[0] === null) {
+                    result[key] = arr
+                } else {
+                    result[key] = (arr as PlainObj[]).map(decodeComplexObjectItem)
+                }
+            } else {
+                // Nested FlowObject
+                result[key] = decodeComplexObjectItem(v)
+            }
+        } else if (val !== undefined) {
+            // Fluent build format: raw primitive stored directly (no $cv wrapping).
+            // buildArrayPayload skips buildCv for array elements, so string/number/boolean
+            // values appear as-is in $COCollectionField items.
+            result[key] = val
+        }
+    }
+    return result
+}
+
 /**
  * Normalize raw input value based on uiType.
  * - Attempts to JSON.parse strings.
@@ -243,7 +358,13 @@ function buildInstanceToShape({
 
         const definitionInputs =
             instanceDef instanceof Record
-                ? instanceDef.flat().filter((v) => v.getTable() === inputsTableName)
+                ? instanceDef
+                      .flat()
+                      .filter(
+                          (v) =>
+                              v.getTable() === inputsTableName &&
+                              getRefSysId(v.get('model')) === instanceDef.getId().getValue()
+                      )
                 : undefined
 
         const zippedInputs = record.get(zippedColumn)?.ifString()?.getValue() ?? ''
@@ -585,6 +706,36 @@ function buildInlineScriptShapeFromXml(
     return undefined
 }
 
+/**
+ * Reconstructs a TemplateValueShape with FDInlineScriptCallShape sub-fields when the
+ * V2 JSON payload carries scripted sub-fields (scriptActive=false at top level, with
+ * a `script` map keyed by sub-field name).
+ *
+ * Called during XML → Fluent transform to restore wfa.inlineScript() calls that were
+ * inside TemplateValue({...}) in the original Fluent source.
+ */
+export function applyTemplateValueSubFieldScripts(
+    value: unknown,
+    script: { [key: string]: { scriptActive: boolean; script: string } } | undefined,
+    source: Record
+): unknown {
+    if (!script || !(value instanceof TemplateValueShape)) {
+        return value
+    }
+
+    const templateValue = value.getTemplateValue()
+    const newProps: globalThis.Record<string, unknown> = {}
+    for (const [field, fieldShape] of templateValue.entries({ resolve: false })) {
+        const fieldScript = script[field]
+        if (fieldScript?.scriptActive && fieldScript?.script) {
+            newProps[field] = new FDInlineScriptCallShape({ source, scriptContent: fieldScript.script })
+        } else {
+            newProps[field] = fieldShape
+        }
+    }
+    return new TemplateValueShape({ source, value: newProps })
+}
+
 /**
  * Build an ObjectShape representing instance inputs from a base64-zipped JSON payload.
  * This is used by both subflow and action instances.
@@ -688,9 +839,29 @@ function buildInputsShapeFromZipped({
                             )
                         }
                     }
-                    // Use the specialized shape or fallback to normalized value
-                    props[name] =
-                        inputShape ?? normalizeInputValue(value as string, uiType ?? parameter.type, record, logger)
+                    // Use the specialized shape or fallback to normalized value.
+                    // Complex-object (FlowObject/FlowArray) inputs: decode the $cv payload to a
+                    // plain object so typed action references (Path 1) satisfy TypeScript types
+                    // and the build's resolveComplexInput path re-encodes them correctly.
+                    // If decode fails (empty payload / spoke references with no data), fall back
+                    // to the verbatim string so Path 2 (snapshot/string reference) still works.
+                    // applyTemplateValueSubFieldScripts reconstructs FDInlineScriptCallShape
+                    // sub-fields for TemplateValue inputs that carry a `script` map.
+                    let baseShape: unknown
+                    if (inputShape) {
+                        baseShape = inputShape
+                    } else if (getComplexObjectPayloadType(value) !== undefined) {
+                        // Only decode when the action schema is available (Path 1: typed action reference,
+                        // definitionInputs is populated from sys_hub_action_input records).
+                        // For Path 2 (snapshot/string reference, definitionInputs is undefined),
+                        // keep the verbatim string so build can re-emit it byte-for-byte.
+                        const decoded =
+                            definitionInputs !== undefined ? decodeComplexObjectPayload(value as string) : undefined
+                        baseShape = decoded !== undefined ? decoded : value
+                    } else {
+                        baseShape = normalizeInputValue(value as string, uiType ?? parameter.type, record, logger)
+                    }
+                    props[name] = applyTemplateValueSubFieldScripts(baseShape, script, record)
                 }
             } catch (e) {
                 const recordInfo = `${record.getTable()}.${record.getId().getValue()}`
@@ -940,6 +1111,22 @@ function processInputValue(
         return primitiveValue
     }
 
+    // Preserve path: the input value is already a serialized FD complex-object payload
+    // (FlowObject/FlowArray). Re-emit it verbatim with the correct parameter.type instead
+    // of reconstructing it — works for typed, string/sys_id, and spoke references alike.
+    const preservedComplexType = getComplexObjectPayloadType(primitiveValue)
+    if (preservedComplexType !== undefined) {
+        return {
+            name: ELEMENT_MAPPING_FIELD_ALIASES_REVERSE[inputName] ?? inputName,
+            value: primitiveValue,
+            displayValue: displayValues?.has(inputName) ? displayValues.get(inputName) : primitiveValue,
+            scriptActive: false,
+            parameter: {
+                type: preservedComplexType,
+            },
+        }
+    }
+
     let finalValue: unknown = primitiveValue
     let finalType: unknown = options?.type ?? 'string'
 
@@ -958,7 +1145,7 @@ function processInputValue(
 
     // Return standard input object
     return {
-        name: inputName,
+        name: ELEMENT_MAPPING_FIELD_ALIASES_REVERSE[inputName] ?? inputName,
         value: finalValue,
         displayValue: displayValues && displayValues.has(inputName) ? displayValues.get(inputName) : finalValue,
         scriptActive: false,
@@ -1090,7 +1277,13 @@ function validateMandatoryFields(
     definitionName?: string
 ): Record[] | undefined {
     const inputDefinitions = definition
-        ? definition.flat().filter((record) => record.getTable() === inputTable)
+        ? definition
+              .flat()
+              .filter(
+                  (record) =>
+                      record.getTable() === inputTable &&
+                      getRefSysId(record.get('model')) === definition.getId().getValue()
+              )
         : undefined
 
     if (inputDefinitions) {
@@ -1366,6 +1559,9 @@ async function prepareActionInstanceValueJson(
         properties: Object.fromEntries(mergedResults),
     })
 
+    // Collect scripted sub-fields for any TemplateValue inputs
+    const tvScripts = extractTemplateValueScripts(instanceInputs)
+
     const result: unknown[] = []
 
     // When isActionDefString is true, there's no action definition in fluent
@@ -1427,6 +1623,18 @@ async function prepareActionInstanceValueJson(
         }
     }
 
+    // Attach scripted sub-fields for any TemplateValue inputs
+    if (tvScripts.size > 0) {
+        for (const item of result) {
+            if (typeof item === 'object' && item !== null && 'name' in item) {
+                const scripts = tvScripts.get((item as globalThis.Record<string, unknown>)['name'] as string)
+                if (scripts) {
+                    ;(item as globalThis.Record<string, unknown>)['script'] = scripts
+                }
+            }
+        }
+    }
+
     return result
 }
 
@@ -1459,7 +1667,10 @@ async function prepareSubflowInstanceValueJson(
         properties: Object.fromEntries(mergedResults),
     })
 
-    return objShape
+    // Collect scripted sub-fields for any TemplateValue inputs
+    const tvScripts = extractTemplateValueScripts(instanceInputs)
+
+    const subflowResult = objShape
         .keys()
         .filter((key) => key !== 'waitForCompletion')
         .map((key) => {
@@ -1496,6 +1707,20 @@ async function prepareSubflowInstanceValueJson(
 
             return result
         })
+
+    // Attach scripted sub-fields for any TemplateValue inputs
+    if (tvScripts.size > 0) {
+        for (const item of subflowResult) {
+            if (typeof item === 'object' && item !== null && 'name' in item) {
+                const scripts = tvScripts.get((item as globalThis.Record<string, unknown>)['name'] as string)
+                if (scripts) {
+                    ;(item as globalThis.Record<string, unknown>)['script'] = scripts
+                }
+            }
+        }
+    }
+
+    return subflowResult
 }
 
 /**
@@ -1559,6 +1784,8 @@ async function resolveObjectShapeRecursively(shape: ObjectShape, transform: Tran
             }
 
             resolvedObject[key] = resolvedArray
+        } else if (valueShape instanceof FDInlineScriptCallShape) {
+            resolvedObject[key] = 'fd-scripted'
         } else {
             // For all other shapes (primitives), get the value directly
             resolvedObject[key] = valueShape.getValue()
@@ -1600,6 +1827,36 @@ function wrapSpecialShape(shape: Shape, resolvedValue: unknown, source: Source):
     return resolvedValue
 }
 
+/**
+ * Extracts scripted sub-fields from any TemplateValue inputs.
+ * Returns a map of input name → { field: { scriptActive, script } } for inputs where
+ * at least one sub-field is an FDInlineScriptCallShape (wfa.inlineScript()).
+ * This map is then attached as a `script` property on the corresponding result item so
+ * ServiceNow can store the script content separately (sys_hub_input_scripts).
+ */
+function extractTemplateValueScripts(
+    instanceInputs: ObjectShape
+): Map<string, globalThis.Record<string, { scriptActive: true; script: string }>> {
+    const result = new Map()
+    for (const [key, shape] of instanceInputs.entries({ resolve: false })) {
+        if (!shape.is(TemplateValueShape)) {
+            continue
+        }
+        const scriptedFields: globalThis.Record<string, { scriptActive: true; script: string }> = {}
+        for (const [field, fieldShape] of (shape as TemplateValueShape)
+            .getTemplateValue()
+            .entries({ resolve: false })) {
+            if (fieldShape instanceof FDInlineScriptCallShape) {
+                scriptedFields[field] = { scriptActive: true, script: fieldShape.getScriptContent() }
+            }
+        }
+        if (Object.keys(scriptedFields).length > 0) {
+            result.set(key, scriptedFields)
+        }
+    }
+    return result
+}
+
 /**
  * Checks for datapills and resolves them in instance inputs.
  * Similar to resolveObjectShapeRecursively but returns key-value pairs and handles special shapes.

package/src/flow/plugins/step-instance-plugin.ts

@@ -30,7 +30,8 @@ import {
     FLOW_OBJECT_API_NAME,
     FLOW_ARRAY_API_NAME,
 } from '../utils/flow-constants'
-import { normalizeInputValue } from './flow-instance-plugin'
+import { normalizeInputValue, applyTemplateValueSubFieldScripts } from './flow-instance-plugin'
+import { FDInlineScriptCallShape } from './inline-script-plugin'
 import { stripPillType, collectPillTypes } from '../utils/flow-pill-utils'
 import { ApprovalRulesShape, ApprovalDueDateShape } from '../utils/flow-shapes'
 import {
@@ -372,7 +373,10 @@ export const StepInstancePlugin = Plugin.create({
             coalesce: ['name'],
         },
         sys_element_mapping: {
-            coalesce: ['field', 'id'],
+            coalesce: ['field', 'table', 'id'],
+        },
+        sys_hub_input_scripts: {
+            coalesce: ['instance', 'input_name'],
         },
         sys_hub_step_instance: {
             relationships: {
@@ -396,6 +400,10 @@ export const StepInstancePlugin = Plugin.create({
                     via: 'documentkey',
                     descendant: true,
                 },
+                sys_hub_input_scripts: {
+                    via: 'instance',
+                    descendant: true,
+                },
             },
             toShape(record, { descendants, logger }) {
                 // Skip step instances that belong to an action definition —
@@ -491,6 +499,32 @@ export const StepInstancePlugin = Plugin.create({
                         : builtInDef.name
                 }
 
+                // Recover wfa.inlineScript() sub-fields from sys_hub_input_scripts descendants.
+                // Without this, TemplateValue fields with fd-scripted placeholders would round-trip
+                // as TemplateValue({ assignment_group: 'fd-scripted' }) instead of
+                // TemplateValue({ assignment_group: wfa.inlineScript('...') }).
+                const inputScripts = descendants.query('sys_hub_input_scripts')
+                for (const scriptRecord of inputScripts) {
+                    const inputName = scriptRecord.get('input_name')?.asString()?.getValue()
+                    const scriptJson = scriptRecord.get('script')?.asString()?.getValue()
+                    if (!inputName || !scriptJson || configObj[inputName] === undefined) {
+                        continue
+                    }
+                    try {
+                        const scriptedFields = JSON.parse(scriptJson) as globalThis.Record<
+                            string,
+                            { scriptActive: boolean; script: string }
+                        >
+                        configObj[inputName] = applyTemplateValueSubFieldScripts(
+                            configObj[inputName],
+                            scriptedFields,
+                            record
+                        )
+                    } catch {
+                        // malformed script JSON — leave the existing value unchanged
+                    }
+                }
+
                 // Build step instance config (2nd arg): $id, label, error_handling_type
                 const configProperties: globalThis.Record<string, unknown> = {
                     $id: NowIdShape.from(record),
@@ -1079,6 +1113,9 @@ async function createVariableRecords(
             // Handle TemplateValueShape specially - serialize to ServiceNow format.
             // When TemplateValue contains datapills, the platform stores the entire encoded string
             // (with pills inline) in a single sys_element_mapping record with field=<parent input name>.
+            // Scripted sub-fields (wfa.inlineScript()) use the 'fd-scripted' placeholder in the
+            // encoded value and have their script content stored in a sys_hub_input_scripts record.
+            const scriptedSubFields: globalThis.Record<string, { scriptActive: true; script: string }> = {}
             let actualValue: unknown
             if (valueShape.is(TemplateValueShape)) {
                 const templateObj = (valueShape as TemplateValueShape).getTemplateValue()
@@ -1091,6 +1128,10 @@ async function createVariableRecords(
                         collectPillTypes(pillString, pillTypeMap)
                         entries.push(`${field}=${stripPillType(pillString)}`)
                         hasPills = true
+                    } else if (fieldShape instanceof FDInlineScriptCallShape) {
+                        // Use fd-scripted placeholder; script content goes to sys_hub_input_scripts
+                        entries.push(`${field}=fd-scripted`)
+                        scriptedSubFields[field] = { scriptActive: true, script: fieldShape.getScriptContent() }
                     } else if (fieldShape.is(TemplateExpressionShape)) {
                         const resolved = resolveTemplateExpression(
                             fieldShape as TemplateExpressionShape,
@@ -1111,6 +1152,8 @@ async function createVariableRecords(
 
                 const encodedValue = entries.join('^')
 
+                const hasScripts = Object.keys(scriptedSubFields).length > 0
+
                 if (hasPills) {
                     // TemplateValue with datapills → single sys_element_mapping record
                     // No sys_variable_value for this field — platform reads from element_mapping only
@@ -1126,6 +1169,19 @@ async function createVariableRecords(
                             },
                         })
                     )
+                    if (hasScripts) {
+                        allRecords.push(
+                            await factory.createRecord({
+                                source: callExpression,
+                                table: 'sys_hub_input_scripts',
+                                properties: {
+                                    instance: stepInstanceSysId,
+                                    input_name: key,
+                                    script: JSON.stringify(scriptedSubFields),
+                                },
+                            })
+                        )
+                    }
                     return
                 }
 
@@ -1236,6 +1292,22 @@ async function createVariableRecords(
                 },
             })
             allRecords.push(record)
+
+            // For TemplateValue with scripted sub-fields (no datapills path),
+            // create sys_hub_input_scripts record alongside the sys_variable_value
+            if (Object.keys(scriptedSubFields).length > 0) {
+                allRecords.push(
+                    await factory.createRecord({
+                        source: callExpression,
+                        table: 'sys_hub_input_scripts',
+                        properties: {
+                            instance: stepInstanceSysId,
+                            input_name: key,
+                            script: JSON.stringify(scriptedSubFields),
+                        },
+                    })
+                )
+            }
         })
     )
     return allRecords

package/src/flow/post-install.ts

@@ -1,4 +1,4 @@
-import type { PostInstallTask, PostInstallContext } from '@servicenow/sdk-build-core'
+import type { PostInstallTask, PostInstallContext, RecordEntry } from '@servicenow/sdk-build-core'
 
 type ActivateFlowsResult = {
     status: string
@@ -16,8 +16,11 @@ type ActivateFlowsResult = {
     }>
 }
 
+const FLOW_TABLE = 'sys_hub_flow'
+const ACTION_TABLE = 'sys_hub_action_type_definition'
+
 async function activateFlows(context: PostInstallContext): Promise<void> {
-    const { instanceClient, logger, config } = context
+    const { instanceClient, logger, config, recordIds } = context
     const { scopeId } = config
 
     if (!instanceClient) {
@@ -25,13 +28,28 @@ async function activateFlows(context: PostInstallContext): Promise<void> {
         return
     }
 
-    logger.debug('Activating flows...')
+    const flowAndSubflowIds = recordIds?.[FLOW_TABLE] ?? []
+    const actionIds = recordIds?.[ACTION_TABLE] ?? []
+
+    if (flowAndSubflowIds.length === 0 && actionIds.length === 0) {
+        logger.debug('No flows, subflows, or actions found in project, skipping flow activation')
+        return
+    }
+
+    logger.debug(`Activating flows... (${flowAndSubflowIds.length} flow/subflow(s), ${actionIds.length} action(s))`)
 
     const response = await instanceClient.fetch(
         'api/now/wfa_fluent/activate_flows',
         {
             method: 'POST',
-            headers: { Accept: 'application/json' },
+            headers: {
+                Accept: 'application/json',
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                flows: flowAndSubflowIds,
+                actions: actionIds,
+            }),
         },
         new URLSearchParams({ sysparm_transaction_scope: scopeId })
     )
@@ -40,7 +58,7 @@ async function activateFlows(context: PostInstallContext): Promise<void> {
     // Any other non-OK status (400, 401, 403, 500, etc.) is an error
     if (!response.ok && response.status !== 422) {
         const body = await response.json().catch(() => null)
-        const msg = body?.error?.message ?? body?.message ?? response.statusText
+        const msg = body?.result?.error?.message ?? body?.error?.message ?? body?.message ?? response.statusText
 
         // Instances without the endpoint return 400 with "does not represent any resource"
         if (msg.includes('does not represent any resource')) {
@@ -84,6 +102,19 @@ async function activateFlows(context: PostInstallContext): Promise<void> {
     logger.warn(msg)
 }
 
+export function getRecordIdsByTable(keysRegistry: Now.Internal.KeysRegistry): Record<string, RecordEntry[]> {
+    const result: Record<string, RecordEntry[]> = {}
+
+    for (const entry of Object.values(keysRegistry.explicit)) {
+        if (entry.deleted) {
+            continue
+        }
+        const entries = (result[entry.table] ??= [])
+        entries.push({ sys_id: entry.id, active: '', state: '' })
+    }
+    return result
+}
+
 export const FlowActivationTask: PostInstallTask = {
     name: 'flow-activation',
     skipFlag: 'skipFlowActivation',

package/src/flow/utils/complex-object-resolver.ts

@@ -850,8 +850,10 @@ function buildCv(typeNode: unknown, valueNode: unknown): unknown {
         // Special handling for primitive arrays (schema: ["Any"], value: ["item1", "item2", ...])
         if (Array.isArray(typeNode) && Array.isArray(valueNode)) {
             if (typeNode.length === 1 && typeNode[0] === 'Any') {
-                // Primitive array: return plain string values without $cv wrapping
-                return valueNode.map((v) => String(v))
+                // Primitive array: preserve native types (string, number, boolean) without $cv wrapping.
+                // Do NOT force String(v) — that would convert [10,20,30] to ['10','20','30'] and
+                // [true,false] to ['true','false'], breaking the round-trip for IntegerColumn/BooleanColumn.
+                return valueNode
             }
         }