@servicenow/sdk-build-plugins 4.3.0 → 4.4.1

package/src/flow/utils/service-catalog.ts

@@ -0,0 +1,174 @@
+import type { Database, Record, Shape, Source } from '@servicenow/sdk-build-core'
+import {
+    ArrayShape,
+    IdentifierShape,
+    PropertyAccessShape,
+    TemplateExpressionShape,
+    TemplateSpanShape,
+    isGUID,
+} from '@servicenow/sdk-build-core'
+import { getIdentifierFromRecord } from './utils'
+import {
+    CATALOG_VARIABLE_ACTIONS,
+    CORE_ACTIONS_SYS_ID_NAME_MAP,
+    CATALOG_ITEM_TABLE,
+    CATALOG_VARIABLE_TABLE,
+} from './flow-constants'
+
+/**
+ * Service Catalog Utility Functions
+ *
+ * This module contains utilities for transforming catalog item and catalog variable
+ * data between XML and Fluent formats, including:
+ * - Checking if an action is catalog-related
+ * - Finding catalog items by sys_id
+ * - Creating template expressions for catalog item references
+ * - Converting slushbucket format to catalog variable arrays
+ */
+
+/**
+ * Check if an action definition is a catalog-related action (getCatalogVariables or createCatalogTask).
+ * @param actionDefinition - The action definition shape
+ * @returns true if the action is getCatalogVariables or createCatalogTask, false otherwise
+ */
+export function isCatalogAction(actionDefinition: Shape | undefined): boolean {
+    const actionName = CORE_ACTIONS_SYS_ID_NAME_MAP[actionDefinition?.getValue() as string]
+    return actionName ? CATALOG_VARIABLE_ACTIONS.includes(actionName) : false
+}
+
+/**
+ * Helper function to find catalog item record by sys_id from database.
+ * @param sysId - The sys_id of the catalog item (must be 32 characters)
+ * @param database - Database instance to query
+ * @returns Catalog item record or undefined if not found
+ */
+export function findCatalogItemBySysId(sysId: string | undefined, database: Database | undefined): Record | undefined {
+    if (!database || !sysId || !isGUID(sysId)) {
+        return undefined
+    }
+    return database.get(CATALOG_ITEM_TABLE, sysId)
+}
+
+/**
+ * Helper function to create a template expression from an identifier.
+ * Creates: `${identifierName}`
+ */
+export function createTemplateExpressionFromIdentifier(
+    identifierName: string,
+    source: Source
+): TemplateExpressionShape {
+    return new TemplateExpressionShape({
+        source,
+        literalText: '',
+        spans: [
+            new TemplateSpanShape({
+                source,
+                expression: new IdentifierShape({ source, name: identifierName }),
+                literalText: '',
+            }),
+        ],
+    })
+}
+
+/**
+ * Helper function to create a PropertyAccessShape for a catalog variable reference.
+ * Creates: catalogItemIdentifierName.variables.varName
+ */
+export function createCatalogVariablePropertyAccess(
+    catalogItemRecord: Record,
+    catalogItemIdentifierName: string,
+    varName: string,
+    source: Source
+): PropertyAccessShape {
+    const catalogItemIdentifier = new IdentifierShape({
+        source: catalogItemRecord.getOriginalNode() || source,
+        name: catalogItemIdentifierName,
+        value: catalogItemRecord,
+    })
+    const variablesIdentifier = new IdentifierShape({
+        source,
+        name: 'variables',
+    })
+    const varNameIdentifier = new IdentifierShape({
+        source,
+        name: varName,
+    })
+
+    return new PropertyAccessShape({
+        source,
+        elements: [catalogItemIdentifier, variablesIdentifier, varNameIdentifier],
+    })
+}
+
+/**
+ * Convert slushbucket format (comma-separated sys_id:name pairs) to an array of catalog variable references.
+ * Example: "abc123:email,def456:html" → [catalogItem.variables.email, catalogItem.variables.html]
+ *
+ * @param slushBucketValue - Slushbucket string from XML
+ * @param catalogItemRecord - Catalog item record to look up variables
+ * @param source - Source for creating shapes
+ * @param actionInstanceUUID - UUID of the action instance (for label_cache lookup)
+ * @param flowRecord - Flow record containing label_cache
+ * @returns ArrayShape of PropertyAccessShape elements or undefined if conversion fails
+ */
+export function convertSlushBucketToCatalogVariableArray(
+    slushBucketValue: string,
+    catalogItemRecord: Record | undefined,
+    source: Source
+): ArrayShape | undefined {
+    if (!catalogItemRecord) {
+        return undefined
+    }
+
+    const variableShapes: PropertyAccessShape[] = []
+    const catalogItemIdentifierName = getIdentifierFromRecord(catalogItemRecord) || 'catalogItem'
+
+    //use slushbucket sys_ids to look up variable names
+    if (!slushBucketValue || !slushBucketValue.trim()) {
+        return undefined
+    }
+
+    const entries = slushBucketValue
+        .split(',')
+        .map((entry) => entry.trim())
+        .filter(Boolean)
+
+    // Build a map of sysId → record by iterating allRecords once
+    const variableRecordBySysId = new Map<string, Record>()
+    for (const rec of catalogItemRecord.flat()) {
+        if (rec.getTable() === CATALOG_VARIABLE_TABLE) {
+            variableRecordBySysId.set(rec.getId().getValue(), rec)
+        }
+    }
+
+    for (const entry of entries) {
+        const [sysId] = entry.split(':')
+        if (!sysId || !sysId.trim()) {
+            continue
+        }
+        const variableRecord = variableRecordBySysId.get(sysId)
+
+        if (variableRecord) {
+            const varName = variableRecord.get('name')?.asString()?.getValue()
+            if (varName) {
+                // Create PropertyAccessShape: catalogItemIdentifierName.variables.varName
+                const propertyAccess = createCatalogVariablePropertyAccess(
+                    catalogItemRecord,
+                    catalogItemIdentifierName,
+                    varName,
+                    source
+                )
+                variableShapes.push(propertyAccess)
+            }
+        }
+    }
+
+    if (variableShapes.length === 0) {
+        return undefined
+    }
+
+    return new ArrayShape({
+        source,
+        elements: variableShapes,
+    })
+}

package/src/index.ts

@@ -58,7 +58,6 @@ export * from './ux-list-menu-config-plugin'
 export * from './workspace-plugin'
 export * from './dashboard/dashboard-plugin'
 export * from './applicability-plugin'
-
 // non-plugins
 export * from './atf/step-configs'
 export { REPACK_OUTPUT_DIR, checkModuleExists, resolveModule } from './repack'

package/src/now-attach-plugin.ts

@@ -214,17 +214,23 @@ export const NowAttachPlugin = Plugin.create({
     records: {
         '*': {
             async toFile(record, { config, database, factory, transform }) {
+                const entries = record.entries()
+                const hasAttachments =
+                    entries.some(([, shape]) => isLazyValue(shape)) ||
+                    Object.keys(record.properties()).some((field) => hasAssociatedRecords(record.get(field)))
+
+                if (!hasAttachments) {
+                    return { success: false }
+                }
+
                 const recordBuilder = unloadBuilder(config)
                 const updateName = await transform.getUpdateName(record)
                 const builder = recordBuilder.record(record, updateName)
-                let attachmentsProcessed = false
 
-                record
-                    .entries()
+                entries
                     .sort(([a], [b]) => a.localeCompare(b)) // Sort keys to make outputs more deterministic
                     .forEach(([prop, shape]) => {
                         if (isLazyValue(shape)) {
-                            attachmentsProcessed = true
                             builder.field(prop, shape.evaluate(record, prop))
                         } else {
                             builder.field(prop, shape)
@@ -234,7 +240,6 @@ export const NowAttachPlugin = Plugin.create({
                 for (const field in record.properties()) {
                     const shape = record.get(field)
                     if (hasAssociatedRecords(shape)) {
-                        attachmentsProcessed = true
                         for (const rec of await shape.createAssociatedRecords({
                             parentRecord: record,
                             factory,
@@ -249,12 +254,6 @@ export const NowAttachPlugin = Plugin.create({
                     }
                 }
 
-                if (!attachmentsProcessed) {
-                    return {
-                        success: false,
-                    }
-                }
-
                 const claims = database
                     .query('sys_claim')
                     .filter((claim) => claim.get('metadata_update_name').equals(updateName))

package/src/now-ref-plugin.ts

@@ -24,7 +24,7 @@ export const NowRefPlugin = Plugin.create({
                     .getArgument(1)
                     .as(
                         [StringShape, ObjectShape],
-                        'The second argument to Now.ref() must be a GUID or a coalesce keys object'
+                        'The second argument to Now.ref() must be a GUID, a Now ID string, or a coalesce keys object'
                     )
                 const maybeKeys = callExpression.hasArgument(2)
                     ? callExpression

package/src/server-module-plugin/index.ts

@@ -19,7 +19,6 @@ import { SBOMBuilder } from './sbom-builder'
 import isEqual from 'lodash/isEqual'
 import { INVALID_XML_CHARACTERS, applyPathMappings } from '../utils'
 import zip from 'lodash/zip'
-import type { DependencyNode } from '@servicenow/sdk-repack'
 
 const GLUE_CODE_PREFIX = '// @fluent-module'
 const GLUE_CODE_META_REGEX = new RegExp(`^${GLUE_CODE_PREFIX} (.*);(true|false);(.*)`) // name;isDefault;path
@@ -32,7 +31,7 @@ const GLUE_CODE_WARNING = `
 // SDK from regenerating it. However, you will then be responsible for the
 // management of this code in your Fluent file.`
 
-const NODE_MODULES = 'node_modules'
+export const NODE_MODULES = 'node_modules'
 
 /**
  * Check if a module matches any trusted module patterns.
@@ -250,41 +249,7 @@ function isValidRequireCall(callExpression: ts.CallExpression, requirePath: ts.S
     return isRequire && !isRelativePath
 }
 
-function buildParentPathMap(dependencyNodes: DependencyNode[]): { [key: string]: string[] } {
-    const importerMap: { [key: string]: string[] } = {}
-    for (const node of dependencyNodes) {
-        let parent = node.parentPackage
-
-        while (parent) {
-            const importerMapKey = `${node.pkgName}@${node.updatedManifest.version}`
-            if (!importerMap[importerMapKey]) {
-                importerMap[importerMapKey] = []
-            }
-            if (parent.pkgName) {
-                importerMap[importerMapKey].push(parent.pkgName)
-            }
-
-            const newParent = dependencyNodes.find((potentialParent) => {
-                if (!parent || !parent.pkgName) {
-                    return false
-                }
-                if (potentialParent.updatedManifest.dependencies[parent!.pkgName]) {
-                    return potentialParent
-                }
-                return false
-            })
-            parent = newParent
-                ? {
-                      pkgName: newParent.updatedManifest.name,
-                      version: newParent.updatedManifest.version,
-                  }
-                : undefined
-        }
-    }
-    return importerMap
-}
-
-class ModuleDependencyShape extends Shape {
+export class ModuleDependencyShape extends Shape {
     private readonly moduleName: string
 
     constructor({
@@ -369,34 +334,16 @@ function generateSBOMContent(context: RecordContext) {
 
 function getModuleDependencyPath(
     config: NowConfig,
-    module: { name: string; file: string; version: string; packageJson: Package; importerPath?: string[] }
+    module: { name: string; file: string; version: string; packageJson: Package; modulePath?: string }
 ) {
-    const { name, file, packageJson, importerPath, version } = module
+    const { name, file, packageJson, modulePath, version } = module
 
     if (NowConfig.legacyPackageResolution(config)) {
         return NowConfig.moduleResolutionPath(config, packageJson, true, name, version, file)
     }
 
-    if (config.hoistDependencies) {
-        return NowConfig.moduleResolutionPath(config, packageJson, true, NODE_MODULES, name, file)
-    }
-
-    if (importerPath && importerPath.length > 0) {
-        const pathSegments = [...importerPath].reverse()
-        const pathSegmentsWithNodeModules: string[] = []
-        pathSegments.forEach((segment) => {
-            pathSegmentsWithNodeModules.push(NODE_MODULES)
-            pathSegmentsWithNodeModules.push(segment)
-        })
-        return NowConfig.moduleResolutionPath(
-            config,
-            packageJson,
-            true,
-            ...pathSegmentsWithNodeModules,
-            NODE_MODULES,
-            name,
-            file
-        )
+    if (modulePath) {
+        return NowConfig.moduleResolutionPath(config, packageJson, true, modulePath, file)
     }
 
     return NowConfig.moduleResolutionPath(config, packageJson, true, NODE_MODULES, name, file)
@@ -511,7 +458,8 @@ export const ServerModulePlugin = Plugin.create({
             shape: ModuleDependencyShape,
             fileTypes: ['module'],
             // TODO: When managed cache is provided to plugins, cache dependencies that were already handled to avoid reprocessing
-            async toRecord(shape, { packageJson, diagnostics, fs, logger, project, factory, config }) {
+            async toRecord(shape, context) {
+                const { packageJson, diagnostics, fs, logger, project, factory, config } = context
                 if (config.type === 'configuration') {
                     throw new Error(`Modules cannot be used in a configuration project`)
                 }
@@ -531,22 +479,24 @@ export const ServerModulePlugin = Plugin.create({
                 const dependencyNodes = await repack.execute({
                     id,
                     entry: entry ? [entry] : ['.'],
+                    legacyPackageResolution: NowConfig.legacyPackageResolution(config),
                 })
                 if (!dependencyNodes) {
                     throw new Error(`Failed to build dependency ${id}`)
                 }
 
-                let importerMap: { [key: string]: string[] } = {}
-                if (!config.hoistDependencies) {
-                    importerMap = buildParentPathMap(dependencyNodes)
-                }
-
                 const modules: { id: string; path: string; content: string }[] = []
                 const { Lint } = await import('../repack/lint/index.js')
                 for (const node of dependencyNodes) {
-                    const { packagePath, files, updatedManifest, pkgName } = node
+                    const { packagePath, files, updatedManifest, originalPath } = node
                     const { name, version } = updatedManifest
 
+                    const { modulePath, idPath } = buildDependencyPackagePath(
+                        project.getRootDir(),
+                        name,
+                        version,
+                        originalPath
+                    )
                     for (const file of files) {
                         const fileContent = fs.readFileSync(pathModule.join(packagePath, file)).toString('utf-8')
                         if (/(.js|.cjs|.mjs)$/.test(pathModule.extname(file))) {
@@ -557,15 +507,16 @@ export const ServerModulePlugin = Plugin.create({
                             }
                         }
 
-                        const importerPath = importerMap[`${pkgName}@${version}`]
                         modules.push({
-                            id: `${name}@${version}/${file}`,
+                            id: NowConfig.legacyPackageResolution(config)
+                                ? `${name}@${version}/${file}`
+                                : `${idPath}@${version}/${file}`,
                             path: getModuleDependencyPath(config, {
                                 name,
                                 file,
                                 version,
                                 packageJson,
-                                ...(importerPath ? { importerPath } : {}),
+                                modulePath,
                             }),
                             content: fileContent,
                         })
@@ -635,3 +586,42 @@ export const ServerModulePlugin = Plugin.create({
         },
     ],
 })
+
+/**
+ * Builds a relative dependency package path from an absolute path.
+ * Handles special cases for monorepo dependencies and pnpm-style paths.
+ *
+ * @param rootDir - The project root directory
+ * @param name - The package name
+ * @param version - The package version
+ * @param path - The absolute path to the package (optional)
+ * @returns Relative path suitable for module resolution
+ */
+function buildDependencyPackagePath(
+    rootDir: string,
+    name: string,
+    version: string,
+    path?: string
+): {
+    modulePath: string
+    idPath: string
+} {
+    let relative = pathModule.relative(rootDir, path ?? '')
+    const isMonorepoDependency = relative.includes(`../`)
+    const isPnpm = relative.includes('.pnpm')
+    if (isMonorepoDependency) {
+        // Treat monorepo node_modules as if they are inside app node_modules
+        relative = relative.replaceAll('../', '').replaceAll('+', '/')
+    }
+    if (isPnpm) {
+        // Do our best to turn this pnpm path into an npm path
+        relative = relative.replaceAll('+', '/').replaceAll(`node_modules/.pnpm/${name}@${version}/`, '')
+    }
+
+    // IDs will resemble the legacy paths and share sys_ids if possible
+    const idPath = relative.replaceAll('node_modules/', '').replaceAll('.pnpm/', '')
+    return {
+        modulePath: relative,
+        idPath,
+    }
+}

package/src/service-catalog/sc-record-producer-plugin.ts

@@ -162,7 +162,6 @@ export const CatalogItemRecordProducerPlugin = Plugin.create({
                 if (!validateVariableNameConflicts(arg, diagnostics, 'RecordProducer')) {
                     return { success: false }
                 }
-
                 const m2mRecords = await createSharedM2MRecords(callExpression, arg, recordProducer, factory)
 
                 if (arg.get('variables').isDefined()) {
@@ -172,6 +171,7 @@ export const CatalogItemRecordProducerPlugin = Plugin.create({
                         variablesConfig,
                         factory,
                         parent: recordProducer,
+                        parentArg: arg,
                         diagnostics,
                     })
 

package/src/service-catalog/service-catalog-base.ts

@@ -446,8 +446,8 @@ export function transformCatalogItemSpecificFieldsToRecord(arg: ObjectShape, $:
             .toCdata()
             .def(''),
         request_method: $.from('requestMethod')
-            .map((v: Shape) => (v.ifString()?.getValue() === '' ? undefined : v.getValue()))
-            .def('order'),
+            .map((v: Shape) => (v.ifString()?.getValue() === 'order' ? '' : v.getValue()))
+            .def(''),
         no_cart_v2: $.from('hideAddToCart').def(false),
         no_quantity_v2: $.from('hideQuantitySelector').def(false),
         no_delivery_time_v2: $.from('hideDeliveryTime').def(false),

package/src/service-catalog/service-catalog-diagnostics.ts

@@ -7,7 +7,10 @@ import type { Diagnostics, ObjectShape } from '@servicenow/sdk-build-core'
  */
 export function validateFulfillmentProcessExclusivity(arg: ObjectShape, diagnostics: Diagnostics): boolean {
     const fields = ['executionPlan', 'flow', 'workflow'] as const
-    const defined = fields.filter((f) => arg.get(f).isDefined() && !arg.get(f).ifString()?.isEmpty())
+    const defined = fields.filter((f) => {
+        const val = arg.get(f)
+        return val.isDefined() && (!!val.ifRecordId() || !val.ifString()?.isEmpty())
+    })
 
     if (defined.length > 1) {
         diagnostics.error(

package/src/service-catalog/shape-to-record.ts

@@ -7,7 +7,7 @@ import {
 } from '@servicenow/sdk-build-core'
 import { getVariableTypeFromName } from './variable-helper'
 import { VariableTypeName } from './variable-helper'
-import { convertRolesToString, getVisibilityId } from './utils'
+import { convertRolesToString, getVisibilityId, validateFieldNameBelongsToTable } from './utils'
 import {
     validateMapToFieldRequiresField,
     validateMandatoryReadOnlyHidden,
@@ -20,8 +20,9 @@ export async function buildVariableRecords(options: {
     diagnostics: Diagnostics
     variablesConfig: ObjectShape
     parent: Record
+    parentArg?: ObjectShape
 }): Promise<Record[]> {
-    const { variablesConfig, factory, parent, diagnostics } = options
+    const { variablesConfig, factory, parent, diagnostics, parentArg } = options
     const records: Record[] = []
     let catItemRecord: Record
     let variableSetRecord: Record
@@ -31,6 +32,9 @@ export async function buildVariableRecords(options: {
     if (parent?.getTable() === 'item_option_new_set') {
         variableSetRecord = parent
     }
+    if (parent?.getTable() === 'sc_cat_item_producer' && parentArg) {
+        validateFieldNameBelongsToTable(parentArg, diagnostics, 'RecordProducer')
+    }
 
     // Convert entries to array to use for-of loop
     const entries = Array.from(variablesConfig.entries())

package/src/service-catalog/utils.ts

@@ -1360,3 +1360,96 @@ export function resolveAndValidateVariableId(
 
     return variableId
 }
+
+/**
+ * Validates that each variable's 'field' value (when 'mapToField' is true) belongs to the record producer's target table.
+ * Resolves the table record from arg.get('table'), collects field names from sys_documentation descendants via .flat(),
+ * and checks each variable's 'field' against those keys.
+ * @param arg - The ObjectShape containing the record producer configuration
+ * @param diagnostics - Diagnostics instance for reporting errors
+ * @param context - Context where the validation is being performed ('RecordProducer')
+ * @returns True if all mapped fields belong to the table, false otherwise
+ */
+export function validateFieldNameBelongsToTable(arg: ObjectShape, diagnostics: Diagnostics, context: string): boolean {
+    if (!arg.get('variables').isDefined()) {
+        return true
+    }
+
+    // Resolve the table record from arg.get('table')
+    // table can be a direct record reference (IdentifierShape) or a plain string table name
+    const tableShape = arg.get('table')
+
+    let tableRecord: Record | undefined
+
+    if (tableShape.isRecord()) {
+        tableRecord = tableShape.asRecord()
+    } else if (tableShape.is(IdentifierShape)) {
+        const resolved = tableShape.as(IdentifierShape).resolve(true)
+        if (resolved?.isRecord()) {
+            tableRecord = resolved.asRecord()
+        }
+    }
+
+    // Collect field names from sys_documentation descendants via .flat() (only when table resolves to a record)
+    let tableFieldSet: Set<string> | undefined
+
+    if (tableRecord) {
+        const tableFields = tableRecord
+            .flat()
+            .filter((r: Record) => r.getTable() === 'sys_dictionary')
+            .map((r: Record) => r.get('element')?.ifString()?.getValue())
+            .filter((element): element is string => !!element)
+
+        if (tableFields.length > 0) {
+            tableFieldSet = new Set(tableFields)
+        }
+    }
+
+    // Iterate over variables and validate field names for those with mapToField: true
+    const variablesConfig = arg.get('variables').asObject()
+    const entries = Array.from(variablesConfig.entries())
+
+    // Track which fields have already been mapped to detect duplicates (always enforced)
+    const mappedFields = new Map<string, string>() // field -> first variableKey that mapped it
+
+    for (const [variableKey, value] of entries) {
+        const callExpr = value.as(CallExpressionShape)
+        const config = callExpr.getArgument(0).asObject()
+
+        const mapToField = config.get('mapToField')
+        const isMapToFieldTrue = mapToField.isDefined() && mapToField.ifBoolean()?.getValue() === true
+
+        if (!isMapToFieldTrue) {
+            continue
+        }
+
+        const fieldShape = config.get('field')
+        const fieldValue = fieldShape.isDefined() ? fieldShape.ifString()?.getValue() : undefined
+
+        if (!fieldValue) {
+            continue
+        }
+
+        // Check field belongs to table (only when table resolved to a record with sys_documentation)
+        if (tableFieldSet && !tableFieldSet.has(fieldValue)) {
+            diagnostics.error(
+                fieldShape,
+                `${context} variable '${variableKey}': field '${fieldValue}' does not belong to the target table. Valid fields are: ${[...tableFieldSet].join(', ')}.`
+            )
+            return false
+        }
+
+        // Check if this field is already mapped by another variable (always enforced)
+        const existingVariable = mappedFields.get(fieldValue)
+        if (existingVariable) {
+            diagnostics.error(
+                fieldShape,
+                `${context} variable '${variableKey}': field '${fieldValue}' is already mapped by variable '${existingVariable}'. Each table field can only be mapped by one variable.`
+            )
+            return false
+        }
+        mappedFields.set(fieldValue, variableKey)
+    }
+
+    return true
+}

package/src/static-content-plugin.ts

@@ -71,6 +71,20 @@ const attachmentRelationships = {
     },
 }
 
+const sourceArtifactRelationships = {
+    sn_glider_source_artifact_m2m: {
+        via: 'application_file',
+        descendant: true,
+        relationships: {
+            sn_glider_source_artifact: {
+                via: 'source_artifact',
+                inverse: true,
+                descendant: true,
+            },
+        },
+    },
+}
+
 const toNoOpShape = (record: Record) => {
     return { success: true, value: Shape.noOp(record) }
 }
@@ -87,9 +101,14 @@ export const StaticContentPlugin = Plugin.create({
             toShape: toNoOpShape,
         },
         sys_ux_lib_asset: {
-            relationships: attachmentRelationships,
+            coalesce: ['name'],
+            relationships: { ...attachmentRelationships, ...sourceArtifactRelationships },
             toShape: toNoOpShape,
-            toFile: multipleRecordsToFile,
+            toFile: async (mainRecord, context) => {
+                const existingRelated = mainRecord.flat().slice(1)
+                const m2mRecords = context.descendants.query('sn_glider_source_artifact_m2m')
+                return multipleRecordsToFile(mainRecord.with(...existingRelated, ...m2mRecords), context)
+            },
         },
         db_image: {
             relationships: attachmentRelationships,
@@ -142,6 +161,10 @@ export const StaticContentPlugin = Plugin.create({
                 })
                 if (mimeType === 'text/html') {
                     // This content will be handled by the UiPage referencing it
+                } else if (relativePath.endsWith('.ui-source-manifest.json')) {
+                    // Build-time manifest produced by the uiPageSourceManifest rollup plugin.
+                    // Consumed by UiPage during build to determine which source files to include
+                    // in the source artifact record. Not a deployable asset.
                 } else if (mimeType === 'application/javascript') {
                     tableName = 'sys_ux_lib_asset'
                     assetName = pathModule.join(