@servicenow/sdk-build-plugins 4.4.1 → 4.6.0

package/src/arrow-function-plugin.ts

@@ -1,17 +1,31 @@
-import { Plugin, Shape, type Source, ts, IdentifierShape, type StringShape } from '@servicenow/sdk-build-core'
+import {
+    Plugin,
+    Shape,
+    type Source,
+    ts,
+    IdentifierShape,
+    type StringShape,
+    ObjectShape,
+} from '@servicenow/sdk-build-core'
 
 export class ArrowFunctionShape extends Shape {
     private readonly parameters: IdentifierShape[]
     private readonly statements: Shape[]
+    private readonly returnValue: Shape | undefined
+    private readonly implicitReturn: boolean
 
     constructor({
         source,
         parameters,
         statements,
+        returnValue,
+        implicitReturn,
     }: {
         source: Source
         parameters?: (IdentifierShape | StringShape | string)[]
         statements?: Shape[]
+        returnValue?: Shape
+        implicitReturn?: boolean
     }) {
         super({ source })
         this.parameters = (parameters ?? []).map((s) =>
@@ -23,6 +37,8 @@ export class ArrowFunctionShape extends Shape {
                   })
         )
         this.statements = statements ?? []
+        this.returnValue = returnValue
+        this.implicitReturn = implicitReturn ?? false
     }
 
     getParameters(): IdentifierShape[] {
@@ -51,18 +67,51 @@ export class ArrowFunctionShape extends Shape {
         return statement
     }
 
+    getReturnValue(): Shape | undefined {
+        return this.returnValue
+    }
+
     override getCode(): string {
-        return `(${this.getParameters()
+        const params = `(${this.getParameters()
             .map((p) => p.getCode())
-            .join(', ')}) => {\n    ${this.getStatements()
-            .map((s) => s.getCode())
-            .join('\n    ')}\n}`
+            .join(', ')})`
+
+        // Use concise arrow function syntax when there are no statements and only a return value
+        if (this.implicitReturn && this.returnValue) {
+            if (this.returnValue instanceof ObjectShape) {
+                return `${params} => (${this.returnValue.getCode()})`
+            }
+            return `${params} => ${this.returnValue.getCode()}`
+        }
+
+        // Block body syntax
+        const parts = this.getStatements().map((s) => s.getCode())
+        if (this.returnValue) {
+            parts.push(`return ${this.returnValue.getCode()}`)
+        }
+        return `${params} => {\n    ${parts.join('\n    ')}\n}`
     }
 }
 
 export const ArrowFunctionPlugin = Plugin.create({
     name: 'ArrowFunctionPlugin',
+    docs: [],
     nodes: [
+        /**
+         * Catch-all handler for ReturnStatement nodes encountered outside of arrow functions.
+         * Return statements within arrow functions are handled inline by the ArrowFunction
+         * node handler below, which extracts the return expression from the last statement.
+         * Any ReturnStatement that reaches this handler is outside an arrow function context
+         * and is not supported.
+         */
+        {
+            node: 'ReturnStatement',
+            fileTypes: ['fluent'],
+            toShape(node, { diagnostics }) {
+                diagnostics.error(node, 'Return statements are only supported inside arrow functions')
+                return { success: false }
+            },
+        },
         {
             node: 'ArrowFunction',
             fileTypes: ['fluent'],
@@ -78,24 +127,64 @@ export const ArrowFunctionPlugin = Plugin.create({
                     }
                 }
 
+                // Check if this is an expression-body arrow function (concise form) - () => 'value'
+                const body = node.getBody()
+                const isExpressionBody = body && !ts.Node.isBlock(body)
+
+                if (isExpressionBody) {
+                    // Expression body: () => expr - treat the body as the return value
+                    const result = await transform.toShape(body)
+                    if (!result.success) {
+                        diagnostics.error(body, 'Unsupported expression in arrow function body')
+                        return { success: false }
+                    }
+                    return {
+                        success: true,
+                        value: new ArrowFunctionShape({
+                            source: node,
+                            parameters,
+                            statements: [],
+                            returnValue: result.value,
+                            implicitReturn: true,
+                        }),
+                    }
+                }
+
+                const nodeStatements = node.getStatements()
+                const lastStatement = nodeStatements[nodeStatements.length - 1]
+                const hasReturn = lastStatement && ts.Node.isReturnStatement(lastStatement)
+                const bodyStatements = hasReturn ? nodeStatements.slice(0, -1) : nodeStatements
+
                 const statements: Shape[] = []
-                for (const statement of node.getStatements()) {
+                for (const statement of bodyStatements) {
                     const result = await transform.toShape(statement)
                     if (!result.success) {
                         diagnostics.error(statement, 'Unsupported statement in arrow function body')
                         return { success: false }
                     }
-
                     statements.push(result.value)
                 }
 
+                let returnValue: Shape | undefined
+                if (hasReturn) {
+                    const expr = lastStatement.getExpression()
+                    if (expr) {
+                        const result = await transform.toShape(expr)
+                        if (!result.success) {
+                            diagnostics.error(lastStatement, 'Unsupported expression in return statement')
+                            return { success: false }
+                        }
+                        returnValue = result.value
+                    }
+                }
+
+                const args = { source: node, parameters, statements }
+
                 return {
                     success: true,
-                    value: new ArrowFunctionShape({
-                        source: node,
-                        parameters,
-                        statements,
-                    }),
+                    value: returnValue
+                        ? new ArrowFunctionShape({ ...args, returnValue })
+                        : new ArrowFunctionShape(args),
                 }
             },
         },
@@ -110,7 +199,19 @@ export const ArrowFunctionPlugin = Plugin.create({
 
                 const nodeStatements = arrowFunction.getStatements()
                 const shapeStatements = shape.getStatements()
-                const excess = nodeStatements.length - shapeStatements.length
+                const returnValue = shape.getReturnValue()
+
+                if (ts.Node.isArrowFunction(target)) {
+                    const body = target.getBody()
+                    if (!ts.Node.isBlock(body) && shapeStatements.length === 0 && returnValue) {
+                        // Already inline form - commit directly to the expression
+                        await commit(returnValue, body)
+                        return { success: true }
+                    }
+                }
+
+                const totalExpected = shapeStatements.length + (returnValue ? 1 : 0)
+                const excess = nodeStatements.length - totalExpected
                 for (let i = 1; i <= excess; i++) {
                     arrowFunction.removeStatement(nodeStatements.length - i)
                 }
@@ -120,6 +221,20 @@ export const ArrowFunctionPlugin = Plugin.create({
                     await commit(statement, targetStatement)
                 }
 
+                if (returnValue) {
+                    const returnIndex = shapeStatements.length
+                    const targetReturn =
+                        nodeStatements[returnIndex] ?? arrowFunction.addStatements('return undefined')[0]!
+                    if (ts.Node.isReturnStatement(targetReturn)) {
+                        const expr = targetReturn.getExpression()
+                        if (expr) {
+                            await commit(returnValue, expr)
+                        }
+                    } else {
+                        targetReturn.replaceWithText(`return ${returnValue.getCode()}`)
+                    }
+                }
+
                 return { success: true }
             },
         },

package/src/atf/test-plugin.ts

@@ -19,6 +19,7 @@ import {
 } from '@servicenow/sdk-build-core'
 import { NowIdShape } from '../now-id-plugin'
 import { ArrowFunctionShape } from '../arrow-function-plugin'
+import { createSdkDocEntry } from '../utils'
 import { create } from 'xmlbuilder2'
 import { Test } from '@servicenow/sdk-core/runtime/app'
 import {
@@ -33,6 +34,7 @@ import type { Duration } from '@servicenow/sdk/core'
 
 export const TestPlugin = Plugin.create({
     name: 'TestPlugin',
+    docs: [createSdkDocEntry('Test', ['sys_atf_test'])],
     records: {
         sys_atf_test: {
             relationships: {

package/src/basic-syntax-plugin.ts

@@ -30,9 +30,11 @@ import {
 } from '@servicenow/sdk-build-core'
 import { isDataHelper } from './data-plugin'
 import { getCallExpressionName } from './utils'
+import { NowIncludePlugin, NowIncludeShape } from './now-include-plugin'
 
 export const BasicSyntaxPlugin = Plugin.create({
     name: 'BasicSyntaxPlugin',
+    docs: [],
     files: [
         {
             entryPoint: true,
@@ -309,6 +311,7 @@ export const BasicSyntaxPlugin = Plugin.create({
 
                 const propsToRetain = new Set<string>(['$meta'])
                 const propsToAdd: ts.PropertyAssignmentStructure[] = []
+                const nowIncludePropsToCommit = new Set<string>()
                 for (const [name, value] of shape.entries({ resolve: false })) {
                     const existingPropKey = [...shape.getAliases(name), name].find((aliasedKey) =>
                         existingNames.has(aliasedKey)
@@ -324,6 +327,9 @@ export const BasicSyntaxPlugin = Plugin.create({
 
                         await commit(value, existingNames.get(existingPropKey) as ts.Expression)
                     } else if (!value.equals(shape.getDefault(name))) {
+                        if (value.is(NowIncludeShape)) {
+                            nowIncludePropsToCommit.add(name)
+                        }
                         propsToAdd.push({
                             name: ObjectShape.quotePropertyNameIfNeeded(name),
                             initializer: value.getCode(),
@@ -338,6 +344,15 @@ export const BasicSyntaxPlugin = Plugin.create({
                     target.addPropertyAssignments(propsToAdd)
                 }
 
+                // commit Now.include props to generate the include file.
+                for (const prop of nowIncludePropsToCommit) {
+                    const includeInitializer = target
+                        .getPropertyOrThrow(prop)
+                        .asKindOrThrow(ts.SyntaxKind.PropertyAssignment)
+                        .getInitializerOrThrow()
+                    await commit(shape.get(prop, false), includeInitializer, NowIncludePlugin)
+                }
+
                 const propsToRemove = [...existingNames.keys()].filter((key) => !propsToRetain.has(key))
                 propsToRemove.forEach((prop) => {
                     target.getProperty(prop)?.asKindOrThrow(ts.SyntaxKind.PropertyAssignment).remove()
@@ -544,6 +559,12 @@ export const BasicSyntaxPlugin = Plugin.create({
                 return transform.toShape(node.getExpression())
             },
         },
+        {
+            node: 'ParenthesizedExpression',
+            toShape(node, { transform }) {
+                return transform.toShape(node.getExpression())
+            },
+        },
         {
             node: 'Identifier',
             async toShape(node, { transform }) {

package/src/call-expression-plugin.ts

@@ -3,6 +3,7 @@ import { getCallExpressionName } from './utils'
 
 export const CallExpressionPlugin = Plugin.create({
     name: 'CallExpressionPlugin',
+    docs: [],
     nodes: [
         {
             node: 'CallExpression',

package/src/claims-plugin.ts

@@ -8,6 +8,7 @@ function getClaimsPath(project: Project, config: NowConfig): string {
 
 export const ClaimsPlugin = Plugin.create({
     name: 'ClaimsPlugin',
+    docs: [],
     files: [
         {
             entryPoint: true,

package/src/client-script-plugin.ts

@@ -1,6 +1,6 @@
 import { CallExpressionShape, Plugin } from '@servicenow/sdk-build-core'
 import { NowIdShape } from './now-id-plugin'
-import { generateDeprecatedDiagnostics, validateClientSideScript } from './utils'
+import { createSdkDocEntry, generateDeprecatedDiagnostics, validateClientSideScript } from './utils'
 import { NowIncludeShape } from './now-include-plugin'
 
 enum UITypeMapping {
@@ -44,6 +44,7 @@ const clientScriptAliases = {
  */
 export const ClientScriptPlugin = Plugin.create({
     name: 'ClientScriptPlugin',
+    docs: [createSdkDocEntry('ClientScript', ['sys_script_client'])],
     records: {
         sys_script_client: {
             async toShape(record, { transform }) {

package/src/column-plugin.ts

@@ -66,6 +66,7 @@ const documentationAliases = {
 
 export const ColumnPlugin = Plugin.create({
     name: 'ColumnPlugin',
+    docs: [],
     records: {
         sys_choice: {
             coalesce: ['name', 'element', 'value'],
@@ -91,11 +92,6 @@ export const ColumnPlugin = Plugin.create({
                 value: `sys_choice_${record.get('name').getValue()}_${record.get('element').getValue()}`,
             }),
             async toFile(choiceSet, { config, descendants, transform }) {
-                if (config.tableOutputFormat === 'bootstrap' && config.type === 'package') {
-                    // Defer to table plugin
-                    return { success: false }
-                }
-
                 const tableName = choiceSet.get('name').asString().getValue()
                 const elementName = choiceSet.get('element').asString().getValue()
                 const xml = create().ele('record_update')
@@ -164,14 +160,14 @@ export const ColumnPlugin = Plugin.create({
                     factory,
                     diagnostics,
                     true,
-                    config.tableDefaultLanguage
+                    config.defaultLanguage
                 )
                 const choiceRecords = await getChoiceRecords(
                     callExpression,
                     choiceAliases,
                     factory,
                     diagnostics,
-                    config.tableDefaultLanguage
+                    config.defaultLanguage
                 )
                 const choiceSetRecords: Record[] = []
                 if (choiceRecords.length > 0) {
@@ -355,7 +351,7 @@ export const ColumnPlugin = Plugin.create({
                                     .map((f) => f.isString() && f.getValue() !== '')
                                     .def(false),
                                 column_label: $.from('label')
-                                    .map((label) => getLabelForDefaultLanguage(label, config.tableDefaultLanguage))
+                                    .map((label) => getLabelForDefaultLanguage(label, config.defaultLanguage))
                                     .def(column.get('name').asString()),
                                 mandatory: $.toBoolean().def(false),
                                 max_length: $.from('maxLength')

package/src/cross-scope-privilege-plugin.ts

@@ -1,6 +1,6 @@
 import { CallExpressionShape, Plugin } from '@servicenow/sdk-build-core'
 import { NowIdShape } from './now-id-plugin'
-import { generateDeprecatedDiagnostics } from './utils'
+import { createSdkDocEntry, generateDeprecatedDiagnostics } from './utils'
 
 const crossScopeAliases = {
     targetName: ['target_name'],
@@ -23,6 +23,7 @@ const crossScopeAliases = {
  */
 export const CrossScopePrivilegePlugin = Plugin.create({
     name: 'CrossScopePrivilegePlugin',
+    docs: [createSdkDocEntry('CrossScopePrivilege', ['sys_scope_privilege'])],
     records: {
         sys_scope_privilege: {
             relationships: {

package/src/dashboard/dashboard-plugin.ts

@@ -1,6 +1,7 @@
 import { CallExpressionShape, type ObjectShape, Plugin, type Record as RecordType } from '@servicenow/sdk-build-core'
 import { NowIdShape } from '../now-id-plugin'
 import { resolveComponentToSysId, resolveComponentToName } from './dashboard-component-resolver'
+import { createSdkDocEntry } from '../utils'
 import { DEFAULT_PROPERTY_VALUES, removeRestrictedValues } from './dashboard-component-property-defaults'
 
 const transformWidget = (widget: RecordType) =>
@@ -55,6 +56,7 @@ const createWidgetProperties = (widgetData: ObjectShape, canvas: ObjectShape) =>
  */
 export const DashboardPlugin = Plugin.create({
     name: 'DashboardPlugin',
+    docs: [createSdkDocEntry('Dashboard', ['par_dashboard'])],
     records: {
         par_dashboard: {
             relationships: {

package/src/data-plugin.ts

@@ -41,6 +41,7 @@ const shapeCreators: Record<
 
 export const DataPlugin = Plugin.create({
     name: 'DataPlugin',
+    docs: [],
     shapes: [
         {
             shape: CallExpressionShape,

package/src/email-notification-plugin.ts

@@ -1,12 +1,6 @@
-import {
-    CallExpressionShape,
-    Plugin,
-    isGUID,
-    Shape,
-    type ObjectShape,
-    type Diagnostics,
-} from '@servicenow/sdk-build-core'
+import { CallExpressionShape, Plugin, isGUID, Shape, type ObjectShape } from '@servicenow/sdk-build-core'
 import { NowIdShape } from './now-id-plugin'
+import { showGuidFieldDiagnostic, createSdkDocEntry } from './utils'
 import type { EmailNotification } from '@servicenow/sdk-core/runtime/notification'
 
 // Use index access types instead of exported utility types
@@ -59,23 +53,9 @@ const isValidEmail = (email: string): boolean => {
     return emailRegex.test(email)
 }
 
-const showGuidFieldDiagnostic = (
-    inputReceived: Shape | undefined,
-    fieldName: string,
-    tableName: string,
-    diagnostics: Diagnostics
-) => {
-    if (inputReceived) {
-        const receivedValue = inputReceived.getValue()
-        diagnostics.error(
-            inputReceived,
-            `'${fieldName}' must be a valid GUID or a Record<'${tableName}'>. Received: '${receivedValue}'`
-        )
-    }
-}
-
 export const EmailNotificationPlugin = Plugin.create({
     name: 'EmailNotificationPlugin',
+    docs: [createSdkDocEntry('EmailNotification', ['sysevent_email_action'])],
     records: {
         sysevent_email_action: {
             toShape(record) {

package/src/flow/constants/flow-plugin-constants.ts

@@ -15,7 +15,7 @@ export const FLOW_PRIORITY_DEFAULT = 'MEDIUM'
 /**
  * Default user context for flow execution
  */
-export const RUN_AS_DEFAULT = 'system'
+export const RUN_AS_DEFAULT = 'user'
 
 /**
  * Default access level for flows

package/src/flow/flow-logic/flow-logic-diagnostics.ts

@@ -433,7 +433,7 @@ function validateSetFlowVariables(expr: FlowLogicInstanceShape): string | undefi
  * Performs comprehensive validation of arguments, types, structure, and placement.
  *
  * **Validations performed:**
- * 1. Placement: Must be within a Subflow or SubflowDefinition (not in regular Flow)
+ * 1. Placement: Must be within a Subflow() definition (not in regular Flow)
  * 2. Argument count: Must have exactly 3 arguments
  * 3. Config object: Must contain required $id property
  * 4. Schema argument: Must be params.outputs (schema reference)
@@ -450,7 +450,7 @@ function validateSetFlowVariables(expr: FlowLogicInstanceShape): string | undefi
  * - Datapills: params.action.result, params.complexObject (PropertyAccessShape)
  * - Template expressions: `Result: ${params.action.result}` (TemplateExpressionShape)
  *
- * **Important:** AssignSubflowOutputs can ONLY be used within Subflow or SubflowDefinition.
+ * **Important:** AssignSubflowOutputs can ONLY be used within a Subflow() definition.
  * Using it in a regular Flow will result in a validation error.
  *
  * @param expr - The AssignSubflowOutputs flow logic instance shape
@@ -473,12 +473,11 @@ function validateAssignSubflowOutputs(expr: FlowLogicInstanceShape): string | un
         return undefined
     }
 
-    // Validate that this is called within a SubflowDefinition or Subflow
+    // Validate that this is called within a Subflow() definition
     const node = expr.getOriginalNode()
-    const subflowAncestor =
-        findAncestorByCalleeName(node, 'SubflowDefinition') || findAncestorByCalleeName(node, 'Subflow')
+    const subflowAncestor = findAncestorByCalleeName(node, 'Subflow')
     if (!subflowAncestor) {
-        return 'AssignSubflowOutputs can only be used within a SubflowDefinition or Subflow'
+        return 'AssignSubflowOutputs can only be used within a Subflow'
     }
 
     // Validate argument count

package/src/flow/flow-logic/flow-logic-plugin-helpers.ts

@@ -130,7 +130,7 @@ type FlowLogicParseResult =
  * FlowLogicValueInput objects with name/value pairs that represent the
  * original TypeScript configuration properties.
  */
-namespace FlowLogicValueProcessor {
+export namespace FlowLogicValueProcessor {
     /**
      * Generic factory function for creating flow logic entry objects.
      * All entry types (AssignSubflowOutput, SetFlowVariablesInput, FlowLogicValueInput)
@@ -766,8 +766,6 @@ namespace FlowLogicValueProcessor {
     // Constants for type handling
     const ARRAY_TYPE_PREFIX = 'array.' as const
     const ARRAY_TYPE_PREFIX_LENGTH = ARRAY_TYPE_PREFIX.length
-    const EXCLUDED_TYPE_ANNOTATIONS = new Set(['string', 'glide_date_time'])
-
     /**
      * Interface for child entry structure used in parsing
      */
@@ -829,50 +827,29 @@ namespace FlowLogicValueProcessor {
         return value
     }
 
-    /**
-     * Adds type annotation to a datapill if needed based on label cache
-     * @param pillName - Datapill name without braces
-     * @param labelCacheMap - Map of datapill names to types
-     * @returns Datapill with annotation if applicable
-     */
-    function addTypeAnnotationIfNeeded(pillName: string, labelCacheMap?: Map<string, string>): string {
-        if (!labelCacheMap) {
-            return `{{${pillName}}}`
-        }
-
-        const cachedType = labelCacheMap.get(pillName.trim())
-        if (cachedType && !EXCLUDED_TYPE_ANNOTATIONS.has(cachedType)) {
-            return `{{${pillName}|${cachedType}}}`
-        }
-
-        return `{{${pillName}}}`
-    }
-
     /**
      * Processes a pure datapill value (starts and ends with {{}})
+     * Strips any existing |type annotation and returns a clean datapill.
+     * Type info is preserved via labelCacheMap in wrapWithWfaDataPillExpression downstream.
      * @param value - Pure datapill string
-     * @param labelCacheMap - Map of datapill names to types
-     * @returns Processed datapill with type annotation if needed
+     * @param _labelCacheMap - Unused (type resolution handled downstream by transformDataPill)
+     * @returns Clean datapill without type annotation
      */
-    function processPureDatapill(value: string, labelCacheMap?: Map<string, string>): string {
-        const strippedValue = stripDatapillTypeAnnotation(value)
-        const pillName = strippedValue.slice(2, -2) // Remove {{ and }}
-        return addTypeAnnotationIfNeeded(pillName, labelCacheMap)
+    function processPureDatapill(value: string, _labelCacheMap?: Map<string, string>): string {
+        return stripDatapillTypeAnnotation(value)
     }
 
     /**
-     * Processes a template expression containing datapills mixed with text
+     * Processes a template expression containing datapills mixed with text.
+     * Strips any existing |type annotations and returns clean datapills.
+     * Type info is preserved via labelCacheMap in wrapWithWfaDataPillExpression downstream.
      * @param value - Template expression string
-     * @param labelCacheMap - Map of datapill names to types
-     * @returns Processed template with type annotations added to datapills
+     * @param _labelCacheMap - Unused (type resolution handled downstream by transformDataPill)
+     * @returns Processed template with type annotations stripped from datapills
      */
-    function processTemplateExpression(value: string, labelCacheMap?: Map<string, string>): string {
-        if (!labelCacheMap) {
-            return value
-        }
-
-        const datapillRegex = /\{\{([^}|]+)(?:\|[^}]+)?\}\}/g
-        return value.replace(datapillRegex, (_match, pillName) => addTypeAnnotationIfNeeded(pillName, labelCacheMap))
+    function processTemplateExpression(value: string, _labelCacheMap?: Map<string, string>): string {
+        const datapillRegex = /\{\{([^}|]+)\|[^}]+\}\}/g
+        return value.replace(datapillRegex, '{{$1}}')
     }
 
     /**
@@ -972,12 +949,26 @@ namespace FlowLogicValueProcessor {
             if (parsed.complexObjectSchema) {
                 // Find the $COCollectionField.$type_facets
                 for (const schemaKey in parsed.complexObjectSchema) {
+                    // Skip top-level $type_facets entries (handled as fallback below)
+                    if (schemaKey.endsWith('.$type_facets')) {
+                        continue
+                    }
                     const schema = parsed.complexObjectSchema[schemaKey]
-                    if (schema && schema.$COCollectionField && schema['$COCollectionField.$type_facets']) {
-                        const typeFacets = schema['$COCollectionField.$type_facets']
-                        if (typeFacets.SimpleMapFacet) {
-                            const facetData = JSON.parse(typeFacets.SimpleMapFacet)
-                            return facetData.child_type
+                    if (schema && schema.$COCollectionField) {
+                        // Array.Object format: child_type nested as $COCollectionField.$type_facets
+                        if (schema['$COCollectionField.$type_facets']?.SimpleMapFacet) {
+                            const facetData = JSON.parse(schema['$COCollectionField.$type_facets'].SimpleMapFacet)
+                            if (facetData.child_type) {
+                                return facetData.child_type
+                            }
+                        }
+                        // DEF0798866: Array.String format: child_type stored in top-level key "schemaKey.$type_facets"
+                        const topLevelTypeFacets = parsed.complexObjectSchema[`${schemaKey}.$type_facets`]
+                        if (topLevelTypeFacets?.SimpleMapFacet) {
+                            const facetData = JSON.parse(topLevelTypeFacets.SimpleMapFacet)
+                            if (facetData.child_type) {
+                                return facetData.child_type
+                            }
                         }
                     }
                 }
@@ -1081,8 +1072,15 @@ namespace FlowLogicValueProcessor {
         const firstBaseName = getBaseName(childObj.name)
 
         // Check if all children have the same base name (indicating FlowArray with repeated childName)
+        // When elementType is defined (i.e., the schema identifies this as a FlowArray — Array.Object,
+        // Array.String, Array.Integer, Array.DateTime, etc.), a single child is still a valid array
+        // element: the child is the childName wrapper whose inner value/children are the actual element.
+        // Without this, single-element FlowArray assignments fall into the object path, generating
+        // { childName: { fields } } or { childName: value } instead of [{ fields }] or [value].
+        // DEF0798866: single-element Array.Object/String subflow outputs generated incorrect Fluent code.
+        const minChildrenForArray = elementType !== undefined ? 1 : 2
         const allSameName =
-            children.length > 1 &&
+            children.length >= minChildrenForArray &&
             children.every((c) => {
                 const entry = c as ChildEntry
                 return getBaseName(entry.name) === firstBaseName
@@ -1525,7 +1523,11 @@ namespace FlowLogicValueProcessor {
                         // Ignore parse errors
                     }
                 }
-                const elementType = getArrayElementType(entry)
+                // DEF0798866: Use typeMap as fallback when schema-based detection fails.
+                // If entry.value doesn't contain complexObjectSchema (e.g., some ServiceNow XML
+                // formats omit the schema), fall back to the typeMap which always contains the
+                // output/variable type (e.g., 'array.string' -> 'string' element type).
+                const elementType = getArrayElementType(entry) ?? extractArrayElementType(typeMap?.get(entry.name))
                 const nestedTypeMap = extractNestedTypeSchema(entry)
                 const parsedValue = parseChildrenArray(
                     entry.children,

package/src/flow/flow-logic/flow-logic-plugin.ts

@@ -72,6 +72,7 @@ import type { ArrowFunctionShape } from '../../arrow-function-plugin'
  */
 export const FlowLogicPlugin = Plugin.create({
     name: 'FlowLogicPlugin',
+    docs: [],
     records: {
         sys_hub_flow_logic_instance_v2: {
             relationships: {

package/src/flow/plugins/approval-rules-plugin.ts

@@ -5,6 +5,7 @@ import { getCallExpressionName } from '../../utils'
 
 export const ApprovalRulesPlugin = Plugin.create({
     name: 'ApprovalRulesPlugin',
+    docs: [],
     nodes: [
         {
             node: 'CallExpression',