@pixelated-tech/components 3.13.15 → 3.14.0

package/dist/scripts/create-pixelated-app.js

@@ -49,7 +49,6 @@ import { promisify } from 'util';
 import readline from 'readline/promises';
 import { stdin as input, stdout as output } from 'process';
 import { fileURLToPath } from 'url';
-import { loadManifest, findTemplateForSlug, pruneTemplateDirs, printAvailableTemplates } from './create-pixelated-app-template-mapper.js';
 import { AmplifyClient, CreateAppCommand, CreateBranchCommand, UpdateAppCommand, UpdateBranchCommand } from '@aws-sdk/client-amplify';
 
 const __filename = fileURLToPath(import.meta.url);
@@ -70,6 +69,51 @@ async function exists(p) {
 	}
 }
 
+// Template manifest utilities
+export async function loadManifest(baseDir = path.resolve(__dirname)) {
+	const manifestPath = path.resolve(baseDir, 'create-pixelated-app.json');
+	try {
+		if (await exists(manifestPath)) {
+			const txt = await fs.readFile(manifestPath, 'utf8');
+			return JSON.parse(txt);
+		}
+	} catch (e) {
+		// ignore parse/read errors
+	}
+	return null;
+}
+
+export function findTemplateForSlug(manifest, slug) {
+	if (!manifest || !Array.isArray(manifest.templates)) return null;
+	slug = (slug || '').toLowerCase();
+	for (const t of manifest.templates) {
+		// Skip templates that have action: "ignore" (metadata routes in Admin section)
+		if (t.action === 'ignore') continue;
+		if (!t.aliases || !Array.isArray(t.aliases)) continue;
+		for (let a of t.aliases) {
+			a = a.toLowerCase().replace(/\s+/g, '-').replace(/[^a-z0-9-]/g, '');
+			if (a === slug) return t;
+		}
+		// also fuzzy match (e.g., 'about-us' -> 'about')
+		for (let a of t.aliases) {
+			a = a.toLowerCase().replace(/\s+/g, '-').replace(/[^a-z0-9-]/g, '');
+			if (slug === a || slug.startsWith(a + '-') || slug.endsWith('-' + a) || slug.includes('-' + a + '-')) return t;
+		}
+	}
+	return null;
+}
+
+export function printAvailableTemplates(manifest) {
+	if (!manifest || !Array.isArray(manifest.templates) || manifest.templates.length === 0) return;
+	console.log('\nAvailable templates:');
+	for (const t of manifest.templates) {
+		// Skip templates in Admin section (marked with action: "ignore")
+		if (t.action === 'ignore') continue;
+		const aliases = Array.isArray(t.aliases) ? t.aliases.join(', ') : '';
+		console.log(` - ${t.name}${aliases ? ': ' + aliases : ''}`);
+	}
+}
+
 async function countFiles(src) {
 	let total = 0;
 	async function walk(p) {
@@ -245,7 +289,8 @@ export async function createAndPushRemote(destPath, siteName, defaultOwner) {
 	const tmpDir = path.join(destPath, '.px-scripts');
 	const tmpFile = path.join(tmpDir, 'get_github_token.ts');
 	await fs.mkdir(tmpDir, { recursive: true });
-	const tmpContent = `import('./src/components/config/config').then(m => {
+	const configModulePath = path.resolve(destPath, 'src', 'components', 'config', 'config');
+	const tmpContent = `import('${configModulePath}').then(m => {
 		const cfg = m.getFullPixelatedConfig();
 		// Only print the github object (or null) as JSON to stdout
 		console.log(JSON.stringify(cfg?.github || null));
@@ -550,121 +595,184 @@ async function main() {
 		}
 
 
-		// Pages prompt: show available templates and ask which pages to create (comma-separated)
-		console.log(`\nStep ${stepNumber++}: Page Creation`);
+		// Pages selection: ask which pages user wants (from template or custom new pages)
+		console.log(`\nStep ${stepNumber++}: Page Selection`);
 		console.log('================================================================================\n');
 		if (manifest && Array.isArray(manifest.templates) && manifest.templates.length) {
 			printAvailableTemplates(manifest);
 		}
-		const pagesInput = (await rl.question('Pages to create (comma-separated, e.g. about,contact) [leave blank to skip]: ')).trim();
-		let pagesToCreate = [];
-		let existingPages = ['humans.txt', 'styleguide'];
+		const pagesInput = (await rl.question('Pages you want (comma-separated, e.g. about,contact,custom-legal) [leave blank to skip]: ')).trim();
+		let wantedPages = [];
 		if (pagesInput) {
 			const raw = pagesInput.split(',').map(s => s.trim()).filter(Boolean);
-			// sanitize and normalize
 			const seen = new Set();
-			for (const r of raw) {
-				const lower = r.toLowerCase();
-				if (lower === 'home' || lower === 'index') {
-					existingPages.push('home');
-					continue;
-				}
-				let slug = r.trim().toLowerCase().replace(/\s+/g, '-').replace(/[^a-z0-9-]/g, '');
-				if (!slug) continue;
-				if (seen.has(slug)) continue;
+			
+			// Normalize each input
+			for (const userInput of raw) {
+				const slug = userInput.toLowerCase().replace(/\s+/g, '-').replace(/[^a-z0-9-]/g, '');
+				if (!slug || seen.has(slug)) continue;
 				seen.add(slug);
+				
+				// Check if it's a template page
 				const matchedTemplate = findTemplateForSlug(manifest, slug);
-				pagesToCreate.push({ slug, displayName: r.trim(), template: matchedTemplate });
+				const isTemplate = !!matchedTemplate;
+				
+				wantedPages.push({
+					slug,
+					displayName: userInput.trim(),
+					isTemplate,
+					matchedTemplate
+				});
 			}
 
-			console.log('\nSummary of pages:');
-			if (existingPages.length) console.log(` - Existing (skipped): ${existingPages.join(', ')}`);
-			if (pagesToCreate.length) {
-				console.log(' - To be created:');
-				for (const p of pagesToCreate) {
-					if (p.template) {
-						console.log(`   - ${p.slug} (mapped to template: ${p.template.name})`);
-					} else {
-						console.log(`   - ${p.slug} (no template match)`);
+			if (wantedPages.length) {
+				console.log('\nSummary of pages:');
+				const templatePages = wantedPages.filter(p => p.isTemplate);
+				const customPages = wantedPages.filter(p => !p.isTemplate);
+				
+				if (templatePages.length) {
+					console.log(' - Template pages:');
+					for (const p of templatePages) {
+						console.log(`   - ${p.slug} (from template: ${p.matchedTemplate.name})`);
+					}
+				}
+				if (customPages.length) {
+					console.log(' - Custom pages (new):');
+					for (const p of customPages) {
+						console.log(`   - ${p.slug}`);
 					}
 				}
 			}
-			const proceedPages = (await rl.question('Proceed to create these pages? (Y/n): ')) || 'y';
+
+			const proceedPages = (await rl.question('Proceed with these pages? (Y/n): ')) || 'y';
 			if (proceedPages.toLowerCase() === 'y' || proceedPages.toLowerCase() === 'yes') {
-				// perform creation
-				const templatePagesHome = path.join(templatePath, 'src', 'app', '(pages)', '(home)');
 				const siteRoutesFile = path.join(destPath, 'src', 'app', 'data', 'routes.json');
 				let routesJson = null;
+				
 				try {
 					routesJson = JSON.parse(await fs.readFile(siteRoutesFile, 'utf8'));
-					// Ensure siteInfo exists and set its name to the root display name
 					routesJson.siteInfo = routesJson.siteInfo || {};
 					routesJson.siteInfo.name = rootDisplayName;
 				} catch (e) {
-					console.warn('⚠️  Could not read routes.json, routes will not be updated.');
+					console.error('❌ Failed to read routes.json:', e?.message || e);
+					process.exit(1);
 				}
 
-				for (const p of pagesToCreate) {
-					const targetDir = path.join(destPath, 'src', 'app', '(pages)', p.slug);
-					console.log(`Creating page ${p.slug} -> ${targetDir}`);
-					let copyResult = null;
-					if (p.template && p.template.src) {
-						copyResult = await copyTemplateForPage(templatePath, p.template.src, templatePagesHome, targetDir);
-						if (copyResult.used === 'template') {
-							console.log(` - Copied template ${p.template.name} from ${copyResult.src}`);
-						} else {
-							console.warn(`⚠️  Template source ${path.join(templatePath, 'src', 'app', '(pages)', path.basename(p.template.src))} not found; using default page template instead.`);
+				const templatePagesHome = path.join(templatePath, 'src', 'app', '(pages)', '(home)');
+				const pagesDir = path.join(destPath, 'src', 'app', '(pages)');
+				const wantedSlugs = new Set(wantedPages.map(p => p.slug));
+
+				// Process wanted pages: rename templates or create custom pages
+				for (const p of wantedPages) {
+					if (p.isTemplate) {
+						// Get the actual template folder name (e.g., "about")
+						const templateFolderName = path.basename(p.matchedTemplate.src);
+						const oldPath = path.join(pagesDir, templateFolderName);
+						const newPath = path.join(pagesDir, p.slug);
+						
+						// Rename if user requested a different name
+						if (templateFolderName !== p.slug) {
+							try {
+								await fs.rename(oldPath, newPath);
+								console.log(`Renamed ${templateFolderName} → ${p.slug}`);
+								
+								// Update component name in page.tsx
+								const pageFile = path.join(newPath, 'page.tsx');
+								let content = await fs.readFile(pageFile, 'utf8');
+								const compName = p.displayName.replace(/[^a-zA-Z0-9]+/g, ' ').split(/\s+/).map(s => s.charAt(0).toUpperCase() + s.slice(1)).join('') + 'Page';
+								content = content.replace(/export default function\s+\w+\s*\(/, `export default function ${compName}(`);
+								await fs.writeFile(pageFile, content, 'utf8');
+								console.log(` - Updated component name to ${compName}`);
+								
+								// Update route path in routes.json
+								const route = routesJson.routes.find(r => r.path === `/${templateFolderName}`);
+								if (route) {
+									route.path = `/${p.slug}`;
+									route.name = p.displayName.split(/\s+/).map(s => s.charAt(0).toUpperCase() + s.slice(1)).join(' ');
+									console.log(` - Updated route path to /${p.slug}`);
+								}
+							} catch (e) {
+								console.error(`❌ Failed to rename ${templateFolderName} to ${p.slug}:`, e?.message || e);
+								process.exit(1);
+							}
 						}
 					} else {
-						await copyRecursive(templatePagesHome, targetDir);
-					}
-					// rename component in page.tsx
-					const pageFile = path.join(targetDir, 'page.tsx');
-					try {
-						let content = await fs.readFile(pageFile, 'utf8');
-						const compName = p.displayName.replace(/[^a-zA-Z0-9]+/g,' ').split(/\s+/).map(s=>s.charAt(0).toUpperCase()+s.slice(1)).join('') + 'Page';
-						content = content.replace(/export default function\s+\w+\s*\(/, `export default function ${compName}(`);
-						await fs.writeFile(pageFile, content, 'utf8');
-						console.log(` - Updated component name to ${compName} in ${path.relative(destPath, pageFile)}`);
-					} catch (e) {
-						console.warn(`⚠️  Failed to update component name for ${p.slug}:`, e?.message || e);
-					}
-
-					// update routes.json
-					if (routesJson && Array.isArray(routesJson.routes)) {
-						// Skip if route path already exists
-						const candidatePath = `/${p.slug}`;
-						if (!routesJson.routes.some(r => r.path === candidatePath)) {
-							routesJson.routes.push({
-								"name": p.displayName.split(/\s+/).map(s=>s.charAt(0).toUpperCase()+s.slice(1)).join(' '),
-								"path": candidatePath,
+						// Create custom page from default template
+						try {
+							const targetDir = path.join(pagesDir, p.slug);
+							await copyRecursive(templatePagesHome, targetDir);
+							console.log(`Created custom page ${p.slug}`);
+							
+							// Update component name in page.tsx
+							const pageFile = path.join(targetDir, 'page.tsx');
+							let content = await fs.readFile(pageFile, 'utf8');
+							const compName = p.displayName.replace(/[^a-zA-Z0-9]+/g, ' ').split(/\s+/).map(s => s.charAt(0).toUpperCase() + s.slice(1)).join('') + 'Page';
+							content = content.replace(/export default function\s+\w+\s*\(/, `export default function ${compName}(`);
+							await fs.writeFile(pageFile, content, 'utf8');
+							console.log(` - Updated component name to ${compName}`);
+							
+							// Add route entry
+							const newRoute = {
+								"name": p.displayName.split(/\s+/).map(s => s.charAt(0).toUpperCase() + s.slice(1)).join(' '),
+								"path": `/${p.slug}`,
 								"title": `${rootDisplayName} - ${p.displayName}`,
 								"description": "",
 								"keywords": ""
-							});
-						} else {
-							console.log(` - Route ${candidatePath} already exists; skipping route add.`);
+							};
+							routesJson.routes.push(newRoute);
+							console.log(` - Added route /${p.slug}`);
+						} catch (e) {
+							console.error(`❌ Failed to create custom page ${p.slug}:`, e?.message || e);
+							process.exit(1);
 						}
 					}
 				}
 
-				if (manifest) {
-					const removed = await pruneTemplateDirs(manifest, destPath, pagesToCreate.map(p=>p.slug));
-					for (const r of removed) {
-						console.log(`Removed unused template page ${r} from new site...`);
+				// Delete unwanted template pages
+				// The Admin section (an object with nested routes for metadata pages) is in routesJson.routes
+				// but doesn't have folders in the (pages) directory, so it's never encountered by fs.readdir().
+				// We can safely delete page folders without worrying about removing the Admin section.
+				try {
+					const existingFolders = await fs.readdir(pagesDir);
+					const foldersToDelete = [];
+					
+					for (const folderName of existingFolders) {
+						if (!wantedSlugs.has(folderName)) {
+							const folderTemplate = findTemplateForSlug(manifest, folderName);
+							if (folderTemplate) {
+								foldersToDelete.push(folderName);
+							}
+						}
+					}
+					
+					// Delete unwanted folders and their routes
+					for (const folderName of foldersToDelete) {
+						try {
+							const folderPath = path.join(pagesDir, folderName);
+							await fs.rm(folderPath, { recursive: true });
+							console.log(`Deleted template page ${folderName}`);
+							
+							// Remove the corresponding route from routes.json
+							routesJson.routes = routesJson.routes.filter(r => r.path !== `/${folderName}`);
+						} catch (e) {
+							console.warn(`⚠️  Failed to delete ${folderName}:`, e?.message || e);
+						}
 					}
+				} catch (e) {
+					// readdir might fail if pages dir doesn't exist, but that's OK
+					console.warn(`⚠️  Could not read pages directory for cleanup:`, e?.message || e);
 				}
 
-				if (routesJson) {
-					try {
-						await fs.writeFile(siteRoutesFile, JSON.stringify(routesJson, null, '\t'), 'utf8');
-						console.log('✅ routes.json updated.');
-					} catch (e) {
-						console.warn('⚠️  Failed to write routes.json:', e?.message || e);
-					}
+				// Write final routes.json
+				try {
+					await fs.writeFile(siteRoutesFile, JSON.stringify(routesJson, null, '\t'), 'utf8');
+					console.log('✅ routes.json updated.');
+				} catch (e) {
+					console.error('❌ Failed to write routes.json:', e?.message || e);
+					process.exit(1);
 				}
 			} else {
-				console.log('Skipping page creation.');
+				console.log('Skipping page selection.');
 			}
 		}
 

package/dist/scripts/create-pixelated-app.json

@@ -10,6 +10,11 @@
 			"aliases": ["blog", "blog-posts", "news", "updates", "articles"],
 			"src": "../../pixelated-template/src/app/(pages)/blog"
 		},
+		{
+			"name": "Blog Calendar",
+			"aliases": ["blogcalendar", "blog-calendar", "calendar", "event-calendar", "events"],
+			"src": "../../pixelated-template/src/app/(pages)/blogcalendar"
+		},
 		{
 			"name": "Contact",
 			"aliases": ["contact", "contact-us", "contact-us-page", "contactus", "support", "get-in-touch", "reach-out", "get-in-touch"],
@@ -22,10 +27,40 @@
 			"src": "../../pixelated-template/src/app/(pages)/faqs",
 			"associated_files": ["src/app/data/faqs.json"]
 		},
+		{
+			"name": "Global Error",
+			"aliases": ["global-error", "globalerror", "error-boundary"],
+			"action": "ignore"
+		},
 		{
 			"name": "Humans.txt",
 			"aliases": ["humans", "humans-txt", "humans.txt", "humansfile", "humansfile.txt", "humanstext"],
-			"src": "../../pixelated-template/src/app/(pages)/humans"
+			"action": "ignore"
+		},
+		{
+			"name": "Loading",
+			"aliases": ["loading", "skeleton", "loader"],
+			"action": "ignore"
+		},
+		{
+			"name": "Manifest",
+			"aliases": ["manifest", "manifest.json", "manifest-json", "webmanifest"],
+			"action": "ignore"
+		},
+		{
+			"name": "Not Found",
+			"aliases": ["not-found", "notfound", "404", "error-404"],
+			"action": "ignore"
+		},
+		{
+			"name": "Partners",
+			"aliases": ["partners", "partner", "affiliates", "integration-partners", "integrations", "collaborators"],
+			"src": "../../pixelated-template/src/app/(pages)/partners"
+		},
+		{
+			"name": "Podcast",
+			"aliases": ["podcast", "podcasts", "audio", "episodes", "show"],
+			"src": "../../pixelated-template/src/app/(pages)/podcast"
 		},
 		{
 			"name": "Projects",
@@ -33,11 +68,26 @@
 				"our-projects", "our-project", "case-studies", "examples", "showcase", "samples"],
 			"src": "../../pixelated-template/src/app/(pages)/projects"
 		},
+		{
+			"name": "Robots",
+			"aliases": ["robots", "robots.txt", "robots-txt"],
+			"action": "ignore"
+		},
+		{
+			"name": "Security.txt",
+			"aliases": ["security", "security.txt", "securitytxt", "security-txt", "well-known", "securityfile", "securityfile.txt", "wellknown"],
+			"action": "ignore"
+		},
 		{
 			"name": "Services",
 			"aliases": ["services", "service", "our-services", "services-page", "offerings", "solutions", "products"],
 			"src": "../../pixelated-template/src/app/(pages)/services"
 		},
+		{
+			"name": "Sitemap",
+			"aliases": ["sitemap", "sitemap.xml", "sitemap-xml"],
+			"action": "ignore"
+		},
 		{
 			"name": "Style Guide",
 			"aliases": ["styleguide", "style-guide", "design-system", "ui-kit", "pattern-library"],

package/dist/scripts/pixelated-eslint-plugin.js

@@ -1152,6 +1152,146 @@ const noDuplicateExportNamesRule = {
 	}
 };
 
+/**
+ * no-hardcoded-config-keys Rule
+ * 
+ * Prevents hardcoding of Pixelated-specific configuration keys that should come from:
+ * - Config provider (usePixelatedConfig)
+ * - Environment variables
+ * - Function parameters/props
+ * 
+ * Only flags keys that are Pixelated-specific to avoid false positives.
+ * Severity: ERROR for secrets, WARNING for other Pixelated config keys.
+ */
+const noHardcodedConfigKeysRule = {
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Prevent hardcoded Pixelated configuration keys that should come from config provider',
+			category: 'Security',
+			recommended: true,
+		},
+		fixable: false,
+		schema: [],
+		messages: {
+			secretConfigKey: 'Hardcoded SECRET configuration key "{{keyName}}" ({{serviceName}}) detected. Must use config provider (usePixelatedConfig) or environment variables.',
+			publicConfigKey: 'Hardcoded Pixelated config key "{{keyName}}" ({{serviceName}}) detected. Should use config provider (usePixelatedConfig) or pass as parameter instead.',
+		},
+	},
+	create(context) {
+		// Pixelated-SPECIFIC configuration keys (keys that are unlikely to be false positives)
+		// Keys that are unique/distinctive to Pixelated integrations, excluding generic names
+		const pixelatedConfigKeys = {
+			// Contentful (very Pixelated-specific)
+			contentful: ['space_id', 'delivery_access_token', 'management_access_token', 'preview_access_token', 'proxyURL', 'base_url', 'environment'],
+			// eBay (very distinctive)
+			ebay: ['appId', 'appDevId', 'appCertId', 'sbxAppId', 'sbxAppDevId', 'sbxAppCertId', 'globalId', 'baseTokenURL', 'baseSearchURL', 'baseAnalyticsURL', 'qsSearchURL', 'baseItemURL', 'qsItemURL'],
+			// AWS (distinctive with service prefix or secretive names)
+			aws: ['access_key_id', 'secret_access_key', 'session_token'],
+			// Cloudinary
+			cloudinary: ['product_env', 'api_key', 'api_secret'],
+			// Flickr
+			flickr: ['user_id'],
+			// GitHub
+			github: ['token', 'apiBaseUrl', 'defaultOwner'],
+			// Google services
+			google: ['client_id', 'client_secret', 'api_key', 'refresh_token'],
+			// Google Analytics
+			googleAnalytics: [],  // Skip 'id' and 'adId' as too generic
+			// Google Maps
+			googleMaps: ['apiKey'],
+			// HubSpot (keep only distinctive ones)
+			hubspot: ['portalId', 'formId', 'trackingCode'],
+			// Instagram
+			instagram: ['accessToken', 'userId'],
+			// NextAuth
+			nextAuth: ['secret'],
+			// PayPal
+			paypal: ['sandboxPayPalApiKey', 'sandboxPayPalSecret', 'payPalApiKey', 'payPalSecret'],
+			// WordPress
+			wordpress: ['baseURL', 'site'],
+			// Puppeteer
+			puppeteer: ['executable_path', 'cache_dir'],
+			// Global
+			global: ['PIXELATED_CONFIG_KEY']
+		};
+
+		// Secret keys that should NEVER be hardcoded (ERROR severity)
+		const secretKeys = new Set([
+			// AWS
+			'access_key_id', 'secret_access_key', 'session_token',
+			// Cloudinary
+			'api_key', 'api_secret',
+			// Contentful
+			'management_access_token', 'preview_access_token',
+			// eBay
+			'sbxAppId',
+			// GitHub
+			'token',
+			// Instagram
+			'accessToken',
+			// PayPal
+			'sandboxPayPalApiKey', 'sandboxPayPalSecret', 'payPalApiKey', 'payPalSecret',
+			// NextAuth
+			'secret',
+			// Global
+			'PIXELATED_CONFIG_KEY'
+		]);
+
+		// Build set of all known Pixelated config keys
+		const allConfigKeys = new Set();
+		Object.values(pixelatedConfigKeys).forEach(keys => {
+			keys.forEach(key => allConfigKeys.add(key));
+		});
+
+		function findServiceForKey(keyName) {
+			for (const [serviceName, keys] of Object.entries(pixelatedConfigKeys)) {
+				if (keys.includes(keyName)) {
+					return serviceName;
+				}
+			}
+			return 'unknown';
+		}
+
+		function isConfigKey(keyName) {
+			return allConfigKeys.has(keyName);
+		}
+
+		function isSecretKey(keyName) {
+			return secretKeys.has(keyName);
+		}
+
+		return {
+			ObjectExpression(node) {
+				node.properties.forEach(prop => {
+					// Check properties that look like { space_id: "value" } or { api_key: "..." }
+					if (prop.type === 'Property' && prop.key) {
+						const keyName = prop.key.name || prop.key.value;
+						
+						// Check if this is a known Pixelated config key
+						if (isConfigKey(keyName)) {
+							// Check if value is a string literal (hardcoded)
+							if (prop.value.type === 'Literal' && typeof prop.value.value === 'string') {
+								const stringValue = prop.value.value;
+								if (stringValue && stringValue.length > 0) {
+									const serviceName = findServiceForKey(keyName);
+									const messageId = isSecretKey(keyName) ? 'secretConfigKey' : 'publicConfigKey';
+									
+									context.report({
+										node: prop,
+										messageId,
+										data: { keyName, serviceName },
+									});
+								}
+							}
+						}
+					}
+				});
+			}
+		};
+	}
+};
+
 export default {
 	rules: {
 		'prop-types-inferprops': propTypesInferPropsRule,
@@ -1169,6 +1309,7 @@ export default {
 		'file-name-kebab-case': fileNameKebabCaseRule,
 		'no-duplicate-export-names': noDuplicateExportNamesRule,
 		'class-name-kebab-case': classNameKebabCaseRule,
+		'no-hardcoded-config-keys': noHardcodedConfigKeysRule,
 	},
 	configs: {
 		recommended: {
@@ -1188,6 +1329,7 @@ export default {
 				'pixelated/required-proptypes-jsdoc': 'error',
 				'pixelated/no-duplicate-export-names': 'error',
 				'pixelated/class-name-kebab-case': 'error',
+				'pixelated/no-hardcoded-config-keys': 'error',
 			},
 		},
 	},

package/dist/scripts/release.sh

@@ -164,21 +164,15 @@ fi
 echo ""
 echo "📦 Step $((STEP_COUNT++)): Updating dependencies (all sections)..."
 echo "================================================="
-# iterate through prod/dev/optional sections, only bumping same-major versions
-for scope in "" dev optional; do
-    flag=$([ "$scope" ] && echo "--$scope" || echo "")
-    save=$([ "$scope" ] && echo "--save-$scope" || echo "--save")
-    pkgs=$(npm outdated $flag --parseable --long | awk -F: '{ split($2,c,"@"); split($4,l,"@"); split(c[2],cv,"\\."); split(l[2],lv,"\\."); if(cv[1]==lv[1]) print $4 }')
-    if [ -n "$pkgs" ]; then
-        echo "Updating $scope packages: $pkgs"
-        echo "$pkgs" | xargs npm install --force $save 2>/dev/null || true
-    else
-        echo "✅ No $scope updates needed"
-    fi
-done
-# report peer deps separately
-peers=$(npm outdated --parseable --long --peer | awk -F: '{print $4}')
-printf "peer deps (manual): %s\n" "$peers"
+if [ -f "src/scripts/update.sh" ]; then
+    bash src/scripts/update.sh
+elif [ -f "scripts/update.sh" ]; then
+    bash scripts/update.sh
+elif command -v npm &> /dev/null; then
+    npm run update 2>/dev/null || echo "⚠️  No update script found; skipping dependency update"
+else
+    echo "⚠️  Could not find update.sh; skipping dependency update"
+fi
 
 
 
@@ -198,7 +192,20 @@ npm run lint
 
 
 echo ""
-echo "🔨 Step $((STEP_COUNT++)): Encrypting configuration..."
+echo "� Step $((STEP_COUNT++)): Running code coverage check..."
+echo "================================================="
+# Check if test directory exists before running coverage
+if [ -d "src/tests" ] || [ -d "src/test" ]; then
+	npm run test:coverage || exit 1
+	echo "✅ Coverage check passed."
+else
+	echo "⚠️  No test directory found; skipping coverage check"
+fi
+
+
+
+echo ""
+echo "�🔨 Step $((STEP_COUNT++)): Encrypting configuration..."
 echo "================================================="
 if grep -q "\"config:encrypt\":" package.json; then
     echo "🔒 Encrypting configuration..."