@platformos/platformos-language-server-common 0.0.12 → 0.0.13

package/dist/utils/searchPaths.d.ts

@@ -0,0 +1,21 @@
+import { AbstractFileSystem } from '@platformos/platformos-common';
+import { URI } from 'vscode-uri';
+/**
+ * Cached loader for theme_search_paths from app/config.yml.
+ *
+ * Caches per root URI so that repeated calls (document links, definitions,
+ * checks) within the same editor session don't re-read and re-parse the
+ * config file on every invocation.
+ *
+ * Call `invalidate()` when app/config.yml changes on disk — the file watcher
+ * in startServer.ts handles this. This is the only reliable invalidation
+ * point because config.yml changes may come from external tools (vim, CLI)
+ * that don't trigger editor-level change events.
+ */
+export declare class SearchPathsLoader {
+    private fs;
+    private cache;
+    constructor(fs: AbstractFileSystem);
+    get(rootUri: URI): Promise<string[] | null>;
+    invalidate(): void;
+}

package/dist/utils/searchPaths.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SearchPathsLoader = void 0;
+const platformos_common_1 = require("@platformos/platformos-common");
+/**
+ * Cached loader for theme_search_paths from app/config.yml.
+ *
+ * Caches per root URI so that repeated calls (document links, definitions,
+ * checks) within the same editor session don't re-read and re-parse the
+ * config file on every invocation.
+ *
+ * Call `invalidate()` when app/config.yml changes on disk — the file watcher
+ * in startServer.ts handles this. This is the only reliable invalidation
+ * point because config.yml changes may come from external tools (vim, CLI)
+ * that don't trigger editor-level change events.
+ */
+class SearchPathsLoader {
+    constructor(fs) {
+        this.fs = fs;
+        this.cache = new Map();
+    }
+    get(rootUri) {
+        const key = rootUri.toString();
+        if (!this.cache.has(key)) {
+            this.cache.set(key, (0, platformos_common_1.loadSearchPaths)(this.fs, rootUri));
+        }
+        return this.cache.get(key);
+    }
+    invalidate() {
+        this.cache.clear();
+    }
+}
+exports.SearchPathsLoader = SearchPathsLoader;
+//# sourceMappingURL=searchPaths.js.map

package/dist/utils/searchPaths.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"searchPaths.js","sourceRoot":"","sources":["../../src/utils/searchPaths.ts"],"names":[],"mappings":";;;AAAA,qEAAoF;AAGpF;;;;;;;;;;;GAWG;AACH,MAAa,iBAAiB;IAG5B,YAAoB,EAAsB;QAAtB,OAAE,GAAF,EAAE,CAAoB;QAFlC,UAAK,GAAG,IAAI,GAAG,EAAoC,CAAC;IAEf,CAAC;IAE9C,GAAG,CAAC,OAAY;QACd,MAAM,GAAG,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC;QAC/B,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;YACzB,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE,IAAA,mCAAe,EAAC,IAAI,CAAC,EAAE,EAAE,OAAO,CAAC,CAAC,CAAC;QACzD,CAAC;QACD,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,CAAE,CAAC;IAC9B,CAAC;IAED,UAAU;QACR,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC;IACrB,CAAC;CACF;AAhBD,8CAgBC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformos/platformos-language-server-common",
-  "version": "0.0.12",
+  "version": "0.0.13",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "author": "platformOS",
@@ -27,10 +27,12 @@
     "type-check": "tsc --noEmit -p ./tsconfig.json"
   },
   "dependencies": {
-    "@platformos/liquid-html-parser": "^0.0.11",
-    "@platformos/platformos-check-common": "0.0.12",
-    "@platformos/platformos-graph": "0.0.12",
+    "@platformos/liquid-html-parser": "^0.0.12",
+    "@platformos/platformos-check-common": "0.0.13",
+    "@platformos/platformos-graph": "0.0.13",
     "@vscode/web-custom-data": "^0.4.6",
+    "graphql": "^16.12.0",
+    "graphql-language-service": "^5.2.2",
     "vscode-json-languageservice": "^5.7.1",
     "vscode-languageserver": "^9.0.1",
     "vscode-css-languageservice": "^6.3.9",

package/src/PropertyShapeInference.spec.ts

@@ -0,0 +1,44 @@
+import { describe, expect, it } from 'vitest';
+import { shapeToJSONPlaceholder } from './PropertyShapeInference';
+import type { PropertyShape } from './PropertyShapeInference';
+
+describe('shapeToJSONPlaceholder', () => {
+  it('returns "null" for undefined', () => {
+    expect(shapeToJSONPlaceholder(undefined)).toBe('null');
+  });
+
+  it('returns "" for string primitive', () => {
+    const shape: PropertyShape = { kind: 'primitive', primitiveType: 'string' };
+    expect(shapeToJSONPlaceholder(shape)).toBe('""');
+  });
+
+  it('returns "0" for number primitive', () => {
+    const shape: PropertyShape = { kind: 'primitive', primitiveType: 'number' };
+    expect(shapeToJSONPlaceholder(shape)).toBe('0');
+  });
+
+  it('returns "true" for boolean primitive', () => {
+    const shape: PropertyShape = { kind: 'primitive', primitiveType: 'boolean' };
+    expect(shapeToJSONPlaceholder(shape)).toBe('true');
+  });
+
+  it('returns "null" for null primitive', () => {
+    const shape: PropertyShape = { kind: 'primitive', primitiveType: 'null' };
+    expect(shapeToJSONPlaceholder(shape)).toBe('null');
+  });
+
+  it('returns "null" for untyped primitive', () => {
+    const shape: PropertyShape = { kind: 'primitive' };
+    expect(shapeToJSONPlaceholder(shape)).toBe('null');
+  });
+
+  it('returns "[]" for array shape', () => {
+    const shape: PropertyShape = { kind: 'array' };
+    expect(shapeToJSONPlaceholder(shape)).toBe('[]');
+  });
+
+  it('returns "{}" for object shape', () => {
+    const shape: PropertyShape = { kind: 'object', properties: new Map() };
+    expect(shapeToJSONPlaceholder(shape)).toBe('{}');
+  });
+});

package/src/PropertyShapeInference.ts

@@ -472,3 +472,30 @@ export function mergePropertyIntoShape(
   newProperties.set(key, valueShape);
   return { kind: 'object', properties: newProperties };
 }
+
+/**
+ * Map a PropertyShape to a JSON literal placeholder string suitable for
+ * substituting a {{ expr | json }} expression during static analysis.
+ */
+export function shapeToJSONPlaceholder(shape: PropertyShape | undefined): string {
+  if (!shape) return 'null';
+  switch (shape.kind) {
+    case 'primitive':
+      switch (shape.primitiveType) {
+        case 'string':
+          return '""';
+        case 'number':
+          return '0';
+        case 'boolean':
+          return 'true';
+        default:
+          return 'null';
+      }
+    case 'array':
+      return '[]';
+    case 'object':
+      return '{}';
+    default:
+      return 'null';
+  }
+}

package/src/TypeSystem.spec.ts

@@ -901,4 +901,63 @@ query {
       }
     });
   });
+
+  describe('parse_json block with {{ expr | json }} children', () => {
+    it('infers object shape from static JSON in block form (baseline)', async () => {
+      // Existing behaviour: static JSON works fine
+      const ast = toLiquidHtmlAST(
+        `{% parse_json data %}{"id": 1, "name": "hello"}{% endparse_json %}{{ data }}`,
+      );
+      const output = ast.children[1];
+      assert(isLiquidVariableOutput(output));
+      const inferredType = await typeSystem.inferType(output.markup, ast, 'file:///file.liquid');
+      assert(typeof inferredType !== 'string' && inferredType.kind === 'shape');
+      expect(inferredType.shape.properties?.has('id')).toBe(true);
+      expect(inferredType.shape.properties?.has('name')).toBe(true);
+    });
+
+    it('infers object shape when values are {{ expr | json }} — unresolvable falls back to null', async () => {
+      // object.unknown_var is not in the docset, so shape is unresolvable → null placeholder
+      const ast = toLiquidHtmlAST(
+        `{% parse_json data %}\n{"id": {{ object.unknown_var | json }}, "name": {{ object.unknown_var2 | json }}}\n{% endparse_json %}{{ data }}`,
+      );
+      const output = ast.children[1];
+      assert(isLiquidVariableOutput(output));
+      const inferredType = await typeSystem.inferType(output.markup, ast, 'file:///file.liquid');
+      // Keys must be discovered even when types are unknown
+      assert(typeof inferredType !== 'string' && inferredType.kind === 'shape');
+      expect(inferredType.shape.properties?.has('id')).toBe(true);
+      expect(inferredType.shape.properties?.has('name')).toBe(true);
+    });
+
+    it('infers correct value types when the expression resolves via the type system', async () => {
+      // user is established as a ShapeType by the first parse_json block
+      const ast = toLiquidHtmlAST(
+        `{% parse_json user %}{"name": "John", "age": 30}{% endparse_json %}\n{% parse_json data %}\n{"username": {{ user.name | json }}, "years": {{ user.age | json }}}\n{% endparse_json %}{{ data }}`,
+      );
+      const output = ast.children[2];
+      assert(isLiquidVariableOutput(output));
+      const inferredType = await typeSystem.inferType(output.markup, ast, 'file:///file.liquid');
+      assert(typeof inferredType !== 'string' && inferredType.kind === 'shape');
+      const usernameShape = inferredType.shape.properties?.get('username');
+      expect(usernameShape?.kind).toBe('primitive');
+      expect(usernameShape?.primitiveType).toBe('string');
+      const yearsShape = inferredType.shape.properties?.get('years');
+      expect(yearsShape?.kind).toBe('primitive');
+      expect(yearsShape?.primitiveType).toBe('number');
+    });
+
+    it('falls back gracefully when no | json filter present on LiquidVariableOutput', async () => {
+      // Without | json, fall back to null for that key; key still discoverable via TextNode context
+      const ast = toLiquidHtmlAST(
+        `{% parse_json data %}\n{"title": "{{ object.title }}"}\n{% endparse_json %}{{ data }}`,
+      );
+      const output = ast.children[1];
+      assert(isLiquidVariableOutput(output));
+      const inferredType = await typeSystem.inferType(output.markup, ast, 'file:///file.liquid');
+      // key must still be discovered (the TextNodes provide `"title": "` and `"`)
+      assert(typeof inferredType !== 'string' && inferredType.kind === 'shape');
+      expect(inferredType.shape.properties?.has('title')).toBe(true);
+    });
+  });
 });

package/src/TypeSystem.ts

@@ -11,6 +11,7 @@ import {
   LiquidTagIncrement,
   LiquidVariable,
   LiquidVariableLookup,
+  LiquidVariableOutput,
   NamedTags,
   NodeTypes,
   TextNode,
@@ -28,8 +29,6 @@ import {
   ReturnType,
   SourceCodeType,
   PlatformOSDocset,
-  isError,
-  parseJSON,
   path,
   BasicParamTypes,
   getValidParamTypes,
@@ -42,10 +41,9 @@ import {
   inferShapeFromJSONString,
   inferShapeFromJsonLiteral,
   inferShapeFromGraphQL,
-  lookupPropertyPath,
   mergeShapes,
   shapeToTypeString,
-  shapeToDetailString,
+  shapeToJSONPlaceholder,
 } from './PropertyShapeInference';
 import { AbstractFileSystem, DocumentsLocator } from '@platformos/platformos-common';
 import { URI } from 'vscode-uri';
@@ -396,58 +394,12 @@ async function buildSymbolsTable(
       let valueShape: PropertyShape | undefined;
 
       // Resolver for variable references inside JSON literals
-      const resolveExpr = (expr: LiquidExpression): PropertyShape | undefined => {
-        if (expr.type !== NodeTypes.VariableLookup || !expr.name) return undefined;
-
-        // Look up the variable's shape from already-processed assignments
-        const shapes = variableShapes.get(expr.name);
-        const shapeEntry = shapes
-          ? findLastApplicableShape(shapes, node.position.start)
-          : undefined;
-        let shape = shapeEntry?.shape;
-
-        // Fall back to seedSymbolsTable
-        if (!shape && seedSymbolsTable[expr.name]) {
-          for (const tr of seedSymbolsTable[expr.name]) {
-            if (tr.range[0] < node.position.start) {
-              if (typeof tr.type !== 'string' && tr.type.kind === 'shape') {
-                shape = tr.type.shape;
-              } else if (typeof tr.type === 'string' || tr.type.kind === 'array') {
-                shape = resolvedTypeToShape(tr.type);
-              }
-            }
-          }
-        }
-
-        if (!shape) return undefined;
-
-        // Resolve lookups (e.g. a.x or a["key"])
-        for (const lookup of expr.lookups) {
-          if (shape.kind === 'object' && lookup.type === NodeTypes.String && shape.properties) {
-            const prop = shape.properties.get(lookup.value);
-            if (prop) {
-              shape = prop;
-            } else {
-              return undefined;
-            }
-          } else if (shape.kind === 'array') {
-            if (
-              lookup.type === NodeTypes.Number ||
-              (lookup.type === NodeTypes.String &&
-                (lookup.value === 'first' || lookup.value === 'last'))
-            ) {
-              shape = shape.itemShape;
-              if (!shape) return undefined;
-            } else {
-              return undefined;
-            }
-          } else {
-            return undefined;
-          }
-        }
-
-        return shape;
-      };
+      const resolveExpr = resolveExpressionShape(
+        node.position.start,
+        variableShapes,
+        seedSymbolsTable,
+        objectMap,
+      );
 
       // Case 1: JSON literal expression
       if (
@@ -649,9 +601,26 @@ async function buildSymbolsTable(
       else if (isLiquidTagParseJson(node)) {
         const variableName = node.markup.name;
         if (variableName && node.children) {
+          const resolveExprAtTag = resolveExpressionShape(
+            node.position.start,
+            variableShapes,
+            seedSymbolsTable,
+            objectMap,
+          );
           const textContent = node.children
-            .filter((c): c is TextNode => c.type === NodeTypes.TextNode)
-            .map((c) => c.value)
+            .map((child) => {
+              if (child.type === NodeTypes.TextNode) return (child as TextNode).value;
+              if (child.type === NodeTypes.LiquidVariableOutput) {
+                const variable = (child as LiquidVariableOutput).markup;
+                if (typeof variable === 'string') return 'null';
+                const lastFilter = variable.filters?.at(-1);
+                if (lastFilter?.name === 'json') {
+                  return shapeToJSONPlaceholder(resolveExprAtTag(variable.expression));
+                }
+                return 'null';
+              }
+              return 'null';
+            })
             .join('');
           const shape = inferShapeFromJSONString(textContent);
           if (shape) {
@@ -1746,6 +1715,98 @@ function mergeNestedPropertyIntoShape(
   return { kind: 'object', properties: newProperties };
 }
 
+/**
+ * Resolve a LiquidExpression to a PropertyShape using accumulated variable shapes,
+ * the seed symbols table, and optionally the docset object map.
+ *
+ * Returns a resolver function that takes a LiquidExpression and returns a PropertyShape
+ * or undefined.
+ */
+function resolveExpressionShape(
+  atPosition: number,
+  variableShapes: Map<string, { shape: PropertyShape; rangeEnd: number }[]>,
+  seedSymbolsTable: Record<string, TypeRange[]>,
+  objectMap?: Record<string, ObjectEntry>,
+): (expr: LiquidExpression | ComplexLiquidExpression) => PropertyShape | undefined {
+  return (expr) => {
+    if (expr.type !== NodeTypes.VariableLookup || !expr.name) return undefined;
+
+    // Look up the variable's shape from already-processed assignments
+    const shapes = variableShapes.get(expr.name);
+    const shapeEntry = shapes ? findLastApplicableShape(shapes, atPosition) : undefined;
+    let shape: PropertyShape | undefined = shapeEntry?.shape;
+
+    // Track the current PseudoType (docset object name) for objectMap-based property resolution
+    let pseudoType: string | undefined;
+
+    // Fall back to seedSymbolsTable
+    if (!shape && !pseudoType && seedSymbolsTable[expr.name]) {
+      for (const tr of seedSymbolsTable[expr.name]) {
+        if (tr.range[0] < atPosition) {
+          if (typeof tr.type !== 'string' && tr.type.kind === 'shape') {
+            shape = tr.type.shape;
+          } else if (typeof tr.type === 'string') {
+            pseudoType = tr.type;
+            shape = resolvedTypeToShape(tr.type);
+          } else if (tr.type.kind === 'array') {
+            shape = resolvedTypeToShape(tr.type);
+          }
+        }
+      }
+    }
+
+    if (!shape && !pseudoType) return undefined;
+
+    // Resolve lookups (e.g. a.x or a["key"])
+    for (const lookup of expr.lookups) {
+      // PseudoType resolution via objectMap (e.g. context.current_user where context is a docset type)
+      if (pseudoType !== undefined && objectMap) {
+        if (lookup.type !== NodeTypes.String) return undefined;
+        const propType = inferPseudoTypePropertyType(pseudoType, lookup, objectMap);
+        // inferPseudoTypePropertyType returns PseudoType | ArrayType (string or { kind: 'array' })
+        if (typeof propType === 'string') {
+          pseudoType = propType;
+          shape = resolvedTypeToShape(propType);
+        } else if (isArrayType(propType)) {
+          pseudoType = undefined;
+          shape = resolvedTypeToShape(propType);
+        } else {
+          return undefined;
+        }
+        continue;
+      }
+
+      if (!shape) return undefined;
+
+      if (shape.kind === 'object' && lookup.type === NodeTypes.String && shape.properties) {
+        const prop = shape.properties.get(lookup.value);
+        if (prop) {
+          pseudoType = undefined;
+          shape = prop;
+        } else {
+          return undefined;
+        }
+      } else if (shape.kind === 'array') {
+        if (
+          lookup.type === NodeTypes.Number ||
+          (lookup.type === NodeTypes.String &&
+            (lookup.value === 'first' || lookup.value === 'last'))
+        ) {
+          pseudoType = undefined;
+          shape = shape.itemShape;
+          if (!shape) return undefined;
+        } else {
+          return undefined;
+        }
+      } else {
+        return undefined;
+      }
+    }
+
+    return shape;
+  };
+}
+
 /**
  * Find the last applicable shape for a variable at a given position
  */

package/src/VariableShapeExtractor.ts

@@ -107,8 +107,7 @@ export async function extractVariableShapes(
           closeShapeRange(variableName, node.position.end);
 
           const textContent = node.children
-            .filter((c): c is TextNode => c.type === NodeTypes.TextNode)
-            .map((c) => c.value)
+            .map((c) => (c.type === NodeTypes.TextNode ? (c as TextNode).value : 'null'))
             .join('');
           const shape = inferShapeFromJSONString(textContent);
           if (shape) {
@@ -129,8 +128,7 @@ export async function extractVariableShapes(
 
         if (node.children) {
           const textContent = node.children
-            .filter((c): c is TextNode => c.type === NodeTypes.TextNode)
-            .map((c) => c.value)
+            .map((c) => (c.type === NodeTypes.TextNode ? (c as TextNode).value : 'null'))
             .join('');
           const shape = inferShapeFromGraphQL(textContent, graphqlSchema);
           if (shape) {

package/src/completions/CompletionsProvider.ts

@@ -27,6 +27,7 @@ import {
   TranslationCompletionProvider,
 } from './providers';
 import { GetPartialNamesForURI } from './providers/PartialCompletionProvider';
+import { GraphQLFieldCompletionProvider } from './providers/GraphQLFieldCompletionProvider';
 
 export interface CompletionProviderDependencies {
   documentManager: DocumentManager;
@@ -47,6 +48,7 @@ export interface CompletionProviderDependencies {
 
 export class CompletionsProvider {
   private providers: Provider[] = [];
+  private graphqlFieldCompletionProvider: GraphQLFieldCompletionProvider;
   readonly documentManager: DocumentManager;
   readonly platformosDocset: PlatformOSDocset;
   readonly log: (message: string) => void;
@@ -66,6 +68,10 @@ export class CompletionsProvider {
     this.platformosDocset = platformosDocset;
     this.log = log;
     const typeSystem = new TypeSystem(platformosDocset, fs, documentsLocator, findAppRootURI);
+    this.graphqlFieldCompletionProvider = new GraphQLFieldCompletionProvider(
+      platformosDocset,
+      documentManager,
+    );
 
     this.providers = [
       new HtmlTagCompletionProvider(),
@@ -88,6 +94,11 @@ export class CompletionsProvider {
     const uri = params.textDocument.uri;
     const document = this.documentManager.get(uri);
 
+    // GraphQL files get dedicated completion support
+    if (document?.type === SourceCodeType.GraphQL) {
+      return this.graphqlFieldCompletionProvider.completions(params);
+    }
+
     // Supports only Liquid resources
     if (document?.type !== SourceCodeType.LiquidHtml) {
       return [];

package/src/completions/providers/GraphQLFieldCompletionProvider.ts

@@ -0,0 +1,78 @@
+import { CompletionItem, CompletionItemKind, CompletionParams } from 'vscode-languageserver';
+import { DocumentManager } from '../../documents';
+import { PlatformOSDocset } from '@platformos/platformos-check-common';
+
+/**
+ * graphql-language-service and graphql must be loaded dynamically to avoid
+ * the "Cannot use GraphQLList from another module or realm" error that occurs
+ * when vitest transforms the graphql ESM module into separate instances.
+ */
+let _glsMod: typeof import('graphql-language-service') | undefined;
+function getGLS(): typeof import('graphql-language-service') {
+  if (!_glsMod) _glsMod = require('graphql-language-service');
+  return _glsMod!;
+}
+
+let _graphqlMod: typeof import('graphql') | undefined;
+function getGraphQL(): typeof import('graphql') {
+  if (!_graphqlMod) _graphqlMod = require('graphql');
+  return _graphqlMod!;
+}
+
+export class GraphQLFieldCompletionProvider {
+  private schemaCache: any;
+  private schemaLoaded = false;
+
+  constructor(
+    private platformosDocset: PlatformOSDocset,
+    private documentManager: DocumentManager,
+  ) {}
+
+  private async getSchema(): Promise<any> {
+    if (!this.schemaLoaded) {
+      const sdl = await this.platformosDocset.graphQL();
+      if (sdl) {
+        try {
+          this.schemaCache = getGraphQL().buildSchema(sdl);
+        } catch {
+          // Invalid schema SDL
+        }
+      }
+      this.schemaLoaded = true;
+    }
+    return this.schemaCache;
+  }
+
+  async completions(params: CompletionParams): Promise<CompletionItem[]> {
+    const uri = params.textDocument.uri;
+    const document = this.documentManager.get(uri);
+    if (!document) return [];
+
+    const schema = await this.getSchema();
+    if (!schema) return [];
+
+    const content = document.textDocument.getText();
+    const gls = getGLS();
+    const position = new gls.Position(params.position.line, params.position.character);
+
+    try {
+      const suggestions = gls.getAutocompleteSuggestions(schema, content, position);
+
+      return suggestions.map((suggestion) => ({
+        label: suggestion.label,
+        kind: toCompletionItemKind(suggestion.kind),
+        detail: suggestion.detail ?? undefined,
+        documentation: suggestion.documentation ?? undefined,
+      }));
+    } catch {
+      return [];
+    }
+  }
+}
+
+function toCompletionItemKind(kind: number | undefined): CompletionItemKind {
+  if (kind !== undefined && kind >= 1 && kind <= 25) {
+    return kind as CompletionItemKind;
+  }
+  return CompletionItemKind.Field;
+}

package/src/definitions/DefinitionProvider.ts

@@ -1,20 +1,72 @@
 import { findCurrentNode, SourceCodeType } from '@platformos/platformos-check-common';
+import { AbstractFileSystem, DocumentsLocator, RouteTable } from '@platformos/platformos-common';
 import { DefinitionLink, DefinitionParams } from 'vscode-languageserver';
 
 import { AugmentedJsonSourceCode, DocumentManager } from '../documents';
+import { SearchPathsLoader } from '../utils/searchPaths';
 import { BaseDefinitionProvider } from './BaseDefinitionProvider';
+import { PageRouteDefinitionProvider } from './providers/PageRouteDefinitionProvider';
+import { RenderPartialDefinitionProvider } from './providers/RenderPartialDefinitionProvider';
 import { TranslationStringDefinitionProvider } from './providers/TranslationStringDefinitionProvider';
 
 export class DefinitionProvider {
   private providers: BaseDefinitionProvider[];
+  private pageRouteProvider?: PageRouteDefinitionProvider;
 
   constructor(
     private documentManager: DocumentManager,
     getDefaultLocaleSourceCode: (uri: string) => Promise<AugmentedJsonSourceCode | null>,
+    fs?: AbstractFileSystem,
+    findAppRootURI?: (uri: string) => Promise<string | null>,
+    documentsLocator?: DocumentsLocator,
+    searchPathsCache?: SearchPathsLoader,
   ) {
     this.providers = [
       new TranslationStringDefinitionProvider(documentManager, getDefaultLocaleSourceCode),
     ];
+
+    if (fs && findAppRootURI) {
+      this.pageRouteProvider = new PageRouteDefinitionProvider(documentManager, fs, findAppRootURI);
+      this.providers.push(this.pageRouteProvider);
+
+      if (documentsLocator && searchPathsCache) {
+        this.providers.push(
+          new RenderPartialDefinitionProvider(
+            documentManager,
+            documentsLocator,
+            searchPathsCache,
+            findAppRootURI,
+          ),
+        );
+      }
+    }
+  }
+
+  /** Notify the route table that a page file was created or changed. */
+  onPageFileChanged(uri: string, content: string): void {
+    this.pageRouteProvider?.onPageFileChanged(uri, content);
+  }
+
+  /** Notify the route table that a page file was deleted. */
+  onPageFileDeleted(uri: string): void {
+    this.pageRouteProvider?.onPageFileDeleted(uri);
+  }
+
+  /**
+   * Invalidate the route table so it will be fully rebuilt on next use.
+   * Call after bulk filesystem changes (e.g., git checkout, branch switch).
+   */
+  invalidateRouteTable(): void {
+    this.pageRouteProvider?.invalidate();
+  }
+
+  /**
+   * Returns the shared RouteTable, or undefined if route support is not configured.
+   * When undefined (no fs/findAppRootURI), the check pipeline will build a fresh
+   * RouteTable per run via makeGetRouteTable in context-utils.ts.
+   */
+  getRouteTable(): RouteTable | undefined {
+    return this.pageRouteProvider?.getRouteTable();
   }
 
   async definitions(params: DefinitionParams): Promise<DefinitionLink[] | null> {