@formspec/ts-plugin 0.1.0-alpha.20 → 0.1.0-alpha.22

package/dist/index.cjs

@@ -30,23 +30,30 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  FORMSPEC_ANALYSIS_PROTOCOL_VERSION: () => import_protocol4.FORMSPEC_ANALYSIS_PROTOCOL_VERSION,
+  FORMSPEC_ANALYSIS_SCHEMA_VERSION: () => import_protocol4.FORMSPEC_ANALYSIS_SCHEMA_VERSION,
+  FormSpecPluginService: () => FormSpecPluginService,
+  FormSpecSemanticService: () => FormSpecSemanticService,
+  createLanguageServiceProxy: () => createLanguageServiceProxy,
   init: () => init
 });
 module.exports = __toCommonJS(index_exports);
+var import_protocol4 = require("@formspec/analysis/protocol");
 
 // src/service.ts
 var import_promises = __toESM(require("fs/promises"), 1);
 var import_node_net = __toESM(require("net"), 1);
-var ts = require("typescript");
-var import_analysis2 = require("@formspec/analysis");
+var ts2 = require("typescript");
+var import_protocol3 = require("@formspec/analysis/protocol");
+var import_internal2 = require("@formspec/analysis/internal");
 
 // src/workspace.ts
 var import_node_os = __toESM(require("os"), 1);
 var import_node_path = __toESM(require("path"), 1);
-var import_analysis = require("@formspec/analysis");
+var import_protocol = require("@formspec/analysis/protocol");
 function getFormSpecWorkspaceRuntimePaths(workspaceRoot, platform = process.platform, userScope = getFormSpecUserScope()) {
-  const workspaceId = (0, import_analysis.getFormSpecWorkspaceId)(workspaceRoot);
-  const runtimeDirectory = (0, import_analysis.getFormSpecWorkspaceRuntimeDirectory)(workspaceRoot);
+  const workspaceId = (0, import_protocol.getFormSpecWorkspaceId)(workspaceRoot);
+  const runtimeDirectory = (0, import_protocol.getFormSpecWorkspaceRuntimeDirectory)(workspaceRoot);
   const sanitizedUserScope = sanitizeScopeSegment(userScope);
   const endpoint = platform === "win32" ? {
     kind: "windows-pipe",
@@ -59,15 +66,15 @@ function getFormSpecWorkspaceRuntimePaths(workspaceRoot, platform = process.plat
     workspaceRoot,
     workspaceId,
     runtimeDirectory,
-    manifestPath: (0, import_analysis.getFormSpecManifestPath)(workspaceRoot),
+    manifestPath: (0, import_protocol.getFormSpecManifestPath)(workspaceRoot),
     endpoint
   };
 }
 function createFormSpecAnalysisManifest(workspaceRoot, typescriptVersion, generation, extensionFingerprint = "builtin") {
   const paths = getFormSpecWorkspaceRuntimePaths(workspaceRoot);
   return {
-    protocolVersion: import_analysis.FORMSPEC_ANALYSIS_PROTOCOL_VERSION,
-    analysisSchemaVersion: import_analysis.FORMSPEC_ANALYSIS_SCHEMA_VERSION,
+    protocolVersion: import_protocol.FORMSPEC_ANALYSIS_PROTOCOL_VERSION,
+    analysisSchemaVersion: import_protocol.FORMSPEC_ANALYSIS_SCHEMA_VERSION,
     workspaceRoot,
     workspaceId: paths.workspaceId,
     endpoint: paths.endpoint,
@@ -92,10 +99,411 @@ function sanitizeScopeSegment(value) {
   return sanitized.length > 0 ? sanitized : "formspec";
 }
 
+// src/semantic-service.ts
+var ts = require("typescript");
+var import_protocol2 = require("@formspec/analysis/protocol");
+var import_internal = require("@formspec/analysis/internal");
+
+// src/constants.ts
+var FORM_SPEC_PLUGIN_MAX_SOCKET_PAYLOAD_BYTES = 256 * 1024;
+var FORM_SPEC_PLUGIN_SOCKET_IDLE_TIMEOUT_MS = 3e4;
+var FORM_SPEC_PLUGIN_DEFAULT_PERFORMANCE_LOG_THRESHOLD_MS = 50;
+var FORM_SPEC_PLUGIN_DEFAULT_SNAPSHOT_DEBOUNCE_MS = 250;
+
+// src/perf-utils.ts
+function formatPerformanceEvent(event) {
+  const detailEntries = Object.entries(event.detail ?? {}).map(([key, value]) => `${key}=${String(value)}`).join(" ");
+  return `${event.durationMs.toFixed(1)}ms ${event.name}${detailEntries === "" ? "" : ` ${detailEntries}`}`;
+}
+
+// src/semantic-service.ts
+var STATS_ONLY_EVENT_NAMES = /* @__PURE__ */ new Set([
+  "analysis.syntheticCheckBatch.cacheHit",
+  "analysis.narrowSyntheticCheckBatch.cacheHit",
+  "analysis.syntheticCheckBatch.cacheMiss",
+  "analysis.narrowSyntheticCheckBatch.cacheMiss",
+  "analysis.syntheticCheckBatch.createProgram",
+  "analysis.narrowSyntheticCheckBatch.createProgram"
+]);
+var StatsOnlyPerformanceRecorder = class {
+  mutableEvents = [];
+  get events() {
+    return this.mutableEvents;
+  }
+  measure(name, detail, callback) {
+    const result = callback();
+    if (STATS_ONLY_EVENT_NAMES.has(name)) {
+      this.mutableEvents.push({
+        name,
+        durationMs: 0,
+        ...detail === void 0 ? {} : { detail }
+      });
+    }
+    return result;
+  }
+  record(event) {
+    if (STATS_ONLY_EVENT_NAMES.has(event.name)) {
+      this.mutableEvents.push(event);
+    }
+  }
+};
+var FormSpecSemanticService = class {
+  constructor(options) {
+    this.options = options;
+  }
+  snapshotCache = /* @__PURE__ */ new Map();
+  refreshTimers = /* @__PURE__ */ new Map();
+  stats = {
+    queryTotals: {
+      completion: 0,
+      hover: 0,
+      diagnostics: 0,
+      fileSnapshot: 0
+    },
+    queryPathTotals: {
+      diagnostics: { cold: 0, warm: 0 },
+      fileSnapshot: { cold: 0, warm: 0 }
+    },
+    fileSnapshotCacheHits: 0,
+    fileSnapshotCacheMisses: 0,
+    syntheticBatchCacheHits: 0,
+    syntheticBatchCacheMisses: 0,
+    syntheticCompileCount: 0,
+    syntheticCompileApplications: 0
+  };
+  /** Resolves semantic completion context for a comment cursor position. */
+  getCompletionContext(filePath, offset) {
+    this.stats.queryTotals.completion += 1;
+    return this.runMeasured(
+      "semantic.getCompletionContext",
+      { filePath, offset },
+      (performance2) => this.withCommentQueryContext(filePath, offset, performance2, (context) => ({
+        protocolVersion: import_protocol2.FORMSPEC_ANALYSIS_PROTOCOL_VERSION,
+        sourceHash: context.sourceHash,
+        context: (0, import_internal.serializeCompletionContext)(
+          (0, import_internal.getSemanticCommentCompletionContextAtOffset)(context.sourceFile.text, offset, {
+            checker: context.checker,
+            ...context.placement === null ? {} : { placement: context.placement },
+            ...context.subjectType === void 0 ? {} : { subjectType: context.subjectType }
+          })
+        )
+      }))
+    );
+  }
+  /** Resolves semantic hover payload for a comment cursor position. */
+  getHover(filePath, offset) {
+    this.stats.queryTotals.hover += 1;
+    return this.runMeasured(
+      "semantic.getHover",
+      { filePath, offset },
+      (performance2) => this.withCommentQueryContext(filePath, offset, performance2, (context) => ({
+        protocolVersion: import_protocol2.FORMSPEC_ANALYSIS_PROTOCOL_VERSION,
+        sourceHash: context.sourceHash,
+        hover: (0, import_internal.serializeHoverInfo)(
+          (0, import_internal.getCommentHoverInfoAtOffset)(context.sourceFile.text, offset, {
+            checker: context.checker,
+            ...context.placement === null ? {} : { placement: context.placement },
+            ...context.subjectType === void 0 ? {} : { subjectType: context.subjectType }
+          })
+        )
+      }))
+    );
+  }
+  /** Returns canonical FormSpec diagnostics for a file in the current host program. */
+  getDiagnostics(filePath) {
+    this.stats.queryTotals.diagnostics += 1;
+    return this.runMeasured("semantic.getDiagnostics", { filePath }, (performance2) => {
+      const { snapshot, cacheState } = this.getFileSnapshotWithCacheState(filePath, performance2);
+      this.recordQueryPath("diagnostics", cacheState);
+      return {
+        protocolVersion: import_protocol2.FORMSPEC_ANALYSIS_PROTOCOL_VERSION,
+        sourceHash: snapshot.sourceHash,
+        diagnostics: snapshot.diagnostics
+      };
+    });
+  }
+  /** Returns the full serialized semantic snapshot for a file. */
+  getFileSnapshot(filePath) {
+    this.stats.queryTotals.fileSnapshot += 1;
+    return this.runMeasured("semantic.getFileSnapshot", { filePath }, (performance2) => {
+      const { snapshot, cacheState } = this.getFileSnapshotWithCacheState(filePath, performance2);
+      this.recordQueryPath("fileSnapshot", cacheState);
+      return snapshot;
+    });
+  }
+  /** Schedules a debounced background refresh for the file snapshot cache. */
+  scheduleSnapshotRefresh(filePath) {
+    const existing = this.refreshTimers.get(filePath);
+    if (existing !== void 0) {
+      clearTimeout(existing);
+    }
+    const timer = setTimeout(() => {
+      try {
+        this.getFileSnapshot(filePath);
+      } catch (error) {
+        this.options.logger?.info(
+          `[FormSpec] Failed to refresh semantic snapshot for ${filePath}: ${String(error)}`
+        );
+      }
+      this.refreshTimers.delete(filePath);
+    }, this.options.snapshotDebounceMs ?? FORM_SPEC_PLUGIN_DEFAULT_SNAPSHOT_DEBOUNCE_MS);
+    timer.unref();
+    this.refreshTimers.set(filePath, timer);
+  }
+  /** Clears pending timers and cached semantic snapshots. */
+  dispose() {
+    for (const timer of this.refreshTimers.values()) {
+      clearTimeout(timer);
+    }
+    this.refreshTimers.clear();
+    this.snapshotCache.clear();
+  }
+  /** Returns a copy of the current performance and cache counters. */
+  getStats() {
+    return {
+      queryTotals: { ...this.stats.queryTotals },
+      queryPathTotals: {
+        diagnostics: { ...this.stats.queryPathTotals.diagnostics },
+        fileSnapshot: { ...this.stats.queryPathTotals.fileSnapshot }
+      },
+      fileSnapshotCacheHits: this.stats.fileSnapshotCacheHits,
+      fileSnapshotCacheMisses: this.stats.fileSnapshotCacheMisses,
+      syntheticBatchCacheHits: this.stats.syntheticBatchCacheHits,
+      syntheticBatchCacheMisses: this.stats.syntheticBatchCacheMisses,
+      syntheticCompileCount: this.stats.syntheticCompileCount,
+      syntheticCompileApplications: this.stats.syntheticCompileApplications
+    };
+  }
+  runMeasured(name, detail, fn) {
+    const performance2 = this.options.enablePerformanceLogging === true ? (0, import_internal.createFormSpecPerformanceRecorder)() : new StatsOnlyPerformanceRecorder();
+    const result = (0, import_internal.optionalMeasure)(performance2, name, detail, () => fn(performance2));
+    this.updateStatsFromPerformanceEvents(performance2.events);
+    if (this.options.enablePerformanceLogging === true) {
+      this.logPerformanceEvents(name, performance2.events);
+    }
+    return result;
+  }
+  withCommentQueryContext(filePath, offset, performance2, handler) {
+    return (0, import_internal.optionalMeasure)(
+      performance2,
+      "semantic.resolveCommentQueryContext",
+      {
+        filePath,
+        offset
+      },
+      () => {
+        const environment = this.getSourceEnvironment(filePath, performance2);
+        if (environment === null) {
+          return null;
+        }
+        const declaration = (0, import_internal.optionalMeasure)(
+          performance2,
+          "semantic.findDeclarationForCommentOffset",
+          {
+            filePath,
+            offset
+          },
+          () => (0, import_internal.findDeclarationForCommentOffset)(environment.sourceFile, offset)
+        );
+        const placement = declaration === null ? null : (0, import_internal.optionalMeasure)(
+          performance2,
+          "semantic.resolveDeclarationPlacement",
+          void 0,
+          () => (0, import_internal.resolveDeclarationPlacement)(declaration)
+        );
+        const subjectType = declaration === null ? void 0 : (0, import_internal.optionalMeasure)(
+          performance2,
+          "semantic.getSubjectType",
+          void 0,
+          () => (0, import_internal.getSubjectType)(declaration, environment.checker)
+        );
+        return handler({
+          ...environment,
+          declaration,
+          placement,
+          subjectType
+        });
+      }
+    );
+  }
+  getFileSnapshotWithCacheState(filePath, performance2) {
+    const startedAt = (0, import_internal.getFormSpecPerformanceNow)();
+    const environment = this.getSourceEnvironment(filePath, performance2);
+    if (environment === null) {
+      this.stats.fileSnapshotCacheMisses += 1;
+      const snapshot2 = {
+        filePath,
+        sourceHash: "",
+        generatedAt: this.getNow().toISOString(),
+        comments: [],
+        diagnostics: [
+          {
+            code: "MISSING_SOURCE_FILE",
+            category: "infrastructure",
+            message: `Unable to resolve TypeScript source file for ${filePath}`,
+            range: { start: 0, end: 0 },
+            severity: "warning",
+            relatedLocations: [],
+            data: {
+              filePath
+            }
+          }
+        ]
+      };
+      performance2.record({
+        name: "semantic.getFileSnapshot.result",
+        durationMs: (0, import_internal.getFormSpecPerformanceNow)() - startedAt,
+        detail: {
+          filePath,
+          cache: "missing-source"
+        }
+      });
+      return {
+        snapshot: snapshot2,
+        cacheState: "missing-source"
+      };
+    }
+    const cached = this.snapshotCache.get(filePath);
+    if (cached?.sourceHash === environment.sourceHash) {
+      this.stats.fileSnapshotCacheHits += 1;
+      performance2.record({
+        name: "semantic.getFileSnapshot.result",
+        durationMs: (0, import_internal.getFormSpecPerformanceNow)() - startedAt,
+        detail: {
+          filePath,
+          cache: "hit"
+        }
+      });
+      return {
+        snapshot: cached.snapshot,
+        cacheState: "hit"
+      };
+    }
+    this.stats.fileSnapshotCacheMisses += 1;
+    const snapshot = (0, import_internal.buildFormSpecAnalysisFileSnapshot)(environment.sourceFile, {
+      checker: environment.checker,
+      now: () => this.getNow(),
+      performance: performance2
+    });
+    this.snapshotCache.set(filePath, {
+      sourceHash: environment.sourceHash,
+      snapshot
+    });
+    performance2.record({
+      name: "semantic.getFileSnapshot.result",
+      durationMs: (0, import_internal.getFormSpecPerformanceNow)() - startedAt,
+      detail: {
+        filePath,
+        cache: "miss"
+      }
+    });
+    return {
+      snapshot,
+      cacheState: "miss"
+    };
+  }
+  getNow() {
+    return this.options.now?.() ?? /* @__PURE__ */ new Date();
+  }
+  getSourceEnvironment(filePath, performance2) {
+    return (0, import_internal.optionalMeasure)(
+      performance2,
+      "semantic.getSourceEnvironment",
+      {
+        filePath
+      },
+      () => {
+        const program = (0, import_internal.optionalMeasure)(
+          performance2,
+          "semantic.sourceEnvironment.getProgram",
+          void 0,
+          () => this.options.getProgram()
+        );
+        if (program === void 0) {
+          return null;
+        }
+        const sourceFile = (0, import_internal.optionalMeasure)(
+          performance2,
+          "semantic.sourceEnvironment.getSourceFile",
+          void 0,
+          () => program.getSourceFile(filePath)
+        );
+        if (sourceFile === void 0) {
+          return null;
+        }
+        const checker = (0, import_internal.optionalMeasure)(
+          performance2,
+          "semantic.sourceEnvironment.getTypeChecker",
+          void 0,
+          () => program.getTypeChecker()
+        );
+        const sourceHash = (0, import_internal.optionalMeasure)(
+          performance2,
+          "semantic.sourceEnvironment.computeTextHash",
+          void 0,
+          () => (0, import_protocol2.computeFormSpecTextHash)(sourceFile.text)
+        );
+        return {
+          sourceFile,
+          checker,
+          sourceHash
+        };
+      }
+    );
+  }
+  recordQueryPath(kind, cacheState) {
+    if (cacheState === "hit") {
+      this.stats.queryPathTotals[kind].warm += 1;
+      return;
+    }
+    this.stats.queryPathTotals[kind].cold += 1;
+  }
+  updateStatsFromPerformanceEvents(events) {
+    for (const event of events) {
+      if (event.name === "analysis.syntheticCheckBatch.cacheHit" || event.name === "analysis.narrowSyntheticCheckBatch.cacheHit") {
+        this.stats.syntheticBatchCacheHits += 1;
+        continue;
+      }
+      if (event.name === "analysis.syntheticCheckBatch.cacheMiss" || event.name === "analysis.narrowSyntheticCheckBatch.cacheMiss") {
+        this.stats.syntheticBatchCacheMisses += 1;
+        const applicationCount = event.detail?.["applicationCount"];
+        if (typeof applicationCount === "number") {
+          this.stats.syntheticCompileApplications += applicationCount;
+        }
+        continue;
+      }
+      if (event.name === "analysis.syntheticCheckBatch.createProgram" || event.name === "analysis.narrowSyntheticCheckBatch.createProgram") {
+        this.stats.syntheticCompileCount += 1;
+      }
+    }
+  }
+  logPerformanceEvents(rootEventName, events) {
+    const logger = this.options.logger;
+    if (logger === void 0 || events.length === 0) {
+      return;
+    }
+    const rootEvent = [...events].reverse().find((event) => event.name === rootEventName);
+    if (rootEvent === void 0) {
+      return;
+    }
+    const thresholdMs = this.options.performanceLogThresholdMs ?? FORM_SPEC_PLUGIN_DEFAULT_PERFORMANCE_LOG_THRESHOLD_MS;
+    if (rootEvent.durationMs < thresholdMs) {
+      return;
+    }
+    const sortedHotspots = [...events].filter((event) => event.name !== rootEventName).sort((left, right) => right.durationMs - left.durationMs).slice(0, 8);
+    const lines = [
+      `[FormSpec][perf] ${formatPerformanceEvent(rootEvent)}`,
+      ...sortedHotspots.map((event) => `  ${formatPerformanceEvent(event)}`)
+    ];
+    logger.info(lines.join("\n"));
+  }
+};
+
 // src/service.ts
 var FormSpecPluginService = class {
   constructor(options) {
     this.options = options;
+    this.semanticService = new FormSpecSemanticService(options);
     this.runtimePaths = getFormSpecWorkspaceRuntimePaths(options.workspaceRoot);
     this.manifest = createFormSpecAnalysisManifest(
       options.workspaceRoot,
@@ -105,12 +513,19 @@ var FormSpecPluginService = class {
   }
   manifest;
   runtimePaths;
-  snapshotCache = /* @__PURE__ */ new Map();
-  refreshTimers = /* @__PURE__ */ new Map();
+  semanticService;
   server = null;
   getManifest() {
     return this.manifest;
   }
+  /**
+   * Returns the underlying semantic service used by this reference wrapper.
+   *
+   * @public
+   */
+  getSemanticService() {
+    return this.semanticService;
+  }
   async start() {
     if (this.server !== null) {
       return;
@@ -122,8 +537,25 @@ var FormSpecPluginService = class {
     this.server = import_node_net.default.createServer((socket) => {
       let buffer = "";
       socket.setEncoding("utf8");
+      socket.setTimeout(FORM_SPEC_PLUGIN_SOCKET_IDLE_TIMEOUT_MS, () => {
+        this.options.logger?.info(
+          `[FormSpec] Closing idle semantic query socket for ${this.runtimePaths.workspaceRoot}`
+        );
+        socket.destroy();
+      });
       socket.on("data", (chunk) => {
         buffer += String(chunk);
+        if (buffer.length > FORM_SPEC_PLUGIN_MAX_SOCKET_PAYLOAD_BYTES) {
+          socket.end(
+            `${JSON.stringify({
+              protocolVersion: import_protocol3.FORMSPEC_ANALYSIS_PROTOCOL_VERSION,
+              kind: "error",
+              error: `FormSpec semantic query exceeded ${String(FORM_SPEC_PLUGIN_MAX_SOCKET_PAYLOAD_BYTES)} bytes`
+            })}
+`
+          );
+          return;
+        }
         const newlineIndex = buffer.indexOf("\n");
         if (newlineIndex < 0) {
           return;
@@ -152,11 +584,7 @@ var FormSpecPluginService = class {
     await this.writeManifest();
   }
   async stop() {
-    for (const timer of this.refreshTimers.values()) {
-      clearTimeout(timer);
-    }
-    this.refreshTimers.clear();
-    this.snapshotCache.clear();
+    this.semanticService.dispose();
     const server = this.server;
     this.server = null;
     if (server?.listening === true) {
@@ -173,96 +601,65 @@ var FormSpecPluginService = class {
     await this.cleanupRuntimeArtifacts();
   }
   scheduleSnapshotRefresh(filePath) {
-    const existing = this.refreshTimers.get(filePath);
-    if (existing !== void 0) {
-      clearTimeout(existing);
-    }
-    const timer = setTimeout(() => {
-      try {
-        this.getFileSnapshot(filePath);
-      } catch (error) {
-        this.options.logger?.info(
-          `[FormSpec] Failed to refresh semantic snapshot for ${filePath}: ${String(error)}`
-        );
-      }
-      this.refreshTimers.delete(filePath);
-    }, this.options.snapshotDebounceMs ?? 250);
-    this.refreshTimers.set(filePath, timer);
+    this.semanticService.scheduleSnapshotRefresh(filePath);
   }
   handleQuery(query) {
+    if (this.options.enablePerformanceLogging === true) {
+      const startedAt = performance.now();
+      const response = this.executeQuery(query);
+      this.logQueryDuration(query, performance.now() - startedAt);
+      return response;
+    }
+    return this.executeQuery(query);
+  }
+  executeQuery(query) {
     switch (query.kind) {
       case "health":
         return {
-          protocolVersion: import_analysis2.FORMSPEC_ANALYSIS_PROTOCOL_VERSION,
+          protocolVersion: import_protocol3.FORMSPEC_ANALYSIS_PROTOCOL_VERSION,
           kind: "health",
           manifest: this.manifest
         };
       case "completion": {
-        const environment = this.getSourceEnvironment(query.filePath);
-        if (environment === null) {
+        const result = this.semanticService.getCompletionContext(query.filePath, query.offset);
+        if (result === null) {
           return {
-            protocolVersion: import_analysis2.FORMSPEC_ANALYSIS_PROTOCOL_VERSION,
+            protocolVersion: import_protocol3.FORMSPEC_ANALYSIS_PROTOCOL_VERSION,
             kind: "error",
             error: `Unable to resolve TypeScript source file for ${query.filePath}`
           };
         }
-        const declaration = (0, import_analysis2.findDeclarationForCommentOffset)(environment.sourceFile, query.offset);
-        const placement = declaration === null ? null : (0, import_analysis2.resolveDeclarationPlacement)(declaration);
-        const subjectType = declaration === null ? void 0 : (0, import_analysis2.getSubjectType)(declaration, environment.checker);
-        const context = (0, import_analysis2.getSemanticCommentCompletionContextAtOffset)(
-          environment.sourceFile.text,
-          query.offset,
-          {
-            checker: environment.checker,
-            ...placement === null ? {} : { placement },
-            ...subjectType === void 0 ? {} : { subjectType }
-          }
-        );
         return {
-          protocolVersion: import_analysis2.FORMSPEC_ANALYSIS_PROTOCOL_VERSION,
-          kind: "completion",
-          sourceHash: (0, import_analysis2.computeFormSpecTextHash)(environment.sourceFile.text),
-          context: (0, import_analysis2.serializeCompletionContext)(context)
+          ...result,
+          kind: "completion"
         };
       }
       case "hover": {
-        const environment = this.getSourceEnvironment(query.filePath);
-        if (environment === null) {
+        const result = this.semanticService.getHover(query.filePath, query.offset);
+        if (result === null) {
           return {
-            protocolVersion: import_analysis2.FORMSPEC_ANALYSIS_PROTOCOL_VERSION,
+            protocolVersion: import_protocol3.FORMSPEC_ANALYSIS_PROTOCOL_VERSION,
             kind: "error",
             error: `Unable to resolve TypeScript source file for ${query.filePath}`
           };
         }
-        const declaration = (0, import_analysis2.findDeclarationForCommentOffset)(environment.sourceFile, query.offset);
-        const placement = declaration === null ? null : (0, import_analysis2.resolveDeclarationPlacement)(declaration);
-        const subjectType = declaration === null ? void 0 : (0, import_analysis2.getSubjectType)(declaration, environment.checker);
-        const hover = (0, import_analysis2.getCommentHoverInfoAtOffset)(environment.sourceFile.text, query.offset, {
-          checker: environment.checker,
-          ...placement === null ? {} : { placement },
-          ...subjectType === void 0 ? {} : { subjectType }
-        });
         return {
-          protocolVersion: import_analysis2.FORMSPEC_ANALYSIS_PROTOCOL_VERSION,
-          kind: "hover",
-          sourceHash: (0, import_analysis2.computeFormSpecTextHash)(environment.sourceFile.text),
-          hover: (0, import_analysis2.serializeHoverInfo)(hover)
+          ...result,
+          kind: "hover"
         };
       }
       case "diagnostics": {
-        const snapshot = this.getFileSnapshot(query.filePath);
+        const result = this.semanticService.getDiagnostics(query.filePath);
         return {
-          protocolVersion: import_analysis2.FORMSPEC_ANALYSIS_PROTOCOL_VERSION,
-          kind: "diagnostics",
-          sourceHash: snapshot.sourceHash,
-          diagnostics: snapshot.diagnostics
+          ...result,
+          kind: "diagnostics"
         };
       }
       case "file-snapshot":
         return {
-          protocolVersion: import_analysis2.FORMSPEC_ANALYSIS_PROTOCOL_VERSION,
+          protocolVersion: import_protocol3.FORMSPEC_ANALYSIS_PROTOCOL_VERSION,
           kind: "file-snapshot",
-          snapshot: this.getFileSnapshot(query.filePath)
+          snapshot: this.semanticService.getFileSnapshot(query.filePath)
         };
       default: {
         throw new Error(`Unhandled semantic query: ${JSON.stringify(query)}`);
@@ -272,7 +669,7 @@ var FormSpecPluginService = class {
   respondToSocket(socket, payload) {
     try {
       const query = JSON.parse(payload);
-      if (!(0, import_analysis2.isFormSpecSemanticQuery)(query)) {
+      if (!(0, import_protocol3.isFormSpecSemanticQuery)(query)) {
         throw new Error("Invalid FormSpec semantic query payload");
       }
       const response = this.handleQuery(query);
@@ -281,7 +678,7 @@ var FormSpecPluginService = class {
     } catch (error) {
       socket.end(
         `${JSON.stringify({
-          protocolVersion: import_analysis2.FORMSPEC_ANALYSIS_PROTOCOL_VERSION,
+          protocolVersion: import_protocol3.FORMSPEC_ANALYSIS_PROTOCOL_VERSION,
           kind: "error",
           error: error instanceof Error ? error.message : String(error)
         })}
@@ -301,54 +698,24 @@ var FormSpecPluginService = class {
       await import_promises.default.rm(this.runtimePaths.endpoint.address, { force: true });
     }
   }
-  getSourceEnvironment(filePath) {
-    const program = this.options.getProgram();
-    if (program === void 0) {
-      return null;
+  logQueryDuration(query, durationMs) {
+    const logger = this.options.logger;
+    if (logger === void 0) {
+      return;
     }
-    const sourceFile = program.getSourceFile(filePath);
-    if (sourceFile === void 0) {
-      return null;
+    const thresholdMs = this.options.performanceLogThresholdMs ?? FORM_SPEC_PLUGIN_DEFAULT_PERFORMANCE_LOG_THRESHOLD_MS;
+    if (durationMs < thresholdMs) {
+      return;
     }
-    return {
-      sourceFile,
-      checker: program.getTypeChecker()
+    const event = {
+      name: "plugin.handleQuery",
+      durationMs,
+      detail: {
+        kind: query.kind,
+        ...query.kind === "health" ? {} : { filePath: query.filePath }
+      }
     };
-  }
-  getFileSnapshot(filePath) {
-    const environment = this.getSourceEnvironment(filePath);
-    if (environment === null) {
-      return {
-        filePath,
-        sourceHash: "",
-        generatedAt: this.getNow().toISOString(),
-        comments: [],
-        diagnostics: [
-          {
-            code: "MISSING_SOURCE_FILE",
-            message: `Unable to resolve TypeScript source file for ${filePath}`,
-            range: { start: 0, end: 0 },
-            severity: "warning"
-          }
-        ]
-      };
-    }
-    const sourceHash = (0, import_analysis2.computeFormSpecTextHash)(environment.sourceFile.text);
-    const cached = this.snapshotCache.get(filePath);
-    if (cached?.sourceHash === sourceHash) {
-      return cached.snapshot;
-    }
-    const snapshot = (0, import_analysis2.buildFormSpecAnalysisFileSnapshot)(environment.sourceFile, {
-      checker: environment.checker
-    });
-    this.snapshotCache.set(filePath, {
-      sourceHash,
-      snapshot
-    });
-    return snapshot;
-  }
-  getNow() {
-    return this.options.now?.() ?? /* @__PURE__ */ new Date();
+    logger.info(`[FormSpec][perf] ${formatPerformanceEvent(event)}`);
   }
 };
 function createLanguageServiceProxy(languageService, semanticService) {
@@ -385,9 +752,23 @@ function createLanguageServiceProxy(languageService, semanticService) {
 
 // src/index.ts
 var services = /* @__PURE__ */ new Map();
+var PERF_LOG_ENV_VAR = "FORMSPEC_PLUGIN_PROFILE";
+var PERF_LOG_THRESHOLD_ENV_VAR = "FORMSPEC_PLUGIN_PROFILE_THRESHOLD_MS";
 function formatPluginError(error) {
   return error instanceof Error ? error.stack ?? error.message : String(error);
 }
+function readBooleanEnvFlag(name) {
+  const rawValue = process.env[name];
+  return rawValue === "1" || rawValue === "true";
+}
+function readNumberEnvFlag(name) {
+  const rawValue = process.env[name];
+  if (rawValue === void 0 || rawValue.trim() === "") {
+    return void 0;
+  }
+  const parsed = Number(rawValue);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
 function getOrCreateService(info, typescriptVersion) {
   const workspaceRoot = info.project.getCurrentDirectory();
   const existing = services.get(workspaceRoot);
@@ -396,11 +777,14 @@ function getOrCreateService(info, typescriptVersion) {
     attachProjectCloseHandler(info, workspaceRoot, existing);
     return existing.service;
   }
+  const performanceLogThresholdMs = readNumberEnvFlag(PERF_LOG_THRESHOLD_ENV_VAR);
   const service = new FormSpecPluginService({
     workspaceRoot,
     typescriptVersion,
     getProgram: () => info.languageService.getProgram(),
-    logger: info.project.projectService.logger
+    logger: info.project.projectService.logger,
+    enablePerformanceLogging: readBooleanEnvFlag(PERF_LOG_ENV_VAR),
+    ...performanceLogThresholdMs === void 0 ? {} : { performanceLogThresholdMs }
   });
   const serviceEntry = {
     service,
@@ -442,12 +826,17 @@ function init(modules) {
   return {
     create(info) {
       const service = getOrCreateService(info, typescriptVersion);
-      return createLanguageServiceProxy(info.languageService, service);
+      return createLanguageServiceProxy(info.languageService, service.getSemanticService());
     }
   };
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  FORMSPEC_ANALYSIS_PROTOCOL_VERSION,
+  FORMSPEC_ANALYSIS_SCHEMA_VERSION,
+  FormSpecPluginService,
+  FormSpecSemanticService,
+  createLanguageServiceProxy,
   init
 });
 //# sourceMappingURL=index.cjs.map