@norrix/cli 0.0.25 → 0.0.27

package/dist/lib/defaults.js

@@ -6,4 +6,3 @@ export function assertNorrixCliEnv(value) {
         return v;
     throw new Error(`Invalid --env value '${value}'. Expected 'prod' or 'dev'.`);
 }
-//# sourceMappingURL=defaults.js.map

package/dist/lib/dev-defaults.js

@@ -15,4 +15,3 @@ export const DEV_DEFAULTS = {
     s3Bucket: 'amplify-d1lgodyads0fq7-de-amplifyteamdrivebucket28-vpf5n13xyzow',
     s3Region: 'us-east-1',
 };
-//# sourceMappingURL=dev-defaults.js.map

package/dist/lib/fingerprinting.js

@@ -265,4 +265,3 @@ export function writeRuntimeFingerprintFile(projectRoot, fingerprint, _platform)
 // If needed in the future, we can add helpers to read the
 // runtime fingerprint file from the app source tree, but for
 // now only the build-time writer is required.
-//# sourceMappingURL=fingerprinting.js.map

package/dist/lib/norrix-cli.js

@@ -1,4 +1,3 @@
 export function norrixCli() {
     return 'norrix-cli';
 }
-//# sourceMappingURL=norrix-cli.js.map

package/dist/lib/prod-defaults.js

@@ -10,4 +10,3 @@ export const PROD_DEFAULTS = {
     s3Bucket: 'amplify-d1lgodyads0fq7-ma-amplifyteamdrivebucket28-mljpo0rcjin7',
     s3Region: 'us-east-1',
 };
-//# sourceMappingURL=prod-defaults.js.map

package/dist/lib/workspace.d.ts

@@ -48,6 +48,15 @@ export interface NxProjectInfo {
     implicitDependencies?: string[];
     tags?: string[];
 }
+/**
+ * Available Nx build configurations for a project
+ */
+export interface NxBuildConfigurations {
+    /** List of configuration names (e.g., ['prod', 'stg', 'dev']) */
+    configurations: string[];
+    /** The default configuration if specified in project.json */
+    defaultConfiguration?: string;
+}
 export interface WorkspaceDependencies {
     /** Relative paths to lib directories that the app depends on */
     libPaths: string[];
@@ -57,17 +66,25 @@ export interface WorkspaceDependencies {
     toolPaths: string[];
     /** Asset paths referenced by the app */
     assetPaths: string[];
+    /** Local file dependencies from package.json (file: protocol paths) */
+    localFileDeps: string[];
 }
 /**
  * Detect the workspace context from the current working directory.
  * Walks up the directory tree looking for nx.json to identify Nx workspaces.
  */
 export declare function detectWorkspaceContext(appRoot?: string): WorkspaceContext;
+/**
+ * Detect available Nx build configurations from project.json.
+ * Reads the 'build' target's configurations to find options like 'prod', 'stg', 'dev'.
+ */
+export declare function detectNxBuildConfigurations(appRoot: string): NxBuildConfigurations | undefined;
 /**
  * Query Nx for the project dependency graph.
  * Returns the list of lib paths that the specified project depends on.
+ * Also supplements with webpack alias detection for SCSS and other non-TS dependencies.
  */
-export declare function getNxProjectDependencies(projectName: string, workspaceRoot: string, verbose?: boolean): WorkspaceDependencies | undefined;
+export declare function getNxProjectDependencies(projectName: string, workspaceRoot: string, verbose?: boolean, appRoot?: string): WorkspaceDependencies | undefined;
 /**
  * Get project info using nx show project command
  */

package/dist/lib/workspace.js

@@ -59,6 +59,34 @@ function detectProjectName(appRoot) {
     }
     return undefined;
 }
+/**
+ * Detect available Nx build configurations from project.json.
+ * Reads the 'build' target's configurations to find options like 'prod', 'stg', 'dev'.
+ */
+export function detectNxBuildConfigurations(appRoot) {
+    const projectJsonPath = path.join(appRoot, 'project.json');
+    if (!fs.existsSync(projectJsonPath)) {
+        return undefined;
+    }
+    try {
+        const projectJson = JSON.parse(fs.readFileSync(projectJsonPath, 'utf8'));
+        const buildTarget = projectJson.targets?.build;
+        if (!buildTarget || !buildTarget.configurations) {
+            return undefined;
+        }
+        const configurations = Object.keys(buildTarget.configurations);
+        if (configurations.length === 0) {
+            return undefined;
+        }
+        return {
+            configurations,
+            defaultConfiguration: buildTarget.defaultConfiguration,
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
 /**
  * Load TypeScript path mappings from tsconfig.base.json
  */
@@ -81,8 +109,9 @@ function loadPathMappings(workspaceRoot) {
 /**
  * Query Nx for the project dependency graph.
  * Returns the list of lib paths that the specified project depends on.
+ * Also supplements with webpack alias detection for SCSS and other non-TS dependencies.
  */
-export function getNxProjectDependencies(projectName, workspaceRoot, verbose = false) {
+export function getNxProjectDependencies(projectName, workspaceRoot, verbose = false, appRoot) {
     try {
         // Check if nx is available
         execSync('npx nx --version', {
@@ -101,27 +130,44 @@ export function getNxProjectDependencies(projectName, workspaceRoot, verbose = f
         // Extract all dependencies for the project (recursive)
         const allDeps = collectAllDependencies(projectName, graph);
         if (verbose) {
-            console.log(`[workspace] Found ${allDeps.size} dependencies for ${projectName}`);
+            console.log(`[workspace] Nx graph found ${allDeps.size} dependencies for ${projectName}`);
         }
         // Convert to paths
-        const libPaths = [];
+        const libPaths = new Set();
         for (const depName of allDeps) {
             const node = graph.graph.nodes[depName];
             if (node && node.data.root) {
-                libPaths.push(node.data.root);
+                libPaths.add(node.data.root);
             }
         }
+        // Supplement with webpack alias detection (catches SCSS and other non-TS dependencies)
+        // The Nx graph may miss webpack-only aliases that aren't in tsconfig
+        if (appRoot) {
+            const webpackRefs = parseWebpackReferences(appRoot, workspaceRoot, verbose);
+            for (const ref of webpackRefs) {
+                if (!libPaths.has(ref)) {
+                    libPaths.add(ref);
+                    if (verbose) {
+                        console.log(`[workspace] Added webpack alias dependency: ${ref}`);
+                    }
+                }
+            }
+        }
+        // Scan package.json for local file dependencies
+        const localFileDeps = scanLocalFileDependencies(workspaceRoot, verbose);
         return {
-            libPaths,
+            libPaths: Array.from(libPaths),
             rootConfigs: [
                 'nx.json',
                 'tsconfig.base.json',
                 'package.json',
                 'package-lock.json',
                 '.npmrc',
+                'references.d.ts', // NativeScript global type definitions
             ],
             toolPaths: ['tools/'],
-            assetPaths: ['libs/assets/'],
+            assetPaths: ['libs/assets/', 'packages/assets/'],
+            localFileDeps,
         };
     }
     catch (error) {
@@ -186,8 +232,8 @@ export function getWorkspaceDependenciesFallback(workspaceCtx, verbose = false)
             }
         }
     }
-    // 2. Parse webpack.config.js for additional references
-    const webpackRefs = parseWebpackReferences(workspaceCtx.appRoot, workspaceCtx.workspaceRoot);
+    // 2. Parse webpack.config.js for additional references (includes SCSS aliases)
+    const webpackRefs = parseWebpackReferences(workspaceCtx.appRoot, workspaceCtx.workspaceRoot, verbose);
     for (const ref of webpackRefs) {
         libPaths.add(ref);
     }
@@ -196,22 +242,195 @@ export function getWorkspaceDependenciesFallback(workspaceCtx, verbose = false)
     for (const ref of hookRefs) {
         libPaths.add(ref);
     }
-    if (verbose) {
-        console.log(`[workspace] Fallback found ${libPaths.size} lib dependencies`);
+    // 4. Parse project.json for implicit dependencies
+    const implicitDeps = parseImplicitDependencies(workspaceCtx.appRoot, workspaceCtx.workspaceRoot, verbose);
+    for (const dep of implicitDeps) {
+        libPaths.add(dep);
+    }
+    // 5. Recursively scan lib dependencies to find transitive deps
+    if (workspaceCtx.pathMappings) {
+        const initialLibCount = libPaths.size;
+        scanTransitiveLibDependencies(Array.from(libPaths), workspaceCtx.workspaceRoot, workspaceCtx.pathMappings, libPaths, verbose);
+        if (verbose && libPaths.size > initialLibCount) {
+            console.log(`[workspace] Found ${libPaths.size - initialLibCount} transitive lib dependencies`);
+        }
     }
+    if (verbose) {
+        console.log(`[workspace] Fallback found ${libPaths.size} total lib dependencies`);
+    }
+    // 6. Scan package.json for local file dependencies
+    const allLocalFileDeps = scanLocalFileDependencies(workspaceCtx.workspaceRoot, verbose);
+    // Filter out local file deps that are already covered by libPaths to avoid duplicates
+    const libPathsArray = Array.from(libPaths);
+    const localFileDeps = allLocalFileDeps.filter(localDep => {
+        for (const libPath of libPathsArray) {
+            // Skip if local dep is inside a lib path or vice versa
+            if (localDep.startsWith(libPath + '/') || localDep === libPath ||
+                libPath.startsWith(localDep + '/')) {
+                if (verbose) {
+                    console.log(`[workspace] Filtering redundant local dep: ${localDep} (covered by ${libPath})`);
+                }
+                return false;
+            }
+        }
+        return true;
+    });
     return {
-        libPaths: Array.from(libPaths),
+        libPaths: libPathsArray,
         rootConfigs: [
             'nx.json',
             'tsconfig.base.json',
             'package.json',
             'package-lock.json',
             '.npmrc',
+            'references.d.ts', // NativeScript global type definitions
         ],
         toolPaths: ['tools/'],
-        assetPaths: ['libs/assets/'],
+        assetPaths: ['libs/assets/', 'packages/assets/'],
+        localFileDeps,
     };
 }
+/**
+ * Parse project.json for implicit dependencies.
+ * These are libs explicitly declared as dependencies in the Nx project config.
+ */
+function parseImplicitDependencies(appRoot, workspaceRoot, verbose = false) {
+    const deps = [];
+    const projectJsonPath = path.join(appRoot, 'project.json');
+    if (!fs.existsSync(projectJsonPath)) {
+        return deps;
+    }
+    try {
+        const content = fs.readFileSync(projectJsonPath, 'utf8');
+        const projectJson = JSON.parse(content);
+        const implicitDeps = projectJson.implicitDependencies;
+        if (Array.isArray(implicitDeps)) {
+            for (const depName of implicitDeps) {
+                // Try to find the lib path by scanning for project.json with this name
+                const libPath = findLibPathByProjectName(depName, workspaceRoot);
+                if (libPath) {
+                    deps.push(libPath);
+                    if (verbose) {
+                        console.log(`[workspace] Found implicit dependency: ${depName} -> ${libPath}`);
+                    }
+                }
+            }
+        }
+    }
+    catch {
+        // Ignore parse errors
+    }
+    return deps;
+}
+/**
+ * Find a lib's path by its Nx project name.
+ * Scans libs/ and packages/ directories for project.json files with matching name.
+ */
+function findLibPathByProjectName(projectName, workspaceRoot) {
+    // Cache of project name -> lib path mappings (built on first call)
+    const projectNameCache = buildProjectNameCache(workspaceRoot);
+    return projectNameCache.get(projectName);
+}
+// Module-level cache for project name mappings
+let _projectNameCache;
+let _projectNameCacheRoot;
+function buildProjectNameCache(workspaceRoot) {
+    // Return cached version if same workspace
+    if (_projectNameCache && _projectNameCacheRoot === workspaceRoot) {
+        return _projectNameCache;
+    }
+    const cache = new Map();
+    // Scan both libs/ and packages/ directories (common Nx workspace layouts)
+    const sharedDirs = ['libs', 'packages'];
+    for (const dir of sharedDirs) {
+        const sharedPath = path.join(workspaceRoot, dir);
+        if (fs.existsSync(sharedPath)) {
+            scanForProjectJsonFiles(sharedPath, workspaceRoot, cache);
+        }
+    }
+    _projectNameCache = cache;
+    _projectNameCacheRoot = workspaceRoot;
+    return cache;
+}
+function scanForProjectJsonFiles(dir, workspaceRoot, cache) {
+    try {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.name === 'node_modules' || entry.name.startsWith('.')) {
+                continue;
+            }
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                // Check for project.json in this directory
+                const projectJsonPath = path.join(fullPath, 'project.json');
+                if (fs.existsSync(projectJsonPath)) {
+                    try {
+                        const content = fs.readFileSync(projectJsonPath, 'utf8');
+                        const projectJson = JSON.parse(content);
+                        if (projectJson.name) {
+                            const relativePath = path.relative(workspaceRoot, fullPath);
+                            cache.set(projectJson.name, relativePath);
+                        }
+                    }
+                    catch {
+                        // Ignore parse errors
+                    }
+                }
+                // Continue scanning subdirectories
+                scanForProjectJsonFiles(fullPath, workspaceRoot, cache);
+            }
+        }
+    }
+    catch {
+        // Ignore directory read errors
+    }
+}
+/**
+ * Recursively scan libs for their dependencies on other libs.
+ * This finds transitive dependencies that the app doesn't directly import.
+ */
+function scanTransitiveLibDependencies(initialLibPaths, workspaceRoot, pathMappings, allLibPaths, verbose = false) {
+    const toScan = [...initialLibPaths];
+    const scanned = new Set();
+    while (toScan.length > 0) {
+        const libPath = toScan.pop();
+        if (scanned.has(libPath)) {
+            continue;
+        }
+        scanned.add(libPath);
+        const absoluteLibPath = path.join(workspaceRoot, libPath);
+        if (!fs.existsSync(absoluteLibPath)) {
+            continue;
+        }
+        // Scan this lib's source files for imports of other path aliases
+        const usedAliases = scanForUsedPathAliases(absoluteLibPath, Object.keys(pathMappings), false // Don't verbose for recursive scans
+        );
+        for (const alias of usedAliases) {
+            const paths = pathMappings[alias];
+            if (paths && paths.length > 0) {
+                const depLibPath = extractLibPath(paths[0]);
+                if (depLibPath && !allLibPaths.has(depLibPath)) {
+                    allLibPaths.add(depLibPath);
+                    toScan.push(depLibPath);
+                    if (verbose) {
+                        console.log(`[workspace] Found transitive dependency: ${libPath} -> ${depLibPath}`);
+                    }
+                }
+            }
+        }
+        // Also check the lib's project.json for implicit dependencies
+        const implicitDeps = parseImplicitDependencies(absoluteLibPath, workspaceRoot, false);
+        for (const dep of implicitDeps) {
+            if (!allLibPaths.has(dep)) {
+                allLibPaths.add(dep);
+                toScan.push(dep);
+                if (verbose) {
+                    console.log(`[workspace] Found transitive implicit dependency: ${libPath} -> ${dep}`);
+                }
+            }
+        }
+    }
+}
 /**
  * Scan source files for path alias imports
  */
@@ -263,22 +482,24 @@ function scanForUsedPathAliases(appRoot, aliases, verbose = false) {
  */
 function extractLibPath(mappingPath) {
     // e.g., "libs/xplat/core/src/index.ts" -> "libs/xplat/core"
+    // e.g., "packages/shared/utils/src/index.ts" -> "packages/shared/utils"
     // e.g., "libs/xplat/core/src/lib/*" -> "libs/xplat/core"
-    const match = mappingPath.match(/^(libs\/[^/]+(?:\/[^/]+)*?)\/src/);
+    const match = mappingPath.match(/^((?:libs|packages)\/[^/]+(?:\/[^/]+)*?)\/src/);
     if (match) {
         return match[1];
     }
     // Try simpler pattern
-    const simpleMatch = mappingPath.match(/^(libs\/[^/]+(?:\/[^/]+)*)/);
+    const simpleMatch = mappingPath.match(/^((?:libs|packages)\/[^/]+(?:\/[^/]+)*)/);
     if (simpleMatch) {
         return simpleMatch[1];
     }
     return undefined;
 }
 /**
- * Parse webpack.config.js for references to workspace paths
+ * Parse webpack.config.js for references to workspace paths.
+ * Handles both relative path references and resolve.alias configurations.
  */
-function parseWebpackReferences(appRoot, workspaceRoot) {
+function parseWebpackReferences(appRoot, workspaceRoot, verbose = false) {
     const refs = [];
     const webpackPath = path.join(appRoot, 'webpack.config.js');
     if (!fs.existsSync(webpackPath)) {
@@ -286,7 +507,7 @@ function parseWebpackReferences(appRoot, workspaceRoot) {
     }
     try {
         const content = fs.readFileSync(webpackPath, 'utf8');
-        // Look for patterns like '../../../libs/...' or 'tools/...'
+        // Look for patterns like '../../../libs/...' or '../../../packages/...' or 'tools/...'
         const relativePathRegex = /['"`](\.\.\/)+([^'"`]+)['"`]/g;
         let match;
         while ((match = relativePathRegex.exec(content)) !== null) {
@@ -294,11 +515,15 @@ function parseWebpackReferences(appRoot, workspaceRoot) {
             const absolutePath = path.resolve(appRoot, relativePath);
             const relativeToWorkspace = path.relative(workspaceRoot, absolutePath);
             if (relativeToWorkspace.startsWith('libs/') ||
+                relativeToWorkspace.startsWith('packages/') ||
                 relativeToWorkspace.startsWith('tools/')) {
-                // Extract the base directory
-                const parts = relativeToWorkspace.split('/');
-                if (parts.length >= 2) {
-                    refs.push(parts.slice(0, 3).join('/'));
+                // Extract the lib directory - need to handle deep paths like libs/xplat/nativescript/scss/src
+                const libPath = extractLibPathFromRelative(relativeToWorkspace);
+                if (libPath) {
+                    refs.push(libPath);
+                    if (verbose) {
+                        console.log(`[webpack] Found lib reference: ${libPath}`);
+                    }
                 }
             }
         }
@@ -306,10 +531,31 @@ function parseWebpackReferences(appRoot, workspaceRoot) {
         const copyRuleRegex = /from:\s*['"`]([^'"`]+)['"`]/g;
         while ((match = copyRuleRegex.exec(content)) !== null) {
             const fromPath = match[1];
-            if (fromPath.includes('libs/')) {
-                const libMatch = fromPath.match(/(libs\/[^/]+(?:\/[^/]+)*)/);
+            if (fromPath.includes('libs/') || fromPath.includes('packages/')) {
+                const libMatch = fromPath.match(/((?:libs|packages)\/[^/]+(?:\/[^/]+)*)/);
                 if (libMatch) {
-                    refs.push(libMatch[1]);
+                    const libPath = extractLibPathFromRelative(libMatch[1]);
+                    if (libPath) {
+                        refs.push(libPath);
+                    }
+                }
+            }
+        }
+        // Look for webpack resolve.alias patterns like:
+        // config.resolve.alias.set('@ups/xplat-scss', resolve(__dirname, '../../../libs/xplat/scss/src/'))
+        // or: alias: { '@ups/xplat-scss': path.resolve(...) }
+        const aliasSetRegex = /\.alias\.set\s*\(\s*['"`]([^'"`]+)['"`]\s*,\s*(?:resolve|path\.resolve)\s*\([^,]+,\s*['"`]([^'"`]+)['"`]\s*\)/g;
+        while ((match = aliasSetRegex.exec(content)) !== null) {
+            const aliasPath = match[2];
+            const absolutePath = path.resolve(appRoot, aliasPath);
+            const relativeToWorkspace = path.relative(workspaceRoot, absolutePath);
+            if (relativeToWorkspace.startsWith('libs/') || relativeToWorkspace.startsWith('packages/')) {
+                const libPath = extractLibPathFromRelative(relativeToWorkspace);
+                if (libPath) {
+                    refs.push(libPath);
+                    if (verbose) {
+                        console.log(`[webpack] Found alias reference: ${match[1]} -> ${libPath}`);
+                    }
                 }
             }
         }
@@ -319,6 +565,49 @@ function parseWebpackReferences(appRoot, workspaceRoot) {
     }
     return [...new Set(refs)];
 }
+/**
+ * Extract the lib directory from a relative path.
+ * Handles paths like:
+ * - libs/xplat/scss/src -> libs/xplat/scss
+ * - packages/shared/utils/src -> packages/shared/utils
+ * - libs/xplat/nativescript/scss/src/ -> libs/xplat/nativescript/scss
+ * - libs/assets/mobile/fonts -> libs/assets
+ */
+function extractLibPathFromRelative(relativePath) {
+    // Remove trailing slash
+    const cleanPath = relativePath.replace(/\/+$/, '');
+    // Handle /src or /src/... suffix - find the lib root
+    const srcMatch = cleanPath.match(/^((?:libs|packages)\/(?:[^/]+\/)*[^/]+)\/src(?:\/|$)/);
+    if (srcMatch) {
+        return srcMatch[1];
+    }
+    // For paths without /src, extract based on common patterns
+    // libs/assets -> libs/assets
+    // libs/xplat/core -> libs/xplat/core
+    // packages/shared -> packages/shared
+    if (cleanPath.startsWith('libs/') || cleanPath.startsWith('packages/')) {
+        const parts = cleanPath.split('/');
+        // Check if this path has a project.json to determine lib boundary
+        // For now, use heuristics: assets are at libs/assets, others are deeper
+        if (parts[1] === 'assets') {
+            return `${parts[0]}/${parts[1]}`;
+        }
+        // For xplat and other nested structures, typically 3 levels: libs/xplat/core
+        // But can be deeper: libs/xplat/nativescript/scss
+        // Try to find project.json to determine the actual lib root
+        let testPath = '';
+        for (let i = 0; i < parts.length; i++) {
+            testPath += (i > 0 ? '/' : '') + parts[i];
+            // We'll return the deepest valid lib path that's not a 'src' dir
+            if (parts[i] === 'src') {
+                return parts.slice(0, i).join('/');
+            }
+        }
+        // If no /src found, return up to 4 levels or the full path
+        return parts.slice(0, Math.min(parts.length, 4)).join('/');
+    }
+    return undefined;
+}
 /**
  * Parse nativescript.config.ts for hook script references
  */
@@ -351,6 +640,71 @@ function parseNativeScriptHooks(appRoot, workspaceRoot) {
     }
     return [...new Set(refs)];
 }
+/**
+ * Scan package.json for local file dependencies (file: protocol).
+ * Returns an array of relative paths (files or directories) that need to be included in the bundle.
+ */
+function scanLocalFileDependencies(workspaceRoot, verbose = false) {
+    const localDeps = new Set();
+    const packageJsonPath = path.join(workspaceRoot, 'package.json');
+    if (!fs.existsSync(packageJsonPath)) {
+        return [];
+    }
+    try {
+        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+        // Scan dependencies, devDependencies, and overrides for file: protocol
+        const sections = [
+            packageJson.dependencies,
+            packageJson.devDependencies,
+            packageJson.optionalDependencies,
+            packageJson.overrides,
+        ];
+        for (const section of sections) {
+            if (!section || typeof section !== 'object')
+                continue;
+            for (const [name, value] of Object.entries(section)) {
+                if (typeof value !== 'string')
+                    continue;
+                // Match file: protocol (e.g., "file:libs/xplat/web/plugins/util-0.12.5.tgz")
+                if (value.startsWith('file:')) {
+                    const relativePath = value.slice(5); // Remove 'file:' prefix
+                    const absolutePath = path.resolve(workspaceRoot, relativePath);
+                    // Verify the path exists
+                    if (fs.existsSync(absolutePath)) {
+                        // If it's a file (like a .tgz), include the directory containing it
+                        const stat = fs.statSync(absolutePath);
+                        if (stat.isFile()) {
+                            // Include the specific file
+                            localDeps.add(relativePath);
+                            if (verbose) {
+                                console.log(`[workspace] Found local file dependency: ${relativePath}`);
+                            }
+                        }
+                        else if (stat.isDirectory()) {
+                            // Include the directory
+                            localDeps.add(relativePath);
+                            if (verbose) {
+                                console.log(`[workspace] Found local directory dependency: ${relativePath}`);
+                            }
+                        }
+                    }
+                    else if (verbose) {
+                        console.log(`[workspace] Warning: Local dependency not found: ${relativePath}`);
+                    }
+                }
+            }
+        }
+    }
+    catch (error) {
+        if (verbose) {
+            console.log(`[workspace] Error scanning package.json for local deps: ${error?.message}`);
+        }
+    }
+    if (verbose && localDeps.size > 0) {
+        console.log(`[workspace] Found ${localDeps.size} local file dependencies`);
+    }
+    return Array.from(localDeps);
+}
 export function createWorkspaceManifest(workspaceCtx, deps) {
     return {
         version: '1.0',