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

package/dist/index.cjs

@@ -30,16 +30,22 @@ 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_protocol2 = require("@formspec/analysis/protocol");
-var import_internal = require("@formspec/analysis/internal");
+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);
@@ -93,112 +99,139 @@ 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;
-var FORM_SPEC_PLUGIN_PERFORMANCE_EVENT = {
-  handleQuery: "plugin.handleQuery"
-};
 
-// src/service.ts
-var FormSpecPluginService = class {
+// 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;
-    this.runtimePaths = getFormSpecWorkspaceRuntimePaths(options.workspaceRoot);
-    this.manifest = createFormSpecAnalysisManifest(
-      options.workspaceRoot,
-      options.typescriptVersion,
-      Date.now()
-    );
   }
-  manifest;
-  runtimePaths;
   snapshotCache = /* @__PURE__ */ new Map();
   refreshTimers = /* @__PURE__ */ new Map();
-  server = null;
-  getManifest() {
-    return this.manifest;
+  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 }
+          })
+        )
+      }))
+    );
   }
-  async start() {
-    if (this.server !== null) {
-      return;
-    }
-    await import_promises.default.mkdir(this.runtimePaths.runtimeDirectory, { recursive: true });
-    if (this.runtimePaths.endpoint.kind === "unix-socket") {
-      await import_promises.default.rm(this.runtimePaths.endpoint.address, { force: true });
-    }
-    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_protocol2.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;
-        }
-        const payload = buffer.slice(0, newlineIndex);
-        const remaining = buffer.slice(newlineIndex + 1);
-        if (remaining.trim().length > 0) {
-          this.options.logger?.info(
-            `[FormSpec] Ignoring extra semantic query payload data for ${this.runtimePaths.workspaceRoot}`
-          );
-        }
-        buffer = remaining;
-        this.respondToSocket(socket, payload);
-      });
-    });
-    await new Promise((resolve, reject) => {
-      const handleError = (error) => {
-        reject(error);
+  /** 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
       };
-      this.server?.once("error", handleError);
-      this.server?.listen(this.runtimePaths.endpoint.address, () => {
-        this.server?.off("error", handleError);
-        resolve();
-      });
     });
-    await this.writeManifest();
   }
-  async stop() {
-    for (const timer of this.refreshTimers.values()) {
-      clearTimeout(timer);
-    }
-    this.refreshTimers.clear();
-    this.snapshotCache.clear();
-    const server = this.server;
-    this.server = null;
-    if (server?.listening === true) {
-      await new Promise((resolve, reject) => {
-        server.close((error) => {
-          if (error === void 0) {
-            resolve();
-            return;
-          }
-          reject(error);
-        });
-      });
-    }
-    await this.cleanupRuntimeArtifacts();
+  /** 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) {
@@ -206,7 +239,7 @@ var FormSpecPluginService = class {
     }
     const timer = setTimeout(() => {
       try {
-        this.getFileSnapshot(filePath, void 0);
+        this.getFileSnapshot(filePath);
       } catch (error) {
         this.options.logger?.info(
           `[FormSpec] Failed to refresh semantic snapshot for ${filePath}: ${String(error)}`
@@ -214,76 +247,58 @@ var FormSpecPluginService = class {
       }
       this.refreshTimers.delete(filePath);
     }, this.options.snapshotDebounceMs ?? FORM_SPEC_PLUGIN_DEFAULT_SNAPSHOT_DEBOUNCE_MS);
+    timer.unref();
     this.refreshTimers.set(filePath, timer);
   }
-  handleQuery(query) {
-    const performance = this.options.enablePerformanceLogging === true ? (0, import_internal.createFormSpecPerformanceRecorder)() : void 0;
-    const response = (0, import_internal.optionalMeasure)(
-      performance,
-      FORM_SPEC_PLUGIN_PERFORMANCE_EVENT.handleQuery,
-      {
-        kind: query.kind,
-        ...query.kind === "health" ? {} : { filePath: query.filePath }
-      },
-      () => this.executeQuery(query, performance)
-    );
-    if (performance !== void 0) {
-      this.logPerformanceEvents(performance.events);
-    }
-    return response;
-  }
-  respondToSocket(socket, payload) {
-    try {
-      const query = JSON.parse(payload);
-      if (!(0, import_protocol2.isFormSpecSemanticQuery)(query)) {
-        throw new Error("Invalid FormSpec semantic query payload");
-      }
-      const response = this.handleQuery(query);
-      socket.end(`${JSON.stringify(response)}
-`);
-    } catch (error) {
-      socket.end(
-        `${JSON.stringify({
-          protocolVersion: import_protocol2.FORMSPEC_ANALYSIS_PROTOCOL_VERSION,
-          kind: "error",
-          error: error instanceof Error ? error.message : String(error)
-        })}
-`
-      );
+  /** Clears pending timers and cached semantic snapshots. */
+  dispose() {
+    for (const timer of this.refreshTimers.values()) {
+      clearTimeout(timer);
     }
+    this.refreshTimers.clear();
+    this.snapshotCache.clear();
   }
-  async writeManifest() {
-    const tempManifestPath = `${this.runtimePaths.manifestPath}.tmp`;
-    await import_promises.default.writeFile(tempManifestPath, `${JSON.stringify(this.manifest, null, 2)}
-`, "utf8");
-    await import_promises.default.rename(tempManifestPath, this.runtimePaths.manifestPath);
+  /** 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
+    };
   }
-  async cleanupRuntimeArtifacts() {
-    await import_promises.default.rm(this.runtimePaths.manifestPath, { force: true });
-    if (this.runtimePaths.endpoint.kind === "unix-socket") {
-      await import_promises.default.rm(this.runtimePaths.endpoint.address, { force: true });
+  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, handler, performance) {
+  withCommentQueryContext(filePath, offset, performance2, handler) {
     return (0, import_internal.optionalMeasure)(
-      performance,
-      "plugin.resolveCommentQueryContext",
+      performance2,
+      "semantic.resolveCommentQueryContext",
       {
         filePath,
         offset
       },
       () => {
-        const environment = this.getSourceEnvironment(filePath, performance);
+        const environment = this.getSourceEnvironment(filePath, performance2);
         if (environment === null) {
-          return {
-            protocolVersion: import_protocol2.FORMSPEC_ANALYSIS_PROTOCOL_VERSION,
-            kind: "error",
-            error: `Unable to resolve TypeScript source file for ${filePath}`
-          };
+          return null;
         }
         const declaration = (0, import_internal.optionalMeasure)(
-          performance,
-          "plugin.findDeclarationForCommentOffset",
+          performance2,
+          "semantic.findDeclarationForCommentOffset",
           {
             filePath,
             offset
@@ -291,14 +306,14 @@ var FormSpecPluginService = class {
           () => (0, import_internal.findDeclarationForCommentOffset)(environment.sourceFile, offset)
         );
         const placement = declaration === null ? null : (0, import_internal.optionalMeasure)(
-          performance,
-          "plugin.resolveDeclarationPlacement",
+          performance2,
+          "semantic.resolveDeclarationPlacement",
           void 0,
           () => (0, import_internal.resolveDeclarationPlacement)(declaration)
         );
         const subjectType = declaration === null ? void 0 : (0, import_internal.optionalMeasure)(
-          performance,
-          "plugin.getSubjectType",
+          performance2,
+          "semantic.getSubjectType",
           void 0,
           () => (0, import_internal.getSubjectType)(declaration, environment.checker)
         );
@@ -311,11 +326,12 @@ var FormSpecPluginService = class {
       }
     );
   }
-  getFileSnapshot(filePath, performance) {
+  getFileSnapshotWithCacheState(filePath, performance2) {
     const startedAt = (0, import_internal.getFormSpecPerformanceNow)();
-    const environment = this.getSourceEnvironment(filePath, performance);
+    const environment = this.getSourceEnvironment(filePath, performance2);
     if (environment === null) {
-      const missingSourceSnapshot = {
+      this.stats.fileSnapshotCacheMisses += 1;
+      const snapshot2 = {
         filePath,
         sourceHash: "",
         generatedAt: this.getNow().toISOString(),
@@ -323,131 +339,83 @@ var FormSpecPluginService = class {
         diagnostics: [
           {
             code: "MISSING_SOURCE_FILE",
+            category: "infrastructure",
             message: `Unable to resolve TypeScript source file for ${filePath}`,
             range: { start: 0, end: 0 },
-            severity: "warning"
+            severity: "warning",
+            relatedLocations: [],
+            data: {
+              filePath
+            }
           }
         ]
       };
-      performance?.record({
-        name: "plugin.getFileSnapshot",
+      performance2.record({
+        name: "semantic.getFileSnapshot.result",
         durationMs: (0, import_internal.getFormSpecPerformanceNow)() - startedAt,
         detail: {
           filePath,
           cache: "missing-source"
         }
       });
-      return missingSourceSnapshot;
+      return {
+        snapshot: snapshot2,
+        cacheState: "missing-source"
+      };
     }
     const cached = this.snapshotCache.get(filePath);
     if (cached?.sourceHash === environment.sourceHash) {
-      performance?.record({
-        name: "plugin.getFileSnapshot",
+      this.stats.fileSnapshotCacheHits += 1;
+      performance2.record({
+        name: "semantic.getFileSnapshot.result",
         durationMs: (0, import_internal.getFormSpecPerformanceNow)() - startedAt,
         detail: {
           filePath,
           cache: "hit"
         }
       });
-      return cached.snapshot;
+      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 === void 0 ? {} : { performance }
+      performance: performance2
     });
     this.snapshotCache.set(filePath, {
       sourceHash: environment.sourceHash,
       snapshot
     });
-    performance?.record({
-      name: "plugin.getFileSnapshot",
+    performance2.record({
+      name: "semantic.getFileSnapshot.result",
       durationMs: (0, import_internal.getFormSpecPerformanceNow)() - startedAt,
       detail: {
         filePath,
         cache: "miss"
       }
     });
-    return snapshot;
+    return {
+      snapshot,
+      cacheState: "miss"
+    };
   }
   getNow() {
     return this.options.now?.() ?? /* @__PURE__ */ new Date();
   }
-  executeQuery(query, performance) {
-    switch (query.kind) {
-      case "health":
-        return {
-          protocolVersion: import_protocol2.FORMSPEC_ANALYSIS_PROTOCOL_VERSION,
-          kind: "health",
-          manifest: this.manifest
-        };
-      case "completion":
-        return this.withCommentQueryContext(
-          query.filePath,
-          query.offset,
-          (context) => ({
-            protocolVersion: import_protocol2.FORMSPEC_ANALYSIS_PROTOCOL_VERSION,
-            kind: "completion",
-            sourceHash: context.sourceHash,
-            context: (0, import_internal.serializeCompletionContext)(
-              (0, import_internal.getSemanticCommentCompletionContextAtOffset)(context.sourceFile.text, query.offset, {
-                checker: context.checker,
-                ...context.placement === null ? {} : { placement: context.placement },
-                ...context.subjectType === void 0 ? {} : { subjectType: context.subjectType }
-              })
-            )
-          }),
-          performance
-        );
-      case "hover":
-        return this.withCommentQueryContext(
-          query.filePath,
-          query.offset,
-          (context) => ({
-            protocolVersion: import_protocol2.FORMSPEC_ANALYSIS_PROTOCOL_VERSION,
-            kind: "hover",
-            sourceHash: context.sourceHash,
-            hover: (0, import_internal.serializeHoverInfo)(
-              (0, import_internal.getCommentHoverInfoAtOffset)(context.sourceFile.text, query.offset, {
-                checker: context.checker,
-                ...context.placement === null ? {} : { placement: context.placement },
-                ...context.subjectType === void 0 ? {} : { subjectType: context.subjectType }
-              })
-            )
-          }),
-          performance
-        );
-      case "diagnostics": {
-        const snapshot = this.getFileSnapshot(query.filePath, performance);
-        return {
-          protocolVersion: import_protocol2.FORMSPEC_ANALYSIS_PROTOCOL_VERSION,
-          kind: "diagnostics",
-          sourceHash: snapshot.sourceHash,
-          diagnostics: snapshot.diagnostics
-        };
-      }
-      case "file-snapshot":
-        return {
-          protocolVersion: import_protocol2.FORMSPEC_ANALYSIS_PROTOCOL_VERSION,
-          kind: "file-snapshot",
-          snapshot: this.getFileSnapshot(query.filePath, performance)
-        };
-      default: {
-        throw new Error(`Unhandled semantic query: ${JSON.stringify(query)}`);
-      }
-    }
-  }
-  getSourceEnvironment(filePath, performance) {
+  getSourceEnvironment(filePath, performance2) {
     return (0, import_internal.optionalMeasure)(
-      performance,
-      "plugin.getSourceEnvironment",
+      performance2,
+      "semantic.getSourceEnvironment",
       {
         filePath
       },
       () => {
         const program = (0, import_internal.optionalMeasure)(
-          performance,
-          "plugin.sourceEnvironment.getProgram",
+          performance2,
+          "semantic.sourceEnvironment.getProgram",
           void 0,
           () => this.options.getProgram()
         );
@@ -455,8 +423,8 @@ var FormSpecPluginService = class {
           return null;
         }
         const sourceFile = (0, import_internal.optionalMeasure)(
-          performance,
-          "plugin.sourceEnvironment.getSourceFile",
+          performance2,
+          "semantic.sourceEnvironment.getSourceFile",
           void 0,
           () => program.getSourceFile(filePath)
         );
@@ -464,14 +432,14 @@ var FormSpecPluginService = class {
           return null;
         }
         const checker = (0, import_internal.optionalMeasure)(
-          performance,
-          "plugin.sourceEnvironment.getTypeChecker",
+          performance2,
+          "semantic.sourceEnvironment.getTypeChecker",
           void 0,
           () => program.getTypeChecker()
         );
         const sourceHash = (0, import_internal.optionalMeasure)(
-          performance,
-          "plugin.sourceEnvironment.computeTextHash",
+          performance2,
+          "semantic.sourceEnvironment.computeTextHash",
           void 0,
           () => (0, import_protocol2.computeFormSpecTextHash)(sourceFile.text)
         );
@@ -483,19 +451,38 @@ var FormSpecPluginService = class {
       }
     );
   }
-  logPerformanceEvents(events) {
-    const logger = this.options.logger;
-    if (logger === void 0 || events.length === 0) {
+  recordQueryPath(kind, cacheState) {
+    if (cacheState === "hit") {
+      this.stats.queryPathTotals[kind].warm += 1;
       return;
     }
-    let rootEvent;
-    for (let index = events.length - 1; index >= 0; index -= 1) {
-      const candidate = events[index];
-      if (candidate?.name === FORM_SPEC_PLUGIN_PERFORMANCE_EVENT.handleQuery) {
-        rootEvent = candidate;
-        break;
+    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;
     }
@@ -503,18 +490,234 @@ var FormSpecPluginService = class {
     if (rootEvent.durationMs < thresholdMs) {
       return;
     }
-    const sortedHotspots = [...events].filter((event) => event.name !== FORM_SPEC_PLUGIN_PERFORMANCE_EVENT.handleQuery).sort((left, right) => right.durationMs - left.durationMs).slice(0, 8);
+    const sortedHotspots = [...events].filter((event) => event.name !== rootEventName).sort((left, right) => right.durationMs - left.durationMs).slice(0, 8);
     const lines = [
-      `[FormSpec][perf] ${rootEvent.name} ${formatPerformanceEvent(rootEvent)}`,
+      `[FormSpec][perf] ${formatPerformanceEvent(rootEvent)}`,
       ...sortedHotspots.map((event) => `  ${formatPerformanceEvent(event)}`)
     ];
     logger.info(lines.join("\n"));
   }
 };
-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/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,
+      options.typescriptVersion,
+      Date.now()
+    );
+  }
+  manifest;
+  runtimePaths;
+  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;
+    }
+    await import_promises.default.mkdir(this.runtimePaths.runtimeDirectory, { recursive: true });
+    if (this.runtimePaths.endpoint.kind === "unix-socket") {
+      await import_promises.default.rm(this.runtimePaths.endpoint.address, { force: true });
+    }
+    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;
+        }
+        const payload = buffer.slice(0, newlineIndex);
+        const remaining = buffer.slice(newlineIndex + 1);
+        if (remaining.trim().length > 0) {
+          this.options.logger?.info(
+            `[FormSpec] Ignoring extra semantic query payload data for ${this.runtimePaths.workspaceRoot}`
+          );
+        }
+        buffer = remaining;
+        this.respondToSocket(socket, payload);
+      });
+    });
+    await new Promise((resolve, reject) => {
+      const handleError = (error) => {
+        reject(error);
+      };
+      this.server?.once("error", handleError);
+      this.server?.listen(this.runtimePaths.endpoint.address, () => {
+        this.server?.off("error", handleError);
+        resolve();
+      });
+    });
+    await this.writeManifest();
+  }
+  async stop() {
+    this.semanticService.dispose();
+    const server = this.server;
+    this.server = null;
+    if (server?.listening === true) {
+      await new Promise((resolve, reject) => {
+        server.close((error) => {
+          if (error === void 0) {
+            resolve();
+            return;
+          }
+          reject(error);
+        });
+      });
+    }
+    await this.cleanupRuntimeArtifacts();
+  }
+  scheduleSnapshotRefresh(filePath) {
+    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_protocol3.FORMSPEC_ANALYSIS_PROTOCOL_VERSION,
+          kind: "health",
+          manifest: this.manifest
+        };
+      case "completion": {
+        const result = this.semanticService.getCompletionContext(query.filePath, query.offset);
+        if (result === null) {
+          return {
+            protocolVersion: import_protocol3.FORMSPEC_ANALYSIS_PROTOCOL_VERSION,
+            kind: "error",
+            error: `Unable to resolve TypeScript source file for ${query.filePath}`
+          };
+        }
+        return {
+          ...result,
+          kind: "completion"
+        };
+      }
+      case "hover": {
+        const result = this.semanticService.getHover(query.filePath, query.offset);
+        if (result === null) {
+          return {
+            protocolVersion: import_protocol3.FORMSPEC_ANALYSIS_PROTOCOL_VERSION,
+            kind: "error",
+            error: `Unable to resolve TypeScript source file for ${query.filePath}`
+          };
+        }
+        return {
+          ...result,
+          kind: "hover"
+        };
+      }
+      case "diagnostics": {
+        const result = this.semanticService.getDiagnostics(query.filePath);
+        return {
+          ...result,
+          kind: "diagnostics"
+        };
+      }
+      case "file-snapshot":
+        return {
+          protocolVersion: import_protocol3.FORMSPEC_ANALYSIS_PROTOCOL_VERSION,
+          kind: "file-snapshot",
+          snapshot: this.semanticService.getFileSnapshot(query.filePath)
+        };
+      default: {
+        throw new Error(`Unhandled semantic query: ${JSON.stringify(query)}`);
+      }
+    }
+  }
+  respondToSocket(socket, payload) {
+    try {
+      const query = JSON.parse(payload);
+      if (!(0, import_protocol3.isFormSpecSemanticQuery)(query)) {
+        throw new Error("Invalid FormSpec semantic query payload");
+      }
+      const response = this.handleQuery(query);
+      socket.end(`${JSON.stringify(response)}
+`);
+    } catch (error) {
+      socket.end(
+        `${JSON.stringify({
+          protocolVersion: import_protocol3.FORMSPEC_ANALYSIS_PROTOCOL_VERSION,
+          kind: "error",
+          error: error instanceof Error ? error.message : String(error)
+        })}
+`
+      );
+    }
+  }
+  async writeManifest() {
+    const tempManifestPath = `${this.runtimePaths.manifestPath}.tmp`;
+    await import_promises.default.writeFile(tempManifestPath, `${JSON.stringify(this.manifest, null, 2)}
+`, "utf8");
+    await import_promises.default.rename(tempManifestPath, this.runtimePaths.manifestPath);
+  }
+  async cleanupRuntimeArtifacts() {
+    await import_promises.default.rm(this.runtimePaths.manifestPath, { force: true });
+    if (this.runtimePaths.endpoint.kind === "unix-socket") {
+      await import_promises.default.rm(this.runtimePaths.endpoint.address, { force: true });
+    }
+  }
+  logQueryDuration(query, durationMs) {
+    const logger = this.options.logger;
+    if (logger === void 0) {
+      return;
+    }
+    const thresholdMs = this.options.performanceLogThresholdMs ?? FORM_SPEC_PLUGIN_DEFAULT_PERFORMANCE_LOG_THRESHOLD_MS;
+    if (durationMs < thresholdMs) {
+      return;
+    }
+    const event = {
+      name: "plugin.handleQuery",
+      durationMs,
+      detail: {
+        kind: query.kind,
+        ...query.kind === "health" ? {} : { filePath: query.filePath }
+      }
+    };
+    logger.info(`[FormSpec][perf] ${formatPerformanceEvent(event)}`);
+  }
+};
 function createLanguageServiceProxy(languageService, semanticService) {
   const wrapWithSnapshotRefresh = (fn) => {
     return (fileName, ...args) => {
@@ -623,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