@servicenow/sdk-build-plugins 4.8.0 → 4.8.1

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

@@ -82,7 +82,12 @@ import { isDataPill } from '../utils/complex-object-resolver'
 import { wrapWithDataPillCall, extractDataPillNames } from '../utils/pill-shape-helpers'
 import { ArrayShape } from '@servicenow/sdk-build-core'
 import { processFlowInputs, processFlowOutputs, processFlowVariables } from '../utils/flow-variable-processor'
-import { buildUuidToIdentifierMap, processInstanceForDatapills, uuidToRecordMap } from '../utils/datapill-transformer'
+import {
+    buildUuidToIdentifierMap,
+    detectHoistedOutputBindings,
+    processInstanceForDatapills,
+    uuidToRecordMap,
+} from '../utils/datapill-transformer'
 import {
     DEFAULT_PARAM_NAME,
     PARALLEL_ORDER_SEPARATOR,
@@ -646,7 +651,6 @@ function extractAllPills(
                         })
                     }
                 } else {
-                    // NOT a forEach parameter - preserve full property path
                     expression = new PropertyAccessShape({
                         source,
                         elements: [identifier, property],
@@ -774,6 +778,7 @@ function transformDataPill(
     // {{flowVariables}} and {{outputs}} should remain as bare PropertyAccessShape without wrapping
     if (stringValue === '{{flowVariables}}' || stringValue === '{{outputs}}') {
         const allPills = extractAllPills(stringValue, uuidToIdentifierMap, source, diagnostics, parameterName)
+
         if (allPills.length === 1 && allPills[0]?.expression.is(PropertyAccessShape)) {
             return allPills[0].expression as PropertyAccessShape
         }
@@ -1497,7 +1502,7 @@ function postProcessAssignSubflowOutputs(
     subflowDefinitionRecord: Record,
     logger: Logger
 ): ValuesJSON {
-    if (!valuesJSON || !valuesJSON.outputsToAssign || !Array.isArray(valuesJSON.outputsToAssign)) {
+    if (!valuesJSON?.outputsToAssign || !Array.isArray(valuesJSON.outputsToAssign)) {
         return valuesJSON
     }
 
@@ -1682,6 +1687,8 @@ export const FlowDefinitionPlugin = Plugin.create({
                 return deleteMultipleDiff(existing, incoming, descendants, context)
             },
             async toShape(record, { descendants, diagnostics, transform, database, logger }) {
+                const masterSnapshotId = record.get('master_snapshot')?.ifString()?.getValue()
+
                 let type = record.get('type')?.getValue()
                 if (!type) {
                     logger.warn(`sys_hub_flow record has no type specified, defaulting to 'flow'`)
@@ -1771,6 +1778,15 @@ export const FlowDefinitionPlugin = Plugin.create({
                 // Use recordToShapeMap to access ui_id from records (datapills reference ui_id, not $id)
                 const uuidToIdentifierMap = buildUuidToIdentifierMap(recordToShapeMap)
 
+                // Hoisting guard: if any action nested inside a DoInParallel or TryCatch block has its output
+                // referenced from outside that block, fall back to Record() API.
+                if (detectHoistedOutputBindings(allInstances)) {
+                    logger.warn(
+                        `Hoisting detected: action instance outputs are referenced outside their DoInParallel/TryCatch scope, falling back to Record() api. Flow = ${record.getId().getValue()}`
+                    )
+                    return { success: false }
+                }
+
                 // For the flow body, only use top-level instances (those without parent_ui_id). Also exclude Catch
                 // records — they are subsumed into their paired Try's `wfa.flowLogic.tryCatch(...)` shape via
                 // `connected_to`, and emitting them separately would produce a duplicate top-level statement.
@@ -1830,7 +1846,6 @@ export const FlowDefinitionPlugin = Plugin.create({
                 // 2. Semantic pills: {{trigger.property}}, {{flow_variable.name}} → references to flow parameters (e.g., {{trigger.table_name}} → params.trigger.table_name)
 
                 // Process all instances (Action, Subflow, and Flow Logic) recursively
-                // This handles datapill transformation for all instance types and their nested children
                 instanceShapes.forEach((instanceShape: Shape, index) => {
                     const result = processInstanceForDatapills(
                         instanceShape,
@@ -1848,6 +1863,7 @@ export const FlowDefinitionPlugin = Plugin.create({
                         instanceShapes[index] = result.shape
                     }
                 })
+
                 const flowBody = new ArrowFunctionShape({
                     source: record,
                     parameters: [new IdentifierShape({ source: record, name: paramName })],
@@ -1862,6 +1878,7 @@ export const FlowDefinitionPlugin = Plugin.create({
                         record.transform(({ $ }) => ({
                             $id: $.val(NowIdShape.from(record)),
                             name: $,
+                            internalName: $.from('internal_name'),
                             description: $.def(EMPTY_STRING),
                             protectionPolicy: $.from('sys_policy').def(EMPTY_STRING),
                             runAs: $.from('run_as').def(RUN_AS_DEFAULT),
@@ -1877,6 +1894,7 @@ export const FlowDefinitionPlugin = Plugin.create({
                             flowPriority: $.from('flow_priority')
                                 .map((p) => p.ifString()?.getValue() || FLOW_PRIORITY_DEFAULT)
                                 .def(FLOW_PRIORITY_DEFAULT),
+                            ...(masterSnapshotId ? { masterSnapshot: $.val(masterSnapshotId) } : {}),
                             ...(isSubflow
                                 ? {
                                       annotation: $.def(EMPTY_STRING),
@@ -1975,12 +1993,14 @@ export const FlowDefinitionPlugin = Plugin.create({
                 }
 
                 const roles = flowConfiguration.get('runWithRoles').ifArray()?.getElements() ?? []
+                const internalName = flowConfiguration.get('internalName').ifString()?.getValue()
                 const flowDefinitionRecord = await factory.createRecord({
                     source: callExpression,
                     table: 'sys_hub_flow',
                     explicitId: flowConfiguration.get('$id'),
                     properties: flowConfiguration.transform(({ $ }) => ({
                         name: $,
+                        ...(internalName ? { internal_name: $.val(internalName) } : {}),
                         annotation: $.def(EMPTY_STRING),
                         description: $.def(EMPTY_STRING),
                         access: $.def(ACCESS_DEFAULT),
@@ -2046,9 +2066,11 @@ export const FlowDefinitionPlugin = Plugin.create({
                     relatedRecords.push(...flowVarRecords)
                 }
 
+                const inputsConfig = isSubflow ? flowConfiguration.get('inputs').ifObject()?.asObject() : undefined
+                const outputsConfig = isSubflow ? flowConfiguration.get('outputs').ifObject()?.asObject() : undefined
+
                 if (isSubflow) {
                     // Process subflow inputs and outputs
-                    const inputsConfig = flowConfiguration.get('inputs').ifObject()?.asObject()
                     const inputRecords = await processFlowInputs(
                         inputsConfig,
                         flowDefinitionRecord,
@@ -2057,7 +2079,6 @@ export const FlowDefinitionPlugin = Plugin.create({
                     )
                     relatedRecords.push(...inputRecords)
 
-                    const outputsConfig = flowConfiguration.get('outputs').ifObject()?.asObject()
                     const outputRecords = await processFlowOutputs(
                         outputsConfig,
                         flowDefinitionRecord,
@@ -2260,16 +2281,101 @@ export const FlowDefinitionPlugin = Plugin.create({
                 )
 
                 const labelCacheData = Array.from(labelCacheMap.values())
+                const labelCacheValue = labelCacheData.length > 0 ? JSON.stringify(labelCacheData) : '[]'
+
                 const flowDefWithMetadata =
                     labelCacheData.length > 0
                         ? flowDefinitionRecord.merge({
-                              label_cache: JSON.stringify(labelCacheData),
+                              label_cache: labelCacheValue,
                           })
                         : flowDefinitionRecord
 
+                const masterSnapshotFromConfig = flowConfiguration.get('masterSnapshot')?.ifString()?.getValue()
+
+                if (!masterSnapshotFromConfig) {
+                    return {
+                        success: true,
+                        value: flowDefWithMetadata.with(...relatedRecords),
+                    }
+                }
+
+                const snapshotRecord = await factory.createRecord({
+                    source: callExpression,
+                    table: 'sys_hub_flow_snapshot',
+                    explicitId: masterSnapshotFromConfig,
+                    properties: flowConfiguration.transform(({ $ }) => ({
+                        access: $.def(ACCESS_DEFAULT),
+                        active: $.val(false),
+                        allow_high_security_roles: $.def(BOOLEAN_FALSE_STRING),
+                        annotation: $.def(EMPTY_STRING),
+                        attributes: $.def(EMPTY_STRING),
+                        callable_by_client_api: $.def(BOOLEAN_FALSE_STRING),
+                        category: $.def(EMPTY_STRING),
+                        description: $.def(EMPTY_STRING),
+                        flow_priority: $.from('flowPriority').def(FLOW_PRIORITY_DEFAULT),
+                        label_cache: $.val(labelCacheValue),
+                        master: $.val(true),
+                        name: $,
+                        natlang: $.def(EMPTY_STRING),
+                        outputs: $.def(EMPTY_STRING),
+                        parent_flow: $.val(flowDefinitionRecord.getId().getValue()),
+                        remote_trigger_id: $.def(EMPTY_STRING),
+                        run_as: $.from('runAs').def(RUN_AS_DEFAULT),
+                        run_with_roles: $.val(
+                            Array.from(
+                                new Set(roles.map((r) => r.ifRecord()?.getId().getValue() ?? r.getValue()))
+                            ).join(',')
+                        ),
+                        sc_callable: $.def(BOOLEAN_FALSE_STRING),
+                        status: $.val(FLOW_STATUS_DRAFT),
+                        sys_policy: $.from('protectionPolicy').def(EMPTY_STRING),
+                        type: isFlow ? $.def(FLOW_TYPE_FLOW) : $.def(FLOW_TYPE_SUBFLOW),
+                        version: $.def(FLOW_VERSION),
+                    })),
+                })
+
+                const snapshotRelatedRecords: Record[] = []
+
+                if (isSubflow) {
+                    const snapshotInputRecords = await processFlowInputs(
+                        inputsConfig,
+                        snapshotRecord,
+                        factory,
+                        diagnostics,
+                        'sys_hub_flow_snapshot'
+                    )
+                    snapshotRelatedRecords.push(...snapshotInputRecords)
+
+                    const snapshotOutputRecords = await processFlowOutputs(
+                        outputsConfig,
+                        snapshotRecord,
+                        factory,
+                        diagnostics,
+                        'sys_hub_flow_snapshot'
+                    )
+                    snapshotRelatedRecords.push(...snapshotOutputRecords)
+                }
+
+                if (flowConfiguration.has('flowVariables')) {
+                    const snapshotVarRecords = await processFlowVariables(
+                        flowConfiguration.get('flowVariables').asObject(),
+                        snapshotRecord,
+                        factory,
+                        diagnostics,
+                        'sys_hub_flow_snapshot'
+                    )
+                    snapshotRelatedRecords.push(...snapshotVarRecords)
+                }
+
+                const snapshotId = snapshotRecord.getId().getValue()
+                const finalFlowRecord = flowDefWithMetadata.merge({
+                    latest_snapshot: snapshotId,
+                    master_snapshot: snapshotId,
+                })
+
                 return {
                     success: true,
-                    value: flowDefWithMetadata.with(...relatedRecords),
+                    value: finalFlowRecord.with(...relatedRecords, snapshotRecord, ...snapshotRelatedRecords),
                 }
             },
         },

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'
@@ -142,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.
@@ -244,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() ?? ''
@@ -586,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.
@@ -689,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()}`
@@ -941,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'
 
@@ -1091,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) {
@@ -1367,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
@@ -1428,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
 }
 
@@ -1460,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) => {
@@ -1497,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
 }
 
 /**
@@ -1560,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()
@@ -1601,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.