@ttsc/lint 0.13.0 → 0.14.0-dev.20260528

package/plugin/main.go

@@ -1,7 +1,7 @@
 // Command @ttsc/lint is the native backend for the `@ttsc/lint` plugin.
 //
-// The plugin host (ttsc / ttsx) spawns this binary with one of six
-// subcommands:
+// The plugin host (ttsc / ttsx) spawns this binary with one of these
+// subcommands (canonical list lives in `linthost/dispatch.go`):
 //
 //   - `version` / `-v` / `--version` — print the binary banner.
 //   - `check` — typecheck + lint without emit. Failure exit code if any
@@ -13,6 +13,13 @@
 //   - `build` — typecheck + lint, then run the standard tsgo emit pipeline
 //     so JS files land on disk.
 //   - `transform --file=PATH` — single-file emit with the same lint pass.
+//   - `lsp-command-ids` — print workspace/executeCommand ids owned by
+//     `@ttsc/lint`.
+//   - `lsp-code-action-kinds` — print CodeActionKind values offered.
+//   - `lsp-diagnostics` — produce LSP diagnostic JSON for one file URI.
+//   - `lsp-code-actions` — produce LSP code actions for one file URI.
+//   - `lsp-execute-command` — return a WorkspaceEdit for a lint-owned
+//     command.
 //
 // Diagnostics share the renderer with tsgo's own output, so warnings come
 // out yellow, errors come out red, and the trailing `Found N errors`
@@ -25,11 +32,50 @@
 package main
 
 import (
+  "fmt"
   "os"
+  "runtime"
+  "runtime/pprof"
 
   "github.com/samchon/ttsc/packages/lint/linthost"
 )
 
 func main() {
-  os.Exit(linthost.Main(os.Args[1:]))
+  // Opt-in CPU profile capture for the lint binary. Set
+  // `TTSC_LINT_CPUPROFILE=/path/to/out.prof` before running `ttsc check`
+  // to record where the in-process lint engine spends time on a real
+  // project. The file is flushed before the process exits; the binary's
+  // exit code is unchanged. NOTE: `os.Exit` skips deferred calls, so the
+  // profile must be stopped explicitly before exit — `defer
+  // pprof.StopCPUProfile()` would silently produce a zero-byte file.
+  var profileFile *os.File
+  if path := os.Getenv("TTSC_LINT_CPUPROFILE"); path != "" {
+    f, err := os.Create(path)
+    if err != nil {
+      fmt.Fprintf(os.Stderr, "@ttsc/lint: cannot create cpuprofile %q: %v\n", path, err)
+    } else if err := pprof.StartCPUProfile(f); err != nil {
+      fmt.Fprintf(os.Stderr, "@ttsc/lint: pprof.StartCPUProfile: %v\n", err)
+      f.Close()
+    } else {
+      profileFile = f
+    }
+  }
+  code := linthost.Main(os.Args[1:])
+  if profileFile != nil {
+    pprof.StopCPUProfile()
+    profileFile.Close()
+  }
+  if path := os.Getenv("TTSC_LINT_MEMPROFILE"); path != "" {
+    f, err := os.Create(path)
+    if err != nil {
+      fmt.Fprintf(os.Stderr, "@ttsc/lint: cannot create memprofile %q: %v\n", path, err)
+    } else {
+      runtime.GC()
+      if err := pprof.WriteHeapProfile(f); err != nil {
+        fmt.Fprintf(os.Stderr, "@ttsc/lint: pprof.WriteHeapProfile: %v\n", err)
+      }
+      f.Close()
+    }
+  }
+  os.Exit(code)
 }

package/rule/astutil/astutil.go

@@ -19,10 +19,17 @@ import (
 )
 
 // NodeText returns the source text under `node` with leading trivia
-// (whitespace + comments) stripped. Mirrors `nodeText` in the built-in
+// (whitespace + comments) stripped AND trailing ASCII whitespace
+// (` `, `\t`, `\r`, `\n`) trimmed. Mirrors `nodeText` in the built-in
 // engine — useful for rules that compare textual identity (the
-// `no-self-assign` / `no-self-compare` shape) or that splice a sub-node's
-// text into a fix string.
+// `no-self-assign` / `no-self-compare` shape) or that splice a
+// sub-node's text into a fix string.
+//
+// The trailing trim is deliberate so callers using the returned text
+// as the right-hand side of a `TextEdit{End: ...}` splice don't drag
+// in a node's trailing newline. Callers that need the literal byte
+// range without trimming should call `TokenRange` and read `file.Text()`
+// directly.
 //
 // Returns "" when `file` or `node` is nil, or when the computed range
 // falls outside the file (defensive — shouldn't happen for engine-supplied

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,4 +1,4 @@
-import type { ITtscLintFormatConfig } from "./structures/ITtscLintFormatConfig";
+import type { ITtscLintFormat } from "./structures/ITtscLintFormat";
 
 /**
  * Documented defaults for the `format` block's _always-on_ rules
@@ -7,18 +7,21 @@ import type { ITtscLintFormatConfig } from "./structures/ITtscLintFormatConfig";
  *
  * Exported so users can spread defaults next to overrides:
  *
- * Import { defaultFormat, type ITtscLintConfig } from "@ttsc/lint";
+ * ```ts
+ * import { defaultFormat, type ITtscLintConfig } 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.
+ * `format/jsdoc` are opt-in by setting their corresponding fields; 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",
@@ -29,4 +32,4 @@ export const defaultFormat = Object.freeze({
   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?: { 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: { 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;
@@ -456,14 +471,14 @@ function extractPluginSource(value: unknown): string | undefined {
 `;
 
 /**
- * Resolves the contributor plugin entries declared in a .ts/.mjs lint
- * config, memoized through the shared on-disk config cache.
+ * Resolves the contributor plugin entries declared in a .ts/.mjs lint config,
+ * memoized through the shared on-disk config cache.
  *
- * Evaluating such a config spawns a full `ttsx` subprocess. A monorepo
- * build runs one `ttsc` process per package, and each would otherwise
- * re-spawn `ttsx` for the same shared config; the cache collapses that to
- * a single evaluation. The cache is keyed by the config file's path and
- * exact contents (see `configCacheKey`), so an edit re-evaluates cleanly.
+ * Evaluating such a config spawns a full `ttsx` subprocess. A monorepo build
+ * runs one `ttsc` process per package, and each would otherwise re-spawn `ttsx`
+ * for the same shared config; the cache collapses that to a single evaluation.
+ * The cache is keyed by the config file's path and exact contents (see
+ * `configCacheKey`), so an edit re-evaluates cleanly.
  */
 function readTtsxConfigPlugins(
   configPath: string,
@@ -485,9 +500,9 @@ function readTtsxConfigPlugins(
 
 /**
  * Reports whether a cached plugin entry is still usable: a well-formed
- * namespace and an absolute `source` that still points at a directory.
- * Pure predicate — never throws — so a malformed cache entry simply
- * triggers re-evaluation instead of aborting plugin discovery.
+ * namespace and an absolute `source` that still points at a directory. Pure
+ * predicate — never throws — so a malformed cache entry simply triggers
+ * re-evaluation instead of aborting plugin discovery.
  */
 function isValidConfigPluginEntry(entry: unknown): entry is ConfigPluginEntry {
   if (
@@ -655,15 +670,15 @@ function evaluateTtsxConfigPlugins(
 // ────────────────────────────────────────────────────────────────────────────
 
 /**
- * Namespaces the on-disk config cache. Kept in lockstep with the Go
- * sidecar's `configCacheVersion`; bump both when the cached shape changes.
+ * Namespaces the on-disk config cache. Kept in lockstep with the Go sidecar's
+ * `configCacheVersion`; bump both when the cached shape changes.
  */
 const CONFIG_CACHE_VERSION = "v1";
 
 /**
- * Directory shared by this factory and the Go sidecar for cached lint
- * configs. The two write different files (the `kind` segment of the cache
- * key keeps their namespaces apart), so they coexist without collision.
+ * Directory shared by this factory and the Go sidecar for cached lint configs.
+ * The two write different files (the `kind` segment of the cache key keeps
+ * their namespaces apart), so they coexist without collision.
  */
 function configCacheDir(): string {
   return path.join(os.tmpdir(), "ttsc-lint-config-cache");
@@ -675,10 +690,10 @@ function configCacheDisabled(): boolean {
 }
 
 /**
- * Content-addressed cache key for a lint config file. Mirrors the Go
- * sidecar's `configCacheKey`: a version tag, a namespace `kind`, the
- * config's absolute path, and its exact bytes. Returns "" — a "do not
- * cache" signal — when the file cannot be read or the env opt-out is set.
+ * Content-addressed cache key for a lint config file. Mirrors the Go sidecar's
+ * `configCacheKey`: a version tag, a namespace `kind`, the config's absolute
+ * path, and its exact bytes. Returns "" — a "do not cache" signal — when the
+ * file cannot be read or the env opt-out is set.
  */
 function configCacheKey(kind: string, configPath: string): string {
   if (configCacheDisabled()) return "";
@@ -700,9 +715,9 @@ function configCacheKey(kind: string, configPath: string): string {
 }
 
 /**
- * Returns the cached plugin-entry list for `cacheKey`, or undefined on any
- * miss — a missing file, an unreadable file, or content that is not a JSON
- * array. Every failure is a soft miss: the caller re-evaluates.
+ * Returns the cached plugin-entry list for `cacheKey`, or undefined on any miss
+ * — a missing file, an unreadable file, or content that is not a JSON array.
+ * Every failure is a soft miss: the caller re-evaluates.
  */
 function readConfigPluginCache(
   cacheKey: string,
@@ -718,9 +733,7 @@ function readConfigPluginCache(
   }
   try {
     const parsed: unknown = JSON.parse(body);
-    return Array.isArray(parsed)
-      ? (parsed as ConfigPluginEntry[])
-      : undefined;
+    return Array.isArray(parsed) ? (parsed as ConfigPluginEntry[]) : undefined;
   } catch {
     return undefined;
   }
@@ -729,8 +742,8 @@ function readConfigPluginCache(
 /**
  * Writes `entries` to the config cache under `cacheKey`. Best-effort: any
  * failure leaves the cache cold rather than aborting plugin discovery. The
- * temp-file + rename keeps a concurrent reader in a sibling `ttsc` process
- * from observing a half-written file.
+ * temp-file + rename keeps a concurrent reader in a sibling `ttsc` process from
+ * observing a half-written file.
  */
 function writeConfigPluginCache(
   cacheKey: string,
@@ -800,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 "./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.
@@ -25,9 +25,15 @@ export interface ITtscLintConfig {
   /** Contributor plugin objects keyed by namespace. */
   plugins?: Record<string, ITtscLintPlugin>;
 
-  /** 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;
+  /** Prettier-style flat configuration for the format rules. */
+  format?: ITtscLintFormat;
 }

package/src/structures/{ITtscLintFormatConfig.ts → ITtscLintFormat.ts}

@@ -1,7 +1,7 @@
 import type { TtscLintSeverity } from "./TtscLintSeverity";
 
 /**
- * Prettier-style flat configuration for the `format/*` rules.
+ * 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
@@ -51,7 +51,7 @@ import type { TtscLintSeverity } from "./TtscLintSeverity";
  *   Format findings produced from this block are off by default. Set `severity`
  *   only when a project intentionally wants check-time format diagnostics.
  */
-export interface ITtscLintFormatConfig {
+export interface ITtscLintFormat {
   /**
    * Check-time severity for format findings generated from this block.
    *

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".
+ *
+ * @typeParam TOptions - The rule's options shape. Each rule supplies its
+ *   own interface from `TtscLintRuleOptions.ts` (for example
+ *   `ITtscLintBoundariesElementTypesRuleOptions`).
+ *
+ * @example
+ *   const config: ITtscLintConfig = {
+ *     rules: {
+ *       "boundaries/element-types": [
+ *         "error",
+ *         { default: "disallow", rules: [...] },
+ *       ],
+ *     },
+ *   };
+ */
+export type TtscLintRuleOptionsSetting<TOptions> =
+  | TtscLintRuleSetting
+  | readonly [TtscLintSeverity, TOptions];

package/src/structures/index.ts

@@ -1,9 +1,8 @@
 export * from "./ITtscLintConfig";
-export * from "./ITtscLintFormatConfig";
+export * from "./ITtscLintFormat";
 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,128 @@
+/**
+ * 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[];
+}