Hello, VS Code!
Intellij SFCC is now in Visual Studio Code. Build, deploy, and debug SFRA and SiteGenesis storefronts from one connected workspace
Start with 200+ MCP tools, the Pipelines Editor, TypeScript debugging, SFCC LSP, Local Log Center, and full ISML support
Highlights
Six headline features in v1.0.0. Open a card for examples and details
SFCC MCP · 200+ tools
Connect your coding agent to the SFCC workspace and generate project skills for development, deployment, and debugging
Pipelines Editor & debugger
Create and edit pipeline graphs, work with their XML, and debug execution directly in VS Code
TypeScript · zero setup
Write typed cartridges with SFCC APIs, transpile for your sandbox, and debug your original TypeScript
SFCC LSP · JS, TS, DS & ISML
Completion, references, CodeLens, and navigation across scripts, cartridge overrides, and embedded ISML code
Local Log Center
Turn raw logs into grouped issues, filter the noise, and follow stack frames back to your source
ISML support
Edit template tags, expressions, includes, and custom modules with completion, links, and formatting
Managers
Manage credentials, cartridges, connections, deployments, and resource bundles from dedicated panels and editors
Developer tools
Navigate SFCC code, control site context, validate XML, and edit cartridge paths and templates
SFCC MCP
Give your agent a task. Give it the SFCC context to do it. SFCC MCP connects coding agents to more than 200 tools for the full development cycle: understanding a project, making a change, checking it, deploying it, and debugging a live request
Your agent can ask the extension which cartridge owns a route, what module.superModule resolves to, which fields an API provides, or where an error came from. You spend less time copying files, API documentation, and logs into a chat. The agent works with the same SFCC LSP, cartridge order, site, and sandbox context you use in VS Code
We also provide SFCC skills and project instructions. They teach agents which tools to call, which SFCC patterns to follow, and how to check their work. Generate them for your agent and add them directly to the project from the B2C MCP panel
How your agent connects to SFCC
MCP tools provide access; skills guide their use. A skill describes a repeatable workflow, while tool calls return project facts or perform an operation. The selected Tools & Access profile controls which tools are available. Remote operations use the configured connection and the extension's approval flow
Connect your agent
- Open B2C MCP in the Intellij SFCC sidebar and start the local server if it is stopped
- Open Connect AI, choose your AI app and configuration target, then use the generated setup. Copy config is available for clients you configure manually
- Run the panel's verification prompt in your agent, then check Activity for the resulting request. Keep the VS Code workspace open while using its MCP server
The panel supports clients including Codex, Claude Code, Cursor, GitHub Copilot, Gemini, OpenCode, and others. Use the configuration generated for the current workspace so the agent reaches that project's extension and debugger
Generate project skills
Built-in guidance is already available through MCP. Add project-local skills when you want recurring SFCC workflows available in your agent's own instruction format
- Open Skills & Guidance. Under Format & destination, choose the Skill format and Save project files in workspace folder
- Search by task or choose a Topic. For example, find SFRA Controller Routes & Overrides for controller work or SFCC Live Debugger via MCP for a debugging session
- Select View details to inspect triggers, MCP tools, plugin features, and destination files. Open preview shows the generated Markdown before you add it
- Select Add to project. The extension creates the skill or rule files for your chosen agent. An installed skill offers Open installed; existing files are preserved
Use Add selected topic to create a related group, or Add all skills… for the full catalog. Both show a confirmation with the workspace and destination. The separate Project instruction file control can add the base guidance for using the workspace MCP
Select Codex / Agent Skills to generate an Agent Skills package:
.agents/skills/sfcc-sfra-controller-routes/
SKILL.md
agents/openai.yaml
references/mcp-tool-map.md
scripts/print-mcp-workflow.mjsThe package includes the instructions, agent metadata, tool reference, and a workflow helper
Select Claude Code skill to create the skill in Claude's project directory:
.claude/skills/sfcc-sfra-controller-routes/
SKILL.md
references/mcp-tool-map.md
scripts/print-mcp-workflow.mjsThe instructions and supporting references use the same SFCC workflow in Claude's skill format
Select Cursor Rules to generate a project rule:
.cursor/rules/sfcc-sfra-controller-routes.mdcThe rule includes Cursor frontmatter and the MCP tool map in one file
Select GitHub Copilot / VS Code to generate a project instruction file:
.github/instructions/sfcc-sfra-controller-routes.instructions.mdThe instruction file carries the SFCC workflow and its matching file patterns. Other formats are available in the panel's Skill format picker
Explore the skill catalog, previews, and project instructions
From a task to a verified change
Find the effective Product-Show route and explain which cartridges extend it
The agent reads project context, queries the route index, and follows the cartridge override chain. The route skill guides it to the effective implementation, relevant middleware, and callers, with source locations you can inspect
Add a product badge using our custom attribute, check the change, and prepare it for this sandbox
The agent can inspect metadata types, locate the active controller and template, make the source change, and check language-server diagnostics. Deployment and WebDAV tools connect that work to the active target when the selected profile enables them; remote changes follow the extension's plan and approval flow
Investigate this Log Center issue, follow its stack trace, and help me debug the failing request
The agent can inspect grouped issues and mapped source, then use the live debugger tools for breakpoints, paused stack frames, variables, and expression evaluation. The debugger skill explains the prerequisites and execution controls. After a change, diagnostics and runtime evidence help the agent report what was actually verified
Plan, then execute
Tools that change an instance come in pairs. The plan call returns a planId and a planFingerprint, and the matching .execute call has to send both. A plan works once: a reused, expired, unknown or changed plan fails with plan-used, plan-expired, plan-not-found or plan-mismatch
- Clear failures: a failed tool returns
isErrorwith a code and a next step for the agent - Suggestions: a mistyped name gets the closest matches
- Untrusted content: text read from the instance is marked as untrusted, so the agent treats it as data
- GitHub Copilot: the four Intellij SFCC language model tools hide once an Intellij SFCC MCP server is configured, so Copilot uses MCP
Explore SFCC MCP · B2C MCP panel guide
Pipelines Editor
Open a pipeline XML file as an editable graph in VS Code. Follow branches visually, edit nodes and transitions, and move between the graph and XML source as you work on existing SiteGenesis flows or create new pipelines
- Edit the flow: work with start nodes, pipelets, scripts, decisions, and transitions in the visual editor
- Inspect the details: configure node properties and follow the code behind the flow
- Debug execution: set pipeline breakpoints and inspect the live execution state with the integrated debugger
Use Show Pipeline Editor and Show Pipeline Source to move between the graph and XML. In XML, complete script paths, template names, and pipeline endpoints, then use Go to Definition to open their targets. Pipeline scripts also get typed input/output dictionaries from their annotations
TypeScript and debugging
Write controllers, models, hooks, and helpers in TypeScript with SFCC types available immediately. The extension handles the sandbox development loop: it transpiles TypeScript to JavaScript for the SFCC runtime and maps debugging back to your original source
Write with SFCC types
Use typed dw.* APIs, your project's metadata, and cartridge-aware modules in .ts files. No separate type package or TypeScript project setup is required to begin
Deploy to your sandbox
Upload or deploy through the extension and your TypeScript is transpiled to the JavaScript that runs on the sandbox. Show Transpiled File opens the generated output
Pause in your original source
Set a breakpoint in TypeScript, start the SFCC debugger, and trigger the request. Step through the code, inspect variables and the call stack, and evaluate expressions from VS Code
The debugger also supports JavaScript, Digital Script, and pipelines, with conditional breakpoints, pipeline node breakpoints, and a break on pipeline exceptions
Ready for SFCC's runtime
Use SFCC's CommonJS module conventions and synchronous APIs. Transpilation handles syntax; it does not add missing runtime APIs. Keep deployed JavaScript aligned with your local TypeScript for accurate breakpoint mapping. The CI/CD guide covers transpilation for your release pipeline
TypeScript guide · Debugger guide
SFCC LSP
SFCC code depends on more than the file in front of you. A module can be overridden by another cartridge; a string can point to a route, a template, a hook, or a resource key. The SFCC language server understands those relationships and brings them into everyday editing across JavaScript, TypeScript, Digital Script, and embedded ISML scripting
Useful from the first file
Open a recognized SFCC project and start writing. Bundled dw.* definitions and cartridge discovery provide language support without installing a separate types package or creating a tsconfig.json just to get IntelliSense
| While you work | What the editor provides |
|---|---|
Write a dw.* API call | Member completion, API documentation on hover, and parameter signatures |
| Call a project helper | Types inferred from its implementation and JSDoc, including exported members |
| Fill in an SFCC string argument | Suggestions for routes, hooks, templates, resource keys, and bundle names |
| Check a script | Syntax and type diagnostics in the editor and Problems panel |
| Resolve a supported diagnostic | Diagnostic-driven quick fixes through the editor's lightbulb menu |
| Read unfamiliar code | Inlay hints, document outline, and workspace symbol search |
| Follow a dependency | Go to Definition and Find All References across indexed project files |
var ProductMgr = require("dw/catalog/ProductMgr");
var URLUtils = require("dw/web/URLUtils");
var product = ProductMgr.getProduct("demo-product");
if (product) {
var name = product.name;
var url = URLUtils.url("Product-Show", "pid", product.ID);
}Here, ProductMgr, the returned product, and URLUtils carry their SFCC types. The route argument also draws on your project's route index
Cartridge-aware module resolution
The language server resolves SFCC module paths using the configured cartridge order and active site scope. That gives completion and navigation the same cartridge context you use when developing the storefront
| Path or expression | Resolution |
|---|---|
require('*/cartridge/scripts/helpers/product') | Search the cartridge path for the effective implementation |
require('~/cartridge/scripts/helpers/product') | Resolve within the current cartridge |
require('./product') | Resolve relative to the current module |
require('dw/catalog/ProductMgr') | Use the bundled SFCC API definition |
module.superModule | Find the next matching module after the current cartridge in the path |
require(Resource.msg('helper', 'require', null)) | Resolve a module path supplied by an indexed resource bundle |
Follow module.superModule through the override chain
An override should retain what the parent exports. The editor resolves module.superModule to the parent implementation, provides completion for inherited members, and follows their definitions into the supplying cartridge. Members added by the override are available to code that requires the resulting module
For example, with this cartridge path:
app_custom:app_base
cartridge/scripts/helpers/productLabels.jscartridge/scripts/helpers/productLabels.js/** @param {dw.catalog.Product} product */
exports.getName = function (product) {
return product.name;
};The base cartridge exports getName, with an SFCC product parameter described by JSDoc
var base = module.superModule;
/** @param {dw.catalog.Product} product */
base.getLabel = function (product) {
return base.getName(product) + ' [' + product.ID + ']';
};
module.exports = base;Completion on base includes getName. Go to Definition on that member opens the base implementation, while this cartridge adds getLabel to the exported object
var ProductMgr = require('dw/catalog/ProductMgr');
var labels = require('*/cartridge/scripts/helpers/productLabels');
var product = ProductMgr.getProduct('demo-product');
if (product) {
var name = labels.getName(product);
var label = labels.getLabel(product);
}The wildcard path selects app_custom. The editor understands both the inherited getName member and the added getLabel member
For an SFRA controller, the same parent resolution supports the familiar extension pattern:
var server = require("server");
server.extend(module.superModule);
server.append("Show", function (req, res, next) {
res.setViewData({ showStoreMessage: true });
next();
});
module.exports = server.exports();The parent Product.js is resolved after the current cartridge. Route CodeLens also connects indexed append, prepend, and replace actions, making it easier to follow how a route is extended
Cartridge order matters
*/ starts at the beginning of the cartridge path. module.superModule starts after the current cartridge.
Keep the selected site and cartridge order aligned with the sandbox to follow the intended implementation
Definitions, references, and symbols
Use Go to Definition (F12) to move from an SFCC reference to its source, and Find All References (Shift+F12) to understand who depends on it before making a change. Both are also available from the editor's context menu
| Starting point | Where it leads |
|---|---|
| A required module or exported member | The resolved file or member declaration, including cartridge overrides |
| A route name in a URL helper | Its controller or pipeline definition; route references reveal call sites |
A resource key in Resource.msg() or msgf() | Its .properties entry and indexed usages |
| A template path | The corresponding ISML template |
| A hook name or implementation | The registered hook and its implementing script |
| A custom attribute access | The attribute definition in project metadata XML |
| A custom API or job-step declaration | The linked implementation, schema, or step function |
Find All References also works with script symbols and exported module members consumed by other files. Document outlines expose script structure and SFRA routes; workspace symbol search lets you jump to indexed functions, routes, hooks, custom APIs, and step types by name
CodeLens: useful actions above the code
CodeLens brings the extension's indexed SFCC relationships into the editor as clickable links. The available actions follow the file and symbol you are looking at
| Context | CodeLens actions |
|---|---|
| Controller and pipeline routes | Open the endpoint, copy its URL, and inspect its usages. SFRA routes also link to related append, prepend, and replace actions |
| Hook implementations | See the system or custom hook a function implements and jump to its registration in hooks.json |
| Job-step functions | Jump from the implementation to its entry in steptypes.json |
| Custom APIs | Navigate between api.json, the OpenAPI schema, and the implementation script |
| Resource bundles | Open usage and localization results directly above a .properties key |
| Metadata attributes | See an attribute's usage count in XML and open its references. An indexing label appears while usage information is being prepared |
| Cartridge paths in XML | Open the Cartridge Path Editor from a supported site or global cartridge-path value |
| Source linked to parsed logs | See runtime occurrence counts, open the associated issue or error details, and export a linked Log Center issue |
For example, a route's usage lens answers “where is this URL built?”, while its SFRA action lenses answer “which cartridges extend this route?”. A resource key's lenses connect the same text to both its callers and its translations
Your metadata becomes part of IntelliSense
Project metadata feeds the type system. Custom attributes on system objects appear on .custom, and custom-object definitions inform results from CustomObjectMgr. You can discover project-specific fields through completion and navigate back to their XML definitions
These examples assume the named attributes and object type are defined in your local metadata XML. Select a context to see how its generated types reach your code
var ProductMgr = require('dw/catalog/ProductMgr');
var product = ProductMgr.getProduct('demo-product');
if (product && product.custom.ecoFriendly) {
var label = 'Eco-friendly';
}Invoke completion after product.custom. to find the attribute. Hover ecoFriendly for its type and description; Go to Definition opens its metadata XML
var Site = require('dw/system/Site');
var site = Site.getCurrent();
var enabled = site.getCustomPreferenceValue('showProductBadge');
var samePreference = site.getPreferences().custom.showProductBadge;Preference names and return types come from your SitePreferences definitions. The editor describes the preference's type; the value still comes from the active site at runtime
var CustomObjectMgr = require('dw/object/CustomObjectMgr');
var notice = CustomObjectMgr.getCustomObject('StoreNotice', 'homepage');
if (notice) {
var message = notice.custom.message;
}The literal type ID selects the custom object's generated shape and key type. Complete notice.custom. to explore its attributes, including their metadata documentation
Registered system-hook implementations also benefit from known parameter types. For example, a dw.order.calculate implementation gets basket-aware completion in its calculation function
Typed forms and fields
Local form XML becomes part of IntelliSense. Named fields, nested groups, included forms, and actions feed typed native forms and SFRA server.forms.getForm() results
<?xml version="1.0"?>
<form xmlns="http://www.demandware.com/xml/form/2008-04-19">
<field formid="email" type="string" mandatory="true" />
<field formid="subscribe" type="boolean" />
</form>Save the form and allow indexing to finish. The filename supplies the form name; each formid becomes a named member
var server = require('server');
var form = server.forms.getForm('newsletter');
var email = form.email.value;
var subscribed = form.subscribe.checked;Complete form. to discover fields, then hover form.email.value to inspect its type. Go to Definition on a field or the literal form name returns to the form XML
The same generated form map is available through pdict.CurrentForms in ISML. Types describe the local form structure; validation still runs against the deployed form and submitted request
Each form gets its own type: <Name>Form for native forms and <Name>SfraForm for SFRA, so server.forms.getForm('newsletter') returns NewsletterSfraForm. Go to Definition on a field opens its exact formid. The older shared aliases still compile and show as deprecated. Run Regenerate Form Types from the Command Palette after a bulk change to form XML
Digital Script (.ds)
Work on SiteGenesis and pipeline scripts with syntax highlighting, SFCC API completion, hover documentation, definitions, references, and diagnostics. The language server understands Digital Script imports and the input/output annotations used by pipeline scripts
/** @param {dw.catalog.Product} product */
function getProductLabel(product) {
return product.name || product.ID;
}importScript('util/labels.ds');
var ProductMgr = require('dw/catalog/ProductMgr');
var product = ProductMgr.getProduct('demo-product');
var label = product ? getProductLabel(product) : '';getProductLabel is available by its bare name. Complete it, hover for the parameter type, or use Go to Definition to open labels.ds. The analysis also follows transitive imports and reports local declarations that shadow imported names
importPackage(dw.system);
importClass(dw.util.ArrayList);
var status = new Status(Status.OK);
var items = new ArrayList();importPackage exposes the package's classes by short name; importClass exposes a single class. Status and ArrayList retain their SFCC API completion, documentation, and definitions
/**
* @input Product : dw.catalog.Product Product to display.
* @output Label : String Display label.
*/
function execute(args) {
args.Label = args.Product.name || args.Product.ID;
return PIPELET_NEXT;
}Complete args. for the declared inputs and outputs, then args.Product. for product members. Keep annotations in the first block comment and use the named execute(args) function. The pipeline must still bind its dictionary values at runtime
Legacy for each loops are recognized too. The shared cartridge model connects .ds, .js, .ts, and embedded ISML scripts, so you can follow a dependency across file types. Read the Digital Script guide
E4X
Feed, SOAP and export scripts that build XML with E4X now read as code in .ds and cartridge .js. XML literals are highlighted as markup, x.@id, x..item and the other selectors are typed as XML and XMLList, and none of it reports errors. Hover explains each selector, typing .@ or .. lists the names the file's literals write, and Go to Definition opens where a literal writes a name. Template script gets the selectors too
let and const on Rhino
B2C Commerce runs server code on Rhino, where let does not follow ES6 block scope and const is function scoped. In .ds, cartridge .js outside client folders, and template code, both are reported with Replace 'let' with 'var' and Replace every 'let' and 'const' with 'var' in the file, also as the source.fixAll.intellij-sfcc action. A const assigned again, or a block let that would merge with another variable of the same name, is reported without a fix
Hooks and symbols
| Change | What you get |
|---|---|
| Hook exports | After exports. in a hook script, completion offers the hook's function names, such as beforePATCH, and skips the ones already exported |
| Payment hooks | Signatures follow dw.order.hooks.PaymentHooks: capture and refund take an Invoice; reauthorize, releaseAuthorization and validateAuthorization take an Order |
| Go to Symbol | A controller lists its SFRA routes and SiteGenesis exports as SFCC controller route, and a cartridge's steptypes.json lists its step types |
SFCC LSP guides
Continue with a focused guide for examples, supported patterns, and configuration. These guides cover the shared language tools across JavaScript, TypeScript, Digital Script, and ISML
Local Log Center
Open a local log or follow a sandbox stream, then explore it as structured information. Local Log Center groups repeated errors into issues and connects stack frames to indexed cartridge source
- Filter by severity and search the events relevant to a failure
- Use the histogram and occurrence counts to understand when an issue happened and how often it repeated
- Inspect messages and stack traces, then jump to the matching local source
- Tail and parse remote logs, triage unique events with fixed and backlog marks, spot anomalies, and export HTML, JSON, and PDF reports
- Give an MCP-connected agent the same issue context when working through a fix
ISML support
ISML gets a dedicated editing experience, covering both template markup and the script inside it
Use SFCC JavaScript completion, hover information, and navigation inside ${…} expressions and <isscript> blocks. Template variables introduced by constructs such as <isset> and <isloop> participate in the scripting context
<isscript>
var ProductMgr = require('dw/catalog/ProductMgr');
var product = ProductMgr.getProduct('demo-product');
</isscript>
<isif condition="${product}">
<isprint value="${product.name}" />
</isif>Invoke completion after product. inside the expression to discover its SFCC members. The API type comes from ProductMgr, and stays available across the script block and template expression
Format templates with the built-in formatter and customize the color of <is…> tags. Keep template markup quick to write and consistent to read
Type </ to close the innermost open tag, press Toggle Line Comment to wrap a line in <iscomment>, and type & to complete HTML character entities. Then run Format Document to align the template's nested markup. See editing aids and formatter settings
| Change | What you get |
|---|---|
Bare # | An unescaped # in template text is an error, with Replace with ${'#'} and Escape every # in the file. Format Document escapes them too while intellij-sfcc.isml.formatter.escapeHash is on |
| Structural linter | Unclosed or unmatched tags, misplaced <iselse> and missing required attributes are reported. Turning intellij-sfcc.isml.linter off or on applies without a restart |
| Template links | Go to Definition works on template="..." values and on custom tags |
| Highlighting | ${"..."} inside a double-quoted attribute no longer ends the attribute |
Variables across templates
Templates also share their variables now. What an <isset> or <isloop> declares reaches the templates it renders with <isinclude>, a custom tag or <isdecorate>, with completion that names the declaring template, Go to Definition, Find All References and F2 rename across those templates
Tailored UI/DX
The first release also brings the daily SFCC tools together through dedicated panels, custom editors, contextual actions, and status-bar controls. Choose a connection, code version, and site, then carry that context into navigation, deployment, debugging, and logs
Explore the workspace panels and editors
Smart Search
Search for routes, hooks, job step types, custom APIs, and resource entries by their SFCC identity. Open a result at its declaration or implementation, then continue through the related files using navigation and CodeLens. It is particularly useful when you know an endpoint or hook name but not which cartridge owns it
Credentials Manager
The Credentials Manager stores reusable accounts, access keys, and API clients in an encrypted credentials file shared across workspaces. The unlock key is kept separately in the operating system's secret store. The same credentials file works in the JetBrains plugin, so an account added in one IDE is there in the other
Sandbox 02
Unlink File
Delete File
Cartridges and site scopes
The Cartridges Manager discovers and links cartridges, supports shared modules, and helps you navigate a multi-cartridge project. Inspect override chains, compare implementations, and create an override in the cartridge where it belongs
B2C Site Scopes make cartridge context site-specific. Switch the active site to work with its cartridge path, and use that context when resolving wildcard modules and following overrides. A site scope read from the instance refreshes when the connection changes, when the window gets focus and every 5 minutes, and a notification says when its cartridge path changed
Cartridge management · Overrides · B2C Site Scopes
Cartridge Path Editor
Manage cartridge order in a dedicated editor instead of manually rearranging a colon-separated value. Open it from supported site or global preference XML through CodeLens, reorder the entries, and apply the updated path. This makes the order behind */ and module.superModule easier to inspect
Connections and WebDAV
Organize sandbox connections into groups, switch the active instance and code version, and open Business Manager from the same workspace. The WebDAV explorer browses every instance folder, from code versions and logs to IMPEX, catalogs, and libraries. Download and open files, upload by dragging files onto a folder, create and rename folders, copy and paste items within an instance (with a Replace prompt when the name is taken), compress and unzip archives, delete in bulk, and copy a file or folder to another instance
Compare an open file with its copy on the instance before deciding what to upload; Compare with B2C Instance also runs on the active editor from the Command Palette. Connections live in the Connections Manager, not in dw.json; tools that still read a dw.json style file can be kept in sync with the active connection
Connections guide · WebDAV explorer guide
Deployment Manager
Deploy linked cartridges to one or more sandboxes at once, each with its own code version, upload individual changes, or enable upload-on-save and file watching during development. Local-to-remote comparison helps you review differences, and configurable WebDAV concurrency lets you tune uploads for the sandbox. A new concurrency value applies at once, and a value below 1 falls back to 7
Resources Manager
Work with .properties files in the resource bundle editor. Browse keys and locale values together, edit translations, and follow a key back to its usages. In the text editor, usage and localization CodeLens links keep that context available beside each entry
Built-in XML validation
Validate SFCC XML using the extension's bundled validator and schemas, with no separate Java installation or external XML-validation service to configure. Review inline diagnostics and Problems-panel entries while editing metadata and other supported SFCC XML documents. Validation follows unsaved text about 300 ms after you stop typing, and form XML is checked when the workspace opens. Page Designer JSON in cartridge/experience gets schema completion and validation
Get started
Install the extension, open your cartridge workspace, and select a sandbox connection to begin the edit, deploy, and debug loop
Trial and access
The trial starts without an account. When it ends, the status bar reads Intellij SFCC trial ended - sign in and clicking it opens the sign-in step of Getting Started. Pages that need access show the one next step that applies: Sign In, Choose a Plan, Renew Subscription, View Assigned Seat or, when access could not be checked, Sync Access. After you open a checkout page, the extension checks your access again for 30 minutes and tells you when Plugin access is active
Upgrading from an earlier build
- One plugin folder: the files in
.intellijsfccmove to.intellij-sfccon start and the old folder goes. The folder gets a.gitignoreunless it has one - Route completion rules:
intellij-sfcc.completions.routesis empty by default. The language server adds the built-inURLUtilsandURLActionrules after yours, so you no longer list them - Form types: move from the old shared aliases to the per-form
<Name>Formand<Name>SfraFormtypes - Payment hooks: code written against the old payment hook shapes can show new type errors