@servicenow/sdk-build-plugins 4.5.0 → 4.6.0

package/src/flow/utils/label-cache-parser.ts

@@ -1,4 +1,5 @@
 import type { Logger } from '@servicenow/sdk-build-core'
+import { parseSinglePill } from './pill-string-parser'
 
 interface LabelCacheEntry {
     name: string
@@ -13,10 +14,20 @@ interface LabelCacheEntry {
     attributes?: Record<string, string>
 }
 
+/** Action label cache uses pill category ("action", "step", "static") as the type field */
+const ACTION_PILL_CATEGORIES = new Set(['action', 'step', 'static'])
+
 /**
- * Creates a map of name to type from a label_cache string
+ * Creates a map of name to type from a label_cache string.
+ *
+ * Flow/subflow label cache entries use the actual data type in the `type` field and
+ * plain names without braces (e.g., name="flow_variable.userName", type="string").
+ *
+ * Action label cache entries use a pill category in `type` (e.g., "action") and store the
+ * actual data type in `base_type`. Names include braces (e.g., "{{action.variable}}").
+ *
  * @param labelCacheString - The stringified JSON array from label_cache
- * @returns Map where key is the name field and value is the type field
+ * @returns Map where key is the pill name (without braces) and value is the data type
  */
 export function createLableCacheNameToTypeMap(labelCacheString: string, logger: Logger): Map<string, string> {
     const nameToTypeMap = new Map<string, string>()
@@ -25,8 +36,26 @@ export function createLableCacheNameToTypeMap(labelCacheString: string, logger:
         const entries: LabelCacheEntry[] = JSON.parse(labelCacheString)
 
         for (const entry of entries) {
-            if (entry.name && entry.type) {
-                nameToTypeMap.set(entry.name, entry.type)
+            if (!entry.name) {
+                continue
+            }
+
+            if (ACTION_PILL_CATEGORIES.has(entry.type)) {
+                // Action label cache: strip braces from name, use base_type for actual data type
+                const parsed = parseSinglePill(entry.name, true)
+                const key = parsed ? `${parsed.prefix}.${parsed.path}` : entry.name
+                nameToTypeMap.set(key, entry.base_type || 'string')
+            } else if (entry.type) {
+                // Flow/subflow label cache: name is plain, type is the actual data type
+                let type = entry.type
+                // DEF0792627: The platform sometimes stores 'reference' for the sys_id field
+                // when the pill is used in a reference field context (e.g., sysapproval).
+                // sys_id is always a string/GUID field never a reference — except for
+                // step output Record.sys_id which IS a reference to the record itself.
+                if (type === 'reference' && entry.name.endsWith('.sys_id') && !entry.name.includes('.Record.sys_id')) {
+                    type = 'string'
+                }
+                nameToTypeMap.set(entry.name, type)
             }
         }
     } catch (error) {

package/src/flow/utils/pill-shape-helpers.ts

@@ -0,0 +1,42 @@
+import {
+    CallExpressionShape,
+    type IdentifierShape,
+    type PropertyAccessShape,
+    StringLiteralShape,
+    type Source,
+} from '@servicenow/sdk-build-core'
+
+/**
+ * Wraps a PropertyAccessShape or IdentifierShape with wfa.dataPill(expression, type).
+ * Used by both flow-definition-plugin and flow-action-definition-plugin.
+ *
+ * @param expression - The property access or identifier to wrap
+ * @param source - Source for the shape
+ * @param dataType - The data type for the pill
+ */
+export function wrapWithDataPillCall(
+    expression: PropertyAccessShape | IdentifierShape,
+    source: Source,
+    dataType = 'string'
+): CallExpressionShape {
+    return new CallExpressionShape({
+        source,
+        callee: 'wfa.dataPill',
+        args: [expression, new StringLiteralShape({ source, literalText: dataType })],
+    })
+}
+
+/**
+ * Extracts all datapill names (without type annotations) from a string containing {{...}} patterns.
+ * Used by both flow-definition-plugin and flow-action-definition-plugin.
+ */
+export function extractDataPillNames(stringValue: string): string[] {
+    const names: string[] = []
+    for (const match of stringValue.matchAll(/\{\{([^}]+)\}\}/g)) {
+        const pillContent = match[1]?.split('|')[0]
+        if (pillContent) {
+            names.push(pillContent)
+        }
+    }
+    return names
+}

package/src/flow/utils/pill-string-parser.ts

@@ -121,6 +121,7 @@ export function mapPillPrefixToTsRoot(prefix: string, parameterName: string = 'p
         inputs: `${parameterName}.inputs`,
         outputs: `${parameterName}.outputs`, // Schema reference (no property access)
         subflow: `${parameterName}.inputs`, // ServiceNow uses {{subflow.x}} for subflow inputs
+        action: `${parameterName}.inputs`, // ServiceNow uses {{action.x}} for action inputs → params.inputs.x
 
         // Record triggers (prefixed with trigger name + _1)
         Created_1: `${parameterName}.trigger`,

package/src/flow/utils/schema-to-flow-object.ts

@@ -38,20 +38,129 @@ const SCHEMA_TYPE_TO_COLUMN_API: Record<string, string> = {
     reference: ReferenceColumn.name,
 }
 
+// ------------------------------------------------------------
+// Snapshot value extraction helpers
+// ------------------------------------------------------------
+
+/**
+ * Recursively walk a snapshot's `complexObjectSchema` and extract all
+ * datapill mappings from `mapped` fields inside `$field_facets.SimpleMapFacet`.
+ */
+export function extractAllMappedValues(obj: any, result: globalThis.Record<string, string>): void {
+    if (typeof obj !== 'object' || obj === null) {
+        return
+    }
+
+    if (Array.isArray(obj)) {
+        for (const item of obj) {
+            extractAllMappedValues(item, result)
+        }
+        return
+    }
+
+    for (const [key, value] of Object.entries(obj)) {
+        if (key.endsWith('.$field_facets')) {
+            const facet = (value as any)?.SimpleMapFacet
+            if (facet) {
+                try {
+                    const parsed = JSON.parse(facet)
+                    if (parsed.mapped) {
+                        const mappedObj = JSON.parse(parsed.mapped)
+                        for (const [childName, datapill] of Object.entries(mappedObj)) {
+                            if (typeof datapill === 'string' && datapill) {
+                                result[childName] = datapill
+                            }
+                        }
+                    }
+                } catch {
+                    // skip unparseable facets
+                }
+            }
+        } else if (typeof value === 'object' && value !== null) {
+            extractAllMappedValues(value, result)
+        }
+    }
+}
+
+/**
+ * Recursively walk a snapshot's `complexObject` and extract static values
+ * from `{ $cv: { $c: "type", $v: "value" } }` structures.
+ */
+function extractAllStaticValues(obj: any, result: globalThis.Record<string, string>): void {
+    if (typeof obj !== 'object' || obj === null || Array.isArray(obj)) {
+        return
+    }
+
+    for (const [key, value] of Object.entries(obj)) {
+        if (key.startsWith('$') || key.endsWith('$')) {
+            continue
+        }
+        if (typeof value === 'object' && value !== null && (value as any).$cv) {
+            const staticVal = (value as any).$cv.$v
+            if (staticVal !== undefined && staticVal !== '') {
+                result[key] = String(staticVal)
+            }
+        } else if (typeof value === 'object' && value !== null) {
+            extractAllStaticValues(value, result)
+        }
+    }
+}
+
+/**
+ * Parse a snapshot value JSON for a complex object output and extract
+ * per-child value mappings (datapills take priority over static values).
+ */
+function parseSnapshotChildValues(snapshotValue: string | undefined): globalThis.Record<string, string> {
+    if (!snapshotValue) {
+        return {}
+    }
+
+    try {
+        const parsed = JSON.parse(snapshotValue)
+        const result: globalThis.Record<string, string> = {}
+
+        // Extract datapill mappings from schema (higher priority)
+        const schema = parsed.complexObjectSchema
+        if (schema) {
+            extractAllMappedValues(schema, result)
+        }
+
+        // Extract static values from complexObject (lower priority — only if no datapill)
+        const complexObj = parsed.complexObject
+        if (complexObj) {
+            const staticValues: globalThis.Record<string, string> = {}
+            extractAllStaticValues(complexObj, staticValues)
+            for (const [k, v] of Object.entries(staticValues)) {
+                if (!result[k]) {
+                    result[k] = v
+                }
+            }
+        }
+
+        return result
+    } catch {
+        return {}
+    }
+}
+
 /**
  * Build a `CallExpressionShape` for a simple (non-object) field given its
  * schema primitive type and associated facets.
  */
-function buildPrimitiveFieldCallExpr(fieldFacet: ObjectShape, source: FluentRecord): CallExpressionShape {
+function buildPrimitiveFieldCallExpr(
+    fieldFacet: ObjectShape,
+    source: FluentRecord,
+    childValue?: string
+): CallExpressionShape {
     const childType = fieldFacet.get('childType').ifDefined()?.asString()?.getValue()
     const schemaType = childType ?? fieldFacet.get('type')?.asString()?.getValue()
     const callee = SCHEMA_TYPE_TO_COLUMN_API[schemaType] ?? StringColumn.name
 
     const additionalProps: globalThis.Record<string, unknown> = {}
 
-    // Extract referenceTable for ReferenceColumn type
+    // Extract referenceTable for reference and records column types
     const referenceTable = fieldFacet.get('reference')?.ifString()?.getValue()
-    if (referenceTable && schemaType === 'reference') {
+    if (referenceTable && (schemaType === 'reference' || schemaType === 'records')) {
         additionalProps['referenceTable'] = referenceTable
     }
 
@@ -99,6 +208,7 @@ function buildPrimitiveFieldCallExpr(fieldFacet: ObjectShape, source: FluentReco
                             })
                             .def(choiceDropdown[ChoiceDropdown.DROPDOWN_WITH_NONE]),
                     }),
+                    ...(childValue ? { default: $.val(childValue) } : {}),
                 }))
                 .merge(additionalProps),
         ],
@@ -115,7 +225,8 @@ function buildFlowArrayFromSchema(
     source: FluentRecord,
     parentTypeFacet: ObjectShape,
     complexObjectSysId?: string,
-    co_type_name?: string
+    co_type_name?: string,
+    childValues?: globalThis.Record<string, string>
 ): CallExpressionShape {
     const rootContent = schemaContent['$COCollectionField']
     if (!rootContent) {
@@ -129,7 +240,14 @@ function buildFlowArrayFromSchema(
     let elementType: CallExpressionShape
     if (type === 'array.object') {
         const childKey = parentTypeFacet.get('childName')?.asString()?.getValue()
-        elementType = buildFlowObjectFromSchema(rootContent[0][childKey], source, rootTypeFacet)
+        elementType = buildFlowObjectFromSchema(
+            rootContent[0][childKey],
+            source,
+            rootTypeFacet,
+            undefined,
+            undefined,
+            childValues
+        )
     } else {
         elementType = buildPrimitiveFieldCallExpr(parentTypeFacet, source)
     }
@@ -163,7 +281,8 @@ function buildFlowArrayFromSchema(
 function buildNestedFlowArrayFromSchema(
     schemaContent: Record<string, any>,
     source: FluentRecord,
-    parentTypeFacet: ObjectShape
+    parentTypeFacet: ObjectShape,
+    childValues?: globalThis.Record<string, string>
 ): CallExpressionShape {
     const type = parentTypeFacet.get('type')?.asString()?.getValue()
     let elementType: CallExpressionShape
@@ -175,7 +294,14 @@ function buildNestedFlowArrayFromSchema(
         const keys = Object.keys(schemaContent)
         const wrapperKey = keys.find((k) => /^\$\d+_/.test(k)) ?? keys.find((k) => !k.endsWith('.$field_facets'))
         const innerContent = wrapperKey ? schemaContent[wrapperKey] : schemaContent
-        elementType = buildFlowObjectFromSchema(innerContent, source, parentTypeFacet)
+        elementType = buildFlowObjectFromSchema(
+            innerContent,
+            source,
+            parentTypeFacet,
+            undefined,
+            undefined,
+            childValues
+        )
     } else {
         elementType = buildPrimitiveFieldCallExpr(parentTypeFacet, source)
     }
@@ -214,7 +340,9 @@ function buildFlowObjectFromSchema(
     source: FluentRecord,
     parentTypeFacet: ObjectShape,
     complexObjectSysId?: string,
-    co_type_name?: string
+    co_type_name?: string,
+    childValues?: globalThis.Record<string, string>,
+    topLevelDefault?: string
 ): CallExpressionShape {
     const properties: Record<string, unknown> = {}
 
@@ -230,15 +358,22 @@ function buildFlowObjectFromSchema(
                 throw new Error(`Invalid complex object schema: ${key} facet not found`)
             }
             if (typeof value === 'string') {
-                // Primitive field
-                properties[key] = buildPrimitiveFieldCallExpr(fieldFacet, source)
+                // Primitive field — pass per-child snapshot value if available
+                properties[key] = buildPrimitiveFieldCallExpr(fieldFacet, source, childValues?.[key])
             } else if (typeof value === 'object' && value !== null) {
                 if (Array.isArray(value)) {
                     // Nested FlowArray
-                    properties[key] = buildNestedFlowArrayFromSchema(value[0], source, fieldFacet)
+                    properties[key] = buildNestedFlowArrayFromSchema(value[0], source, fieldFacet, childValues)
                 } else {
                     // Nested FlowObject
-                    properties[key] = buildFlowObjectFromSchema(value, source, fieldFacet)
+                    properties[key] = buildFlowObjectFromSchema(
+                        value,
+                        source,
+                        fieldFacet,
+                        undefined,
+                        undefined,
+                        childValues
+                    )
                 }
             }
         }
@@ -256,6 +391,7 @@ function buildFlowObjectFromSchema(
                     .map((label, child) => (child.isDefined() ? child : label))
                     .def(''),
                 mandatory: $.toBoolean().def(false),
+                ...(topLevelDefault ? { default: $.val(topLevelDefault) } : {}),
             })),
         ],
     })
@@ -274,7 +410,8 @@ export function buildComplexObjectFromSchema(
     schema: Record<string, any>,
     attributes: COAttributes,
     complexObjectSysId?: string,
-    co_type_name?: string
+    co_type_name?: string,
+    snapshotValue?: string
 ): CallExpressionShape {
     const { co_type_name: attrCoTypeName, uiType, ...rest } = attributes
     const rootKey = `FlowDesigner:${attrCoTypeName}`
@@ -292,11 +429,42 @@ export function buildComplexObjectFromSchema(
         type: uiType,
         ...rest,
     })
+    // Parse snapshot value into per-child value mappings (datapills and static values)
+    const childValues = parseSnapshotChildValues(snapshotValue)
+    const hasChildValues = Object.keys(childValues).length > 0 ? childValues : undefined
+
+    // Detect plain-string snapshot values (e.g. a whole-object datapill like
+    // {{step[UUID].__step_status__}}) that are not valid JSON complex-object
+    // structures. These map to a top-level `default` on the FlowObject.
+    let topLevelDefault: string | undefined
+    if (snapshotValue && !hasChildValues) {
+        try {
+            JSON.parse(snapshotValue)
+        } catch {
+            topLevelDefault = snapshotValue
+        }
+    }
+
     // Pass the explicit co_type_name parameter (undefined for deterministic, value for non-deterministic)
     if (uiType.startsWith('array.')) {
-        return buildFlowArrayFromSchema(rootContent, source, rootTypeFacet, complexObjectSysId, co_type_name)
+        return buildFlowArrayFromSchema(
+            rootContent,
+            source,
+            rootTypeFacet,
+            complexObjectSysId,
+            co_type_name,
+            hasChildValues
+        )
     }
-    return buildFlowObjectFromSchema(rootContent, source, rootTypeFacet, complexObjectSysId, co_type_name)
+    return buildFlowObjectFromSchema(
+        rootContent,
+        source,
+        rootTypeFacet,
+        complexObjectSysId,
+        co_type_name,
+        hasChildValues,
+        topLevelDefault
+    )
 }
 
 function parseTypeFacet(source: FluentRecord, schema: Record<string, any>, key: string): ObjectShape | undefined {

package/src/flow/utils/utils.ts

@@ -20,7 +20,13 @@ import { CallExpressionPlugin } from '../../call-expression-plugin'
 import { FlowLogicPlugin } from '../flow-logic/flow-logic-plugin'
 import { FlowInstancePlugin } from '../plugins/flow-instance-plugin'
 import { FDInstanceShape } from './flow-shapes'
-import { CORE_ACTIONS_PREFIX, CORE_ACTIONS_SYS_ID_NAME_MAP, UNSUPPORTED_FLOW_DESCENDANTS } from './flow-constants'
+import {
+    CORE_ACTIONS_PREFIX,
+    CORE_ACTIONS_SYS_ID_NAME_MAP,
+    BUILT_IN_STEP_PREFIX,
+    BUILT_IN_STEP_SYS_ID_NAME_MAP,
+    UNSUPPORTED_FLOW_DESCENDANTS,
+} from './flow-constants'
 
 export function sysIdToUuid(id: string): string {
     return id.length === 32
@@ -383,6 +389,11 @@ export const getCoreActionIdentifier = (sysId: string) => {
     return actionName ? `${CORE_ACTIONS_PREFIX}.${actionName}` : undefined
 }
 
+export const getBuiltInStepIdentifier = (sysId: string) => {
+    const stepName = BUILT_IN_STEP_SYS_ID_NAME_MAP[sysId]
+    return stepName ? `${BUILT_IN_STEP_PREFIX}.${stepName}` : undefined
+}
+
 /**
  * Extracts the order value from a record for sorting purposes.
  * Converts the 'order' field to a number, defaulting to 0 if not present or invalid.

package/src/form-plugin.ts

@@ -15,6 +15,7 @@ import {
 import { create } from 'xmlbuilder2'
 import { createSdkDocEntry, showGuidFieldDiagnostic } from './utils'
 import { NowIdShape } from './now-id-plugin'
+import { AnnotationType, Formatter } from '@servicenow/sdk-core/runtime/ui'
 
 const DEFAULT_VIEW = 'Default view'
 const DEFAULT_ANNOTATION_TYPE = '753f88a80f930000b12e6903cfe01206'
@@ -29,9 +30,6 @@ function buildReverseMap(ns: { [key: string]: string }): Map<string, string> {
     return map
 }
 
-//TODO:: Import AnnotationType and Formatter from sdk-api once Form plugin is fixed.
-const AnnotationType = {}
-const Formatter = {}
 const ANNOTATION_TYPE_MAP = buildReverseMap(AnnotationType)
 const FORMATTER_MAP = buildReverseMap(Formatter)
 

package/src/inbound-email-action-plugin.ts

@@ -0,0 +1,145 @@
+import { CallExpressionShape, Plugin, isGUID, type Shape, type ShapeTransform } from '@servicenow/sdk-build-core'
+import { NowIdShape } from './now-id-plugin'
+import { NowIncludeShape } from './now-include-plugin'
+import { ModuleFunctionShape } from './server-module-plugin'
+import { createSdkDocEntry, showGuidFieldDiagnostic } from './utils'
+import { parseString, convertRolesToString } from './service-catalog/utils'
+
+/**
+ * Plugin for handling Inbound Email Action records (sysevent_in_email_action).
+ *
+ * Default Behavior:
+ * - When reading from XML: If 'action' field is missing or empty, defaults to 'record_action'
+ * - When writing to Fluent: The 'action' field is required in the type definition for proper
+ *   discriminated union type narrowing
+ */
+export const InboundEmailActionPlugin = Plugin.create({
+    name: 'InboundEmailActionPlugin',
+    docs: [createSdkDocEntry('InboundEmailAction', ['sysevent_in_email_action'])],
+    records: {
+        sysevent_in_email_action: {
+            async toShape(record, { transform }) {
+                const actionType = record.get('action').getValue() || 'record_action'
+
+                // Process script
+                const script = await NowIncludeShape.fromRecord(record, record.get('script'), transform)
+
+                return {
+                    success: true,
+                    value: new CallExpressionShape({
+                        source: record,
+                        callee: 'InboundEmailAction',
+                        args: [
+                            record.transform(({ $ }) => {
+                                const props: Record<string, ShapeTransform | undefined> = {
+                                    $id: $.val(NowIdShape.from(record)),
+                                    name: $,
+                                    description: $.def(''),
+                                    type: $.def('new'),
+                                    action: $.val(actionType),
+                                    active: $.toBoolean().def(false),
+                                    order: $.toNumber().def(100),
+                                    eventName: $.from('event_name').def('email.read'),
+                                    stopProcessing: $.from('stop_processing').toBoolean().def(false),
+                                    conditionScript: $.from('condition_script').def(''),
+                                    filterCondition: $.from('filter_condition').def(''),
+                                    from: $.def(''),
+                                    requiredRoles: $.from('required_roles')
+                                        .map((v: Shape) => parseString(v))
+                                        .def([]),
+                                }
+
+                                props['replyEmail'] = $.from('reply_email').def('')
+                                props['table'] = $.def('')
+                                props['script'] = $.val(script).def('')
+                                props['fieldAction'] = $.from('template').def('')
+                                props['assignmentOperator'] = $.from('assignment_operator').def('')
+
+                                return props
+                            }),
+                        ],
+                    }),
+                }
+            },
+        },
+    },
+    shapes: [
+        {
+            shape: CallExpressionShape,
+            fileTypes: ['fluent'],
+            async toRecord(callExpression, { factory, diagnostics }) {
+                if (callExpression.getCallee() !== 'InboundEmailAction') {
+                    return { success: false }
+                }
+
+                const args = callExpression.getArgument(0).asObject()
+
+                // Get action type to validate field restrictions
+                const actionArg = args.get('action')
+                const actionType = actionArg?.getValue() ?? 'record_action'
+
+                // Validate that fieldAction can only be used when table is set (for record_action)
+                if (actionType === 'record_action') {
+                    const tableArg = args.get('table')
+                    const fieldActionArg = args.get('fieldAction')
+                    const hasTable = tableArg?.isDefined() && !tableArg.toString().isEmpty()
+                    const hasFieldAction = fieldActionArg?.isDefined() && !fieldActionArg.toString().isEmpty()
+
+                    if (hasFieldAction && !hasTable) {
+                        diagnostics.error(
+                            fieldActionArg,
+                            `Field 'fieldAction' can only be used when 'table' is specified.`
+                        )
+                    }
+                }
+
+                // Validate the 'from' field: must be a GUID string or a Record<'sys_user'>
+                const fromArg = args.get('from')
+                if (fromArg?.isDefined()) {
+                    // Validate that if it's a string, it must be a valid GUID
+                    if (fromArg.isString() && !fromArg.isRecord()) {
+                        const fromStr = fromArg.asString().getValue()
+                        if (fromStr !== '' && !isGUID(fromStr)) {
+                            showGuidFieldDiagnostic(fromArg, 'from', 'sys_user', diagnostics)
+                        }
+                    }
+                }
+
+                const record = await factory.createRecord({
+                    source: callExpression,
+                    table: 'sysevent_in_email_action',
+                    explicitId: args.get('$id'),
+                    properties: args.transform(({ $ }) => ({
+                        name: $,
+                        description: $.def(''),
+                        table: $,
+                        type: $.def('new'),
+                        action: $.def('record_action'),
+                        active: $.toBoolean().def(false),
+                        order: $.toNumber().def(100),
+                        event_name: $.from('eventName').def('email.read'),
+                        stop_processing: $.from('stopProcessing').toBoolean().def(false),
+                        script: $.map(
+                            (v: Shape) =>
+                                v
+                                    .if(ModuleFunctionShape)
+                                    ?.toString(
+                                        (n) => `${n}({{PARAMS}})`,
+                                        ['current', 'event', 'email', 'logger', 'classifier']
+                                    ) ?? v
+                        ).toCdata(),
+                        condition_script: $.from('conditionScript').toCdata().def(''),
+                        filter_condition: $.from('filterCondition').def(''),
+                        template: $.from('fieldAction').toCdata().def(''),
+                        from: $.toString(),
+                        reply_email: $.from('replyEmail').toCdata().def(''),
+                        required_roles: $.from('requiredRoles').map(convertRolesToString).def(''),
+                        assignment_operator: $.from('assignmentOperator').def(''),
+                    })),
+                })
+
+                return { success: true, value: record }
+            },
+        },
+    ],
+})

package/src/index.ts

@@ -24,6 +24,7 @@ export * from './data-plugin'
 export * from './ui-page-plugin'
 export * from './list-plugin'
 export * from './ui-action-plugin'
+export * from './form-plugin'
 export * from './script-include-plugin'
 export * from './arrow-function-plugin'
 export * from './atf/test-plugin'
@@ -34,6 +35,8 @@ export * from './service-portal/portal-plugin'
 export * from './service-portal/page-plugin'
 export * from './service-portal/theme-plugin'
 export * from './service-portal/menu-plugin'
+export * from './service-portal/header-footer-plugin'
+export * from './service-portal/page-route-map-plugin'
 export * from './rest-api-plugin'
 export * from './html-import-plugin'
 export * from './static-content-plugin'
@@ -57,6 +60,7 @@ export * from './import-sets-plugin'
 export * from './now-attach-plugin'
 export * from './sla-plugin'
 export * from './email-notification-plugin'
+export * from './inbound-email-action-plugin'
 
 export * from './service-catalog'
 export * from './ux-list-menu-config-plugin'

package/src/instance-scan-plugin.ts

@@ -19,11 +19,6 @@ export const InstanceScanPlugin = Plugin.create({
     ],
 
     records: {
-        scan_check: {
-            toShape() {
-                return { success: false }
-            },
-        },
         [SCAN_COLUMN_TYPE_CHECK]: {
             getUpdateName(record: Record, _context: Context) {
                 return { success: true, value: `${SCAN_COLUMN_TYPE_CHECK}_${record.getId().getValue()}` }

package/src/property-plugin.ts

@@ -70,7 +70,10 @@ export const PropertyPlugin = Plugin.create({
                 const name = prop.get('name').asString()
 
                 if (!isSNScope(scope) && config.scope !== 'global' && !name.asString().startsWith(`${scope}.`)) {
-                    diagnostics.warn(name.getOriginalNode(), `Property name normally begin with '${scope}.'`)
+                    diagnostics.warn(
+                        name.getOriginalNode(),
+                        `Property names should begin with '${scope}.' to match the app scope and avoid collisions with properties from other scopes`
+                    )
                 }
 
                 return {