spring-boot4-skill 1.0.0

package/README.md

@@ -0,0 +1,144 @@
+# Spring Boot 4 · Java 25 · Spring Framework 7
+
+> **2026-standard** project scaffolder + Claude Code AI skill for Java / Spring development.
+> By [AyrtonAldayr](https://github.com/AyrtonAldayr)
+
+This repository provides two tools in one:
+
+| Tool | What it does |
+|---|---|
+| **`npx spring-boot4-skill`** | Interactive CLI that generates a production-ready Spring Boot 4 project |
+| **Claude Code skill** | AI assistant trained on Spring Boot 4 / Framework 7 / Java 25 standards |
+
+---
+
+## Quick Start — Project Scaffolder
+
+```bash
+npx spring-boot4-skill
+```
+
+Or providing the project name directly:
+
+```bash
+npx spring-boot4-skill my-service
+```
+
+Non-interactive (use all defaults):
+
+```bash
+npx spring-boot4-skill my-service --no-interactive
+
+# Maven instead of Gradle
+npx spring-boot4-skill my-service --maven
+```
+
+### What it generates
+
+After answering a few prompts, you get a complete project with:
+
+- **`build.gradle.kts`** (Gradle Kotlin DSL) or **`pom.xml`** (Maven) — with 2026 BOM versions
+- **`Application.java`** — `@NullMarked`, `proxyBeanMethods = false`, Jakarta EE 11
+- **`application.yaml`** — virtual threads enabled, OTEL endpoints, structured config
+- **`ApplicationTests.java`** — Spring Boot test slice, `WebEnvironment.RANDOM_PORT`
+- **`compose.yaml`** *(optional)* — Docker Compose for PostgreSQL 17, MongoDB 7, OTEL Collector
+- **Spring Modulith module skeleton** *(optional)*
+
+### Wizard options
+
+```
+? Project name:           my-service
+? Base package:           com.acme
+? Build tool:             Gradle Kotlin DSL  ◀ recommended
+? Java version:           25
+? Spring Boot version:    4.0.3
+? Database:               PostgreSQL 17
+? Features:
+  ◉ Actuator + OTEL Observability
+  ◉ Spring Security 7 (OAuth2 Resource Server)
+  ◉ Bean Validation 3.1
+  ◯ Spring Modulith
+  ◯ GraalVM Native Image
+  ◯ Spring WebFlux
+  ◯ Docker Compose support
+? Enable preview features (Structured Concurrency, Scoped Values)?  Yes
+```
+
+---
+
+## Claude Code AI Skill
+
+Install the skill to get AI assistance aligned with Spring Boot 4 / Framework 7 standards.
+
+### Install from GitHub
+
+```bash
+claude skills install github:AyrtonAldayr/agent-skill-java-spring-framework
+```
+
+### What the skill does
+
+Once installed, Claude Code acts as a **Senior Spring Boot 4 architect**:
+
+- Always uses `RestClient`, `JdbcClient`, `HttpServiceProxyFactory` — never `RestTemplate`
+- Uses JSpecify `@NonNull` / `@Nullable` instead of JSR-305
+- Generates `jakarta.*` namespaces (never `javax.*`)
+- Applies Spring Modulith domain-driven patterns
+- Uses Structured Concurrency (`StructuredTaskScope`) and Scoped Values on Java 25
+- Knows native API versioning (`@RequestMapping(version = "...")`)
+- Knows built-in Resilience annotations (`@Retryable`, `@ConcurrencyLimit`)
+
+### Skill reference files
+
+| File | Contents |
+|---|---|
+| `skills/java-spring-framework/references/spring-framework-7.md` | All Spring 7 APIs with code examples |
+| `skills/java-spring-framework/references/spring-boot-4.md` | Boot 4 features: native, virtual threads, Security 7, testing |
+| `skills/java-spring-framework/references/spring-modulith.md` | Module structure, events, integration testing |
+| `skills/java-spring-framework/references/build-templates.md` | Complete Gradle KTS + Maven POM templates |
+
+---
+
+## Platform Requirements
+
+| Component | Version |
+|---|---|
+| Java | 25 (recommended) · 21 · 17 (minimum) |
+| Spring Boot | 4.0.3 |
+| Spring Framework | 7.0.5 |
+| Spring Modulith | 2.0.3 |
+| Jakarta EE | 11 |
+| GraalVM (optional) | 24+ |
+| Node.js (CLI only) | ≥ 20 |
+
+---
+
+## Publishing to npm
+
+```bash
+npm login
+npm publish --access public
+```
+
+After publishing, developers can use:
+
+```bash
+npx spring-boot4-skill
+```
+
+---
+
+## Contributing
+
+PRs welcome. Please keep all generated code aligned with:
+
+- [Spring Boot 4.x docs](https://docs.spring.io/spring-boot/)
+- [Spring Framework 7.x docs](https://docs.spring.io/spring-framework/reference/)
+- [Spring Modulith docs](https://docs.spring.io/spring-modulith/reference/)
+- [JSpecify](https://jspecify.dev/)
+
+---
+
+## License
+
+MIT

package/bin/create-spring-app.js

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+/**
+ * spring-boot4-skill — Interactive CLI scaffolder
+ * Spring Boot 4.x / Spring Framework 7.x / Java 25 (2026 standards)
+ * Author: AyrtonAldayr — https://github.com/AyrtonAldayr/agent-skill-java-spring-framework
+ */
+
+import { program } from 'commander';
+import chalk from 'chalk';
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { runWizard } from '../lib/prompts.js';
+import { generateProject } from '../lib/generator.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(readFileSync(join(__dirname, '../package.json'), 'utf8'));
+
+console.log(
+  chalk.bold.green('\n  ╔══════════════════════════════════════╗') +
+  chalk.bold.green('\n  ║  Spring Boot 4 Project Generator     ║') +
+  chalk.bold.green('\n  ║  Java 25 · Spring Framework 7 · 2026 ║') +
+  chalk.bold.green('\n  ╚══════════════════════════════════════╝\n')
+);
+
+program
+  .name('spring-boot4-skill')
+  .description('Scaffold a Spring Boot 4.x / Java 25 project with 2026 best practices')
+  .version(pkg.version)
+  .argument('[project-name]', 'Project name (skips the prompt)')
+  .option('--gradle', 'Use Gradle Kotlin DSL (default)')
+  .option('--maven', 'Use Maven instead of Gradle')
+  .option('--no-interactive', 'Use defaults without prompts')
+  .action(async (projectName, options) => {
+    try {
+      const answers = await runWizard(projectName, options);
+      await generateProject(answers);
+    } catch (err) {
+      if (err.name === 'ExitPromptError') {
+        console.log(chalk.yellow('\n  Cancelled.'));
+        process.exit(0);
+      }
+      console.error(chalk.red('\n  Error: ') + err.message);
+      process.exit(1);
+    }
+  });
+
+program.parse();

package/lib/generator.js

@@ -0,0 +1,188 @@
+/**
+ * Project generator — renders templates and writes files to disk
+ */
+
+import { mkdirSync, writeFileSync, readFileSync, copyFileSync } from 'fs';
+import { join, dirname, resolve } from 'path';
+import { fileURLToPath } from 'url';
+import chalk from 'chalk';
+import ora from 'ora';
+import { renderTemplate } from './templates.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const TEMPLATES_DIR = join(__dirname, '../templates');
+
+export async function generateProject(config) {
+  const spinner = ora('Generating project…').start();
+  const projectDir = resolve(process.cwd(), config.projectName);
+
+  try {
+    // Derive additional config values
+    const ctx = buildContext(config);
+
+    // Create root project directory
+    mkdirSync(projectDir, { recursive: true });
+
+    // Choose template set
+    const templateSet = config.buildTool === 'maven' ? 'maven' : 'gradle-kotlin';
+
+    // Generate files
+    generateBuildFile(projectDir, templateSet, ctx);
+    generateApplicationClass(projectDir, ctx);
+    generateApplicationYaml(projectDir, ctx, templateSet);
+    generateApplicationTests(projectDir, ctx);
+
+    if (ctx.features.includes('docker-compose')) {
+      generateDockerCompose(projectDir, ctx);
+    }
+
+    if (ctx.features.includes('modulith')) {
+      generateModulithStructure(projectDir, ctx);
+    }
+
+    spinner.succeed(chalk.green(`Project created at ${chalk.bold(projectDir)}`));
+    printNextSteps(config, projectDir);
+
+  } catch (err) {
+    spinner.fail('Generation failed');
+    throw err;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Context builder
+// ---------------------------------------------------------------------------
+
+function buildContext(config) {
+  const appName = toPascalCase(config.projectName);
+  const packagePath = config.packageName.replace(/\./g, '/');
+  const features = config.features || [];
+
+  const dbDependency = {
+    postgresql: "runtimeOnly(\"org.postgresql:postgresql\")",
+    mysql:      "runtimeOnly(\"com.mysql:mysql-connector-j\")",
+    mongodb:    "implementation(\"org.springframework.boot:spring-boot-starter-data-mongodb\")",
+    h2:         "runtimeOnly(\"com.h2database:h2\")",
+    none:       '',
+  }[config.database] || '';
+
+  const dbMavenDep = {
+    postgresql: '<groupId>org.postgresql</groupId><artifactId>postgresql</artifactId><scope>runtime</scope>',
+    mysql:      '<groupId>com.mysql</groupId><artifactId>mysql-connector-j</artifactId><scope>runtime</scope>',
+    mongodb:    '<groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-mongodb</artifactId>',
+    h2:         '<groupId>com.h2database</groupId><artifactId>h2</artifactId><scope>runtime</scope>',
+    none:       '',
+  }[config.database] || '';
+
+  return {
+    ...config,
+    appName,
+    packagePath,
+    features,
+    dbDependency,
+    dbMavenDep,
+    hasJpa: ['postgresql', 'mysql', 'h2'].includes(config.database),
+    hasMongo: config.database === 'mongodb',
+    hasActuator: features.includes('actuator'),
+    hasSecurity: features.includes('security'),
+    hasValidation: features.includes('validation'),
+    hasModulith: features.includes('modulith'),
+    hasNative: features.includes('native'),
+    hasWebFlux: features.includes('webflux'),
+    hasDockerCompose: features.includes('docker-compose'),
+    enablePreview: config.enablePreview !== false && config.javaVersion === '25',
+    year: new Date().getFullYear(),
+    modulithDataDep: (() => {
+      const f = features;
+      const db = config.database;
+      if (!f.includes('modulith')) return '';
+      if (['postgresql', 'mysql', 'h2'].includes(db)) return 'implementation("org.springframework.modulith:spring-modulith-starter-jpa")';
+      if (db === 'mongodb') return 'implementation("org.springframework.modulith:spring-modulith-starter-mongodb")';
+      return '';
+    })(),
+  };
+}
+
+// ---------------------------------------------------------------------------
+// File generators
+// ---------------------------------------------------------------------------
+
+function generateBuildFile(projectDir, templateSet, ctx) {
+  const file = templateSet === 'maven' ? 'pom.xml' : 'build.gradle.kts';
+  const content = renderTemplate(join(TEMPLATES_DIR, templateSet, `${file}.template`), ctx);
+  writeFileSync(join(projectDir, file), content);
+}
+
+function generateApplicationClass(projectDir, ctx) {
+  const srcDir = join(projectDir, 'src/main/java', ctx.packagePath);
+  mkdirSync(srcDir, { recursive: true });
+  const content = renderTemplate(
+    join(TEMPLATES_DIR, 'gradle-kotlin/src/main/java/com/example/app/Application.java.template'),
+    ctx
+  );
+  writeFileSync(join(srcDir, `${ctx.appName}Application.java`), content);
+}
+
+function generateApplicationYaml(projectDir, ctx) {
+  const resourcesDir = join(projectDir, 'src/main/resources');
+  mkdirSync(resourcesDir, { recursive: true });
+  const content = renderTemplate(
+    join(TEMPLATES_DIR, 'gradle-kotlin/src/main/resources/application.yaml.template'),
+    ctx
+  );
+  writeFileSync(join(resourcesDir, 'application.yaml'), content);
+}
+
+function generateApplicationTests(projectDir, ctx) {
+  const testDir = join(projectDir, 'src/test/java', ctx.packagePath);
+  mkdirSync(testDir, { recursive: true });
+  const content = renderTemplate(
+    join(TEMPLATES_DIR, 'gradle-kotlin/src/test/java/com/example/app/ApplicationTests.java.template'),
+    ctx
+  );
+  writeFileSync(join(testDir, `${ctx.appName}ApplicationTests.java`), content);
+}
+
+function generateDockerCompose(projectDir, ctx) {
+  const content = renderTemplate(
+    join(TEMPLATES_DIR, 'gradle-kotlin/compose.yaml.template'),
+    ctx
+  );
+  writeFileSync(join(projectDir, 'compose.yaml'), content);
+}
+
+function generateModulithStructure(projectDir, ctx) {
+  // Create example module structure
+  const modules = ['orders', 'inventory', 'shared'];
+  modules.forEach((mod) => {
+    mkdirSync(join(projectDir, 'src/main/java', ctx.packagePath, mod, 'internal'), { recursive: true });
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function toPascalCase(str) {
+  return str.replace(/(^|[-_])([a-z])/g, (_, __, c) => c.toUpperCase());
+}
+
+function printNextSteps(config, projectDir) {
+  const cd = `cd ${config.projectName}`;
+  const run = config.buildTool === 'maven'
+    ? './mvnw spring-boot:run'
+    : './gradlew bootRun';
+
+  console.log(`
+${chalk.bold('Next steps:')}
+
+  ${chalk.cyan(cd)}
+  ${chalk.cyan(run)}
+
+${chalk.bold('Install the AI coding skill:')}
+
+  ${chalk.cyan(`claude skills install github:AyrtonAldayr/agent-skill-java-spring-framework`)}
+
+${chalk.dim('Docs: https://github.com/AyrtonAldayr/agent-skill-java-spring-framework')}
+`);
+}

package/lib/prompts.js

@@ -0,0 +1,115 @@
+/**
+ * Interactive wizard — collects project configuration
+ */
+
+import inquirer from 'inquirer';
+
+const DEFAULTS = {
+  projectName: 'my-service',
+  packageName: 'com.example',
+  buildTool: 'gradle',
+  javaVersion: '25',
+  bootVersion: '4.0.3',
+  database: 'postgresql',
+  features: ['actuator', 'security', 'validation'],
+};
+
+export async function runWizard(projectNameArg, options = {}) {
+  if (options.interactive === false) {
+    return {
+      ...DEFAULTS,
+      projectName: projectNameArg || DEFAULTS.projectName,
+      buildTool: options.maven ? 'maven' : 'gradle',
+    };
+  }
+
+  const answers = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'projectName',
+      message: 'Project name:',
+      default: projectNameArg || DEFAULTS.projectName,
+      validate: (v) => /^[a-z][a-z0-9-]*$/.test(v) || 'Use lowercase letters, numbers, and hyphens',
+    },
+    {
+      type: 'input',
+      name: 'packageName',
+      message: 'Base package (e.g. com.acme):',
+      default: DEFAULTS.packageName,
+      validate: (v) => /^[a-z][a-z0-9.]*$/.test(v) || 'Use lowercase letters, numbers, and dots',
+    },
+    {
+      type: 'input',
+      name: 'description',
+      message: 'Project description:',
+      default: 'Spring Boot 4 microservice',
+    },
+    {
+      type: 'list',
+      name: 'buildTool',
+      message: 'Build tool:',
+      choices: [
+        { name: 'Gradle Kotlin DSL  (recommended for 2026)', value: 'gradle' },
+        { name: 'Maven POM', value: 'maven' },
+      ],
+      default: options.maven ? 'maven' : 'gradle',
+    },
+    {
+      type: 'list',
+      name: 'javaVersion',
+      message: 'Java version:',
+      choices: [
+        { name: 'Java 25 LTS  (recommended)', value: '25' },
+        { name: 'Java 21 LTS', value: '21' },
+        { name: 'Java 17 LTS  (minimum)', value: '17' },
+      ],
+      default: '25',
+    },
+    {
+      type: 'list',
+      name: 'bootVersion',
+      message: 'Spring Boot version:',
+      choices: [
+        { name: '4.0.3  (stable)', value: '4.0.3' },
+        { name: '4.1.0-M1  (milestone)', value: '4.1.0-M1' },
+      ],
+      default: '4.0.3',
+    },
+    {
+      type: 'list',
+      name: 'database',
+      message: 'Database:',
+      choices: [
+        { name: 'PostgreSQL 17', value: 'postgresql' },
+        { name: 'MySQL 9', value: 'mysql' },
+        { name: 'MongoDB 7.0', value: 'mongodb' },
+        { name: 'H2  (in-memory / dev only)', value: 'h2' },
+        { name: 'None', value: 'none' },
+      ],
+      default: 'postgresql',
+    },
+    {
+      type: 'checkbox',
+      name: 'features',
+      message: 'Features  (space to toggle, enter to confirm):',
+      choices: [
+        { name: 'Spring Actuator + OTEL Observability', value: 'actuator', checked: true },
+        { name: 'Spring Security 7 (OAuth2 Resource Server)', value: 'security', checked: true },
+        { name: 'Bean Validation 3.1', value: 'validation', checked: true },
+        { name: 'Spring Modulith (domain-driven modules)', value: 'modulith', checked: false },
+        { name: 'GraalVM Native Image', value: 'native', checked: false },
+        { name: 'Spring WebFlux (Reactive)', value: 'webflux', checked: false },
+        { name: 'Docker Compose support', value: 'docker-compose', checked: false },
+      ],
+    },
+    {
+      type: 'confirm',
+      name: 'enablePreview',
+      message: 'Enable Java preview features? (Structured Concurrency, Scoped Values)',
+      default: true,
+      when: (ans) => ans.javaVersion === '25',
+    },
+  ]);
+
+  return answers;
+}

package/lib/templates.js

@@ -0,0 +1,45 @@
+/**
+ * Minimal template engine — replaces {{key}} placeholders using a context object.
+ * Supports {{#if key}}...{{/if}} blocks and {{#each array}}...{{/each}}.
+ */
+
+import { readFileSync } from 'fs';
+
+export function renderTemplate(templatePath, ctx) {
+  let source = readFileSync(templatePath, 'utf8');
+  source = processIf(source, ctx);
+  source = processEach(source, ctx);
+  source = interpolate(source, ctx);
+  return source;
+}
+
+/** Replace {{key}} with ctx[key] */
+function interpolate(src, ctx) {
+  return src.replace(/\{\{(\w+)\}\}/g, (_, key) => {
+    const val = ctx[key];
+    return val !== undefined && val !== null ? String(val) : '';
+  });
+}
+
+/** Process {{#if key}}...{{/if}} — supports negation {{#if !key}} */
+function processIf(src, ctx) {
+  return src.replace(
+    /\{\{#if (!?)(\w+)\}\}([\s\S]*?)\{\{\/if\}\}/g,
+    (_, negate, key, body) => {
+      const val = Boolean(ctx[key]);
+      return (negate ? !val : val) ? body : '';
+    }
+  );
+}
+
+/** Process {{#each arrayKey}}...{{/each}} — exposes item as {{item}} */
+function processEach(src, ctx) {
+  return src.replace(
+    /\{\{#each (\w+)\}\}([\s\S]*?)\{\{\/each\}\}/g,
+    (_, key, body) => {
+      const arr = ctx[key];
+      if (!Array.isArray(arr)) return '';
+      return arr.map((item) => body.replace(/\{\{item\}\}/g, String(item))).join('');
+    }
+  );
+}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "spring-boot4-skill",
+  "version": "1.0.0",
+  "description": "Interactive CLI scaffold for Java 25 / Spring Boot 4.x projects — with a bundled Claude Code skill for AI-assisted development.",
+  "type": "module",
+  "bin": {
+    "spring-boot4-skill": "bin/create-spring-app.js"
+  },
+  "scripts": {
+    "start": "node bin/create-spring-app.js",
+    "test": "node --experimental-vm-modules node_modules/.bin/jest"
+  },
+  "keywords": [
+    "spring-boot",
+    "spring-framework",
+    "java",
+    "scaffold",
+    "cli",
+    "generator",
+    "spring-modulith",
+    "graalvm",
+    "jakarta",
+    "claude-skill"
+  ],
+  "author": "AyrtonAldayr",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/AyrtonAldayr/agent-skill-java-spring-framework.git"
+  },
+  "homepage": "https://github.com/AyrtonAldayr/agent-skill-java-spring-framework#readme",
+  "bugs": {
+    "url": "https://github.com/AyrtonAldayr/agent-skill-java-spring-framework/issues"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0",
+    "inquirer": "^10.1.5",
+    "ora": "^8.1.0"
+  }
+}

package/skills/java-spring-framework/SKILL.md

@@ -0,0 +1,56 @@
+---
+name: java-spring-framework
+description: >
+  Senior Java & Spring Boot 4 / Spring Framework 7 architect skill for 2026-standard development.
+  Use when the user asks to build, scaffold, design, review, or explain Java applications using
+  Spring Boot 4.x, Spring Framework 7.x, Spring Modulith, or any related Spring ecosystem project.
+  Triggers include: creating REST APIs, designing microservices, configuring data access (JdbcClient,
+  JPA 3.2, R2DBC), reactive programming (WebFlux), security (Spring Security 7), observability,
+  GraalVM native images, Gradle/Maven build configuration, Jakarta EE 11 migration, and any task
+  requiring idiomatic modern Java (Java 25: records, sealed classes, structured concurrency,
+  scoped values, pattern matching, JSpecify null safety).
+---
+
+# Java & Spring Boot 4 Architect
+
+You are a Senior Java & Spring Boot 4 / Spring Framework 7 architect. All code must be
+idiomatic for **2026 standards**: Spring Boot 4.0.x, Spring Framework 7.0.x, Java 25, Jakarta EE 11.
+
+## Mandatory Workflow
+
+1. **Analyze** — Check if the feature exists natively in Spring 7 before adding a library.
+   (e.g., native API versioning, built-in resilience, `RestClient`, `JdbcClient`)
+2. **Implement** — Use `jakarta.*` namespaces. Use Records for DTOs, Pattern Matching for logic.
+3. **Optimize** — Write Native-Ready code: avoid reflection, prefer functional bean registration.
+4. **Document** — State which Spring 7 / Boot 4 feature is being used in each code block.
+
+## Core Principles
+
+| Concern | Modern Choice | Never Use |
+|---|---|---|
+| HTTP client | `RestClient`, `HttpServiceProxyFactory` | `RestTemplate` |
+| JDBC | `JdbcClient` | `JdbcTemplate` (direct) |
+| Null safety | JSpecify `@Nullable` / `@NonNull` | JSR-305 |
+| Concurrency | `StructuredTaskScope` | raw threads |
+| Build | `build.gradle.kts` (default) | XML Spring config |
+| Namespaces | `jakarta.*` | `javax.*` |
+| DI config | `proxyBeanMethods = false` | proxy-heavy `@Configuration` |
+| Testing | JUnit 5 + `RestTestClient` | JUnit 4, `RestTemplate` in tests |
+
+## Output Style
+
+- Concise, technical, authoritative.
+- Always include full dependency snippet (Gradle KTS preferred).
+- Name the specific Spring Boot / Framework version for each feature used.
+- Use Records for DTOs, `switch` expressions with pattern matching for dispatch logic.
+
+## Reference Files
+
+Load these as needed — do not load all at once:
+
+| Topic | File | Load when |
+|---|---|---|
+| Spring Framework 7 APIs | `references/spring-framework-7.md` | Framework-level features: versioning, resilience, JSpecify, SpEL, streaming |
+| Spring Boot 4 features | `references/spring-boot-4.md` | Boot auto-config, Actuator, native images, testing, virtual threads |
+| Spring Modulith | `references/spring-modulith.md` | Domain-driven module design, event-driven architecture |
+| Build templates | `references/build-templates.md` | Gradle KTS or Maven POM scaffolding with 2026 BOM versions |