@rslint/core 0.6.5 → 0.7.0

package/dist/internal.d.ts

@@ -15,6 +15,15 @@ declare interface Fix {
     endPos: number;
 }
 
+/** Handler for a positive-id request frame sent by the Go peer. */
+declare type InboundRequestHandler = (message: IpcMessage) => unknown;
+
+declare interface IpcMessage {
+    id: number;
+    kind: string;
+    data: any;
+}
+
 /**
  * One-shot convenience: spin up a Node-backed service, run a single lint
  * request, then tear it down. This is an internal/tooling surface (the
@@ -26,8 +35,29 @@ export declare function lint(options: LintOptions): Promise<LintResponse>;
 
 export declare interface LintOptions {
     files?: string[];
+    canonicalFiles?: string[];
     config?: Record<string, unknown>[];
+    /**
+     * Ask native Go to discover and route JS/TS configs for this lint request.
+     * `config` and `configDiscovery` are mutually exclusive. Browser/WASM
+     * backends intentionally do not advertise this host-filesystem capability.
+     */
+    configDiscovery?: {
+        mode: 'auto' | 'explicit';
+        explicitConfigPath?: string;
+        /** Static glob roots; Go visits only branches leading to the supplied files. */
+        directories?: string[];
+        /** Parallel to `files`; true only for caller-literal file targets. */
+        explicitFiles?: boolean[];
+        /** Normalized API override entries appended to every selected config. */
+        overrideConfig?: Record<string, unknown>[];
+    };
+    eslintPlugins?: Array<{
+        prefix: string;
+        ruleNames: string[];
+    }>;
     configDirectory?: string;
+    pluginConfigDirectory?: string;
     workingDirectory?: string;
     fileContents?: Record<string, string>;
     includeEncodedSourceFiles?: boolean;
@@ -60,6 +90,8 @@ export declare class NodeRslintService implements RslintServiceInterface {
     private expectedSize;
     private dead;
     private closing;
+    private inboundHandler;
+    private activeInboundRequests;
     constructor(options?: RSlintOptions);
     /**
      * Keep the Node event loop alive only while a request is in flight. The
@@ -72,10 +104,14 @@ export declare class NodeRslintService implements RslintServiceInterface {
      * them to Readable/Writable, so narrow via `instanceof Socket` to reach those.
      */
     private setLoopActive;
+    private updateLoopActivity;
+    /** Install the handler for positive-id requests sent by the Go peer. */
+    setInboundHandler(handler: InboundRequestHandler | null): void;
     /**
      * Send a message to the rslint process
      */
     sendMessage(kind: string, data: any): Promise<any>;
+    private writeMessage;
     /**
      * Handle incoming binary data chunks
      */
@@ -102,9 +138,6 @@ export declare class NodeRslintService implements RslintServiceInterface {
     terminate(): void;
 }
 
-/**
- * Shared types for rslint IPC protocol across all environments
- */
 declare interface Position {
     line: number;
     column: number;
@@ -122,6 +155,8 @@ declare interface RSlintOptions {
 
 declare interface RslintServiceInterface {
     sendMessage(kind: string, data: any): Promise<any>;
+    /** Optional for one-way backends such as the current browser worker. */
+    setInboundHandler?(handler: InboundRequestHandler | null): void;
     terminate(): void;
 }
 

package/dist/internal.js

@@ -12,12 +12,16 @@ class NodeRslintService {
     expectedSize;
     dead;
     closing;
+    inboundHandler;
+    activeInboundRequests;
     constructor(options = {}){
         this.nextMessageId = 1;
         this.pendingMessages = new Map();
         this.rslintPath = options.rslintPath || resolveRslintBinary();
         this.dead = false;
         this.closing = false;
+        this.inboundHandler = null;
+        this.activeInboundRequests = 0;
         this.process = spawn(this.rslintPath, [
             '--api'
         ], {
@@ -58,6 +62,12 @@ class NodeRslintService {
         ])if (stream instanceof Socket) if (active) stream.ref();
         else stream.unref();
     }
+    updateLoopActivity() {
+        this.setLoopActive(!this.dead && (this.pendingMessages.size > 0 || this.activeInboundRequests > 0));
+    }
+    setInboundHandler(handler) {
+        this.inboundHandler = handler;
+    }
     async sendMessage(kind, data) {
         return new Promise((resolve, reject)=>{
             if (this.dead) return void reject(new Error('rslint service is no longer running'));
@@ -72,17 +82,26 @@ class NodeRslintService {
                 resolve,
                 reject
             });
-            if (1 === this.pendingMessages.size) this.setLoopActive(true);
-            const json = JSON.stringify(message);
-            const jsonBuffer = Buffer.from(json, 'utf8');
-            const length = Buffer.alloc(4);
-            length.writeUInt32LE(jsonBuffer.length, 0);
-            this.process.stdin.write(Buffer.concat([
-                length,
-                jsonBuffer
-            ]));
+            this.updateLoopActivity();
+            try {
+                this.writeMessage(message);
+            } catch (error) {
+                this.pendingMessages.delete(id);
+                this.updateLoopActivity();
+                reject(error instanceof Error ? error : new Error(String(error)));
+            }
         });
     }
+    writeMessage(message) {
+        if (this.dead) return;
+        const jsonBuffer = Buffer.from(JSON.stringify(message), 'utf8');
+        const length = Buffer.alloc(4);
+        length.writeUInt32LE(jsonBuffer.length, 0);
+        this.process.stdin.write(Buffer.concat([
+            length,
+            jsonBuffer
+        ]));
+    }
     handleChunk(chunk) {
         this.chunks.push(chunk);
         this.chunkSize += chunk.length;
@@ -114,22 +133,63 @@ class NodeRslintService {
     }
     handleMessage(message) {
         const { id, kind, data } = message;
-        const pending = this.pendingMessages.get(id);
-        if (!pending) return;
-        this.pendingMessages.delete(id);
-        if ('error' === kind) pending.reject(new Error(data.message));
-        else pending.resolve(data);
-        if (0 === this.pendingMessages.size) this.setLoopActive(false);
+        if ('response' === kind || 'error' === kind) {
+            const pending = this.pendingMessages.get(id);
+            if (!pending) return;
+            this.pendingMessages.delete(id);
+            if ('error' === kind) pending.reject(new Error(data?.message ?? 'rslint request failed'));
+            else pending.resolve(data);
+            this.updateLoopActivity();
+            return;
+        }
+        if (id <= 0) return;
+        this.activeInboundRequests++;
+        this.updateLoopActivity();
+        Promise.resolve().then(async ()=>{
+            if (!this.inboundHandler) throw new Error(`no inbound handler registered (kind=${message.kind})`);
+            return this.inboundHandler(message);
+        }).then((result)=>{
+            try {
+                this.writeMessage({
+                    id,
+                    kind: 'response',
+                    data: result
+                });
+            } catch (error) {
+                const detail = error instanceof Error ? error.message : String(error);
+                this.writeMessage({
+                    id,
+                    kind: 'error',
+                    data: {
+                        message: `failed to encode inbound response: ${detail}`
+                    }
+                });
+            }
+        }, (error)=>{
+            const detail = error instanceof Error ? error.message : String(error);
+            this.writeMessage({
+                id,
+                kind: 'error',
+                data: {
+                    message: detail
+                }
+            });
+        }).finally(()=>{
+            this.activeInboundRequests--;
+            this.updateLoopActivity();
+        }).catch(()=>{});
     }
     rejectAllPending(err) {
         if (0 === this.pendingMessages.size) return;
         for (const [, pending] of this.pendingMessages)pending.reject(err);
         this.pendingMessages.clear();
+        this.updateLoopActivity();
     }
     resolveAllPending() {
         if (0 === this.pendingMessages.size) return;
         for (const [, pending] of this.pendingMessages)pending.resolve(null);
         this.pendingMessages.clear();
+        this.updateLoopActivity();
     }
     terminate() {
         this.dead = true;
@@ -144,8 +204,10 @@ async function lint(options) {
     const service = new RSLintService(new NodeRslintService({
         workingDirectory: options.workingDirectory
     }));
-    const result = await service.lint(options);
-    await service.close();
-    return result;
+    try {
+        return await service.lint(options);
+    } finally{
+        await service.close();
+    }
 }
 export { NodeRslintService, lint };

package/dist/service.d.ts

@@ -1,3 +1,35 @@
+/** Go's final effective-ID selection after ignore/ownership resolution. */
+declare interface ActivateConfigsRequest {
+    protocolVersion: typeof CONFIG_DISCOVERY_PROTOCOL_VERSION;
+    transactionId: string;
+    effectiveConfigIds: string[];
+}
+
+/**
+ * Logical protocol shared by the native CLI, programmatic API, and LSP config
+ * discovery adapters. The transports differ (framed IPC versus JSON-RPC), but
+ * every adapter sends these payloads to the same Node-side module host.
+ *
+ * Paths in requests identify values selected by Go. Node may native-normalize
+ * configPath for local I/O, but configDirectory is an opaque routing identity
+ * and must retain its exact spelling. Load responses correlate only by opaque
+ * candidate ID. Activation responses contain only the transaction identity and
+ * plugin metadata consumed by Go; Node-only preparation data never crosses the
+ * transport boundary.
+ */
+declare const CONFIG_DISCOVERY_PROTOCOL_VERSION: 1;
+
+declare interface ConfigModuleCandidate {
+    /** Opaque, transaction-local identity allocated by the Go coordinator. */
+    id: string;
+    /** Absolute path to the JS/TS config module Node must execute. */
+    configPath: string;
+    /** Go-authoritative directory used for config matching and plugin routing. */
+    configDirectory: string;
+}
+
+declare type ConfigModuleLoadMode = 'cached' | 'fresh';
+
 export declare interface Diagnostic {
     ruleName: string;
     message: string;
@@ -82,6 +114,9 @@ export declare interface GetAstInfoResponse {
     flow?: FlowInfo;
 }
 
+/** Handler for a positive-id request frame sent by the Go peer. */
+export declare type InboundRequestHandler = (message: IpcMessage) => unknown;
+
 /**
  * Index signature information
  */
@@ -97,10 +132,38 @@ export declare interface IpcMessage {
     data: any;
 }
 
+/** Reverse-request handlers that are scoped to one outer lint request. */
+export declare interface LintInboundHandlers {
+    pluginLint?: (request: unknown) => unknown;
+    loadConfigs?: (request: LoadConfigsRequest) => unknown;
+    activateConfigs?: (request: ActivateConfigsRequest) => unknown;
+}
+
 export declare interface LintOptions {
     files?: string[];
+    canonicalFiles?: string[];
     config?: Record<string, unknown>[];
+    /**
+     * Ask native Go to discover and route JS/TS configs for this lint request.
+     * `config` and `configDiscovery` are mutually exclusive. Browser/WASM
+     * backends intentionally do not advertise this host-filesystem capability.
+     */
+    configDiscovery?: {
+        mode: 'auto' | 'explicit';
+        explicitConfigPath?: string;
+        /** Static glob roots; Go visits only branches leading to the supplied files. */
+        directories?: string[];
+        /** Parallel to `files`; true only for caller-literal file targets. */
+        explicitFiles?: boolean[];
+        /** Normalized API override entries appended to every selected config. */
+        overrideConfig?: Record<string, unknown>[];
+    };
+    eslintPlugins?: Array<{
+        prefix: string;
+        ruleNames: string[];
+    }>;
     configDirectory?: string;
+    pluginConfigDirectory?: string;
     workingDirectory?: string;
     fileContents?: Record<string, string>;
     includeEncodedSourceFiles?: boolean;
@@ -120,6 +183,21 @@ export declare interface LintResponse {
     encodedSourceFiles?: Record<string, string>;
 }
 
+declare interface LoadConfigsRequest {
+    protocolVersion: typeof CONFIG_DISCOVERY_PROTOCOL_VERSION;
+    /** Isolates batches belonging to one discovery transaction. */
+    transactionId: string;
+    /**
+     * `cached` preserves one-shot CLI module-import semantics. `fresh` is used
+     * by long-lived API and editor refreshes; it cache-busts the entry module,
+     * while static transitive imports retain Node's normal module cache.
+     */
+    loadMode: ConfigModuleLoadMode;
+    /** Serialize module evaluation when the CLI requested --singleThreaded. */
+    singleThreaded?: boolean;
+    candidates: ConfigModuleCandidate[];
+}
+
 /**
  * Detailed information about an AST node
  */
@@ -224,9 +302,6 @@ export declare interface PendingMessage {
     reject: (error: Error) => void;
 }
 
-/**
- * Shared types for rslint IPC protocol across all environments
- */
 declare interface Position {
     line: number;
     column: number;
@@ -249,24 +324,35 @@ export declare interface RSlintOptions {
  */
 export declare class RSLintService {
     private readonly service;
+    private activeLintHandlers;
+    private requestQueue;
+    private closeRequested;
+    private closePromise;
     constructor(service: RslintServiceInterface);
     /**
      * Run the linter on specified files
      */
-    lint(options?: LintOptions): Promise<LintResponse>;
+    lint(options?: LintOptions, handlers?: LintInboundHandlers): Promise<LintResponse>;
+    private lintExclusive;
     /**
      * Get detailed AST information at a specific position
      * Returns Node, Type, Symbol, Signature, and Flow information
      */
     getAstInfo(options: GetAstInfoRequest): Promise<GetAstInfoResponse>;
+    private getAstInfoExclusive;
     /**
      * Close the service
      */
     close(): Promise<void>;
+    private handshake;
+    private enqueue;
+    private handleInboundRequest;
 }
 
 export declare interface RslintServiceInterface {
     sendMessage(kind: string, data: any): Promise<any>;
+    /** Optional for one-way backends such as the current browser worker. */
+    setInboundHandler?(handler: InboundRequestHandler | null): void;
     terminate(): void;
 }
 

package/dist/service.js

@@ -1,17 +1,45 @@
+const API_REVERSE_PLUGIN_LINT_CAPABILITY = 'reversePluginLint';
+const API_REVERSE_CONFIG_LOAD_CAPABILITY = 'reverseConfigLoadV1';
+const EXIT_REQUEST_TIMEOUT_MS = 1000;
 class RSLintService {
     service;
+    activeLintHandlers = null;
+    requestQueue = Promise.resolve();
+    closeRequested = false;
+    closePromise = null;
     constructor(service){
         this.service = service;
+        this.service.setInboundHandler?.((message)=>this.handleInboundRequest(message));
     }
-    async lint(options = {}) {
-        const { files, config, configDirectory, workingDirectory, fileContents, includeEncodedSourceFiles, fix } = options;
-        await this.service.sendMessage('handshake', {
-            version: '1.0.0'
+    async lint(options = {}, handlers = {}) {
+        if (this.closeRequested) throw new Error('rslint service is closing');
+        return this.enqueue(async ()=>{
+            const hasLoadConfigs = Boolean(handlers.loadConfigs);
+            const hasActivateConfigs = Boolean(handlers.activateConfigs);
+            if (hasLoadConfigs !== hasActivateConfigs) throw new Error('reverse config discovery requires loadConfigs and activateConfigs handlers together');
+            if ((handlers.pluginLint || hasLoadConfigs || hasActivateConfigs) && !this.service.setInboundHandler) throw new Error('rslint backend does not support reverse lint requests');
+            this.activeLintHandlers = handlers;
+            try {
+                return await this.lintExclusive(options, {
+                    pluginLint: Boolean(handlers.pluginLint),
+                    configLoad: hasLoadConfigs && hasActivateConfigs
+                });
+            } finally{
+                this.activeLintHandlers = null;
+            }
         });
+    }
+    async lintExclusive(options, requiredReverse) {
+        const { files, canonicalFiles, config, configDiscovery, eslintPlugins, configDirectory, pluginConfigDirectory, workingDirectory, fileContents, includeEncodedSourceFiles, fix } = options;
+        await this.handshake(requiredReverse);
         return this.service.sendMessage('lint', {
             files,
+            canonicalFiles,
             config,
+            configDiscovery,
+            eslintPlugins,
             configDirectory,
+            pluginConfigDirectory,
             workingDirectory,
             fileContents,
             includeEncodedSourceFiles,
@@ -19,9 +47,17 @@ class RSLintService {
         });
     }
     async getAstInfo(options) {
+        if (this.closeRequested) throw new Error('rslint service is closing');
+        return this.enqueue(async ()=>{
+            const response = await this.getAstInfoExclusive(options);
+            return response;
+        });
+    }
+    async getAstInfoExclusive(options) {
         const { fileContent, position, end, kind, depth = 2, fileName, compilerOptions } = options;
-        await this.service.sendMessage('handshake', {
-            version: '1.0.0'
+        await this.handshake({
+            pluginLint: false,
+            configLoad: false
         });
         return this.service.sendMessage('getAstInfo', {
             fileContent,
@@ -34,10 +70,80 @@ class RSLintService {
         });
     }
     async close() {
-        try {
-            await this.service.sendMessage('exit', {});
-        } catch  {}
-        this.service.terminate();
+        if (this.closePromise) return void await this.closePromise;
+        this.closeRequested = true;
+        let timedOut = false;
+        let timer;
+        const timeout = new Promise((resolve)=>{
+            timer = setTimeout(()=>{
+                timedOut = true;
+                resolve();
+            }, EXIT_REQUEST_TIMEOUT_MS);
+        });
+        const gracefulExit = this.enqueue(async ()=>{
+            if (timedOut) return;
+            try {
+                await this.service.sendMessage('exit', {});
+            } catch  {}
+        });
+        this.closePromise = (async ()=>{
+            try {
+                await Promise.race([
+                    gracefulExit,
+                    timeout
+                ]);
+            } finally{
+                timedOut = true;
+                if (timer) clearTimeout(timer);
+                this.service.terminate();
+            }
+        })();
+        await this.closePromise;
+    }
+    async handshake(requiredReverse) {
+        const requestedCapabilities = [];
+        if (requiredReverse.pluginLint) requestedCapabilities.push(API_REVERSE_PLUGIN_LINT_CAPABILITY);
+        if (requiredReverse.configLoad) requestedCapabilities.push(API_REVERSE_CONFIG_LOAD_CAPABILITY);
+        const response = await this.service.sendMessage('handshake', {
+            version: "2.0.0",
+            capabilities: requestedCapabilities
+        });
+        if (null === response || 'object' != typeof response) throw new Error('rslint backend returned an invalid handshake response');
+        const handshake = response;
+        if (true !== handshake.ok || "2.0.0" !== handshake.version) throw new Error(`rslint API protocol mismatch: expected 2.0.0, received ${String(handshake.version)}`);
+        const capabilities = Array.isArray(handshake.capabilities) ? handshake.capabilities : [];
+        if (requiredReverse.pluginLint && !capabilities.includes(API_REVERSE_PLUGIN_LINT_CAPABILITY)) throw new Error('rslint backend does not support reverse pluginLint requests');
+        if (requiredReverse.configLoad && !capabilities.includes(API_REVERSE_CONFIG_LOAD_CAPABILITY)) throw new Error('rslint backend does not support reverse config loading');
+    }
+    async enqueue(operation) {
+        const result = this.requestQueue.then(operation, operation);
+        this.requestQueue = result.then(()=>void 0, ()=>void 0);
+        const value = await result;
+        return value;
+    }
+    handleInboundRequest(message) {
+        switch(message.kind){
+            case 'pluginLint':
+                {
+                    const handler = this.activeLintHandlers?.pluginLint;
+                    if (!handler) throw new Error('rslint service received pluginLint without an active plugin host');
+                    return handler(message.data);
+                }
+            case 'loadConfigs':
+                {
+                    const handler = this.activeLintHandlers?.loadConfigs;
+                    if (!handler) throw new Error('rslint service received loadConfigs without an active config host');
+                    return handler(message.data);
+                }
+            case 'activateConfigs':
+                {
+                    const handler = this.activeLintHandlers?.activateConfigs;
+                    if (!handler) throw new Error('rslint service received activateConfigs without an active config host');
+                    return handler(message.data);
+                }
+            default:
+                throw new Error(`rslint service received unexpected inbound request '${message.kind}'`);
+        }
     }
 }
 export { RSLintService };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rslint/core",
-  "version": "0.6.5",
+  "version": "0.7.0",
   "exports": {
     ".": {
       "@typescript/source": "./src/index.ts",
@@ -64,7 +64,7 @@
     "globals": "17.7.0",
     "tinyglobby": "0.2.15",
     "typescript": "5.9.3",
-    "@rslint/api": "0.6.5"
+    "@rslint/api": "0.7.0"
   },
   "peerDependencies": {
     "jiti": "^2.0.0"
@@ -75,14 +75,14 @@
     }
   },
   "optionalDependencies": {
-    "@rslint/native-darwin-arm64": "0.6.5",
-    "@rslint/native-linux-arm64-gnu": "0.6.5",
-    "@rslint/native-darwin-x64": "0.6.5",
-    "@rslint/native-linux-x64-gnu": "0.6.5",
-    "@rslint/native-linux-arm64-musl": "0.6.5",
-    "@rslint/native-linux-x64-musl": "0.6.5",
-    "@rslint/native-win32-arm64-msvc": "0.6.5",
-    "@rslint/native-win32-x64-msvc": "0.6.5"
+    "@rslint/native-linux-arm64-gnu": "0.7.0",
+    "@rslint/native-darwin-arm64": "0.7.0",
+    "@rslint/native-darwin-x64": "0.7.0",
+    "@rslint/native-linux-x64-gnu": "0.7.0",
+    "@rslint/native-linux-arm64-musl": "0.7.0",
+    "@rslint/native-win32-arm64-msvc": "0.7.0",
+    "@rslint/native-win32-x64-msvc": "0.7.0",
+    "@rslint/native-linux-x64-musl": "0.7.0"
   },
   "dependencies": {
     "picomatch": "4.0.4"