@ttsc/lint 0.13.1 → 0.14.0-dev.20250530.1

package/rule/rule.go

@@ -110,17 +110,19 @@ type Reporter interface {
 }
 
 // FixReporter is the optional extension a host implements to receive
-// autofix edits alongside a finding. The public `rule.Context` type-asserts
-// against this shape so any host whose reporter exposes both methods opts
-// into fix support without depending on a private interface name.
+// autofix edits alongside a finding. The public `rule.Context`
+// type-asserts against this shape so any host whose reporter exposes
+// both methods opts into fix support without depending on a private
+// interface name.
 //
-// Contributor rules do NOT implement this interface — it is the host-side
-// counterpart to `Context.ReportFix` / `Context.ReportRangeFix`. A
-// contributor authoring a fake reporter for unit tests can declare
-// `var _ rule.FixReporter = &myReporter{}` to compile-check that the fake
-// satisfies the fix surface. Go interface satisfaction is all-or-nothing:
-// a fake that wants the fix path must implement BOTH `ReportFix` and
-// `ReportRangeFix`.
+// Rule production code does NOT touch FixReporter directly — call
+// `ctx.ReportFix` / `ctx.ReportRangeFix`, and the host's reporter
+// receives the edits. The only place a contributor sees this interface
+// is in test code that fakes the reporter: such a fake must implement
+// BOTH `Reporter` (`Report` + `ReportRange`) AND `FixReporter`
+// (`ReportFix` + `ReportRangeFix`), because Go interface satisfaction
+// is all-or-nothing. Declaring `var _ rule.FixReporter = &myFake{}`
+// compile-checks the fake covers the fix surface.
 type FixReporter interface {
   ReportFix(node *shimast.Node, message string, edits ...TextEdit)
   ReportRangeFix(pos, end int, message string, edits ...TextEdit)

package/src/defaultFormat.ts

@@ -1,32 +1,39 @@
-import type { ITtscLintFormatConfig } from "./structures/ITtscLintFormatConfig";
+import type { ITtscLintFormat } from "./structures/format/ITtscLintFormat";
 
 /**
  * Documented defaults for the `format` block's _always-on_ rules
- * (`format/semi`, `format/quotes`, `format/trailing-comma`,
+ * (`format/semi`, `format/quotes`, `format/arrow-parens`,
+ * `format/bracket-spacing`, `format/quote-props`, `format/trailing-comma`,
  * `format/print-width`).
  *
  * Exported so users can spread defaults next to overrides:
  *
- * Import { defaultFormat, type ITtscLintConfig } from "@ttsc/lint";
+ * ```ts
+ * import { type ITtscLintConfig, defaultFormat } from "@ttsc/lint";
  *
- * Export default { format: { ...defaultFormat, printWidth: 100 }, } satisfies
- * ITtscLintConfig;
+ * export default {
+ *   format: { ...defaultFormat, printWidth: 100 },
+ * } satisfies ITtscLintConfig;
+ * ```
  *
  * The values mirror Prettier 1:1 except for the documented `endOfLine`
  * narrowing (no `"cr"` / `"auto"`).
  *
- * Notably absent: `importOrder` and `jsdoc`. `format/sort-imports` and
- * `format/jsdoc` are opt-in by setting their corresponding fields; the defaults
- * const only seeds the rules that turn on unconditionally with a non-empty
- * `format` block.
+ * Notably absent: `importOrder`. `format/sort-imports` is opt-in by setting
+ * `importOrder`; `format/jsdoc` is always-on (set `jsDoc: false` to opt out).
+ * This const documents only the rules that turn on unconditionally with a
+ * non-empty `format` block, the Go host owns runtime activation.
  */
 export const defaultFormat = Object.freeze({
   severity: "off",
   semi: true,
   singleQuote: false,
+  arrowParens: "always",
+  bracketSpacing: true,
+  quoteProps: "as-needed",
   trailingComma: "all",
   printWidth: 80,
   tabWidth: 2,
   useTabs: false,
   endOfLine: "lf",
-} satisfies ITtscLintFormatConfig);
+} satisfies ITtscLintFormat);

package/src/index.ts

@@ -18,7 +18,11 @@ type TtscPluginContributor = {
 
 /** Descriptor shape returned to ttsc's plugin builder by the factory. */
 type TtscPluginDescriptor = {
-  capabilities?: { diagnosticsTiming?: boolean; threadingArgs?: boolean };
+  capabilities?: {
+    diagnosticsTiming?: boolean;
+    lsp?: boolean;
+    threadingArgs?: boolean;
+  };
   contributors?: TtscPluginContributor[];
   name: string;
   reportsTypeScriptDiagnostics?: boolean;
@@ -98,11 +102,10 @@ const FRAMEWORK_KEYS = new Set<string>([
  * upward from the tsconfig directory.
  *
  * The factory locates the config file, evaluates it (via ttsx for TS / ESM
- * sources, `require` for CommonJS, `JSON.parse` for JSON), reads its `plugins`
- * map, and forwards each contributor's Go source directory to ttsc's plugin
- * builder via the descriptor's `contributors` field.
- *
- * @internal
+ * sources, `require` for CommonJS, `JSON.parse` for JSON), reads every
+ * `plugins` map (top-level and inside array-form flat configs), and forwards
+ * each contributor's Go source directory to ttsc's plugin builder via the
+ * descriptor's `contributors` field.
  */
 export default function createTtscPlugin(
   context: TtscPluginFactoryContext<ITtscLintPluginConfig>,
@@ -113,7 +116,7 @@ export default function createTtscPlugin(
   // declared, so consumers (and the existing key-shape regression
   // tests) see the same surface as before this feature shipped.
   const descriptor: TtscPluginDescriptor = {
-    capabilities: { diagnosticsTiming: true, threadingArgs: true },
+    capabilities: { diagnosticsTiming: true, lsp: true, threadingArgs: true },
     name: "@ttsc/lint",
     reportsTypeScriptDiagnostics: true,
     source: path.resolve(__dirname, "..", "plugin"),
@@ -255,14 +258,24 @@ function findLintConfigFile(
   // as ambiguous and skipped (the Go side raises a hard error on the
   // duplicate; here we leave it to the binary's own discovery to surface
   // the issue once with one canonical message).
+  const candidateSet = new Set<string>(LINT_CONFIG_FILENAMES);
   let dir = tsconfigBaseDir(context);
   while (true) {
-    const matches = LINT_CONFIG_FILENAMES.map((name) =>
-      path.join(dir, name),
-    ).filter(
-      (candidate) =>
-        fs.existsSync(candidate) && fs.statSync(candidate).isFile(),
-    );
+    // One `readdirSync` per directory level beats 14 `existsSync`+
+    // `statSync` pairs (= 28 stat syscalls) per level; intersect the
+    // listing with the candidate set instead.
+    let entries: fs.Dirent[];
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      entries = [];
+    }
+    const matches: string[] = [];
+    for (const entry of entries) {
+      if (!candidateSet.has(entry.name)) continue;
+      if (!entry.isFile() && !entry.isSymbolicLink()) continue;
+      matches.push(path.join(dir, entry.name));
+    }
     if (matches.length === 1) {
       return matches[0];
     }
@@ -376,7 +389,6 @@ function readCjsConfigPlugins(configPath: string): ConfigPluginEntry[] {
 const TTSX_EXTRACTOR_SCRIPT = `import * as importedConfig from %CONFIG_IMPORT%;
 
 declare const process: {
-  argv: string[];
   cwd(): string;
   stdout: { write(value: string): void };
   stderr: { write(value: string): void };
@@ -444,7 +456,10 @@ function extractPluginSource(value: unknown): string | undefined {
   // contributors authored as plain \`module.exports = plugin\` both
   // resolve identically.
   let current: Record<string, unknown> = value;
-  for (let i = 0; i < 4; i++) {
+  // 8 hops to match the outer-process unwrapDefault helper; previously
+  // 4, which silently misrouted deeply re-exported plugins while
+  // unwrapDefault would have unwrapped them.
+  for (let i = 0; i < 8; i++) {
     if (typeof current.source === "string") break;
     const next = current.default;
     if (!isObject(next)) break;
@@ -798,7 +813,16 @@ function normalizePluginValue(
         }`,
       );
     }
-    const mod = requireFromConfig(resolved);
+    let mod: unknown;
+    try {
+      mod = requireFromConfig(resolved);
+    } catch (error) {
+      throw new Error(
+        `@ttsc/lint: lint config ${configPath} plugin ${JSON.stringify(namespace)} failed to load from ${resolved}: ${
+          error instanceof Error ? error.message : String(error)
+        }`,
+      );
+    }
     const plugin = validatePluginShape(unwrapDefault(mod), namespace, resolved);
     return { namespace, source: plugin.source };
   }

package/src/structures/ITtscLintConfig.ts

@@ -1,6 +1,6 @@
-import type { ITtscLintFormatConfig } from "./ITtscLintFormatConfig";
+import type { ITtscLintFormat } from "./format/ITtscLintFormat";
 import type { ITtscLintPlugin } from "./ITtscLintPlugin";
-import type { TtscLintRuleMap } from "./TtscLintRuleMap";
+import type { ITtscLintRules } from "./rules/ITtscLintRules";
 
 /**
  * Top-level object accepted by `@ttsc/lint` config files.
@@ -22,12 +22,18 @@ export interface ITtscLintConfig {
    */
   extends?: string;
 
-  /** Contributor plugin objects keyed by namespace. */
-  plugins?: Record<string, ITtscLintPlugin>;
+  /** Prettier-style flat configuration for the format rules. */
+  format?: ITtscLintFormat;
 
-  /** Rule-name to severity map. Supports severity tuples with options. */
-  rules?: TtscLintRuleMap;
+  /**
+   * Kebab-case built-in rule severities plus namespaced contributor rules.
+   *
+   * Built-in rules are concrete interface properties for autocomplete and typo
+   * checking. Namespaced families and contributor rules use the familiar slash
+   * form such as `react/jsx-key` or `demo/no-demo`.
+   */
+  rules?: ITtscLintRules;
 
-  /** Prettier-style flat configuration for the `format/*` rules. */
-  format?: ITtscLintFormatConfig;
+  /** Contributor plugin objects keyed by namespace. */
+  plugins?: Record<string, ITtscLintPlugin>;
 }

package/src/structures/TtscLintRuleSetting.ts

@@ -0,0 +1,55 @@
+import type { TtscLintSeverity } from "./TtscLintSeverity";
+
+/**
+ * Per-rule severity setting used by every rule entry in
+ * `ITtscLintConfig.rules`.
+ *
+ * A rule may be configured either as a bare severity string (`"error"`,
+ * `"warning"`, `"off"`) or as a single-element tuple containing the same
+ * severity. Both forms are equivalent at runtime; the tuple form exists so that
+ * severity-only rules and options-bearing rules look uniform when read
+ * top-to-bottom in a `ttsc.lint.config.ts` file.
+ *
+ * Use {@link TtscLintRuleOptionsSetting} when the rule accepts a typed options
+ * object.
+ *
+ * @example
+ *   const config: ITtscLintConfig = {
+ *     rules: {
+ *       eqeqeq: "error",
+ *       "no-console": ["warning"],
+ *       "no-debugger": "off",
+ *     },
+ *   };
+ */
+export type TtscLintRuleSetting =
+  | TtscLintSeverity
+  | readonly [TtscLintSeverity];
+
+/**
+ * Per-rule severity-plus-options setting for rules that accept a typed options
+ * object.
+ *
+ * This is the tuple form ESLint users know — `[severity, options]` — kept
+ * strongly typed by way of the rule's dedicated options interface (see
+ * `TtscLintRuleOptions.ts`). The bare {@link TtscLintRuleSetting} forms remain
+ * accepted; omitting the options object means "use the rule's default
+ * options".
+ *
+ * @example
+ *   const config: ITtscLintConfig = {
+ *   rules: {
+ *   "boundaries/element-types": [
+ *   "error",
+ *   { default: "disallow", rules: [...] },
+ *   ],
+ *   },
+ *   };
+ *
+ * @typeParam TOptions - The rule's options shape. Each rule supplies its own
+ *   interface from `TtscLintRuleOptions.ts` (for example
+ *   `ITtscLintBoundariesElementTypesRuleOptions`).
+ */
+export type TtscLintRuleOptionsSetting<TOptions> =
+  | TtscLintRuleSetting
+  | readonly [TtscLintSeverity, TOptions];

package/src/structures/format/ITtscLintFormat.ts

@@ -0,0 +1,141 @@
+import type { ITtscLintFormatJsDoc } from "./ITtscLintFormatJsDoc";
+import type { ITtscLintFormatSortImports } from "./ITtscLintFormatSortImports";
+import type { TtscLintSeverity } from "../TtscLintSeverity";
+
+/**
+ * Prettier-style flat configuration for the format rules.
+ *
+ * The `format` block is the recommended way to enable formatting in
+ * `@ttsc/lint`. Each key mirrors a Prettier option of the same name, users
+ * coming from a `.prettierrc` can copy their config almost verbatim. The block
+ * is opt-in by presence: a `lint.config.ts` with no `format` field keeps every
+ * format rule off, exactly as before.
+ *
+ * Once present, the block configures a curated set of format rules at
+ * Prettier-aligned defaults. `ttsc format` uses these rules to rewrite source.
+ * `ttsc check` does not report format findings unless `severity` is set to a
+ * non-off value. Individual rules can be overridden or disabled through the
+ * `rules` map (the `rules` entry wins on conflict).
+ */
+export interface ITtscLintFormat {
+  /**
+   * Check-time severity for format findings generated from this block.
+   *
+   * The default is `"off"` so formatting policy does not affect compilation
+   * unless the project opts into that behavior. `ttsc format` can still use the
+   * rest of this block to rewrite files.
+   *
+   * @default "off"
+   */
+  severity?: TtscLintSeverity;
+
+  /**
+   * Insert trailing semicolons on ASI-terminated statements. Mirrors Prettier's
+   * `semi`. `false` flips the rule to require _no_ trailing semicolon (rare;
+   * matches prettier's `semi: false`).
+   *
+   * @default true
+   */
+  semi?: boolean;
+
+  /**
+   * Prefer single-quoted strings. Mirrors Prettier's `singleQuote`. `false`
+   * means double quotes (Prettier's default).
+   *
+   * @default false
+   */
+  singleQuote?: boolean;
+
+  /**
+   * Parenthesize a single arrow-function parameter. Mirrors Prettier's
+   * `arrowParens`. `"always"` (the default) keeps `(x) => x`; `"avoid"` strips
+   * the parentheses of a single bare-identifier parameter, giving `x => x`. A
+   * typed, destructured, rest, optional, defaulted, or multi-parameter list
+   * keeps its parentheses in both modes.
+   *
+   * @default "always"
+   */
+  arrowParens?: "always" | "avoid";
+
+  /**
+   * Pad the inside of single-line braces with one space. Mirrors Prettier's
+   * `bracketSpacing`. `true` (the default) gives `{ x: 1 }`, `import { foo }`;
+   * `false` gives `{x: 1}`, `import {foo}`. Applies to object literals, object
+   * destructuring patterns, named imports/exports, and type literals; block,
+   * class, interface, and enum braces are unaffected.
+   *
+   * @default true
+   */
+  bracketSpacing?: boolean;
+
+  /**
+   * Quoting policy for object-literal property keys. Mirrors Prettier's
+   * `quoteProps`. `"as-needed"` (the default) removes quotes from a key that
+   * is a valid identifier (`{ "foo": 1 }` becomes `{ foo: 1 }`), keeping them
+   * on non-identifier or numeric keys (`"bar-baz"`, `"123"`). `"consistent"`
+   * keeps every key quoted when any one of them requires quotes. `"preserve"`
+   * never changes quoting.
+   *
+   * @default "as-needed"
+   */
+  quoteProps?: "as-needed" | "consistent" | "preserve";
+
+  /**
+   * Trailing-comma policy. Mirrors Prettier's `trailingComma`. The `"none"`
+   * mode disables the rule's edits.
+   *
+   * @default "all"
+   */
+  trailingComma?: "all" | "es5" | "none";
+
+  /**
+   * Maximum column width before broken-form layout is chosen. Mirrors
+   * Prettier's `printWidth`.
+   *
+   * @default 80
+   */
+  printWidth?: number;
+
+  /**
+   * Indentation increment in columns. Mirrors Prettier's `tabWidth`.
+   *
+   * @default 2
+   */
+  tabWidth?: number;
+
+  /**
+   * Emit indentation as tab characters. Mirrors Prettier's `useTabs`.
+   *
+   * @default false
+   */
+  useTabs?: boolean;
+
+  /**
+   * Line terminator the printer emits on reflow. `@ttsc/lint` supports `"lf"`
+   * and `"crlf"`. Prettier's `"cr"` and `"auto"` are intentionally unsupported
+   * because the printer does not auto-detect line endings.
+   *
+   * @default "lf"
+   */
+  endOfLine?: "lf" | "crlf";
+
+  /**
+   * Import sorting & merging. Off unless present; `true` enables it with
+   * defaults, an object customizes.
+   *
+   * @default false
+   */
+  sortImports?: boolean | ITtscLintFormatSortImports;
+
+  /**
+   * JSDoc tag normalization. On by default like the rest of the format set;
+   * pass `false` to disable, or an object to customize.
+   *
+   * Today it only rewrites tag synonyms (`@return` → `@returns`, `@arg` →
+   * `@param`, ...); tag sorting, `@param` column alignment, and description
+   * wrapping are on the roadmap.
+   *
+   * @default true
+   */
+  jsDoc?: boolean | ITtscLintFormatJsDoc;
+}

package/src/structures/format/ITtscLintFormatJsDoc.ts

@@ -0,0 +1,18 @@
+/**
+ * Object form of {@link ITtscLintFormat.jsDoc}.
+ */
+export interface ITtscLintFormatJsDoc {
+  /**
+   * Extra `from → to` tag rewrites layered on the built-in synonym table
+   * (`@return` → `@returns`, `@arg` → `@param`, ...).
+   */
+  tagSynonyms?: Record<string, string>;
+
+  /**
+   * Sort JSDoc tags into canonical order. Reserved; the current MVP only
+   * rewrites tag names.
+   *
+   * @default false
+   */
+  sortTags?: boolean;
+}

package/src/structures/format/ITtscLintFormatSortImports.ts

@@ -0,0 +1,62 @@
+/**
+ * Object form of {@link ITtscLintFormat.sortImports}.
+ *
+ * The declarative {@link order} array expresses group order, blank-line
+ * separation, and special groups all by position. Multiple imports of the same
+ * module are always merged into one declaration; merging a value import with a
+ * type-only import additionally requires {@link combineTypeAndValue}.
+ */
+export interface ITtscLintFormatSortImports {
+  /**
+   * Group order. Each entry is a regular expression matched against a
+   * declaration's module specifier, or one of these placeholders:
+   *
+   * - `<BUILTIN_MODULES>` — Node built-in modules (`fs`, `node:path`, ...).
+   * - `<THIRD_PARTY_MODULES>` — catch-all for specifiers that match no other
+   *   group. Injected implicitly at the front when omitted.
+   * - `<TYPES>` — `import type` declarations. Combine with a regex to scope it,
+   *   e.g. `<TYPES>^[.]` groups type-only relative imports.
+   * - `""` (empty string) — emit one blank line at this position. An array with
+   *   no `""` entry produces no blank lines between groups.
+   *
+   * Named specifiers inside each declaration are always sorted. Omit for the
+   * default grouping. Example:
+   *
+   * ```ts
+   * order: [
+   *   "<BUILTIN_MODULES>",
+   *   "",
+   *   "<THIRD_PARTY_MODULES>",
+   *   "",
+   *   "<TYPES>^[.]",
+   *   "^[.]",
+   * ]
+   * ```
+   */
+  order?: readonly (
+    | "<BUILTIN_MODULES>"
+    | "<THIRD_PARTY_MODULES>"
+    | "<TYPES>"
+    | ""
+    | (string & {})
+  )[];
+
+  /**
+   * Case-sensitive comparison. `false` (the default) sorts case-insensitively,
+   * so `React` and `react` order together; `true` uses raw ASCII order
+   * (uppercase before lowercase).
+   *
+   * @default false
+   */
+  caseSensitive?: boolean;
+
+  /**
+   * Merge a value import and a type-only import of the same module into one
+   * declaration with inline `type` specifiers: `import { foo } from "m"` plus
+   * `import type { Bar } from "m"` collapse to
+   * `import { foo, type Bar } from "m"`.
+   *
+   * @default false
+   */
+  combineTypeAndValue?: boolean;
+}

package/src/structures/format/index.ts

@@ -0,0 +1,3 @@
+export * from "./ITtscLintFormat";
+export * from "./ITtscLintFormatJsDoc";
+export * from "./ITtscLintFormatSortImports";

package/src/structures/index.ts

@@ -1,9 +1,8 @@
 export * from "./ITtscLintConfig";
-export * from "./ITtscLintFormatConfig";
+export * from "./format";
 export * from "./ITtscLintPlugin";
 export * from "./ITtscLintPluginConfig";
 export * from "./ITtscLintPluginMeta";
-export * from "./TtscLintRule";
-export * from "./TtscLintRuleMap";
-export * from "./TtscLintRuleOptions";
+export * from "./TtscLintRuleSetting";
 export * from "./TtscLintSeverity";
+export * from "./rules";

package/src/structures/rules/ITtscLintBoundariesRuleOptions.ts

@@ -0,0 +1,117 @@
+/**
+ * Options shapes for every rule in {@link ITtscLintBoundariesRules}.
+ *
+ * The `boundaries/*` family classifies each source file as belonging to a named
+ * _element_ (a layer, feature, or app within the project). Every rule below
+ * shares the same element-declaration block, so the helper interfaces in this
+ * file describe that block first and then layer the per-rule options on top.
+ *
+ * @reference https://github.com/javierbrea/eslint-plugin-boundaries
+ */
+
+/** One source-path element used by the `boundaries/*` rules. */
+export interface ITtscLintBoundariesElement {
+  /** Element type name used by `boundaries/element-types` policies. */
+  type: string;
+
+  /**
+   * Glob-like source path pattern. Relative patterns are matched against any
+   * project-path suffix, so `src/app/**` works in temporary and monorepo roots
+   * alike.
+   */
+  pattern: string;
+
+  /**
+   * File(s) inside the element that may be imported from outside that element.
+   * Used by `boundaries/entry-point`.
+   */
+  entry?: string | readonly string[];
+
+  /**
+   * File(s) inside the element that may only be imported by the same element.
+   * Used by `boundaries/no-private`.
+   */
+  private?: string | readonly string[];
+}
+
+/** Dependency policy used by `boundaries/element-types`. */
+export interface ITtscLintBoundariesElementTypesRule {
+  /** Source element type(s) the policy applies to. Omit to match all sources. */
+  from?: string | readonly string[];
+
+  /** Target element type(s) allowed from the matching source. */
+  allow?: string | readonly string[];
+
+  /** Target element type(s) rejected from the matching source. */
+  disallow?: string | readonly string[];
+
+  /** Optional diagnostic override. */
+  message?: string;
+}
+
+/**
+ * Shared element-declaration block used by every TypeScript source-path
+ * `boundaries/*` rule.
+ */
+export interface ITtscLintBoundariesElementsOptions {
+  /** Source path elements used to classify importers and imported files. */
+  elements?: readonly ITtscLintBoundariesElement[];
+}
+
+/** `boundaries/element-types` rule options. */
+export interface ITtscLintBoundariesElementTypesRuleOptions extends ITtscLintBoundariesElementsOptions {
+  /**
+   * Fallback policy when no rule matches.
+   *
+   * @default "allow"
+   */
+  default?: "allow" | "disallow";
+
+  /** Ordered dependency policies. First matching policy wins. */
+  rules?: readonly ITtscLintBoundariesElementTypesRule[];
+}
+
+/** `boundaries/external` rule options. */
+export interface ITtscLintBoundariesExternalRuleOptions {
+  /** External package/specifier patterns that are allowed. Empty means all. */
+  allow?: string | readonly string[];
+
+  /** External package/specifier patterns that are rejected. */
+  disallow?: string | readonly string[];
+
+  /** Optional diagnostic override. */
+  message?: string;
+}
+
+/** `boundaries/entry-point` rule options. */
+export type ITtscLintBoundariesEntryPointRuleOptions =
+  ITtscLintBoundariesElementsOptions;
+
+/** `boundaries/no-private` rule options. */
+export type ITtscLintBoundariesNoPrivateRuleOptions =
+  ITtscLintBoundariesElementsOptions;
+
+/** `boundaries/no-unknown` rule options. */
+export type ITtscLintBoundariesNoUnknownRuleOptions =
+  ITtscLintBoundariesElementsOptions;
+
+/**
+ * `boundaries/dependencies` rule options.
+ *
+ * The upstream unified rule subsumes `element-types`, `entry-point`,
+ * `external`, `no-private`, and `no-unknown` behind a single direction-aware
+ * policy block. The v1 native port registers the rule name and decodes this
+ * config shape but does not yet emit diagnostics (`v1 stub; full validation
+ * deferred` — see `rules_boundaries.go`).
+ */
+export interface ITtscLintBoundariesDependenciesRuleOptions extends ITtscLintBoundariesElementsOptions {
+  /**
+   * Fallback policy when no rule matches.
+   *
+   * @default "allow"
+   */
+  default?: "allow" | "disallow";
+
+  /** Ordered dependency policies. First matching policy wins. */
+  rules?: readonly ITtscLintBoundariesElementTypesRule[];
+}