@ttsc/lint 0.30.3 → 0.31.0

package/lib/structures/rules/ITtscLintUnicornRules.d.ts

@@ -8,10 +8,18 @@ import type { ITtscLintUnicornBetterRegexRuleOptions, ITtscLintUnicornConsistent
  * counterparts, forbid known anti-patterns, and pin a consistent style for
  * things ESLint core and `typescript/*` leave underspecified.
  *
- * Most rules are pure AST checks. Binding-aware rules use the TypeScript
- * checker when lexical identity is part of the upstream contract.
+ * Most rules are native AST policies over recognized syntax and names.
+ * Binding-aware rules use the TypeScript checker where their native matcher
+ * requires lexical identity. References identify the upstream policy; they do
+ * not promise complete upstream option support or runtime equivalence of every
+ * suggested modernization.
  *
  * @reference https://github.com/sindresorhus/eslint-plugin-unicorn
+ *
+ * @evidence contracts/common.md#principled-implementation Explicit optional unicorn identifiers preserve severity-only settings and the twelve dedicated options interfaces, keeping distinct policy values tied to their rule names.
+ * @evidence contracts/common.md#clear-and-simple-design The modernization family shares severity tuple construction while separate option schemas own filename, import, source-pattern and target-environment policies.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Public and retained legacy identifiers are documented configuration keys; the map contains no generic built-in options fallback or fixture-specific setting.
+ * @evidence contracts/common.md#meaningful-documentation Native comments identify modernization intent, default-free string patterns and retained legacy naming; family context, paragraphs and member spacing follow documentation guidance.
  */
 export interface ITtscLintUnicornRules {
     /**
@@ -48,8 +56,8 @@ export interface ITtscLintUnicornRules {
      */
     "unicorn/consistent-destructuring"?: TtscLintRuleSetting;
     /**
-     * Require both branches of a ternary spread inside an array literal to be
-     * array-typed.
+     * Report ternary spreads inside array literals when exactly one branch is an
+     * array literal. The check does not infer either branch's array type.
      *
      * @reference https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/consistent-empty-array-spread.md
      */
@@ -77,8 +85,9 @@ export interface ITtscLintUnicornRules {
      */
     "unicorn/consistent-template-literal-escape"?: TtscLintRuleSetting;
     /**
-     * Require user-defined `Error` subclasses to set `name`, call
-     * `super(message)`, and assign their stack correctly.
+     * Report explicit constructor bodies in source-named built-in Error
+     * subclasses when no own `super(...)` call exists. Message arguments, name
+     * assignments and stack initialization are not validated.
      *
      * @reference https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/custom-error-definition.md
      */
@@ -104,8 +113,8 @@ export interface ITtscLintUnicornRules {
      */
     "unicorn/escape-case"?: TtscLintRuleSetting;
     /**
-     * Require every `TODO`/`FIXME`/`XXX` comment to declare an expiration date or
-     * package version.
+     * Report recognized `TODO`/`FIXME`/`XXX` comment markers unless the following
+     * text contains `[`. Dates and package-version expressions are not parsed.
      *
      * @reference https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/expiring-todo-comments.md
      */
@@ -207,8 +216,8 @@ export interface ITtscLintUnicornRules {
      */
     "unicorn/no-array-sort"?: TtscLintRuleSetting;
     /**
-     * Reject member access on an `await` expression without parens; require
-     * `(await x).y`.
+     * Reject property access on an awaited expression, including `(await x).y`;
+     * assign the awaited value to a variable first.
      *
      * @reference https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-await-expression-member.md
      */
@@ -260,8 +269,9 @@ export interface ITtscLintUnicornRules {
      */
     "unicorn/no-immediate-mutation"?: TtscLintRuleSetting;
     /**
-     * Reject `instanceof Array`, `instanceof Error`, `instanceof Map`, etc. —
-     * they fail across realms and for subclasses.
+     * Reject `instanceof` against recognized bare built-in names such as `Array`,
+     * `Error` and `Map`. The native name policy does not resolve a constructor's
+     * identity or certify cross-realm behavior.
      *
      * @reference https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-instanceof-builtins.md
      */
@@ -301,8 +311,9 @@ export interface ITtscLintUnicornRules {
      */
     "unicorn/no-magic-array-flat-depth"?: TtscLintRuleSetting;
     /**
-     * Reject re-importing or re-exporting a default binding under a name that
-     * differs from the upstream binding.
+     * Reject named import specifiers written `default as Name`; prefer a default
+     * import. Re-export declarations and upstream binding names are not
+     * resolved.
      *
      * @reference https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-named-default.md
      */
@@ -403,12 +414,19 @@ export interface ITtscLintUnicornRules {
      * Reject `.length` / `Infinity` as the deleteCount argument to `splice` /
      * `toSpliced`; omit it to delete to the end.
      *
+     * Only exactly two arguments are considered, and a length must belong to the
+     * same structural receiver. Calls with insertion arguments are retained.
+     *
      * @reference https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-unnecessary-array-splice-count.md
      */
     "unicorn/no-unnecessary-array-splice-count"?: TtscLintRuleSetting;
     /**
      * Reject `await` on non-thenable expressions.
      *
+     * The AST baseline reports ordinary literals under unchanged built-in
+     * prototypes; objects with then, spreads, computed keys or prototype setters
+     * are excluded. Removing await can still change scheduling.
+     *
      * @reference https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-unnecessary-await.md
      */
     "unicorn/no-unnecessary-await"?: TtscLintRuleSetting;
@@ -423,6 +441,9 @@ export interface ITtscLintUnicornRules {
      * Reject `.length` / `Infinity` as the end argument to `slice`; omit it to
      * slice to the end.
      *
+     * The length must belong to the same structural receiver; another receiver's
+     * bound and effectful repeated receiver calls are retained.
+     *
      * @reference https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-unnecessary-slice-end.md
      */
     "unicorn/no-unnecessary-slice-end"?: TtscLintRuleSetting;
@@ -447,22 +468,25 @@ export interface ITtscLintUnicornRules {
      */
     "unicorn/no-unused-properties"?: TtscLintRuleSetting;
     /**
-     * Reject useless initializer arguments (`new Set()`, `new Map([])`, `new
-     * Set(undefined)`) on collection constructors.
+     * Reject a single null, undefined or empty array initializer argument on
+     * source-named Set/Map/WeakSet/WeakMap constructors. Zero-argument
+     * construction is already accepted.
      *
      * @reference https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-useless-collection-argument.md
      */
     "unicorn/no-useless-collection-argument"?: TtscLintRuleSetting;
     /**
-     * Reject `Error.captureStackTrace(this, constructor)` when the surrounding
-     * subclass relies on the default `Error` capture.
+     * Recommend omitting repeated this-target stack capture. A supplied filter
+     * must name the surrounding constructor or new.target; external frame filters
+     * are retained. The AST matcher does not prove inheritance.
      *
      * @reference https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-useless-error-capture-stack-trace.md
      */
     "unicorn/no-useless-error-capture-stack-trace"?: TtscLintRuleSetting;
     /**
-     * Reject `...(x ?? {})` and similar fallbacks when spreading; the spread of
-     * `null` / `undefined` is already a no-op.
+     * Reject `...(x ?? {})` and similar fallbacks in object spread, where `null`
+     * / `undefined` contributes no properties. Array and argument spread require
+     * iterables and retain their fallbacks.
      *
      * @reference https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-useless-fallback-in-spread.md
      */
@@ -478,19 +502,25 @@ export interface ITtscLintUnicornRules {
      * Reject `arr.length` checks that the iteration method itself already
      * handles.
      *
+     * Reports guards before some, and before forEach only when the result is
+     * discarded or consumed for truthiness, preserving false versus undefined.
+     *
      * @reference https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-useless-length-check.md
      */
     "unicorn/no-useless-length-check"?: TtscLintRuleSetting;
     /**
-     * Reject `return Promise.resolve(x)` / `return Promise.reject(e)` inside
-     * `async` functions — `return x` and `throw e` work identically.
+     * Report returned source-named `Promise.resolve` / `Promise.reject` calls
+     * inside async functions. The suggestion does not certify scheduling,
+     * overridden Promise methods or rejection-reason equivalence.
      *
      * @reference https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-useless-promise-resolve-reject.md
      */
     "unicorn/no-useless-promise-resolve-reject"?: TtscLintRuleSetting;
     /**
-     * Reject spreading a single iterable into a new collection of the same kind
-     * (`[...arr]`, `{...obj}`) when the original would suffice.
+     * Reject a single spread of a literal inside another literal of the same kind
+     * (`[...[1, 2]]`, `{...{ a: 1 }}`). Spreads of variables such as `[...arr]`
+     * or `{...obj}` are not inspected; this AST-only rule offers no automatic
+     * edit.
      *
      * @reference https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-useless-spread.md
      */
@@ -503,8 +533,8 @@ export interface ITtscLintUnicornRules {
      */
     "unicorn/no-useless-switch-case"?: TtscLintRuleSetting;
     /**
-     * Reject explicit `undefined` returns, default initializers, and arguments
-     * where the omission has the same meaning.
+     * Report explicit `return undefined` and `return void 0` statements. Default
+     * initializers and call arguments are not checked by this rule.
      *
      * @reference https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-useless-undefined.md
      */
@@ -564,8 +594,8 @@ export interface ITtscLintUnicornRules {
      */
     "unicorn/prefer-array-index-of"?: TtscLintRuleSetting;
     /**
-     * Prefer `Array#some` over `filter(...).length > 0`, `find(...) !==
-     * undefined`, and similar shapes.
+     * Prefer `Array#some` over `filter(...).length > 0` or a nonzero-length
+     * comparison. The always-true `length >= 0` is excluded.
      *
      * @reference https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-array-some.md
      */
@@ -579,6 +609,9 @@ export interface ITtscLintUnicornRules {
     /**
      * Prefer `1n` over `BigInt(1)` and `BigInt("1")`.
      *
+     * Numeric operands must be safe integers. Decimal integer strings can carry
+     * arbitrary precision; the author must normalize their literal spelling.
+     *
      * @reference https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-bigint-literals.md
      */
     "unicorn/prefer-bigint-literals"?: TtscLintRuleSetting;
@@ -613,12 +646,17 @@ export interface ITtscLintUnicornRules {
     /**
      * Prefer `Date.now()` over `new Date().getTime()` / `+new Date()`.
      *
+     * Only zero-argument Date construction is considered. Explicit arguments
+     * select another instant and are retained.
+     *
      * @reference https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-date-now.md
      */
     "unicorn/prefer-date-now"?: TtscLintRuleSetting;
     /**
      * Prefer default parameter syntax over `x = x ?? default` reassignments
-     * inside the function body.
+     * inside the function body. The reported nullish assignment also handles
+     * null, while a parameter default handles only undefined. No edit is
+     * supplied.
      *
      * @reference https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-default-parameters.md
      */
@@ -649,8 +687,9 @@ export interface ITtscLintUnicornRules {
      */
     "unicorn/prefer-dom-node-text-content"?: TtscLintRuleSetting;
     /**
-     * Prefer `EventTarget` over Node's `EventEmitter` when the code is shared
-     * between Node and the browser.
+     * Report `new EventEmitter(...)` by its bare source name and suggest
+     * considering EventTarget. The check does not determine deployment targets or
+     * prove that the two event APIs are interchangeable.
      *
      * @reference https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-event-target.md
      */
@@ -697,7 +736,10 @@ export interface ITtscLintUnicornRules {
      */
     "unicorn/prefer-keyboard-event-key"?: TtscLintRuleSetting;
     /**
-     * Prefer `a || b` / `a ?? b` over the equivalent ternary `a ? a : b`.
+     * Suggest logical operators for `a ? a : b` shapes. This textual baseline
+     * does not prove stable reads: a logical operator evaluates a once, while the
+     * ternary can evaluate it twice. Authors choose truthiness or nullish
+     * behavior; no edit is supplied.
      *
      * @reference https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-logical-operator-over-ternary.md
      */
@@ -746,6 +788,12 @@ export interface ITtscLintUnicornRules {
      * Prefer negative-index lookups (`arr.at(-1)`, `arr.slice(-2)`) over
      * `arr.length - 1` / `arr.length - 2` arithmetic.
      *
+     * The length must belong to the same structural receiver. Only first index
+     * arguments of slice/splice/toSpliced/at are considered, excluding
+     * lastIndexOf search values. For offsets larger than length, authors must
+     * check their intended bounds because the two spellings can select different
+     * positions.
+     *
      * @reference https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-negative-index.md
      */
     "unicorn/prefer-negative-index"?: TtscLintRuleSetting;
@@ -763,7 +811,10 @@ export interface ITtscLintUnicornRules {
      */
     "unicorn/prefer-number-properties"?: TtscLintRuleOptionsSetting<ITtscLintUnicornPreferNumberPropertiesRuleOptions>;
     /**
-     * Prefer `Object.fromEntries` over `reduce`-into-object patterns.
+     * Suggest reviewing two-argument reduce calls with an empty object seed. The
+     * reducer and input pair shape are not inspected. Use Object.fromEntries only
+     * when key/value entry construction preserves the intended behavior. No edit
+     * is supplied.
      *
      * @reference https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-object-from-entries.md
      */
@@ -810,8 +861,8 @@ export interface ITtscLintUnicornRules {
      */
     "unicorn/prefer-response-static-json"?: TtscLintRuleSetting;
     /**
-     * Prefer `Set#has` over `Array#includes` for repeated membership lookups
-     * against a constant collection.
+     * Suggest considering Set membership for `.includes(...)` calls on array
+     * literals. Repetition frequency and runtime performance are not measured.
      *
      * @reference https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-set-has.md
      */
@@ -830,15 +881,16 @@ export interface ITtscLintUnicornRules {
      */
     "unicorn/prefer-simple-condition-first"?: TtscLintRuleSetting;
     /**
-     * Prefer a single `push` / `unshift` / `classList.add` / `addEventListener`
-     * with multiple arguments over consecutive single-argument calls.
+     * Prefer a single `push` / `unshift` with multiple arguments over consecutive
+     * calls. EventTarget listener methods are not variadic and are excluded.
      *
      * @reference https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-single-call.md
      */
     "unicorn/prefer-single-call"?: TtscLintRuleSetting;
     /**
-     * Prefer spread (`[...arr]`, `[...str]`) over `Array.from`,
-     * `Array.prototype.slice.call`, `concat([])`, and `split('')`.
+     * Suggest spread for single-argument Array.from calls. This AST baseline does
+     * not prove iterable input or builtin identity; non-iterable array-like input
+     * needs Array.from. Mapper calls are excluded and no edit is supplied.
      *
      * @reference https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-spread.md
      */
@@ -852,7 +904,7 @@ export interface ITtscLintUnicornRules {
     "unicorn/prefer-string-raw"?: TtscLintRuleSetting;
     /**
      * Prefer `String#replaceAll(literal, replacement)` over `replace(/literal/g,
-     * replacement)`.
+     * replacement)` for fixed patterns without case-insensitive or sticky flags.
      *
      * @reference https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-string-replace-all.md
      */
@@ -864,8 +916,8 @@ export interface ITtscLintUnicornRules {
      */
     "unicorn/prefer-string-slice"?: TtscLintRuleSetting;
     /**
-     * Prefer `String#startsWith` / `String#endsWith` over equivalent
-     * `RegExp#test` and slice-then-compare idioms.
+     * Prefer `String#startsWith` / `String#endsWith` over slice-then-compare
+     * whose fixed bound equals the cooked literal's JavaScript UTF-16 length.
      *
      * @reference https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-string-starts-ends-with.md
      */
@@ -921,8 +973,9 @@ export interface ITtscLintUnicornRules {
      */
     "unicorn/prevent-abbreviations"?: TtscLintRuleOptionsSetting<ITtscLintUnicornPreventAbbreviationsRuleOptions>;
     /**
-     * Enforce a single style (always leading `./` vs. never) for relative URLs
-     * passed to `new URL`.
+     * Remove a leading ./ only when it retains path meaning. Scheme-like and
+     * network-path forms remain; empty/query/fragment forms require a literal
+     * directory base.
      *
      * @reference https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/relative-url-style.md
      */

package/lib/structures/rules/ITtscLintVitestRules.d.ts

@@ -8,6 +8,11 @@ import type { TtscLintRuleSetting } from "../TtscLintRuleSetting";
  * titles, conditional logic, valid `expect` shape.
  *
  * @reference https://github.com/vitest-dev/eslint-plugin-vitest
+ *
+ * @evidence contracts/common.md#principled-implementation Optional vitest keys represent independent runner policies through severity-only settings, retaining a distinct namespace despite shared Jest-style source syntax.
+ * @evidence contracts/common.md#clear-and-simple-design One map groups Vitest test-source concerns and reuses the common severity union without coupling it to the Jest family type.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The declared Vitest policy names are public configuration entries rather than production branches introduced solely for this repository's tests.
+ * @evidence contracts/common.md#meaningful-documentation Native family prose identifies Vitest and member comments explain collection, assertion and callback concerns; paragraph and member separation follow documentation guidance.
  */
 export interface ITtscLintVitestRules {
     /**
@@ -18,8 +23,9 @@ export interface ITtscLintVitestRules {
      */
     "vitest/expect-expect"?: TtscLintRuleSetting;
     /**
-     * Reject `expect(...)` calls under `if`/`try`/`catch` or other conditional
-     * branches in Vitest tests.
+     * Reject recognized `expect(...)` calls in conditional or loop syntax inside
+     * test callbacks. The native conditional-kind set does not include
+     * try/catch.
      *
      * A branch that never runs turns the assertion into a silent no-op rather
      * than a failure.
@@ -46,7 +52,8 @@ export interface ITtscLintVitestRules {
      */
     "vitest/no-disabled-tests"?: TtscLintRuleSetting;
     /**
-     * Reject `done` callback parameters in Vitest tests and lifecycle hooks.
+     * Reject any first callback parameter in recognized Vitest tests and hooks,
+     * regardless of whether its name is `done`.
      *
      * The callback style predates async/await and makes failure propagation easy
      * to miss; return a Promise or mark the body `async` instead.
@@ -83,11 +90,11 @@ export interface ITtscLintVitestRules {
      */
     "vitest/no-standalone-expect"?: TtscLintRuleSetting;
     /**
-     * Reject `return` statements that return non-Promise values from a Vitest
-     * test callback.
+     * Reject explicit return statements in recognized Vitest test callbacks,
+     * including bare returns and returned Promises; return types are not
+     * inferred.
      *
-     * The runner ignores the value and following code is dead, which usually
-     * masks a missing `await` or stray early-exit.
+     * The rule is an AST source policy and does not execute runner completion.
      *
      * @reference https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/no-test-return-statement.md
      */
@@ -105,15 +112,16 @@ export interface ITtscLintVitestRules {
     /**
      * Validate the shape of Vitest `describe` callbacks.
      *
-     * The callback must be synchronous and take no arguments — the runner ignores
-     * returned Promises and `done`-style parameters at the describe level.
+     * The native check requires a function callback without an async modifier. It
+     * does not validate parameter count or infer returned Promise types.
      *
      * @reference https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/valid-describe-callback.md
      */
     "vitest/valid-describe-callback"?: TtscLintRuleSetting;
     /**
-     * Validate `expect(...)` arity and matcher chaining: exactly one argument,
-     * terminated by a matcher call, and async matchers properly awaited.
+     * Require at least one `expect(...)` argument and a terminating matcher call,
+     * permitting `not`, `resolves`, and `rejects` property links. The native
+     * check does not impose a maximum arity or validate asynchronous handling.
      *
      * Malformed expects either throw at runtime or pass without asserting
      * anything.

package/lib/structures/rules/TtscLintContributorOverlay.d.ts

@@ -0,0 +1,34 @@
+import type { TtscLintRuleOptionsSetting, TtscLintRuleSetting } from "../TtscLintRuleSetting";
+/**
+ * Strongly typed settings for the rules of one or more contributor packages.
+ *
+ * A contributor publishes an ordinary exported interface that maps each of its
+ * rule names to the options object the rule accepts, or to `void` when the rule
+ * takes severity only. The user passes that interface, or an intersection of
+ * several, as the generic argument of `ITtscLintConfig`:
+ *
+ * ```ts
+ * export interface IDemoLintRules {
+ *   "demo/no-marker-comment": { markers?: readonly string[] };
+ *   "demo/capitalize-exports": void;
+ * }
+ *
+ * export default {
+ *   rules: { "demo/no-marker-comment": ["error", { markers: ["TODO"] }] },
+ * } satisfies ITtscLintConfig<IDemoLintRules>;
+ * ```
+ *
+ * Each listed rule is optional and receives exact severity-plus-options
+ * checking; a name that no passed interface lists keeps the open
+ * `"<namespace>/<rule>"` fallback of `ITtscLintContributorRules`.
+ *
+ * @typeParam TMap - Rule name to options object, or to `void` for a
+ *   severity-only rule.
+ * @evidence contracts/common.md#principled-implementation Mapping keyof the contributor interface keeps each rule's own options type, and the void check selects the severity-only form for rules that take no options.
+ * @evidence contracts/common.md#clear-and-simple-design One mapped alias derives the typed settings from a plain exported interface, so a contributor declares each rule once and no module augmentation is needed.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The overlay uses TypeScript's supported keyof and conditional-type semantics and an ordinary generic argument rather than casts, ambient module declarations or a widened unknown slot for listed rules.
+ * @evidence contracts/common.md#meaningful-documentation Native prose explains the published interface, the generic argument and the open fallback for unlisted names; the example separates the contributor and user sides.
+ */
+export type TtscLintContributorOverlay<TMap extends object> = {
+    [TRuleName in keyof TMap]?: [TMap[TRuleName]] extends [void] ? TtscLintRuleSetting : TtscLintRuleOptionsSetting<TMap[TRuleName]>;
+};

package/lib/structures/rules/TtscLintContributorOverlay.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=TtscLintContributorOverlay.js.map

package/lib/structures/rules/TtscLintContributorOverlay.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TtscLintContributorOverlay.js","sourceRoot":"","sources":["../../../src/structures/rules/TtscLintContributorOverlay.ts"],"names":[],"mappings":""}

package/lib/structures/rules/index.d.ts

@@ -1,6 +1,7 @@
 export * from "./ITtscLintBoundariesRuleOptions";
 export * from "./ITtscLintBoundariesRules";
 export * from "./ITtscLintContributorRules";
+export * from "./TtscLintContributorOverlay";
 export * from "./ITtscLintCoreRuleOptions";
 export * from "./ITtscLintCoreRules";
 export * from "./ITtscLintCypressRuleOptions";

package/lib/structures/rules/index.js

@@ -17,6 +17,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./ITtscLintBoundariesRuleOptions"), exports);
 __exportStar(require("./ITtscLintBoundariesRules"), exports);
 __exportStar(require("./ITtscLintContributorRules"), exports);
+__exportStar(require("./TtscLintContributorOverlay"), exports);
 __exportStar(require("./ITtscLintCoreRuleOptions"), exports);
 __exportStar(require("./ITtscLintCoreRules"), exports);
 __exportStar(require("./ITtscLintCypressRuleOptions"), exports);

package/lib/structures/rules/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/structures/rules/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,mEAAiD;AACjD,6DAA2C;AAC3C,8DAA4C;AAC5C,6DAA2C;AAC3C,uDAAqC;AACrC,gEAA8C;AAC9C,0DAAwC;AACxC,mEAAiD;AACjD,6DAA2C;AAC3C,uDAAqC;AACrC,wDAAsC;AACtC,0DAAwC;AACxC,yDAAuC;AACvC,6DAA2C;AAC3C,0DAAwC;AACxC,kEAAgD;AAChD,4DAA0C;AAC1C,8DAA4C;AAC5C,wDAAsC;AACtC,yDAAuC;AACvC,4DAA0C;AAC1C,mDAAiC;AACjC,2DAAyC;AACzC,wDAAsC;AACtC,kEAAgD;AAChD,4DAA0C;AAC1C,gEAA8C;AAC9C,uEAAqD;AACrD,iEAA+C;AAC/C,mEAAiD;AACjD,6DAA2C;AAC3C,gEAA8C;AAC9C,0DAAwC;AACxC,yDAAuC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/structures/rules/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,mEAAiD;AACjD,6DAA2C;AAC3C,8DAA4C;AAC5C,+DAA6C;AAC7C,6DAA2C;AAC3C,uDAAqC;AACrC,gEAA8C;AAC9C,0DAAwC;AACxC,mEAAiD;AACjD,6DAA2C;AAC3C,uDAAqC;AACrC,wDAAsC;AACtC,0DAAwC;AACxC,yDAAuC;AACvC,6DAA2C;AAC3C,0DAAwC;AACxC,kEAAgD;AAChD,4DAA0C;AAC1C,8DAA4C;AAC5C,wDAAsC;AACtC,yDAAuC;AACvC,4DAA0C;AAC1C,mDAAiC;AACjC,2DAAyC;AACzC,wDAAsC;AACtC,kEAAgD;AAChD,4DAA0C;AAC1C,gEAA8C;AAC9C,uEAAqD;AACrD,iEAA+C;AAC/C,mEAAiD;AACjD,6DAA2C;AAC3C,gEAA8C;AAC9C,0DAAwC;AACxC,yDAAuC"}

package/linthost/all_rule_names_returns_sorted_caller_owned_enumeration_test.go

@@ -0,0 +1,72 @@
+package linthost
+
+import (
+  "reflect"
+  "sort"
+  "testing"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+type enumerationSentinelRule struct{ name string }
+
+func (r enumerationSentinelRule) Name() string                  { return r.name }
+func (r enumerationSentinelRule) Visits() []shimast.Kind        { return nil }
+func (r enumerationSentinelRule) Check(*Context, *shimast.Node) {}
+
+// TestAllRuleNamesReturnsSortedCallerOwnedEnumeration verifies AllRuleNames lists
+// registered identities in lexical order and hands the caller a slice it owns.
+//
+// Two sentinel rules are registered in reverse lexical order so the expected
+// positions come from the names the test chose, not from the production rule
+// set. The caller then overwrites its slice, and a second enumeration must be
+// unaffected.
+//
+//  1. Register a "zz" sentinel and then an "aa" sentinel.
+//  2. Enumerate and require the whole result to be sorted with "aa" before "zz".
+//  3. Overwrite the first element of the result and enumerate again.
+//
+// @evidence contracts/testing.md#behavioral-verification AllRuleNames runs against the live registry after two sentinel registrations made in reverse lexical order; the result must be sorted, contain each sentinel exactly once with the aa sentinel ahead of the zz sentinel, and a fresh enumeration after the caller overwrote element zero must equal the first result.
+// @evidence contracts/testing.md#independent-expectations The expected relative order is fixed by the two sentinel names chosen in the test (test/enumeration-aa before test/enumeration-zz) and by sort.StringsAreSorted, not by reading names out of the production rule set; no production rule name is asserted to exist.
+// @evidence contracts/testing.md#distinguishing-cases Reverse-order registration distinguishes sorted output from insertion order, and the post-mutation enumeration distinguishes a caller-owned copy from a shared backing slice. Lookup of single names is owned by the register and lookup tests.
+// @evidence contracts/testing.md#execution-ownership Unit entry TestAllRuleNamesReturnsSortedCallerOwnedEnumeration calls Register and AllRuleNames in the shared linthost test process with a private rule stub, deleting the sentinels and invalidating derived rule codes on cleanup; it reads no manifest, document or source text and starts no host.
+func TestAllRuleNamesReturnsSortedCallerOwnedEnumeration(t *testing.T) {
+  const (
+    first  = "test/enumeration-zz"
+    second = "test/enumeration-aa"
+  )
+  for _, name := range []string{first, second} {
+    if LookupRule(name) != nil {
+      t.Fatalf("sentinel name %q is already registered", name)
+    }
+    Register(enumerationSentinelRule{name: name})
+    name := name
+    t.Cleanup(func() {
+      delete(registered.rules, name)
+      invalidateRuntimeRuleCodes()
+    })
+  }
+
+  names := AllRuleNames()
+  if !sort.StringsAreSorted(names) {
+    t.Fatalf("AllRuleNames is not sorted: %v", names)
+  }
+  positions := map[string]int{}
+  for index, name := range names {
+    if _, duplicate := positions[name]; duplicate {
+      t.Fatalf("AllRuleNames lists %q twice", name)
+    }
+    positions[name] = index
+  }
+  aa, hasAA := positions[second]
+  zz, hasZZ := positions[first]
+  if !hasAA || !hasZZ || aa >= zz {
+    t.Fatalf("sentinel order wrong: %q at %d (present=%v), %q at %d (present=%v)", second, aa, hasAA, first, zz, hasZZ)
+  }
+
+  snapshot := append([]string(nil), names...)
+  names[0] = "caller-owned-slice-mutation"
+  if again := AllRuleNames(); !reflect.DeepEqual(again, snapshot) {
+    t.Fatalf("caller mutation changed a later enumeration: %v != %v", again, snapshot)
+  }
+}

package/linthost/as_bool_rejects_non_boolean_value_test.go

@@ -0,0 +1,39 @@
+package linthost
+
+import (
+  "strings"
+  "testing"
+)
+
+// TestAsBoolRejectsNonBooleanValue verifies rejection of string true and
+// preservation of both actual Boolean values.
+//
+// The malformed input must report the supplied format.semi field label.
+// The true and false controls distinguish supported bool input from
+// string coercion or an unconditional truthy default. This fixture calls
+// the conversion helper directly, without loading a format block.
+//
+// @evidence contracts/testing.md#behavioral-verification asBool rejects string true with the offending field name and accepts Boolean true and false without changing their values.
+// @evidence contracts/testing.md#independent-expectations Boolean option fields require actual bool values rather than truthy string coercion; the literal true result and field identity supply independent expectations.
+// @evidence contracts/testing.md#distinguishing-cases Owns a misleading string true and both actual Boolean values across format fields; format-block tests separately exercise the caller field validation.
+// @evidence contracts/testing.md#execution-ownership This discoverable Go unit calls asBool directly on three authored values in the shared lint test process; it observes returned Booleans and errors without filesystem fixtures or a config script host.
+func TestAsBoolRejectsNonBooleanValue(t *testing.T) {
+  _, err := asBool("format.semi", "true")
+  if err == nil {
+    t.Fatal("asBool(field, string): expected error, got nil")
+  }
+  if !strings.Contains(err.Error(), "format.semi") {
+    t.Errorf("asBool error should name the field, got: %v", err)
+  }
+
+  got, err := asBool("format.useTabs", true)
+  if err != nil {
+    t.Fatalf("asBool(field, true): unexpected error: %v", err)
+  }
+  if !got {
+    t.Fatal("asBool(field, true): expected true, got false")
+  }
+  if got, err := asBool("format.semi", false); err != nil || got {
+    t.Fatalf("asBool(field, false): value=%v error=%v", got, err)
+  }
+}