@servicenow/sdk-build-core 4.7.2 → 4.8.1

package/src/compiler.ts

@@ -342,13 +342,17 @@ declare module '*.html' {
         return this.generatedTableFilePath === sourcePath
     }
 
-    // Cache for table column types that need coercion (boolean/number only).
-    // Populated on first call to getTableColumnTypes(); subsequent calls return immediately.
+    // Caches populated by resolveDataTypeProperties() on first access per table.
     private tableColumnTypesCache = new Map<string, Map<string, 'boolean' | 'number' | 'array' | 'array-optional'>>()
+    private mandatoryColumnsCache = new Map<string, Set<string>>()
 
-    getTableColumnTypes(tableName: string): Map<string, 'boolean' | 'number' | 'array' | 'array-optional'> | undefined {
+    /**
+     * Resolves Data<T> for the given table and populates both the column-type
+     * coercion cache and the mandatory-columns cache in a single pass.
+     */
+    private resolveDataTypeProperties(tableName: string): void {
         if (this.tableColumnTypesCache.has(tableName)) {
-            return this.tableColumnTypesCache.get(tableName)
+            return
         }
 
         const tempFilePath = path.join(this.rootDir, 'src', '$$TEMP_DATA_RESOLVER$$.ts')
@@ -362,14 +366,19 @@ declare module '*.html' {
         try {
             const typeAlias = tempSource.getTypeAlias('T')
             if (!typeAlias) {
-                return undefined
+                return
             }
 
             const resolvedType = typeAlias.getType()
             const properties = resolvedType.getProperties()
             const columnTypes = new Map<string, 'boolean' | 'number' | 'array' | 'array-optional'>()
+            const mandatoryColumns = new Set<string>()
 
             properties.forEach((property) => {
+                if (!property.isOptional()) {
+                    mandatoryColumns.add(property.getName())
+                }
+
                 const propType = property.getTypeAtLocation(typeAlias)
                 const typeText = propType.getText()
 
@@ -383,12 +392,22 @@ declare module '*.html' {
             })
 
             this.tableColumnTypesCache.set(tableName, columnTypes)
-            return columnTypes
+            this.mandatoryColumnsCache.set(tableName, mandatoryColumns)
         } finally {
             this.removeSourceFile(tempSource)
         }
     }
 
+    getTableColumnTypes(tableName: string): Map<string, 'boolean' | 'number' | 'array' | 'array-optional'> | undefined {
+        this.resolveDataTypeProperties(tableName)
+        return this.tableColumnTypesCache.get(tableName)
+    }
+
+    getMandatoryColumns(tableName: string): Set<string> | undefined {
+        this.resolveDataTypeProperties(tableName)
+        return this.mandatoryColumnsCache.get(tableName)
+    }
+
     private createModuleProject(fs: FileSystem, tsConfigPath?: string) {
         return new ts.Project({
             fileSystem: new TsMorphFileSystemWrapper(fs),

package/src/compression.ts

@@ -1,4 +1,5 @@
-import { ZipDeflate, unzipSync, zipSync, gunzip as callbackGunzip, Zip, gzipSync, gunzipSync } from 'fflate'
+import { unzipSync, zipSync, gunzip as callbackGunzip, gzipSync, gunzipSync } from 'fflate'
+import type { Zippable } from 'fflate'
 import { FileSystem, TsMorphFileSystemWrapper } from './fs'
 import type { Logger } from './logger'
 import { path } from './path'
@@ -9,7 +10,8 @@ export const unzipAppPackage = async (
     fs: FileSystem,
     zipPath: string,
     targetPath: string,
-    logger?: Logger
+    logger?: Logger,
+    ignore?: (filename: string) => boolean
 ): Promise<{ files: string[] }> => {
     const zipArrBuf = new Uint8Array(fs.readFileSync(zipPath))
     const unzipResult = unzipSync(zipArrBuf)
@@ -31,72 +33,51 @@ export const unzipAppPackage = async (
         delete unzipResult[ZIP_STATUS_FILE]
     }
 
-    const files = Object.entries(unzipResult).map(([filePath, data]) => {
+    const files: string[] = []
+    for (const [filePath, data] of Object.entries(unzipResult)) {
+        const filename = path.basename(filePath)
+
+        if (ignore?.(filename)) {
+            logger?.info(`Skipping file ${filename} due to excludeFilePatterns`)
+            continue
+        }
+
         const fullPath = path.join(targetPath, filePath)
 
         // Create directories if necessary
-        const dir = path.dirname(fullPath)
-        FileSystem.ensureDirSync(fs, dir)
+        FileSystem.ensureDirSync(fs, path.dirname(fullPath))
 
         // Write file content to the filesystem
         fs.writeFileSync(fullPath, data)
 
-        return fullPath
-    })
+        files.push(fullPath)
+    }
 
     return { files }
 }
 
 export const zipDirectory = async (fs: FileSystem, source: string, destination: string): Promise<string> => {
-    return new Promise<string>((resolve, reject) => {
-        try {
-            const z = new Zip()
-
-            const outputStream = FileSystem.createWriteStream(fs, destination)
-
-            z.ondata = (err, data, final) => {
-                if (err) {
-                    outputStream.destroy()
-                    reject(err)
-                } else {
-                    outputStream.write(data)
-                    if (final) {
-                        outputStream.end()
-                    }
-                }
-            }
-
-            outputStream.on('finish', () => {
-                resolve(destination)
-            })
-
-            outputStream.on('error', (error) => {
-                reject(error)
-            })
-
-            // Using our own glob for browser compatibility
-            const wrappedFs = new TsMorphFileSystemWrapper(fs)
-            const files = wrappedFs.globSync(['**'], {
-                cwd: source,
-            })
+    // Using our own glob for browser compatibility
+    const wrappedFs = new TsMorphFileSystemWrapper(fs)
+    const files = wrappedFs.globSync(['**'], {
+        cwd: source,
+    })
 
-            if (files.length === 0) {
-                reject(`No files found in ${source} directory to create zip.`)
-            }
+    if (files.length === 0) {
+        throw new Error(`No files found in ${source} directory to create zip.`)
+    }
 
-            for (const file of files) {
-                const fp = path.normalize(file)
-                const data = fs.readFileSync(fp)
-                const zf = new ZipDeflate(fp.replace(source, ''), { level: 6 })
-                z.add(zf)
-                zf.push(data, true)
-            }
+    const fileMap: Zippable = {}
+    for (const file of files) {
+        const fp = path.normalize(file)
+        const data = new Uint8Array(fs.readFileSync(fp))
+        const entryName = fp.replace(source, '')
+        fileMap[entryName] = [data, { level: 6 }]
+    }
 
-            z.end()
-        } catch (err) {
-            reject(err)
-        }
-    })
+    const zipped = zipSync(fileMap)
+    fs.writeFileSync(destination, zipped)
+    return destination
 }
 
 const gunzip = (data: Uint8Array) =>

package/src/glob.ts

@@ -0,0 +1,20 @@
+/**
+ * Converts a glob pattern to a RegExp.
+ * Supports `*` (match within a path segment), `**` (match across segments), and `?` (single character).
+ */
+function globToRegex(pattern: string): RegExp {
+    const escaped = pattern
+        .replace(/[.+^${}()|[\]\\]/g, '\\$&') // escape regex special chars (not * or ?)
+        .replace(/\*\*/g, '\0') // placeholder for **
+        .replace(/\*/g, '[^/]*') // * → match within segment
+        .replace(/\0/g, '.*') // ** → match across segments
+        .replace(/\?/g, '[^/]') // ? → single char within segment
+    return new RegExp(`^${escaped}$`)
+}
+
+/**
+ * Returns true if `str` matches any of the provided glob patterns.
+ */
+export function matchesGlob(str: string, patterns: string[]): boolean {
+    return patterns.some((pattern) => globToRegex(pattern).test(str))
+}

package/src/index.ts

@@ -22,3 +22,4 @@ export * from './formatter'
 export * from './telemetry'
 export * from './claims'
 export * from './taxonomy'
+export * from './glob'

package/src/now-config.ts

@@ -254,6 +254,7 @@ const NowConfigSchema = z
         npmUpdateCheck: z.literal(false).or(z.number()).default(10),
         dependencies: dependenciesSchema,
         ignoreTransformTableList: z.array(z.string()).default([]),
+        excludeFilePatterns: z.array(z.string()).default([]),
         trustedModules: z.array(z.string()).default([]),
         tsconfigPath: z.string().optional(),
         scripts: z.record(z.string(), z.string()).default({}),
@@ -309,6 +310,7 @@ const NowConfigSchema = z
         type: z.enum(['configuration', 'package']).default('package'),
         taxonomy,
         hostedPlugins: z.record(z.string(), z.string()).optional(),
+        sysCode: z.string().optional(),
 
         // Application Runtime Policy (ARP) fields
         applicationRuntimePolicy: z.enum(['none', 'tracking', 'enforcing']).default('none'),
@@ -329,6 +331,7 @@ const NowConfigSchema = z
                 | 'npmUpdateCheck'
                 | 'dependencies'
                 | 'ignoreTransformTableList'
+                | 'excludeFilePatterns'
                 | 'trustedModules'
                 | 'modulePaths'
                 | 'serverModulesIncludePatterns'
@@ -354,6 +357,7 @@ const NowConfigSchema = z
                 | 'type'
                 | 'taxonomy'
                 | 'hostedPlugins'
+                | 'sysCode'
                 | 'applicationRuntimePolicy'
                 | 'networkPolicies'
                 | 'wildcardPolicy'

package/src/package-inventory.ts

@@ -14,7 +14,7 @@ export interface PackageInventoryConfig {
  */
 export async function sha256(content: string | Uint8Array): Promise<string> {
     const data = typeof content === 'string' ? new TextEncoder().encode(content) : content
-    const hashBuffer = await crypto.subtle.digest('SHA-256', data)
+    const hashBuffer = await crypto.subtle.digest('SHA-256', data as BufferSource)
     const hashArray = Array.from(new Uint8Array(hashBuffer))
     return hashArray.map((b) => b.toString(16).padStart(2, '0')).join('')
 }

package/src/plugins/plugin.ts

@@ -19,7 +19,7 @@ import type { File, OutputFile } from './file'
 import type { Product } from './product'
 import { Database, DiffDatabase } from './database'
 import type { Context as BaseContext, Diagnostics } from './context'
-import { getFileType, isSNScope } from '../util'
+import { getConditionalPluginDir, getFileType, isSNScope } from '../util'
 import { NOW_FILE_EXTENSION, NowConfig } from '..'
 import { path } from '@servicenow/sdk-build-core'
 
@@ -839,6 +839,23 @@ export class Plugin {
         return this.traverseDescendants(parent, database)
     }
 
+    /**
+     * Determines whether the conditional directory of a (if/hosted) child matches that of it's parent.
+     */
+    private isMixedConditionalChild(parent: Record, child: Record): boolean {
+        const parentPlugin = getConditionalPluginDir(parent.getOriginalFilePath())
+        const childPlugin = getConditionalPluginDir(child.getOriginalFilePath())
+        if (!parentPlugin && !childPlugin) {
+            return false
+        } else if (!parentPlugin || !childPlugin) {
+            return true
+        }
+
+        // both conditional - the child belongs to this parent only if they
+        // target the same conditional plugin (the if/<plugin> or hosted_plugins/<plugin> segment)
+        return parentPlugin !== childPlugin
+    }
+
     private traverseDescendants(parent: Record, database: Database, visited: Set<string> = new Set()): Record[] {
         visited.add(parent.getId().getValue())
 
@@ -848,7 +865,7 @@ export class Plugin {
         const descendants: Record[] = []
         const push = (children: Record | Record[] | undefined) => {
             for (const child of [children].flat()) {
-                if (child && !visited.has(child.getId().getValue())) {
+                if (child && !visited.has(child.getId().getValue()) && !this.isMixedConditionalChild(parent, child)) {
                     visited.add(child.getId().getValue())
                     descendants.push(child)
                     descendants.push(...this.traverseDescendants(child, database, visited))

package/src/plugins/post-install.ts

@@ -27,8 +27,16 @@ export type InstanceClient = {
     fetch(path: string, init?: RequestInit, params?: URLSearchParams): Promise<Response>
 }
 
+export type RecordEntry = {
+    sys_id: string
+    active: string
+    state: string
+}
+
 export type PostInstallContext = {
     instanceClient?: InstanceClient
     logger: Logger
     config: { scopeId: string; scope: string; [key: string]: unknown }
+    /** Map of table name → array of record entries from the project's keys registry */
+    recordIds?: Record<string, RecordEntry[]>
 }

package/src/plugins/shape.ts

@@ -658,6 +658,20 @@ export class TemplateSpanShape extends StringShape {
         return `${substitution instanceof Shape ? substitution.getValue() : typeof substitution === 'function' ? substitution(this.expression) : (substitution ?? this.expression.toString().getValue())}${this.literalText}`
     }
 
+    /**
+     * Override equals to compare literal text and expression code instead of
+     * rendered values. The base getValue() resolves expressions via
+     * toString().getValue() which produces identical strings for structurally
+     * different CallExpressionShape instances, causing the commit system to
+     * incorrectly skip updates.
+     */
+    override equals(other: unknown): boolean {
+        if (other instanceof TemplateSpanShape) {
+            return this.literalText === other.literalText && this.expression.getCode() === other.expression.getCode()
+        }
+        return super.equals(other)
+    }
+
     override getCode(): string {
         return `$\{${this.expression.getCode()}}${StringShape.escapeBackticks(this.literalText)}`
     }
@@ -697,6 +711,20 @@ export class TemplateExpressionShape extends StringShape {
         return `${this.literalText}${this.spans.map((s, i) => s.getValue(typeof substitutions === 'function' ? substitutions : substitutions?.[i])).join('')}`
     }
 
+    /**
+     * Override equals to compare literal text and spans structurally instead of
+     * using rendered getValue() strings. See TemplateSpanShape.equals() for details.
+     */
+    override equals(other: unknown): boolean {
+        if (other instanceof TemplateExpressionShape) {
+            if (this.literalText !== other.literalText || this.spans.length !== other.spans.length) {
+                return false
+            }
+            return this.spans.every((span, i) => span.equals(other.spans[i]))
+        }
+        return super.equals(other)
+    }
+
     override getCode(): string {
         return `\`${StringShape.escapeBackticks(this.literalText)}${this.spans.map((s) => s.getCode()).join('')}\``
     }

package/src/plugins/time.ts

@@ -175,6 +175,14 @@ export function parseDateTime(dateTimeStr: string) {
     return undefined
 }
 
+/**
+ * Convert a Duration object to the platform's epoch-relative datetime string.
+ * E.g. `{ days: 4, hours: 3, minutes: 2, seconds: 1 }` → `'1970-01-05 03:02:01'`
+ */
+export function formatDuration(duration: Duration): string {
+    return formatDateToPlatformFormat(durationFieldToXML(duration))
+}
+
 /**
  * Convert a Duration object to a Date for glide_duration fields.
  * Duration fields are timezone-agnostic (they represent a span of time),

package/src/taxonomy.ts

@@ -37,6 +37,15 @@ const TableNames = {
     SYS_FLOW_KNOWLEDGE_TRIGGER: 'sys_flow_knowledge_trigger',
     SYS_FLOW_RT_QUERY_TRIGGER: 'sys_flow_rt_query_trigger',
     SYS_FLOW_TRIGGER: 'sys_flow_trigger',
+    SYS_HUB_STEP_INSTANCE: 'sys_hub_step_instance',
+    SYS_HUB_STEP_EXT_INPUT: 'sys_hub_step_ext_input',
+    SYS_HUB_STEP_EXT_OUTPUT: 'sys_hub_step_ext_output',
+    SYS_HUB_ACTION_INPUT: 'sys_hub_action_input',
+    SYS_HUB_ACTION_OUTPUT: 'sys_hub_action_output',
+    SYS_HUB_ACTION_STATUS_METADATA: 'sys_hub_action_status_metadata',
+    SYS_HUB_STATUS_CONDITION: 'sys_hub_status_condition',
+    SYS_HUB_ACTION_TYPE_SNAPSHOT: 'sys_hub_action_type_snapshot',
+    SYS_HUB_ACTION_PLAN: 'sys_hub_action_plan',
 
     // Client Development tables
     DL_U_ASSIGNMENT: 'dl_u_assignment',
@@ -250,7 +259,6 @@ const taxonomyMapping = z
         [TableNames.SYS_FLOW_TRIGGER]: taxonomyItem.default('automation/trigger'),
         [TableNames.SYS_HUB_FLOW]: flowTaxonomyItem,
         [TableNames.SYS_HUB_ACTION_TYPE_DEFINITION]: flowTaxonomyItem,
-        [TableNames.SYS_ELEMENT_MAPPING]: flowTaxonomyItem,
         [TableNames.SYS_HUB_FLOW_INPUT]: flowTaxonomyItem,
         [TableNames.SYS_HUB_FLOW_OUTPUT]: flowTaxonomyItem,
         [TableNames.SYS_HUB_ACTION_INPUT_ACTION_INSTANCE]: flowTaxonomyItem,
@@ -270,6 +278,15 @@ const taxonomyMapping = z
         [TableNames.SYS_FLOW_TRIGGER_PLAN]: flowTaxonomyItem,
         [TableNames.SYS_HUB_FLOW_SNAPSHOT]: flowTaxonomyItem,
         [TableNames.SYS_FLOW_SUBFLOW_PLAN]: flowTaxonomyItem,
+        [TableNames.SYS_HUB_STEP_INSTANCE]: flowTaxonomyItem,
+        [TableNames.SYS_HUB_STEP_EXT_INPUT]: flowTaxonomyItem,
+        [TableNames.SYS_HUB_STEP_EXT_OUTPUT]: flowTaxonomyItem,
+        [TableNames.SYS_HUB_ACTION_INPUT]: flowTaxonomyItem,
+        [TableNames.SYS_HUB_ACTION_OUTPUT]: flowTaxonomyItem,
+        [TableNames.SYS_HUB_ACTION_STATUS_METADATA]: flowTaxonomyItem,
+        [TableNames.SYS_HUB_STATUS_CONDITION]: flowTaxonomyItem,
+        [TableNames.SYS_HUB_ACTION_TYPE_SNAPSHOT]: flowTaxonomyItem,
+        [TableNames.SYS_HUB_ACTION_PLAN]: flowTaxonomyItem,
 
         // Client Development tables
         [TableNames.DL_U_ASSIGNMENT]: taxonomyItem.default('client-development/assignment-data-lookup'),

package/src/telemetry/clients/abstract-client.ts

@@ -15,9 +15,12 @@ export abstract class AbstractAppSeeClient implements Telemetry {
     protected readonly sdkVersion?: string | undefined
     protected readonly clientName: 'cli' | 'ide' | string
     protected readonly hostname?: string | undefined
+    protected readonly codingAgent?: string | undefined
     protected session?: Session
     protected startPromise?: Promise<void>
     protected userId?: string
+    private lastEventTimestamp = 0
+    private configReceivedTime?: string
 
     constructor(
         protected readonly config: InstanceSettings,
@@ -25,11 +28,19 @@ export abstract class AbstractAppSeeClient implements Telemetry {
             sdkVersion?: string
             clientName: 'cli' | 'ide' | string
             hostname?: string
+            codingAgent?: string
         }
     ) {
         this.sdkVersion = telemetryAttributes.sdkVersion
         this.clientName = telemetryAttributes.clientName
         this.hostname = telemetryAttributes.hostname
+        this.codingAgent = telemetryAttributes.codingAgent
+    }
+
+    private nextTimestamp(): number {
+        const now = Date.now()
+        this.lastEventTimestamp = now > this.lastEventTimestamp ? now : this.lastEventTimestamp + 1
+        return this.lastEventTimestamp
     }
 
     startTimerEvent(name: TelemetryEvent['name']): TimerMetric {
@@ -77,19 +88,18 @@ export abstract class AbstractAppSeeClient implements Telemetry {
 
             const defaultValues = this.getDefaultDataValues()
             const eventData = Array.isArray(events) ? events : [events]
-            const now = Date.now()
             const hostname = this.hostname ? { hostname: this.hostname } : {}
 
             const dataPoints = eventData.map<Datapoint>((d) => ({
                 t: DatapointType.Event,
-                d: now,
+                d: this.nextTimestamp(),
                 n: d.name,
                 p: { scopeId: d.appInfo?.scopeId, ...hostname, ...defaultValues, ...d.data },
             }))
 
             dataPoints.push({
                 t: DatapointType.User,
-                d: now,
+                d: this.nextTimestamp(),
                 n: this.userId ?? 'unknown',
                 p: this.getUserProps(hostname),
             })
@@ -99,7 +109,7 @@ export abstract class AbstractAppSeeClient implements Telemetry {
                 DataPoints: dataPoints,
                 TabId: this.session.TabId || '0',
                 ClientTime: new Date().toISOString(),
-                ConfigReceivedTime: new Date().toISOString(),
+                ConfigReceivedTime: this.configReceivedTime ?? new Date().toISOString(),
             }
 
             fetch(new URL('/web/heartbeat', this.config.BaseUrl), {
@@ -150,6 +160,7 @@ export abstract class AbstractAppSeeClient implements Telemetry {
             const bodyResponse = await response.json()
             if (response.ok) {
                 this.session = { ...bodyResponse, TabId: tabId }
+                this.configReceivedTime = new Date().toISOString()
             } else {
                 throw new Error(`Failed to start session with status ${response.status}: ${bodyResponse.Error}`)
             }

package/src/telemetry/clients/browser-client.ts

@@ -9,6 +9,7 @@ export class BrowserTelemetryClient extends AbstractAppSeeClient {
             clientName?: 'ide' | string
             hostname?: string
             ideVersion?: string
+            codingAgent?: string
         }
     ) {
         const { ideVersion, ...baseAttributes } = telemetryAttributes ?? {}
@@ -68,6 +69,7 @@ export class BrowserTelemetryClient extends AbstractAppSeeClient {
             version: this.sdkVersion || 'unknown',
             clientName: this.clientName,
             ideVersion: this.ideVersion || 'unknown',
+            ...(this.codingAgent ? { codingAgent: this.codingAgent } : {}),
         }
     }
 

package/src/telemetry/clients/node-client.ts

@@ -7,7 +7,12 @@ import { detectCodingAgent, detectIde } from './detect-agent'
 export class NodeTelemetryClient extends AbstractAppSeeClient {
     constructor(
         config: InstanceSettings,
-        telemetryAttributes?: { sdkVersion?: string; clientName?: 'cli' | string; hostname?: string }
+        telemetryAttributes?: {
+            sdkVersion?: string
+            clientName?: 'cli' | string
+            hostname?: string
+            codingAgent?: string
+        }
     ) {
         super(config, {
             ...(telemetryAttributes ?? {}),
@@ -44,9 +49,13 @@ export class NodeTelemetryClient extends AbstractAppSeeClient {
         const env = process.env
         const agentData: TelemetryEventData<{ codingAgent?: string; ide?: string }> = {}
 
-        const codingAgent = detectCodingAgent(env)
-        if (codingAgent) {
-            agentData.codingAgent = codingAgent
+        if (this.codingAgent) {
+            agentData.codingAgent = this.codingAgent
+        } else {
+            const codingAgent = detectCodingAgent(env)
+            if (codingAgent) {
+                agentData.codingAgent = codingAgent
+            }
         }
         const ide = detectIde(env, process.platform)
         if (ide) {

package/src/telemetry/factory.ts

@@ -8,7 +8,13 @@ import { getAppSeeConfig } from './config'
 export class TelemetryFactory {
     static create(options?: {
         type?: 'node' | 'browser'
-        attributes?: { sdkVersion?: string; clientName?: string; hostname?: string; ideVersion?: string }
+        attributes?: {
+            sdkVersion?: string
+            clientName?: string
+            hostname?: string
+            ideVersion?: string
+            codingAgent?: string
+        }
     }): Telemetry {
         if (process.env['NODE_ENV'] === 'test' || !options || !options.type) {
             return new NoOpTelemetry()

package/src/util/conditional-dir.ts

@@ -0,0 +1,19 @@
+const CONDITIONAL_MARKERS = ['if', 'hosted_plugins'] as const
+
+/**
+ * Extracts the conditional plugin directory from a file path — the `if` or
+ * `hosted_plugins` marker plus the plugin segment that follows it (e.g.
+ * `if/com.plugin` from `.../if/com.plugin/update/x.xml`, or
+ * `hosted_plugins/com.plugin` from `.../hosted_plugins/com.plugin/...`).
+ *
+ * Two conditional records belong to the same app only when this value matches,
+ * so it is used both for grouping descendants and for detecting conditional
+ * conflicts. Returns undefined when the path is not under a conditional directory.
+ *
+ * Matches either path separator so it behaves the same on POSIX and Windows.
+ */
+export function getConditionalPluginDir(filePath: string): string | undefined {
+    const marker = `(${CONDITIONAL_MARKERS.join('|')})`
+    const match = filePath.match(new RegExp(`[/\\\\]${marker}[/\\\\]([^/\\\\]+)`))
+    return match ? `${match[1]}/${match[2]}` : undefined
+}

package/src/util/index.ts

@@ -1,3 +1,4 @@
 export * from './is-sn-scope'
 export * from './get-file-type'
 export * from './delete-multiple'
+export * from './conditional-dir'