homebridge-plugin-utils 1.34.0 → 2.0.0

package/dist/clock-double.js

@@ -0,0 +1,141 @@
+/* Copyright(C) 2017-2026, HJD (https://github.com/hjdhjd). All rights reserved.
+ *
+ * clock-double.ts: A reusable, controllable Clock test double - virtual time a test advances explicitly - for the injectable Clock seam in clock.ts.
+ */
+import { onAbort } from "./util.js";
+/**
+ * Construct the rejection a {@link TestClock} `delay` produces when its signal aborts, matching `node:timers/promises` `setTimeout` exactly: a plain `Error` whose `name`
+ * is `"AbortError"` and whose `code` is the STRING `"ABORT_ERR"`. The real primitive's rejection is a dedicated internal class (not a `DOMException`, whose `code` is the
+ * numeric `20`, and there is no constructable `AbortError` global), so the double cannot match the constructor or prototype identity - it matches the observable `name`
+ * and `code` a consumer discriminates on, which is the contract that matters.
+ *
+ * @returns The `AbortError`-shaped rejection.
+ */
+function abortError() {
+    const error = new Error("The operation was aborted");
+    error.name = "AbortError";
+    // `code` is not a standard `Error` field, so assign it through an indexed widening rather than declaring a one-off subclass. The STRING value is what the real
+    // `node:timers/promises` rejection carries and what a consumer's `error.code === "ABORT_ERR"` check reads.
+    error.code = "ABORT_ERR";
+    return error;
+}
+/**
+ * A controllable {@link Clock} double over virtual time. `now()` returns the current virtual time; `delay()` registers a pending wait that resolves only when
+ * {@link TestClock.advance} crosses its deadline (in ascending-deadline order), or rejects with an `AbortError` (matching `node:timers/promises` `setTimeout` - `name`
+ * `"AbortError"`, `code` `"ABORT_ERR"`, NOT the signal's reason) when its signal aborts. No real timers or wall-clock are used.
+ *
+ * The virtual time is a RELATIVE timeline seeded at `start` (default `0`), NOT real epoch milliseconds. A consumer that compares `now()` against an absolute real-epoch
+ * constant would diverge; consumers must only compare `now()` values to each other (deriving elapsed intervals from differences), which is the only use a
+ * `Date.now()`-style read serves in the consuming pacing path - all its time reads come from the one injected clock.
+ *
+ * @example
+ *
+ * ```ts
+ * import { TestClock } from "homebridge-plugin-utils";
+ *
+ * const clock = new TestClock();
+ *
+ * const waited = clock.delay(100);
+ *
+ * // Nothing resolves until virtual time crosses the deadline.
+ * clock.advance(100);
+ *
+ * await waited;
+ * ```
+ *
+ * @see Clock
+ *
+ * @category Testing
+ */
+export class TestClock {
+    // The current virtual time. Seeded by the constructor and moved only by `advance`.
+    #now;
+    // The registered, not-yet-settled delays. An entry leaves this list exactly once - either when `advance` crosses its deadline or when its signal aborts - via
+    // `#remove`, which splices by identity so a mixed resolve-and-abort sequence never strands or mis-removes an entry.
+    #pending = [];
+    /**
+     * Construct a clock seeded at `start` (default `0`). The seed is the initial value `now()` returns; `advance` moves it forward (or back, for a negative delta).
+     *
+     * @param start - The initial virtual time, in the consumer's relative timeline. Defaults to `0`.
+     */
+    constructor(start = 0) {
+        this.#now = start;
+    }
+    /**
+     * Advance virtual time by `ms` and resolve every delay whose deadline the new time has reached. The delta is applied regardless of sign, so a negative `ms` moves time
+     * backward; `advance(0)` moves time nowhere but STILL flushes any already-due entry (a `delay(0)` or a `delay` with a non-positive `ms`), so a zero or negative delay
+     * is never a lost wakeup.
+     *
+     * Due entries resolve in ASCENDING deadline order; entries that share a deadline keep their FIFO registration order, because the snapshot is taken before any removal
+     * and the numeric sort is stable - matching how `setTimeout` fires equal-deadline timers in scheduling order. Each due entry is removed by identity and has its abort
+     * listener detached before it resolves, so the resolve path leaks no listener and the iteration is immune to the index shifts a forward in-place splice would cause.
+     *
+     * @param ms - The amount of virtual time to advance, in milliseconds. May be zero or negative.
+     */
+    advance(ms) {
+        this.#now += ms;
+        // Snapshot the due entries BEFORE mutating `#pending`, then sort them into deadline order. Filtering off a live array while removing from it would shift indices and
+        // strand entries; the snapshot first decouples the iteration from the removal. The sort is a stable numeric comparator, so equal deadlines preserve FIFO order.
+        const due = this.#pending.filter((entry) => entry.deadline <= this.#now).sort((a, b) => a.deadline - b.deadline);
+        for (const entry of due) {
+            // Remove by identity first so a re-entrant observer sees the correct `pending` count, then detach the abort listener (present only when this delay had a signal) so
+            // the resolve path leaves no listener on a long-lived signal, then settle the caller's promise.
+            this.#remove(entry);
+            entry.dispose?.[Symbol.dispose]();
+            entry.resolve();
+        }
+    }
+    /**
+     * Register a delay that resolves when virtual time reaches `this.now() + ms`, or rejects with an `AbortError` (matching `node:timers/promises`) if `init.signal` aborts
+     * first. A non-positive `ms` yields a deadline at or before the current time, which the very next {@link TestClock.advance} (including `advance(0)`) flushes.
+     *
+     * A pre-aborted signal rejects on the executor's microtask exactly as `systemClock` does (NOT a synchronous throw): {@link onAbort} fires the handler inline, which
+     * removes the just-registered entry and rejects, so the entry never lingers in `pending`.
+     *
+     * @param ms   - The delay, in milliseconds. May be zero or negative (flushed by the next `advance`).
+     * @param init - Optional init options. A supplied `signal` rejects the wait with an `AbortError` when it aborts.
+     *
+     * @returns A promise that resolves when the deadline is crossed, or rejects with an `AbortError` if the signal aborts first.
+     */
+    delay(ms, init) {
+        const { promise, reject, resolve } = Promise.withResolvers();
+        const entry = { deadline: this.#now + ms, resolve };
+        // Register the entry FIRST so a pre-aborted signal's inline `onAbort` handler (below) can find and remove it. `onAbort` runs the handler synchronously when the
+        // signal is already aborted, so for a pre-aborted signal the entry is pushed and then immediately removed-and-rejected within this call - settling on the executor's
+        // microtask, identical to `systemClock`. When no signal is supplied, `dispose` stays undefined and the entry only ever leaves via `advance`.
+        this.#pending.push(entry);
+        if (init?.signal !== undefined) {
+            entry.dispose = onAbort(init.signal, () => {
+                this.#remove(entry);
+                reject(abortError());
+            });
+        }
+        return promise;
+    }
+    /**
+     * Return the current virtual time. Compare these values to each other to derive elapsed intervals - they are a relative timeline, not real epoch milliseconds.
+     *
+     * @returns The current virtual time.
+     */
+    now() {
+        return this.#now;
+    }
+    /**
+     * The number of registered delays that have neither resolved nor rejected. A test reads this to assert a consumer registered its waits and later cleared them (no
+     * leak).
+     *
+     * @returns The count of unsettled delays.
+     */
+    get pending() {
+        return this.#pending.length;
+    }
+    // Remove `entry` from `#pending` by identity. Idempotent: a guarded `indexOf` + `splice` makes a second removal (e.g. an abort that races a resolve) a safe no-op and
+    // never removes the wrong entry, so `#pending` stays consistent across any resolve-and-abort interleaving.
+    #remove(entry) {
+        const index = this.#pending.indexOf(entry);
+        if (index !== -1) {
+            this.#pending.splice(index, 1);
+        }
+    }
+}
+//# sourceMappingURL=clock-double.js.map

package/dist/clock-double.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"clock-double.js","sourceRoot":"","sources":["../src/clock-double.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAiBH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAcpC;;;;;;;GAOG;AACH,SAAS,UAAU;IAEjB,MAAM,KAAK,GAAG,IAAI,KAAK,CAAC,2BAA2B,CAAC,CAAC;IAErD,KAAK,CAAC,IAAI,GAAG,YAAY,CAAC;IAE1B,+JAA+J;IAC/J,2GAA2G;IAC1G,KAAkC,CAAC,IAAI,GAAG,WAAW,CAAC;IAEvD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,OAAO,SAAS;IAEpB,mFAAmF;IACnF,IAAI,CAAS;IAEb,8JAA8J;IAC9J,oHAAoH;IAC3G,QAAQ,GAAiB,EAAE,CAAC;IAErC;;;;OAIG;IACH,YAAmB,KAAK,GAAG,CAAC;QAE1B,IAAI,CAAC,IAAI,GAAG,KAAK,CAAC;IACpB,CAAC;IAED;;;;;;;;;;OAUG;IACI,OAAO,CAAC,EAAU;QAEvB,IAAI,CAAC,IAAI,IAAI,EAAE,CAAC;QAEhB,qKAAqK;QACrK,gKAAgK;QAChK,MAAM,GAAG,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,QAAQ,IAAI,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,GAAG,CAAC,CAAC,QAAQ,CAAC,CAAC;QAEjH,KAAI,MAAM,KAAK,IAAI,GAAG,EAAE,CAAC;YAEvB,oKAAoK;YACpK,gGAAgG;YAChG,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;YACpB,KAAK,CAAC,OAAO,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC;YAClC,KAAK,CAAC,OAAO,EAAE,CAAC;QAClB,CAAC;IACH,CAAC;IAED;;;;;;;;;;;OAWG;IACI,KAAK,CAAC,EAAU,EAAE,IAA+B;QAEtD,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,GAA+B,OAAO,CAAC,aAAa,EAAE,CAAC;QACzF,MAAM,KAAK,GAAe,EAAE,QAAQ,EAAE,IAAI,CAAC,IAAI,GAAG,EAAE,EAAE,OAAO,EAAE,CAAC;QAEhE,gKAAgK;QAChK,qKAAqK;QACrK,6IAA6I;QAC7I,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAE1B,IAAG,IAAI,EAAE,MAAM,KAAK,SAAS,EAAE,CAAC;YAE9B,KAAK,CAAC,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,EAAE;gBAExC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;gBACpB,MAAM,CAAC,UAAU,EAAE,CAAC,CAAC;YACvB,CAAC,CAAC,CAAC;QACL,CAAC;QAED,OAAO,OAAO,CAAC;IACjB,CAAC;IAED;;;;OAIG;IACI,GAAG;QAER,OAAO,IAAI,CAAC,IAAI,CAAC;IACnB,CAAC;IAED;;;;;OAKG;IACH,IAAW,OAAO;QAEhB,OAAO,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC;IAC9B,CAAC;IAED,sKAAsK;IACtK,2GAA2G;IAC3G,OAAO,CAAC,KAAiB;QAEvB,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;QAE3C,IAAG,KAAK,KAAK,CAAC,CAAC,EAAE,CAAC;YAEhB,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;QACjC,CAAC;IACH,CAAC;CACF"}

package/dist/clock.d.ts

@@ -0,0 +1,39 @@
+/**
+ * The injectable wall-clock contract: the platform time primitives time-dependent code reads. A consumer holds a `Clock` rather than calling `Date.now()` /
+ * `node:timers/promises` `setTimeout` directly, so a test can substitute a controllable double (`TestClock`) and drive time deterministically while production behavior
+ * stays unchanged through {@link systemClock}.
+ *
+ * @see systemClock
+ *
+ * @category Utilities
+ */
+export interface Clock {
+    /**
+     * Resolve after `ms` milliseconds, or reject if `init.signal` aborts first. The production {@link systemClock} implements this as `node:timers/promises` `setTimeout`,
+     * so an abort rejects with that primitive's `AbortError` (`name` `"AbortError"`, `code` `"ABORT_ERR"`) rather than the signal's reason.
+     *
+     * @param ms   - The delay, in milliseconds.
+     * @param init - Optional init options. `signal` cancels the delay - resolving the wait early with a rejection - when it aborts.
+     *
+     * @returns A promise that resolves after the delay, or rejects with an `AbortError` if the signal aborts first.
+     */
+    delay(ms: number, init?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    /**
+     * Return the current time as epoch milliseconds. The production {@link systemClock} implements this as `Date.now()`.
+     *
+     * @returns The current time in epoch milliseconds.
+     */
+    now(): number;
+}
+/**
+ * The behavior-neutral production {@link Clock}: `now()` IS `Date.now()` and `delay()` IS `node:timers/promises` `setTimeout`. A consumer that routes its time reads
+ * through this clock instead of calling those primitives directly cannot observe any behavior change - it is the same two calls, one indirection removed at test time.
+ *
+ * @see Clock
+ *
+ * @category Utilities
+ */
+export declare const systemClock: Clock;
+//# sourceMappingURL=clock.d.ts.map

package/dist/clock.js

@@ -0,0 +1,34 @@
+/* Copyright(C) 2017-2026, HJD (https://github.com/hjdhjd). All rights reserved.
+ *
+ * clock.ts: An injectable wall-clock seam - the current time and an abortable delay - so time-dependent code can be driven deterministically under test.
+ */
+/**
+ * An injectable wall-clock time seam.
+ *
+ * Time-dependent code reads the platform time primitives it needs: the current epoch time (`Date.now()`) and a delay that can be cancelled (`node:timers/promises`
+ * `setTimeout`). Calling those directly bakes real wall-clock time into the code, so a test cannot exercise a pacing or timeout path without multi-second real waits, and
+ * `node:test`'s mock timers do not patch the `node:timers/promises` primitives. Holding a {@link Clock} instead - the abstraction over those primitives - inverts the
+ * dependency: production wires {@link systemClock}, whose `now()` IS `Date.now()` and whose `delay()` IS `node:timers/promises` `setTimeout`, so routing through the seam
+ * is behavior-neutral; a test wires a `TestClock` (see `clock-double.ts`) that advances virtual time explicitly, so the consumer's time-dependent path runs
+ * deterministically and instantly.
+ *
+ * This module imports `node:timers/promises` and is therefore Node-only (not browser-safe), like `util.ts`. A browser-targeted consumer cannot resolve that import.
+ *
+ * @module
+ */
+import { setTimeout as delay } from "node:timers/promises";
+/**
+ * The behavior-neutral production {@link Clock}: `now()` IS `Date.now()` and `delay()` IS `node:timers/promises` `setTimeout`. A consumer that routes its time reads
+ * through this clock instead of calling those primitives directly cannot observe any behavior change - it is the same two calls, one indirection removed at test time.
+ *
+ * @see Clock
+ *
+ * @category Utilities
+ */
+export const systemClock = {
+    // `setTimeout(ms, value, options)` from `node:timers/promises`: pass `undefined` for the resolution value and forward `init` as the options so the caller's signal
+    // cancels the wait. `setTimeout(ms, undefined, opts)` resolves to `Promise<undefined>`, which is assignable to the `Promise<void>` the contract declares.
+    delay: (ms, init) => delay(ms, undefined, init),
+    now: () => Date.now()
+};
+//# sourceMappingURL=clock.js.map

package/dist/clock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"clock.js","sourceRoot":"","sources":["../src/clock.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;;;GAaG;AACH,OAAO,EAAE,UAAU,IAAI,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAgC3D;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,WAAW,GAAU;IAEhC,mKAAmK;IACnK,0JAA0J;IAC1J,KAAK,EAAE,CAAC,EAAU,EAAE,IAA+B,EAAiB,EAAE,CAAC,KAAK,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,CAAC;IACjG,GAAG,EAAE,GAAW,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE;CAC9B,CAAC"}

package/dist/eslint-plugin/config.d.mts

@@ -0,0 +1,193 @@
+export default config;
+/**
+ * Build a ready-to-use ESLint flat config array. Consumers call this function and export default the result.
+ *
+ * Every option is optional and defaults to an empty array, mirrored by the destructuring defaults in the signature below. The JSDoc marks them optional with the
+ * bracket form so the emitted declaration types each property as optional, matching how consumers actually call this - passing only the subset they need.
+ *
+ * @param {object} [options] - Configuration options.
+ * @param {string[]} [options.ts] - Glob patterns for TypeScript files (strict + stylistic type-checked rules).
+ * @param {string[]} [options.js] - Glob patterns for JavaScript files (disable-type-checked rules).
+ * @param {string[]} [options.ui] - Glob patterns for browser UI files (adds browser globals).
+ * @param {string[]} [options.allowDefaultProject] - Globs passed to parserOptions.projectService.allowDefaultProject.
+ * @param {string[]} [options.ignores] - Global ignore patterns (in addition to the hardcoded "dist" ignore on the common block).
+ * @param {object[]} [options.extraConfigs] - Additional flat config objects appended to the output.
+ * @returns {object[]} A flat config array suitable for `export default` in eslint.config.mjs. Block ordering is significant - do not reorder.
+ */
+export function config({ allowDefaultProject, extraConfigs, ignores, js, ts: tsFiles, ui }?: {
+    ts?: string[] | undefined;
+    js?: string[] | undefined;
+    ui?: string[] | undefined;
+    allowDefaultProject?: string[] | undefined;
+    ignores?: string[] | undefined;
+    extraConfigs?: any[] | undefined;
+}): object[];
+/**
+ * Rule preset applied to every linted file regardless of language. Disables the base ESLint rules that are redundant once TypeScript's own compiler
+ * and syntax already catch the same errors, mirroring the `typescript-eslint` compatibility overlay it spreads in; the enabled ESLint-recommended
+ * baseline itself comes from the separate `eslintJs.configs.recommended` block pushed in {@link config}. Layers on top of that the full `@hjdhjd/*`
+ * rule set, the `@stylistic/*` whitespace and formatting rules, and the project's opinionated `sort-imports` / `sort-keys` / `quotes` / `eqeqeq` /
+ * `curly` constraints.
+ *
+ * Spread into the `rules:` slot of the all-files block of a flat config.
+ */
+export const commonRules: {
+    "@hjdhjd/blank-line-after-open-brace": string;
+    "@hjdhjd/comment-style": string;
+    "@hjdhjd/enforce-node-protocol": string;
+    "@hjdhjd/paren-comparisons-in-logical": string;
+    "@hjdhjd/split-type-imports": string;
+    "@stylistic/array-bracket-spacing": (string | {
+        arraysInArrays: boolean;
+        objectsInArrays: boolean;
+        singleValue: boolean;
+    })[];
+    "@stylistic/block-spacing": string;
+    "@stylistic/brace-style": (string | {
+        allowSingleLine: boolean;
+    })[];
+    "@stylistic/comma-dangle": string;
+    "@stylistic/eol-last": string[];
+    "@stylistic/generator-star-spacing": string;
+    "@stylistic/implicit-arrow-linebreak": string;
+    "@stylistic/indent": (string | number | {
+        SwitchCase: number;
+    })[];
+    "@stylistic/keyword-spacing": (string | {
+        overrides: {
+            for: {
+                after: boolean;
+            };
+            if: {
+                after: boolean;
+            };
+            switch: {
+                after: boolean;
+            };
+            while: {
+                after: boolean;
+            };
+        };
+    })[];
+    "@stylistic/linebreak-style": string[];
+    "@stylistic/lines-between-class-members": (string | {
+        exceptAfterSingleLine: boolean;
+    })[];
+    "@stylistic/max-len": (string | number)[];
+    "@stylistic/no-tabs": string;
+    "@stylistic/no-trailing-spaces": string;
+    "@stylistic/operator-linebreak": (string | {
+        overrides: {
+            ":": string;
+            "?": string;
+        };
+    })[];
+    "@stylistic/padding-line-between-statements": (string | {
+        blankLine: string;
+        next: string[];
+        prev: string;
+    } | {
+        blankLine: string;
+        next: string;
+        prev: string[];
+    } | {
+        blankLine: string;
+        next: string[];
+        prev: string[];
+    } | {
+        blankLine: string;
+        next: string;
+        prev: string;
+    })[];
+    "@stylistic/semi": string[];
+    "@stylistic/space-before-function-paren": (string | {
+        anonymous: string;
+        asyncArrow: string;
+        catch: string;
+        named: string;
+    })[];
+    "@stylistic/space-in-parens": string;
+    "@stylistic/space-infix-ops": string;
+    "@stylistic/space-unary-ops": string;
+    "@typescript-eslint/dot-notation": (string | {
+        allowIndexSignaturePropertyAccess: boolean;
+    })[];
+    "@typescript-eslint/no-this-alias": string;
+    camelcase: string;
+    curly: string[];
+    "dot-notation": string;
+    eqeqeq: string;
+    "logical-assignment-operators": (string | {
+        enforceForIfStatements: boolean;
+    })[];
+    "no-await-in-loop": string;
+    "no-console": string;
+    "no-restricted-syntax": string[];
+    "prefer-arrow-callback": string;
+    "prefer-const": string;
+    quotes: (string | {
+        allowTemplateLiterals: boolean;
+        avoidEscape: boolean;
+    })[];
+    "sort-imports": string;
+    "sort-keys": string;
+    "sort-vars": string;
+};
+/**
+ * Browser-environment globals typically present in Homebridge webUI files - `window`, `document`, `fetch`, the Homebridge configuration API entry
+ * point, and a few timer functions. Each is declared as `"readonly"` so `no-undef` accepts references without permitting reassignment.
+ *
+ * Pass into the `languageOptions.globals` slot of a flat config block scoped to UI files.
+ */
+export const globalsUi: {
+    [k: string]: string;
+};
+/**
+ * Rule preset for JavaScript source files. Starts from `typescript-eslint`'s `disableTypeChecked` set (so type-aware rules don't fire on plain JS), then
+ * re-enables `no-unused-vars` with the underscore-prefix ignore pattern. The `require-await` rule is left disabled here for the same reason the TypeScript
+ * preset omits its pair - see the omission paragraph in the {@link tsRules} JSDoc.
+ *
+ * Spread into the `rules:` slot of a flat config block scoped to `.js` / `.mjs` files.
+ */
+export const jsRules: {
+    "@typescript-eslint/no-floating-promises": string;
+    "no-unused-vars": (string | {
+        argsIgnorePattern: string;
+        caughtErrors: string;
+        caughtErrorsIgnorePattern: string;
+        varsIgnorePattern: string;
+    })[];
+};
+/**
+ * The ESLint plugin namespace map used by the composed configuration: `@hjdhjd` (this package's rules), `@stylistic` (the official stylistic-rules
+ * plugin), and `@typescript-eslint`. Drop this object into the `plugins` slot of a flat config block to register every plugin namespace this preset
+ * composes at once.
+ *
+ * The type annotation is deliberately loose since consumers that read the named `plugins` export do their own narrowing before touching rule entries.
+ * It's annotated explicitly so the emitted type stays portable - the raw inference picks up typescript-eslint's exported `CompatiblePlugin` shape,
+ * and the `tsconfig.eslint-plugin.json` declaration-only build (TS2742) refuses to serialize it into the `.d.ts` without citing a deep module path.
+ *
+ * @type {Record<string, { meta?: { name: string; version?: string }; rules?: Record<string, unknown> }>}
+ */
+export const plugins: Record<string, {
+    meta?: {
+        name: string;
+        version?: string;
+    };
+    rules?: Record<string, unknown>;
+}>;
+/**
+ * Rule preset for TypeScript source files. Builds on `typescript-eslint`'s strict and stylistic type-checked configs, then layers project-specific
+ * overrides: type-aware lint rules (`await-thenable`, `no-floating-promises`, `prefer-nullish-coalescing`, etc.) at warn level, explicit return-type and
+ * module-boundary requirements, and `@stylistic/member-delimiter-style`. Disables the JavaScript-recommended versions of rules that have TypeScript-aware
+ * equivalents to avoid double-flagging.
+ *
+ * Deliberately omits `@typescript-eslint/promise-function-async` and forces `@typescript-eslint/require-await` (and the base `require-await`) off. The pair
+ * encodes a tight coupling between Promise return types and the `async` keyword that predates the Disposable protocol: `[Symbol.asyncDispose]()` must be declared
+ * `async ...(): Promise<void>` to satisfy `await using` even when the body is synchronous, and identity-preserving Promise pass-throughs (e.g., `markHandled` in
+ * `src/util.ts`) cannot be marked `async` without wrapping the return in a fresh chain and breaking reference equality. Encoding the stance at the preset level
+ * rather than scattering per-site `eslint-disable` directives is the SSOT.
+ *
+ * Spread into the `rules:` slot of a flat config block scoped to `.ts` files.
+ */
+export const tsRules: any;

package/dist/eslint-plugin/index.d.mts

@@ -0,0 +1,2 @@
+export { default as plugin } from "./plugin.mjs";
+export { commonRules, config, globalsUi, jsRules, plugins, tsRules, default } from "./config.mjs";

package/dist/eslint-plugin/plugin.d.mts

@@ -0,0 +1,87 @@
+export default plugin;
+declare namespace plugin {
+    namespace meta {
+        let name: string;
+        let version: string;
+    }
+    let rules: {
+        "blank-line-after-open-brace": {
+            create(context: any): {
+                BlockStatement(node: any): void;
+                ClassBody(node: any): void;
+                ObjectExpression(node: any): void;
+                TSInterfaceBody(node: any): void;
+                TSTypeAliasDeclaration(node: any): void;
+            };
+            meta: {
+                docs: {
+                    description: string;
+                    recommended: boolean;
+                };
+                fixable: string;
+                schema: never[];
+                type: string;
+            };
+        };
+        "comment-style": {
+            create(context: any): {
+                Program(): void;
+            };
+            meta: {
+                docs: {
+                    description: string;
+                    recommended: boolean;
+                };
+                fixable: string;
+                schema: never[];
+                type: string;
+            };
+        };
+        "enforce-node-protocol": {
+            create(context: any): {
+                ExportAllDeclaration(node: any): void;
+                ExportNamedDeclaration(node: any): void;
+                ImportDeclaration(node: any): void;
+                ImportExpression(node: any): void;
+            };
+            meta: {
+                docs: {
+                    description: string;
+                    recommended: boolean;
+                };
+                fixable: string;
+                schema: never[];
+                type: string;
+            };
+        };
+        "paren-comparisons-in-logical": {
+            create(context: any): {
+                LogicalExpression(node: any): void;
+            };
+            meta: {
+                docs: {
+                    description: string;
+                    recommended: boolean;
+                };
+                fixable: string;
+                schema: never[];
+                type: string;
+            };
+        };
+        "split-type-imports": {
+            create(context: any): {
+                ExportNamedDeclaration(node: any): void;
+                ImportDeclaration(node: any): void;
+            };
+            meta: {
+                docs: {
+                    description: string;
+                    recommended: boolean;
+                };
+                fixable: string;
+                schema: never[];
+                type: string;
+            };
+        };
+    };
+}

package/dist/eslint-plugin/rules/blank-line-after-open-brace.d.mts

@@ -0,0 +1,19 @@
+export default ruleBlankAfterOpenBrace;
+declare namespace ruleBlankAfterOpenBrace {
+    function create(context: any): {
+        BlockStatement(node: any): void;
+        ClassBody(node: any): void;
+        ObjectExpression(node: any): void;
+        TSInterfaceBody(node: any): void;
+        TSTypeAliasDeclaration(node: any): void;
+    };
+    namespace meta {
+        namespace docs {
+            let description: string;
+            let recommended: boolean;
+        }
+        let fixable: string;
+        let schema: never[];
+        let type: string;
+    }
+}

package/dist/eslint-plugin/rules/comment-style.d.mts

@@ -0,0 +1,15 @@
+export default ruleCommentStyle;
+declare namespace ruleCommentStyle {
+    function create(context: any): {
+        Program(): void;
+    };
+    namespace meta {
+        namespace docs {
+            let description: string;
+            let recommended: boolean;
+        }
+        let fixable: string;
+        let schema: never[];
+        let type: string;
+    }
+}

package/dist/eslint-plugin/rules/enforce-node-protocol.d.mts

@@ -0,0 +1,18 @@
+export default ruleEnforceNodeProtocol;
+declare namespace ruleEnforceNodeProtocol {
+    function create(context: any): {
+        ExportAllDeclaration(node: any): void;
+        ExportNamedDeclaration(node: any): void;
+        ImportDeclaration(node: any): void;
+        ImportExpression(node: any): void;
+    };
+    namespace meta {
+        namespace docs {
+            let description: string;
+            let recommended: boolean;
+        }
+        let fixable: string;
+        let schema: never[];
+        let type: string;
+    }
+}

package/dist/eslint-plugin/rules/paren-comparisons-in-logical.d.mts

@@ -0,0 +1,15 @@
+export default ruleParenComparisonsInLogical;
+declare namespace ruleParenComparisonsInLogical {
+    function create(context: any): {
+        LogicalExpression(node: any): void;
+    };
+    namespace meta {
+        namespace docs {
+            let description: string;
+            let recommended: boolean;
+        }
+        let fixable: string;
+        let schema: never[];
+        let type: string;
+    }
+}

package/dist/eslint-plugin/rules/split-type-imports.d.mts

@@ -0,0 +1,16 @@
+export default ruleSplitTypeImports;
+declare namespace ruleSplitTypeImports {
+    function create(context: any): {
+        ExportNamedDeclaration(node: any): void;
+        ImportDeclaration(node: any): void;
+    };
+    namespace meta {
+        namespace docs {
+            let description: string;
+            let recommended: boolean;
+        }
+        let fixable: string;
+        let schema: never[];
+        let type: string;
+    }
+}