implements PLN-0137 (3/7) folding-and-selection-ranges

Advertise folding and selection only when the frontend supports them.
Folding uses recovered spans for the listed declarations, their bodies,
parameter lists, and Doc text blocks. A brace, parenthesis, or text
block the tree does not cover still folds, including an unmatched
opener through the end of the text. Selection grows outward from the
identifier to the argument or parameter list, the block, and the
declaration.

docs/specs/compiler/23. Compiler Pipeline Entry Points Specification.md

@@ -290,6 +290,10 @@ When tooling publishes an editor diagnostic, `source` MUST be the `languageId` o
 
 When a frontend exposes document links, each link MUST cover the span of a module reference whose resolved destination is a compiler-known regular file. A module reference that does not resolve to a regular file MUST produce no link. Tooling MUST NOT target virtual, untitled, or synthetic URIs, including virtual stdlib documents. Document links MUST NOT replace definition. A missing document-link capability MUST NOT be advertised and MUST produce an empty list rather than a protocol error.
 
+When a frontend exposes folding ranges, the ranges MUST come from recovered syntax spans for top-level `fn`, `struct`, `service`, `contract`, `enum`, `error`, `callback`, and `host` declarations, their bodies, and `Doc` text blocks. A parameter list MUST fold from the parenthesis pair. A brace, parenthesis, or text-block delimiter that the recovered tree does not cover MUST still produce a token range, including an unmatched opener through the end of the text. Folding ranges MUST NOT be document symbols.
+
+When a frontend exposes selection ranges, the chain at a cursor MUST run from the inside outward in this order: identifier, argument or parameter list, block or `Doc` text block, declaration. A layer that does not contain the cursor MUST be omitted. A missing folding or selection capability MUST NOT be advertised and MUST produce an empty list rather than a protocol error.
+
 `FrontendSpec` remains the source of static frontend-owned presentation metadata such as semantic vocabularies, host projections, and visual themes. Producing semantic tokens for a live document is an optional editor-facing capability; the existence of static presentation metadata MUST NOT imply that every frontend can provide live semantic-token results.
 
 The frontend registry MUST resolve providers by `languageId`. A lookup for an unknown `languageId` MUST fail explicitly with a diagnostic-friendly error. Unknown languages MUST NOT silently fall back to PBS or to any other frontend.

prometeu-compiler/frontends/prometeu-frontend-pbs/src/main/java/p/studio/compiler/PBSFrontendLanguageService.java

@@ -16,12 +16,15 @@ import p.studio.compiler.pbs.semantics.PbsEditorialSupportService.EditorialDocum
 import p.studio.compiler.models.SourceKind;
 import p.studio.compiler.pbs.semantics.PbsEditorialRename;
 import p.studio.compiler.pbs.semantics.PbsEditorialWorkspaceSymbol;
+import p.studio.compiler.pbs.PbsStructureRanges;
 import p.studio.compiler.pbs.semantics.PbsQuickFix;
 import p.studio.compiler.pbs.semantics.PbsQuickFixCollector;
 import p.studio.compiler.services.PBSFrontendPhaseService.PbsSemanticReadSurface;
 import p.studio.compiler.services.FrontendCodeAction;
 import p.studio.compiler.services.FrontendCompletionCandidate;
 import p.studio.compiler.services.FrontendDocumentLink;
+import p.studio.compiler.services.FrontendFoldingRange;
+import p.studio.compiler.services.FrontendSelectionRange;
 import p.studio.compiler.services.FrontendDefinitionLocation;
 import p.studio.compiler.services.FrontendDocumentRequest;
 import p.studio.compiler.services.FrontendDocumentSymbol;
@@ -443,6 +446,35 @@ public final class PBSFrontendLanguageService implements FrontendLanguageService
         return List.copyOf(links);
     }
 
+    @Override
+    public boolean foldingRangesSupported() {
+        return true;
+    }
+
+    @Override
+    public List<FrontendFoldingRange> foldingRanges(
+            final FrontendDocumentRequest request,
+            final FrontendEditorialContext editorialContext) {
+        return PbsStructureRanges.foldingRanges(request == null || request.documentText() == null
+                ? ""
+                : request.documentText());
+    }
+
+    @Override
+    public boolean selectionRangesSupported() {
+        return true;
+    }
+
+    @Override
+    public List<FrontendSelectionRange> selectionRanges(
+            final FrontendDocumentRequest request,
+            final FrontendEditorialContext editorialContext,
+            final List<Integer> offsets) {
+        return PbsStructureRanges.selectionRanges(
+                request == null || request.documentText() == null ? "" : request.documentText(),
+                offsets);
+    }
+
     @Override
     public boolean codeActionsSupported() {
         return true;

prometeu-compiler/frontends/prometeu-frontend-pbs/src/main/java/p/studio/compiler/pbs/PbsStructureRanges.java

@@ -0,0 +1,380 @@
+package p.studio.compiler.pbs;
+
+import p.studio.compiler.pbs.ast.PbsAst;
+import p.studio.compiler.pbs.lexer.PbsLexer;
+import p.studio.compiler.pbs.lexer.PbsToken;
+import p.studio.compiler.pbs.lexer.PbsTokenKind;
+import p.studio.compiler.pbs.parser.PbsParser;
+import p.studio.compiler.services.FrontendFoldingRange;
+import p.studio.compiler.services.FrontendSelectionRange;
+import p.studio.compiler.source.Span;
+import p.studio.compiler.source.diagnostics.DiagnosticSink;
+import p.studio.compiler.source.identifiers.FileId;
+import p.studio.utilities.structures.ReadOnlyList;
+
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.LinkedHashSet;
+import java.util.List;
+
+public final class PbsStructureRanges {
+    private PbsStructureRanges() {
+    }
+
+    public static List<FrontendFoldingRange> foldingRanges(final String documentText) {
+        final String text = documentText == null ? "" : documentText;
+        final ReadOnlyList<PbsToken> tokens = PbsLexer.lex(text, FileId.none(), DiagnosticSink.empty());
+        final PbsAst.File ast = PbsParser.parse(tokens, FileId.none(), DiagnosticSink.empty());
+        return foldingRanges(text, ast, tokens);
+    }
+
+    public static List<FrontendSelectionRange> selectionRanges(
+            final String documentText,
+            final List<Integer> offsets) {
+        final String text = documentText == null ? "" : documentText;
+        final ReadOnlyList<PbsToken> tokens = PbsLexer.lex(text, FileId.none(), DiagnosticSink.empty());
+        final PbsAst.File ast = PbsParser.parse(tokens, FileId.none(), DiagnosticSink.empty());
+        if (offsets == null || offsets.isEmpty()) {
+            return List.of();
+        }
+        final Collected collected = collect(ast);
+        final List<SpanPair> delimiters = delimiters(tokens, textEnd(text));
+        final ArrayList<FrontendSelectionRange> ranges = new ArrayList<>();
+        for (final Integer offset : offsets) {
+            if (offset == null || offset < 0) {
+                continue;
+            }
+            final FrontendSelectionRange range = selectionAt(offset, tokens, collected, delimiters);
+            if (range != null) {
+                ranges.add(range);
+            }
+        }
+        return List.copyOf(ranges);
+    }
+
+    private static List<FrontendFoldingRange> foldingRanges(
+            final String text,
+            final PbsAst.File ast,
+            final ReadOnlyList<PbsToken> tokens) {
+        final Collected collected = collect(ast);
+        final LinkedHashSet<String> emitted = new LinkedHashSet<>();
+        final ArrayList<SpanPair> ranges = new ArrayList<>();
+        for (final SpanPair span : collected.folding()) {
+            addRange(ranges, emitted, span);
+        }
+        for (final SpanPair delimiter : delimiters(tokens, textEnd(text))) {
+            if (collected.coveredKeys().contains(delimiter.key())) {
+                continue;
+            }
+            addRange(ranges, emitted, delimiter);
+        }
+        ranges.sort(Comparator.comparingInt(SpanPair::start).thenComparingInt(SpanPair::end));
+        return ranges.stream()
+                .map(span -> new FrontendFoldingRange(span.start(), span.end()))
+                .toList();
+    }
+
+    private static FrontendSelectionRange selectionAt(
+            final int offset,
+            final ReadOnlyList<PbsToken> tokens,
+            final Collected collected,
+            final List<SpanPair> delimiters) {
+        final SpanPair identifier = smallest(identifierSpans(tokens), offset);
+        final SpanPair parameters = smallest(delimiters, offset);
+        final SpanPair block = smallest(collected.blocks(), offset);
+        final SpanPair declaration = smallest(collected.declarations(), offset);
+        FrontendSelectionRange node = null;
+        SpanPair previous = null;
+        for (final SpanPair layer : new SpanPair[] {declaration, block, parameters, identifier}) {
+            if (layer == null) {
+                continue;
+            }
+            if (previous != null && previous.start() == layer.start() && previous.end() == layer.end()) {
+                continue;
+            }
+            node = new FrontendSelectionRange(layer.start(), layer.end(), node);
+            previous = layer;
+        }
+        return node;
+    }
+
+    private static Collected collect(final PbsAst.File ast) {
+        final Collected collected = new Collected();
+        if (ast == null || ast.topDecls() == null) {
+            return collected;
+        }
+        for (final PbsAst.TopDecl topDecl : ast.topDecls()) {
+            visitTop(topDecl, true, collected);
+        }
+        return collected;
+    }
+
+    private static void visitTop(
+            final PbsAst.TopDecl topDecl,
+            final boolean topLevel,
+            final Collected collected) {
+        if (topDecl == null) {
+            return;
+        }
+        if (topLevel && isListedDeclaration(topDecl)) {
+            addSpan(collected.folding(), topDecl.span());
+        }
+        if (isListedDeclaration(topDecl) || topDecl instanceof PbsAst.FunctionDecl) {
+            addSpan(collected.declarations(), topDecl.span());
+        }
+        switch (topDecl) {
+            case PbsAst.FunctionDecl functionDecl -> visitFunction(functionDecl, collected);
+            case PbsAst.StructDecl structDecl -> {
+                visitAttributes(structDecl.attributes(), collected);
+                if (structDecl.methods() != null) {
+                    for (final PbsAst.FunctionDecl method : structDecl.methods()) {
+                        visitTop(method, false, collected);
+                    }
+                }
+                if (structDecl.ctors() != null) {
+                    for (final PbsAst.CtorDecl ctor : structDecl.ctors()) {
+                        visitCtor(ctor, collected);
+                    }
+                }
+            }
+            case PbsAst.ServiceDecl serviceDecl -> {
+                visitAttributes(serviceDecl.attributes(), collected);
+                if (serviceDecl.methods() != null) {
+                    for (final PbsAst.FunctionDecl method : serviceDecl.methods()) {
+                        visitTop(method, false, collected);
+                    }
+                }
+            }
+            case PbsAst.ContractDecl contractDecl -> visitAttributes(contractDecl.attributes(), collected);
+            case PbsAst.HostDecl hostDecl -> visitAttributes(hostDecl.attributes(), collected);
+            case PbsAst.EnumDecl enumDecl -> visitAttributes(enumDecl.attributes(), collected);
+            case PbsAst.ErrorDecl errorDecl -> visitAttributes(errorDecl.attributes(), collected);
+            case PbsAst.CallbackDecl callbackDecl -> visitAttributes(callbackDecl.attributes(), collected);
+            default -> {
+            }
+        }
+    }
+
+    private static void visitFunction(
+            final PbsAst.FunctionDecl functionDecl,
+            final Collected collected) {
+        visitAttributes(functionDecl.attributes(), collected);
+        coverBlock(functionDecl.body(), true, collected);
+    }
+
+    private static void visitCtor(
+            final PbsAst.CtorDecl ctor,
+            final Collected collected) {
+        if (ctor == null) {
+            return;
+        }
+        addSpan(collected.declarations(), ctor.span());
+        coverBlock(ctor.body(), true, collected);
+    }
+
+    private static void visitAttributes(
+            final ReadOnlyList<PbsAst.Attribute> attributes,
+            final Collected collected) {
+        if (attributes == null) {
+            return;
+        }
+        for (final PbsAst.Attribute attribute : attributes) {
+            if (attribute == null || attribute.arguments() == null) {
+                continue;
+            }
+            for (final PbsAst.AttributeArgument argument : attribute.arguments()) {
+                if (argument != null && argument.value() instanceof PbsAst.AttributeDocTextBlockValue doc) {
+                    addSpan(collected.folding(), doc.span());
+                    addSpan(collected.blocks(), doc.span());
+                    collected.cover(doc.span());
+                }
+            }
+        }
+    }
+
+    private static void coverBlock(
+            final PbsAst.Block block,
+            final boolean emit,
+            final Collected collected) {
+        if (block == null) {
+            return;
+        }
+        if (emit) {
+            addSpan(collected.folding(), block.span());
+        }
+        addSpan(collected.blocks(), block.span());
+        collected.cover(block.span());
+        if (block.statements() == null) {
+            return;
+        }
+        for (final PbsAst.Statement statement : block.statements()) {
+            coverStatement(statement, collected);
+        }
+    }
+
+    private static void coverStatement(
+            final PbsAst.Statement statement,
+            final Collected collected) {
+        switch (statement) {
+            case null -> {
+            }
+            case PbsAst.IfStatement ifStatement -> {
+                coverBlock(ifStatement.thenBlock(), false, collected);
+                coverBlock(ifStatement.elseBlock(), false, collected);
+                coverStatement(ifStatement.elseIf(), collected);
+            }
+            case PbsAst.ForStatement forStatement -> coverBlock(forStatement.body(), false, collected);
+            case PbsAst.WhileStatement whileStatement -> coverBlock(whileStatement.body(), false, collected);
+            default -> {
+            }
+        }
+    }
+
+    private static boolean isListedDeclaration(final PbsAst.TopDecl topDecl) {
+        return topDecl instanceof PbsAst.FunctionDecl
+                || topDecl instanceof PbsAst.StructDecl
+                || topDecl instanceof PbsAst.ServiceDecl
+                || topDecl instanceof PbsAst.ContractDecl
+                || topDecl instanceof PbsAst.HostDecl
+                || topDecl instanceof PbsAst.EnumDecl
+                || topDecl instanceof PbsAst.ErrorDecl
+                || topDecl instanceof PbsAst.CallbackDecl;
+    }
+
+    private static List<SpanPair> delimiters(
+            final ReadOnlyList<PbsToken> tokens,
+            final int textEnd) {
+        final ArrayList<PbsToken> stack = new ArrayList<>();
+        final ArrayList<SpanPair> pairs = new ArrayList<>();
+        if (tokens == null) {
+            return pairs;
+        }
+        for (final PbsToken token : tokens) {
+            if (token == null) {
+                continue;
+            }
+            if (token.kind() == PbsTokenKind.LEFT_BRACE || token.kind() == PbsTokenKind.LEFT_PAREN) {
+                stack.add(token);
+                continue;
+            }
+            if (token.kind() == PbsTokenKind.DOC_TEXT_BLOCK) {
+                addPair(pairs, token.start(), token.end());
+                continue;
+            }
+            if (token.kind() == PbsTokenKind.RIGHT_BRACE || token.kind() == PbsTokenKind.RIGHT_PAREN) {
+                final PbsTokenKind openKind = token.kind() == PbsTokenKind.RIGHT_BRACE
+                        ? PbsTokenKind.LEFT_BRACE
+                        : PbsTokenKind.LEFT_PAREN;
+                if (!stack.isEmpty() && stack.getLast().kind() == openKind) {
+                    final PbsToken open = stack.removeLast();
+                    addPair(pairs, open.start(), token.end());
+                }
+            }
+        }
+        for (final PbsToken open : stack) {
+            addPair(pairs, open.start(), textEnd);
+        }
+        return pairs;
+    }
+
+    private static List<SpanPair> identifierSpans(final ReadOnlyList<PbsToken> tokens) {
+        final ArrayList<SpanPair> spans = new ArrayList<>();
+        if (tokens == null) {
+            return spans;
+        }
+        for (final PbsToken token : tokens) {
+            if (token != null && token.kind() == PbsTokenKind.IDENTIFIER) {
+                addPair(spans, token.start(), token.end());
+            }
+        }
+        return spans;
+    }
+
+    private static SpanPair smallest(final List<SpanPair> spans, final int offset) {
+        SpanPair best = null;
+        for (final SpanPair span : spans) {
+            if (span.start() > offset || offset >= span.end()) {
+                continue;
+            }
+            if (best == null
+                    || span.end() - span.start() < best.end() - best.start()
+                    || (span.end() - span.start() == best.end() - best.start() && span.start() > best.start())) {
+                best = span;
+            }
+        }
+        return best;
+    }
+
+    private static void addSpan(final List<SpanPair> spans, final Span span) {
+        if (span == null) {
+            return;
+        }
+        addPair(spans, toOffset(span.getStart()), toOffset(span.getEnd()));
+    }
+
+    private static void addPair(final List<SpanPair> spans, final int start, final int end) {
+        if (start < 0 || end <= start) {
+            return;
+        }
+        spans.add(new SpanPair(start, end));
+    }
+
+    private static void addRange(
+            final List<SpanPair> ranges,
+            final LinkedHashSet<String> emitted,
+            final SpanPair span) {
+        if (span == null || !emitted.add(span.key())) {
+            return;
+        }
+        ranges.add(span);
+    }
+
+    private static int textEnd(final String text) {
+        return text.getBytes(StandardCharsets.UTF_8).length;
+    }
+
+    private static int toOffset(final long value) {
+        if (value <= 0L) {
+            return 0;
+        }
+        return (int) Math.min(Integer.MAX_VALUE, value);
+    }
+
+    private record SpanPair(int start, int end) {
+        private String key() {
+            return start + ":" + end;
+        }
+    }
+
+    private static final class Collected {
+        private final ArrayList<SpanPair> folding = new ArrayList<>();
+        private final ArrayList<SpanPair> covered = new ArrayList<>();
+        private final ArrayList<SpanPair> blocks = new ArrayList<>();
+        private final ArrayList<SpanPair> declarations = new ArrayList<>();
+
+        private List<SpanPair> folding() {
+            return folding;
+        }
+
+        private void cover(final Span span) {
+            addSpan(covered, span);
+        }
+
+        private LinkedHashSet<String> coveredKeys() {
+            final LinkedHashSet<String> keys = new LinkedHashSet<>();
+            for (final SpanPair span : covered) {
+                keys.add(span.key());
+            }
+            return keys;
+        }
+
+        private List<SpanPair> blocks() {
+            return blocks;
+        }
+
+        private List<SpanPair> declarations() {
+            return declarations;
+        }
+    }
+}

prometeu-compiler/frontends/prometeu-frontend-pbs/src/test/java/p/studio/compiler/pbs/PbsStructureRangesTest.java

@@ -0,0 +1,73 @@
+package p.studio.compiler.pbs;
+
+import org.junit.jupiter.api.Test;
+import p.studio.compiler.services.FrontendFoldingRange;
+import p.studio.compiler.services.FrontendSelectionRange;
+
+import java.nio.charset.StandardCharsets;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class PbsStructureRangesTest {
+    private static final String SOURCE = """
+            [Doc(markdown = \"\"\"
+            hello
+            \"\"\")]
+            fn length(value: int) -> int {
+              return value;
+            }
+            """;
+
+    @Test
+    void foldingUsesDeclarationBodyParameterListAndDocText() {
+        final var ranges = PbsStructureRanges.foldingRanges(SOURCE);
+        final var slices = ranges.stream().map(range -> slice(SOURCE, range)).toList();
+
+        assertTrue(slices.stream().anyMatch(slice -> slice.contains("hello")), slices.toString());
+        assertTrue(slices.stream().anyMatch(slice -> slice.equals("(value: int)")), slices.toString());
+        assertTrue(slices.stream().anyMatch(slice -> slice.startsWith("{")), slices.toString());
+        assertTrue(slices.stream().anyMatch(slice -> slice.contains("fn length")), slices.toString());
+    }
+
+    @Test
+    void selectionGrowsFromIdentifierToBlockToDeclaration() {
+        final int marker = SOURCE.indexOf("return value");
+        assertTrue(marker >= 0, SOURCE);
+        final int offset = marker + "return ".length();
+        final var selections = PbsStructureRanges.selectionRanges(SOURCE, List.of(offset));
+        assertEquals(1, selections.size(), "offset " + offset);
+        final FrontendSelectionRange selection = selections.getFirst();
+
+        assertEquals("value", slice(SOURCE, selection.startOffset(), selection.endOffset()));
+        assertNotNull(selection.parent());
+        assertTrue(slice(SOURCE, selection.parent().startOffset(), selection.parent().endOffset()).startsWith("{"));
+        assertNotNull(selection.parent().parent());
+        assertTrue(slice(SOURCE, selection.parent().parent().startOffset(), selection.parent().parent().endOffset())
+                .contains("fn length"));
+    }
+
+    @Test
+    void unmatchedBraceFoldsThroughTheEndOfTheText() {
+        final String broken = """
+                fn broken() -> void {
+                  let x: int = 1;
+                """;
+        final int textEnd = broken.getBytes(StandardCharsets.UTF_8).length;
+        final var ranges = PbsStructureRanges.foldingRanges(broken);
+
+        assertTrue(ranges.stream().anyMatch(range ->
+                range.endOffset() == textEnd && slice(broken, range).startsWith("{")));
+    }
+
+    private static String slice(final String text, final FrontendFoldingRange range) {
+        return slice(text, range.startOffset(), range.endOffset());
+    }
+
+    private static String slice(final String text, final int start, final int end) {
+        final byte[] bytes = text.getBytes(StandardCharsets.UTF_8);
+        return new String(bytes, start, end - start, StandardCharsets.UTF_8);
+    }
+}

prometeu-compiler/prometeu-frontend-api/src/main/java/p/studio/compiler/services/FrontendFoldingRange.java

@@ -0,0 +1,15 @@
+package p.studio.compiler.services;
+
+public record FrontendFoldingRange(
+        int startOffset,
+        int endOffset) {
+
+    public FrontendFoldingRange {
+        if (startOffset < 0) {
+            throw new IllegalArgumentException("startOffset must not be negative");
+        }
+        if (endOffset < startOffset) {
+            throw new IllegalArgumentException("endOffset must not be before startOffset");
+        }
+    }
+}

prometeu-compiler/prometeu-frontend-api/src/main/java/p/studio/compiler/services/FrontendLanguageService.java

@@ -153,6 +153,37 @@ public interface FrontendLanguageService {
         return documentLinks(request);
     }
 
+    default boolean foldingRangesSupported() {
+        return false;
+    }
+
+    default List<FrontendFoldingRange> foldingRanges(final FrontendDocumentRequest request) {
+        return List.of();
+    }
+
+    default List<FrontendFoldingRange> foldingRanges(
+            final FrontendDocumentRequest request,
+            final FrontendEditorialContext editorialContext) {
+        return foldingRanges(request);
+    }
+
+    default boolean selectionRangesSupported() {
+        return false;
+    }
+
+    default List<FrontendSelectionRange> selectionRanges(
+            final FrontendDocumentRequest request,
+            final List<Integer> offsets) {
+        return List.of();
+    }
+
+    default List<FrontendSelectionRange> selectionRanges(
+            final FrontendDocumentRequest request,
+            final FrontendEditorialContext editorialContext,
+            final List<Integer> offsets) {
+        return selectionRanges(request, offsets);
+    }
+
     default boolean codeActionsSupported() {
         return false;
     }

prometeu-compiler/prometeu-frontend-api/src/main/java/p/studio/compiler/services/FrontendSelectionRange.java

@@ -0,0 +1,16 @@
+package p.studio.compiler.services;
+
+public record FrontendSelectionRange(
+        int startOffset,
+        int endOffset,
+        FrontendSelectionRange parent) {
+
+    public FrontendSelectionRange {
+        if (startOffset < 0) {
+            throw new IllegalArgumentException("startOffset must not be negative");
+        }
+        if (endOffset < startOffset) {
+            throw new IllegalArgumentException("endOffset must not be before startOffset");
+        }
+    }
+}

prometeu-compiler/prometeu-frontend-api/src/test/java/p/studio/compiler/services/FrontendLanguageServiceTest.java

@@ -33,6 +33,12 @@ class FrontendLanguageServiceTest {
         assertFalse(service.documentLinksSupported());
         assertTrue(service.documentLinks(request).isEmpty());
         assertTrue(service.documentLinks(request, null).isEmpty());
+        assertFalse(service.foldingRangesSupported());
+        assertTrue(service.foldingRanges(request).isEmpty());
+        assertTrue(service.foldingRanges(request, null).isEmpty());
+        assertFalse(service.selectionRangesSupported());
+        assertTrue(service.selectionRanges(request, List.of(0)).isEmpty());
+        assertTrue(service.selectionRanges(request, null, List.of(0)).isEmpty());
         assertFalse(service.codeActionsSupported());
         assertTrue(service.codeActions(request).isEmpty());
         assertTrue(service.codeActions(request, null).isEmpty());

prometeu-lsp/prometeu-lsp-v1/src/main/java/p/studio/lsp/messages/BaselineFoldingRange.java

@@ -0,0 +1,14 @@
+package p.studio.lsp.messages;
+
+public record BaselineFoldingRange(
+        int startLine,
+        int startCharacter,
+        int endLine,
+        int endCharacter) {
+
+    public BaselineFoldingRange {
+        if (startLine < 0 || startCharacter < 0 || endLine < 0 || endCharacter < 0) {
+            throw new IllegalArgumentException("folding range coordinates must not be negative");
+        }
+    }
+}

prometeu-lsp/prometeu-lsp-v1/src/main/java/p/studio/lsp/messages/BaselineFoldingRanges.java

@@ -0,0 +1,13 @@
+package p.studio.lsp.messages;
+
+import java.util.List;
+
+public record BaselineFoldingRanges(List<BaselineFoldingRange> ranges) {
+    public BaselineFoldingRanges {
+        ranges = ranges == null ? List.of() : List.copyOf(ranges);
+    }
+
+    public static BaselineFoldingRanges empty() {
+        return new BaselineFoldingRanges(List.of());
+    }
+}

prometeu-lsp/prometeu-lsp-v1/src/main/java/p/studio/lsp/messages/BaselineSelectionRange.java

@@ -0,0 +1,15 @@
+package p.studio.lsp.messages;
+
+public record BaselineSelectionRange(
+        int startLine,
+        int startCharacter,
+        int endLine,
+        int endCharacter,
+        BaselineSelectionRange parent) {
+
+    public BaselineSelectionRange {
+        if (startLine < 0 || startCharacter < 0 || endLine < 0 || endCharacter < 0) {
+            throw new IllegalArgumentException("selection range coordinates must not be negative");
+        }
+    }
+}

prometeu-lsp/prometeu-lsp-v1/src/main/java/p/studio/lsp/messages/BaselineSelectionRanges.java

@@ -0,0 +1,13 @@
+package p.studio.lsp.messages;
+
+import java.util.List;
+
+public record BaselineSelectionRanges(List<BaselineSelectionRange> ranges) {
+    public BaselineSelectionRanges {
+        ranges = ranges == null ? List.of() : List.copyOf(ranges);
+    }
+
+    public static BaselineSelectionRanges empty() {
+        return new BaselineSelectionRanges(List.of());
+    }
+}

prometeu-lsp/prometeu-lsp-v1/src/main/java/p/studio/lsp/messages/BaselineServerDescription.java

@@ -17,6 +17,8 @@ public record BaselineServerDescription(
         boolean renameSupported,
         boolean codeActionsSupported,
         boolean documentLinksSupported,
+        boolean foldingRangesSupported,
+        boolean selectionRangesSupported,
         List<String> semanticTokenTypes,
         List<BaselineSemanticHostProjection> semanticHostProjections,
         List<BaselineVisualTheme> visualThemes,

prometeu-lsp/prometeu-lsp-v1/src/main/java/p/studio/lsp/services/LanguageServiceBridge.java

@@ -10,6 +10,9 @@ import p.studio.lsp.messages.BaselineWorkspaceSymbols;
 import p.studio.lsp.messages.BaselineCodeActionDiagnostic;
 import p.studio.lsp.messages.BaselineCodeActions;
 import p.studio.lsp.messages.BaselineDocumentLinks;
+import p.studio.lsp.messages.BaselineFoldingRanges;
+import p.studio.lsp.messages.BaselineSelectionRanges;
+import p.studio.lsp.messages.DocumentPosition;
 import p.studio.lsp.messages.BaselinePrepareRename;
 import p.studio.lsp.messages.BaselineRename;
 import p.studio.lsp.messages.BaselineSemanticTokens;
@@ -65,6 +68,18 @@ public interface LanguageServiceBridge {
         return BaselineDocumentLinks.empty();
     }
 
+    default BaselineFoldingRanges foldingRanges(LspProjectContext context, String documentUri, String text) {
+        return BaselineFoldingRanges.empty();
+    }
+
+    default BaselineSelectionRanges selectionRanges(
+            LspProjectContext context,
+            String documentUri,
+            String text,
+            List<DocumentPosition> positions) {
+        return BaselineSelectionRanges.empty();
+    }
+
     BaselineCodeActions codeActions(
             LspProjectContext context,
             String documentUri,

prometeu-lsp/prometeu-lsp-v1/src/main/java/p/studio/lsp/services/compiler/CompilerLanguageServiceBridge.java

@@ -7,6 +7,8 @@ import p.studio.compiler.models.*;
 import p.studio.compiler.services.FrontendCodeAction;
 import p.studio.compiler.services.FrontendCompletionCandidate;
 import p.studio.compiler.services.FrontendDocumentLink;
+import p.studio.compiler.services.FrontendFoldingRange;
+import p.studio.compiler.services.FrontendSelectionRange;
 import p.studio.compiler.services.FrontendLanguageService;
 import p.studio.compiler.services.FrontendDefinitionLocation;
 import p.studio.compiler.services.FrontendDocumentRequest;
@@ -61,6 +63,12 @@ public final class CompilerLanguageServiceBridge implements LanguageServiceBridg
         final boolean documentLinksSupported = languageService
                 .map(FrontendLanguageService::documentLinksSupported)
                 .orElse(false);
+        final boolean foldingRangesSupported = languageService
+                .map(FrontendLanguageService::foldingRangesSupported)
+                .orElse(false);
+        final boolean selectionRangesSupported = languageService
+                .map(FrontendLanguageService::selectionRangesSupported)
+                .orElse(false);
         return new BaselineServerDescription(
                 "Prometeu Studio LSP",
                 "0.1.0",
@@ -75,6 +83,8 @@ public final class CompilerLanguageServiceBridge implements LanguageServiceBridg
                 languageServicePresent,
                 codeActionsSupported,
                 documentLinksSupported,
+                foldingRangesSupported,
+                selectionRangesSupported,
                 presentation.semanticKeys(),
                 presentation.hostProjections().stream().map(this::mapSemanticHostProjection).toList(),
                 presentation.themes().stream().map(this::mapVisualTheme).toList(),
@@ -393,6 +403,120 @@ public final class CompilerLanguageServiceBridge implements LanguageServiceBridg
                 .orElseGet(BaselineDocumentLinks::empty);
     }
 
+    @Override
+    public BaselineFoldingRanges foldingRanges(
+            final LspProjectContext context,
+            final String documentUri,
+            final String text) {
+        return structureRanges(context, documentUri, text, true, List.of()).folding();
+    }
+
+    @Override
+    public BaselineSelectionRanges selectionRanges(
+            final LspProjectContext context,
+            final String documentUri,
+            final String text,
+            final List<DocumentPosition> positions) {
+        return structureRanges(context, documentUri, text, false, positions == null ? List.of() : positions).selection();
+    }
+
+    private StructureRanges structureRanges(
+            final LspProjectContext context,
+            final String documentUri,
+            final String text,
+            final boolean folding,
+            final List<DocumentPosition> positions) {
+        Objects.requireNonNull(context, "context");
+        final var languageService = frontendProvider(context).languageService();
+        if (languageService.isEmpty()) {
+            return StructureRanges.empty();
+        }
+        final boolean supported = folding
+                ? languageService.orElseThrow().foldingRangesSupported()
+                : languageService.orElseThrow().selectionRangesSupported();
+        if (!supported) {
+            return StructureRanges.empty();
+        }
+        final String effectiveText = text == null ? "" : text;
+        final FrontendDocumentRequest request = new FrontendDocumentRequest(
+                context.projectRoot(),
+                normalizeDocumentPath(documentUri),
+                effectiveText);
+        final DocumentPositionMapper mapper = new DocumentPositionMapper(effectiveText);
+        if (folding) {
+            return new StructureRanges(new BaselineFoldingRanges(mapFoldingRanges(
+                    languageService.orElseThrow().foldingRanges(request, null),
+                    mapper)), BaselineSelectionRanges.empty());
+        }
+        final ArrayList<Integer> offsets = new ArrayList<>();
+        for (final DocumentPosition position : positions) {
+            if (position == null) {
+                offsets.add(0);
+                continue;
+            }
+            offsets.add(mapper.byteOffsetOf(position.line(), position.character()));
+        }
+        return new StructureRanges(
+                BaselineFoldingRanges.empty(),
+                new BaselineSelectionRanges(mapSelectionRanges(
+                        languageService.orElseThrow().selectionRanges(request, null, offsets),
+                        mapper)));
+    }
+
+    private List<BaselineFoldingRange> mapFoldingRanges(
+            final List<FrontendFoldingRange> ranges,
+            final DocumentPositionMapper mapper) {
+        if (ranges == null || ranges.isEmpty()) {
+            return List.of();
+        }
+        final ArrayList<BaselineFoldingRange> mapped = new ArrayList<>();
+        for (final FrontendFoldingRange range : ranges) {
+            final DocumentPosition start = mapper.positionOf(range.startOffset());
+            final DocumentPosition end = mapper.positionOf(range.endOffset());
+            mapped.add(new BaselineFoldingRange(
+                    start.line(),
+                    start.character(),
+                    end.line(),
+                    end.character()));
+        }
+        return List.copyOf(mapped);
+    }
+
+    private List<BaselineSelectionRange> mapSelectionRanges(
+            final List<FrontendSelectionRange> ranges,
+            final DocumentPositionMapper mapper) {
+        if (ranges == null || ranges.isEmpty()) {
+            return List.of();
+        }
+        final ArrayList<BaselineSelectionRange> mapped = new ArrayList<>();
+        for (final FrontendSelectionRange range : ranges) {
+            mapped.add(mapSelectionRange(range, mapper));
+        }
+        return List.copyOf(mapped);
+    }
+
+    private BaselineSelectionRange mapSelectionRange(
+            final FrontendSelectionRange range,
+            final DocumentPositionMapper mapper) {
+        if (range == null) {
+            return null;
+        }
+        final DocumentPosition start = mapper.positionOf(range.startOffset());
+        final DocumentPosition end = mapper.positionOf(range.endOffset());
+        return new BaselineSelectionRange(
+                start.line(),
+                start.character(),
+                end.line(),
+                end.character(),
+                mapSelectionRange(range.parent(), mapper));
+    }
+
+    private record StructureRanges(BaselineFoldingRanges folding, BaselineSelectionRanges selection) {
+        private static StructureRanges empty() {
+            return new StructureRanges(BaselineFoldingRanges.empty(), BaselineSelectionRanges.empty());
+        }
+    }
+
     @Override
     public BaselineCodeActions codeActions(
             final LspProjectContext context,

prometeu-lsp/prometeu-lsp-v1/src/main/java/p/studio/lsp/services/protocol/PrometeuTextDocumentService.java

@@ -9,6 +9,7 @@ import org.eclipse.lsp4j.jsonrpc.messages.ResponseErrorCode;
 import org.eclipse.lsp4j.services.LanguageClient;
 import org.eclipse.lsp4j.services.TextDocumentService;
 import p.studio.lsp.messages.BaselineCodeActionDiagnostic;
+import p.studio.lsp.messages.DocumentPosition;
 import p.studio.lsp.messages.LspProjectContext;
 import p.studio.lsp.services.LanguageServiceBridge;
 import p.studio.lsp.services.protocol.mapping.ProtocolMessageMapper;
@@ -168,6 +169,31 @@ public final class PrometeuTextDocumentService implements TextDocumentService {
         return CompletableFuture.completedFuture(protocolMessageMapper.mapRename(result));
     }
 
+    @Override
+    public CompletableFuture<List<FoldingRange>> foldingRange(final FoldingRangeRequestParams params) {
+        final String uri = params.getTextDocument().getUri();
+        final String text = documentTextByUri.get(uri);
+        return CompletableFuture.completedFuture(protocolMessageMapper.mapFoldingRanges(
+                languageServiceBridge.foldingRanges(project, uri, text)));
+    }
+
+    @Override
+    public CompletableFuture<List<SelectionRange>> selectionRange(final SelectionRangeParams params) {
+        final String uri = params.getTextDocument().getUri();
+        final String text = documentTextByUri.get(uri);
+        final ArrayList<DocumentPosition> positions = new ArrayList<>();
+        if (params.getPositions() != null) {
+            for (final Position position : params.getPositions()) {
+                if (position == null) {
+                    continue;
+                }
+                positions.add(new DocumentPosition(position.getLine(), position.getCharacter()));
+            }
+        }
+        return CompletableFuture.completedFuture(protocolMessageMapper.mapSelectionRanges(
+                languageServiceBridge.selectionRanges(project, uri, text, positions)));
+    }
+
     @Override
     public CompletableFuture<List<DocumentLink>> documentLink(final DocumentLinkParams params) {
         final String uri = params.getTextDocument().getUri();

prometeu-lsp/prometeu-lsp-v1/src/main/java/p/studio/lsp/services/protocol/mapping/Lsp4jProtocolMessageMapper.java

@@ -58,6 +58,12 @@ public final class Lsp4jProtocolMessageMapper implements ProtocolMessageMapper {
             documentLinkOptions.setResolveProvider(false);
             capabilities.setDocumentLinkProvider(documentLinkOptions);
         }
+        if (description.foldingRangesSupported()) {
+            capabilities.setFoldingRangeProvider(true);
+        }
+        if (description.selectionRangesSupported()) {
+            capabilities.setSelectionRangeProvider(true);
+        }
         final SemanticTokensWithRegistrationOptions semanticTokens = new SemanticTokensWithRegistrationOptions();
         semanticTokens.setLegend(new SemanticTokensLegend(description.semanticTokenTypes(), List.of()));
         semanticTokens.setFull(true);
@@ -181,6 +187,47 @@ public final class Lsp4jProtocolMessageMapper implements ProtocolMessageMapper {
         return List.copyOf(mapped);
     }
 
+    @Override
+    public List<FoldingRange> mapFoldingRanges(final BaselineFoldingRanges ranges) {
+        if (ranges == null || ranges.ranges().isEmpty()) {
+            return List.of();
+        }
+        final ArrayList<FoldingRange> mapped = new ArrayList<>();
+        for (final BaselineFoldingRange range : ranges.ranges()) {
+            final FoldingRange foldingRange = new FoldingRange();
+            foldingRange.setStartLine(range.startLine());
+            foldingRange.setStartCharacter(range.startCharacter());
+            foldingRange.setEndLine(range.endLine());
+            foldingRange.setEndCharacter(range.endCharacter());
+            mapped.add(foldingRange);
+        }
+        return List.copyOf(mapped);
+    }
+
+    @Override
+    public List<SelectionRange> mapSelectionRanges(final BaselineSelectionRanges ranges) {
+        if (ranges == null || ranges.ranges().isEmpty()) {
+            return List.of();
+        }
+        final ArrayList<SelectionRange> mapped = new ArrayList<>();
+        for (final BaselineSelectionRange range : ranges.ranges()) {
+            mapped.add(mapSelectionRange(range));
+        }
+        return List.copyOf(mapped);
+    }
+
+    private SelectionRange mapSelectionRange(final BaselineSelectionRange range) {
+        if (range == null) {
+            return null;
+        }
+        final SelectionRange selectionRange = new SelectionRange();
+        selectionRange.setRange(new Range(
+                new Position(range.startLine(), range.startCharacter()),
+                new Position(range.endLine(), range.endCharacter())));
+        selectionRange.setParent(mapSelectionRange(range.parent()));
+        return selectionRange;
+    }
+
     @Override
     public List<Either<Command, CodeAction>> mapCodeActions(
             final BaselineCodeActions actions,

prometeu-lsp/prometeu-lsp-v1/src/main/java/p/studio/lsp/services/protocol/mapping/ProtocolMessageMapper.java

@@ -11,6 +11,8 @@ import org.eclipse.lsp4j.SemanticTokens;
 import org.eclipse.lsp4j.Diagnostic;
 import org.eclipse.lsp4j.DocumentLink;
 import org.eclipse.lsp4j.DocumentSymbol;
+import org.eclipse.lsp4j.FoldingRange;
+import org.eclipse.lsp4j.SelectionRange;
 import org.eclipse.lsp4j.Location;
 import org.eclipse.lsp4j.Range;
 import org.eclipse.lsp4j.SymbolInformation;
@@ -21,6 +23,8 @@ import org.eclipse.lsp4j.PrepareRenameDefaultBehavior;
 import org.eclipse.lsp4j.PrepareRenameResult;
 import p.studio.lsp.messages.BaselineDocumentAnalysis;
 import p.studio.lsp.messages.BaselineDocumentLinks;
+import p.studio.lsp.messages.BaselineFoldingRanges;
+import p.studio.lsp.messages.BaselineSelectionRanges;
 import p.studio.lsp.messages.BaselineDocumentSymbols;
 import p.studio.lsp.messages.BaselineWorkspaceSymbols;
 import p.studio.lsp.messages.BaselineCodeActions;
@@ -65,6 +69,14 @@ public interface ProtocolMessageMapper {
         return List.of();
     }
 
+    default List<FoldingRange> mapFoldingRanges(BaselineFoldingRanges ranges) {
+        return List.of();
+    }
+
+    default List<SelectionRange> mapSelectionRanges(BaselineSelectionRanges ranges) {
+        return List.of();
+    }
+
     CompletionList mapCompletion(BaselineCompletion completion);
 
     SignatureHelp mapSignatureHelp(BaselineSignatureHelp signatureHelp);

prometeu-lsp/prometeu-lsp-v1/src/test/java/p/studio/lsp/services/compiler/CompilerLanguageServiceBridgeTest.java

@@ -11,6 +11,7 @@ import p.studio.compiler.services.FrontendProvider;
 import p.studio.compiler.source.diagnostics.DiagnosticSink;
 import p.studio.lsp.messages.BaselineCodeActionDiagnostic;
 import p.studio.lsp.messages.BaselineIssueSeverity;
+import p.studio.lsp.messages.DocumentPosition;
 import p.studio.lsp.messages.LspProjectContext;
 import p.studio.utilities.logs.LogAggregator;
 import p.studio.utilities.structures.ReadOnlySet;
@@ -77,6 +78,9 @@ class CompilerLanguageServiceBridgeTest {
                 new BaselineCodeActionDiagnostic("E_SEM_DUPLICATE_RESERVED_ATTRIBUTE", 0, 0, 0, 1)))
                 .actions().isEmpty());
         assertTrue(bridge.documentLinks(context, documentUri, "fn main() {}").links().isEmpty());
+        assertTrue(bridge.foldingRanges(context, documentUri, "fn main() {}").ranges().isEmpty());
+        assertTrue(bridge.selectionRanges(context, documentUri, "fn main() {}", List.of(new DocumentPosition(0, 0)))
+                .ranges().isEmpty());
     }
 
     @Test
@@ -772,6 +776,8 @@ class CompilerLanguageServiceBridgeTest {
         assertTrue(description.renameSupported());
         assertTrue(description.codeActionsSupported());
         assertTrue(description.documentLinksSupported());
+        assertTrue(description.foldingRangesSupported());
+        assertTrue(description.selectionRangesSupported());
         assertEquals(1, description.semanticHostProjections().size());
         assertEquals("vscode", description.semanticHostProjections().getFirst().hostId());
         assertTrue(description.semanticHostProjections().getFirst().tokenProjections().stream()

prometeu-lsp/prometeu-lsp-v1/src/test/java/p/studio/lsp/services/protocol/PrometeuLanguageServerTest.java

@@ -106,6 +106,8 @@ class PrometeuLanguageServerTest {
                 true,
                 false,
                 false,
+                false,
+                false,
                 List.of(),
                 List.of(new BaselineSemanticHostProjection(
                         "vscode",

prometeu-lsp/prometeu-lsp-v1/src/test/java/p/studio/lsp/services/protocol/mapping/Lsp4jProtocolMessageMapperTest.java

@@ -58,6 +58,8 @@ final class Lsp4jProtocolMessageMapperTest {
                 true,
                 true,
                 true,
+                true,
+                true,
                 List.of("demo-keyword"),
                 List.of(new BaselineSemanticHostProjection(
                         "vscode",
@@ -86,6 +88,8 @@ final class Lsp4jProtocolMessageMapperTest {
         assertEquals(List.of(CodeActionKind.QuickFix), result.getCapabilities().getCodeActionProvider().getRight().getCodeActionKinds());
         assertEquals(Boolean.FALSE, result.getCapabilities().getCodeActionProvider().getRight().getResolveProvider());
         assertEquals(Boolean.FALSE, result.getCapabilities().getDocumentLinkProvider().getResolveProvider());
+        assertEquals(Boolean.TRUE, result.getCapabilities().getFoldingRangeProvider().getLeft());
+        assertEquals(Boolean.TRUE, result.getCapabilities().getSelectionRangeProvider().getLeft());
 
         final var experimental = assertInstanceOf(Map.class, result.getCapabilities().getExperimental());
         final var semanticPayload = assertInstanceOf(Map.class, experimental.get("prometeuSemanticHostProjections"));
@@ -308,6 +312,8 @@ final class Lsp4jProtocolMessageMapperTest {
         final var mapper = new Lsp4jProtocolMessageMapper();
         final var unsupported = mapper.mapInitializeResult(serverDescription(false));
         assertNull(unsupported.getCapabilities().getDocumentLinkProvider());
+        assertNull(unsupported.getCapabilities().getFoldingRangeProvider());
+        assertNull(unsupported.getCapabilities().getSelectionRangeProvider());
 
         final var mapped = mapper.mapDocumentLinks(new BaselineDocumentLinks(List.of(
                 new BaselineDocumentLink("file:///tmp/a/source.pbs", 0, 19, 0, 25))));
@@ -335,6 +341,8 @@ final class Lsp4jProtocolMessageMapperTest {
                 true,
                 true,
                 documentLinksSupported,
+                documentLinksSupported,
+                documentLinksSupported,
                 List.of("demo-keyword"),
                 List.of(new BaselineSemanticHostProjection(
                         "vscode",