@sarj/eslint-plugin 19.2.0 → 19.7.0

package/dist/catalog.js

@@ -2,7 +2,7 @@ import {
   publicDocumentation,
   ruleSpec,
   src_default
-} from "./chunk-JBAPB4JX.js";
+} from "./chunk-OX5DMK42.js";
 
 // src/docs/directive-disable-enable-pair.ts
 var DIRECTIVE_DISABLE_ENABLE_PAIR_DOCUMENTATION = {
@@ -4120,22 +4120,175 @@ var PREFER_AWAIT_IN_ASYNC_RETURN_DOCUMENTATION = {
 var PREFER_CODED_ERROR_RESULT_DOCUMENTATION = {
   summary: "Return a stable error code and typed context instead of only a rendered failure message.",
   defaultLevel: "warning",
-  rationale: "A message-only failure hides the identity needed for repair, conflict handling, localization and exhaustive dispatch. Preserve a finite error code and the minimum handling context; let the consumer format its message.",
+  rationale: "A message-only or opaque failure hides the identity needed for repair, conflict handling, localization and exhaustive dispatch. Preserve a finite error code and the minimum handling context; let the consumer format its message. Reuse the native no-explicit-any rule, compiler narrowing and type-aware exhaustiveness checks.",
   remediation: "Use the existing Result or outcome union with a finite error code and variant-specific context. Preserve public behavior through a presentation adapter, and handle or propagate each relevant variant without parsing message text.",
   category: "correctness",
   autofix: "none",
   limitations: [
-    "Checks source-resolved local unions with required literal ok/success true and false branches, and named neverthrow Result/ResultAsync imports. Broad string error/message/reason payloads and open string code fields are review candidates. String literal error-code unions remain valid.",
-    "Local aliases, unmerged interfaces without inheritance and generic substitutions are bounded to 16 resolution levels, 64 union members and 256 traversal steps. Imported local declarations, namespace imports, conditional/intersection/mapped types and unresolved contracts abstain. Optional discriminants, independent success/error payloads and partial-data failures are excluded.",
+    "Accepting an inferred producer does not prove a finite inferred contract: object payloads or errAsync can widen a code to string. Annotate the existing Result/ResultAsync return when necessary. Native assignability, narrowing and exhaustive-handler checks remain authoritative.",
+    "Checks source-resolved local unions with required literal ok/success booleans, or status/state/kind/type/tag values ok/success versus err/error/failure/failed (case insensitive). Conflicting outcome tags abstain. A shared outcome tag does not also count as a domain error code. Named and namespace neverthrow Result/ResultAsync imports establish their generic error position.",
+    "Presence-selected unions require an error property on every failure branch and the same single required non-control value property on every success branch. Optional error/value fields, multiple value keys, loading states and error branches carrying the success value abstain. Required errorMessage and Error-suffixed failure channels are also reviewed; multiple custom channels abstain and a primary error payload retains precedence.",
+    "Broad string and unknown error channels, unshadowed native Error-family types and open string/unknown code fields receive review. Explicit Any stays with the existing no-explicit-any rule. Finite literal codes need no invented payload. Imported domain errors, validation-library errors, generic error parameters, ordinary formatters, legitimate absence and redacted failure states remain valid.",
+    "Local aliases, unmerged interfaces without inheritance and generic substitutions are bounded to 16 resolution levels, 64 union members and 256 traversal steps. Imported local declarations, conditional/intersection/mapped types and unresolved contracts abstain. Optional discriminants, independent success/error payloads and partial-data failures are excluded.",
     "Required code/kind/type/tag fields of unresolved or imported type defer to the type checker; a finite code does not prove that its cases or payloads are useful. Generic error parameters are retained rather than guessed. Ordinary string formatters, absence, validation-library errors and redacted failure states without a string payload are not flagged.",
-    "A directly returned plain object with literal ok/success false and a literal string code/kind/type/tag also receives review when its message/reason is an interpolated template or proven string concatenation. Nested plain error objects and expression-bodied arrows are supported. Spreads, accessors, computed keys, helper formatting calls and nonliteral codes abstain. This proves formatting ownership, not which context the domain must expose; presentation adapters remain a reviewed exception.",
-    "This warning requests domain review: a final presentation boundary may intentionally accept every failure and render one message. No fix invents error codes, fields, handlers or changes serialization, exception unwinding, transactions, retries or logging."
+    "A directly returned failure object, neverthrow err/errAsync call or new Err with an interpolated template or proven string concatenation receives review. Without a code, the diagnostic asks for a domain contract; with a literal code, it asks for consumer formatting. Literal-only compositions, including earlier stable local constants, remain valid codes. Nested plain error objects, expression-bodied arrows and one direct await are supported. Import identity and value-space shadowing are checked; arbitrary aliases, spreads, accessors, computed keys, helper formatting calls and nonliteral codes abstain. This proves formatting ownership, not which context the domain must expose; presentation adapters remain a reviewed exception.",
+    "This warning requests domain review: an infrastructure adapter may intentionally retain unknown/Error, and a final presentation boundary may accept every failure and render one message. Neither proves a recoverable domain rejection. No fix invents error codes, fields, handlers or changes serialization, exception unwinding, transactions, retries or logging."
   ],
   references: [
     "https://www.typescriptlang.org/docs/handbook/2/narrowing.html#discriminated-unions",
     "https://github.com/supermacro/neverthrow"
   ],
   examples: [
+    {
+      id: "presence-selected-message",
+      scenarioId: "presence-selected-result",
+      title: "An error-presence check still needs a useful error contract",
+      outcome: "match",
+      files: [
+        {
+          path: "app/result.ts",
+          source: "export type Outcome<T> = { value: T } | { error: string; field?: 'name' };"
+        }
+      ],
+      focusPath: "app/result.ts",
+      expectedCount: 1,
+      public: true
+    },
+    {
+      id: "presence-selected-domain-error",
+      scenarioId: "presence-selected-result",
+      title: "Retain the existing presence check with a finite error union",
+      outcome: "no-match",
+      files: [
+        {
+          path: "app/result.ts",
+          source: "type SaveError = { code: 'duplicate'; name: string } | { code: 'denied' }; export type Outcome<T> = { value: T } | { error: SaveError };"
+        }
+      ],
+      focusPath: "app/result.ts",
+      expectedCount: 0,
+      public: true
+    },
+    {
+      id: "string-outcome-tag",
+      scenarioId: "string-outcome",
+      title: "An outcome tag distinguishes success from failure, not the failure's cause",
+      outcome: "match",
+      files: [
+        {
+          path: "app/result.ts",
+          source: "export type Outcome<T> = { kind: 'ok'; value: T } | { kind: 'error'; message: string };"
+        }
+      ],
+      focusPath: "app/result.ts",
+      expectedCount: 1,
+      public: true
+    },
+    {
+      id: "string-outcome-domain-code",
+      scenarioId: "string-outcome",
+      title: "Preserve the established string tag and add the actionable error",
+      outcome: "no-match",
+      files: [
+        {
+          path: "app/result.ts",
+          source: "export type Outcome<T> = { kind: 'ok'; value: T } | { kind: 'error'; error: { code: 'duplicate'; name: string } };"
+        }
+      ],
+      focusPath: "app/result.ts",
+      expectedCount: 0,
+      public: true
+    },
+    {
+      id: "opaque-error-channel",
+      scenarioId: "opaque-error",
+      title: "Unknown preserves the need to narrow but hides the domain's cases",
+      outcome: "match",
+      files: [
+        {
+          path: "app/result.ts",
+          source: "type Result<T, E> = { ok: true; value: T } | { ok: false; error: E }; export type Saved = Result<number, unknown>;"
+        }
+      ],
+      focusPath: "app/result.ts",
+      expectedCount: 1,
+      public: true
+    },
+    {
+      id: "specific-error-channel",
+      scenarioId: "opaque-error",
+      title: "Expose the domain's rejection case without inventing context",
+      outcome: "no-match",
+      files: [
+        {
+          path: "app/result.ts",
+          source: "type Result<T, E> = { ok: true; value: T } | { ok: false; error: E }; export type Saved = Result<number, { code: 'unavailable' }>;"
+        }
+      ],
+      focusPath: "app/result.ts",
+      expectedCount: 0,
+      public: true
+    },
+    {
+      id: "named-error-carrier",
+      scenarioId: "named-error-channel",
+      title: "A failure-only Error-suffixed field can still erase its cases",
+      outcome: "match",
+      files: [
+        {
+          path: "app/result.ts",
+          source: "export type Outcome<T> = { ok: true; value: T } | { ok: false; fallbackError: string };"
+        }
+      ],
+      focusPath: "app/result.ts",
+      expectedCount: 1,
+      public: true
+    },
+    {
+      id: "typed-named-error-carrier",
+      scenarioId: "named-error-channel",
+      title: "Preserve the existing field name with the required context",
+      outcome: "no-match",
+      files: [
+        {
+          path: "app/result.ts",
+          source: "export type Outcome<T> = { ok: true; value: T } | { ok: false; fallbackError: { code: 'unsupported'; requestedKind: string } };"
+        }
+      ],
+      focusPath: "app/result.ts",
+      expectedCount: 0,
+      public: true
+    },
+    {
+      id: "library-error-constructor",
+      scenarioId: "library-error-presentation",
+      title: "A proven Result constructor does not make formatted text actionable",
+      outcome: "match",
+      files: [
+        {
+          path: "app/result.ts",
+          source: "import { err } from 'neverthrow'; export function reject(name: string) { return err(`Missing ${name}`); }"
+        }
+      ],
+      focusPath: "app/result.ts",
+      expectedCount: 1,
+      public: true
+    },
+    {
+      id: "library-domain-constructor",
+      scenarioId: "library-error-presentation",
+      title: "Reuse the established Result library with a typed domain error",
+      outcome: "no-match",
+      files: [
+        {
+          path: "app/result.ts",
+          source: "import { err, type Result } from 'neverthrow'; type Missing = { code: 'missing'; name: string }; export function reject(name: string): Result<never, Missing> { return err({ code: 'missing', name }); }"
+        }
+      ],
+      focusPath: "app/result.ts",
+      expectedCount: 0,
+      public: true
+    },
     {
       id: "message-only-result",
       title: "A failure erases identity into a message",
@@ -4194,6 +4347,66 @@ var PREFER_CODED_ERROR_RESULT_DOCUMENTATION = {
       expectedCount: 0,
       public: true
     },
+    {
+      id: "exclusive-message-outcome",
+      scenarioId: "partial-data",
+      title: "An exclusive failure still needs an actionable identity",
+      outcome: "match",
+      files: [
+        {
+          path: "app/result.ts",
+          source: "export type Outcome<T> = { ok: true; data: T } | { ok: false; error: string };"
+        }
+      ],
+      focusPath: "app/result.ts",
+      expectedCount: 1,
+      public: true
+    },
+    {
+      id: "independent-partial-outcomes",
+      scenarioId: "partial-data",
+      title: "Partial data and its independent error remain separate outcomes",
+      outcome: "no-match",
+      files: [
+        {
+          path: "app/result.ts",
+          source: "export type Partial<T> = { ok: true; data: T; error?: string } | { ok: false; data: T; error: string };"
+        }
+      ],
+      focusPath: "app/result.ts",
+      expectedCount: 0,
+      public: true
+    },
+    {
+      id: "exclusive-error-state",
+      scenarioId: "absence-state",
+      title: "Conventional success and failure tags establish one Result",
+      outcome: "match",
+      files: [
+        {
+          path: "app/result.ts",
+          source: "export type Outcome<T> = { status: 'success'; value: T } | { status: 'failure'; reason: string };"
+        }
+      ],
+      focusPath: "app/result.ts",
+      expectedCount: 1,
+      public: true
+    },
+    {
+      id: "legitimate-unconfigured-state",
+      scenarioId: "absence-state",
+      title: "A loading report can preserve an unconfigured absence state",
+      outcome: "no-match",
+      files: [
+        {
+          path: "app/result.ts",
+          source: "export type Source<T> = { status: 'loaded'; value: T } | { status: 'failed' | 'unconfigured'; reason: string };"
+        }
+      ],
+      focusPath: "app/result.ts",
+      expectedCount: 0,
+      public: true
+    },
     {
       id: "producer-renders-context",
       scenarioId: "consumer-formatting",
@@ -4259,22 +4472,25 @@ var PREFER_DEPENDENCY_INTERFACE_DOCUMENTATION = {
 
 // src/docs/prefer-discriminated-union.ts
 var PREFER_DISCRIMINATED_UNION_DOCUMENTATION = {
-  summary: "Prefer discriminated unions for result contracts and locally proven tag-specific return payloads.",
+  summary: "Preserve producer-proven tag/payload and Boolean state relationships in return types.",
   defaultLevel: "warning",
   rationale: "A flat object with optional branch data loses the relationship between a tag and its payload. Callers cannot narrow to the required fields, and the type permits incomplete or contradictory combinations.",
   remediation: "If the variants are mutually exclusive, represent each with a literal tag and its required payload. Preserve shared fields on every member, including payload value types and nullability. For a producer returning a subset of a broader wire contract, give the producer a precise domain return type after validation.",
   category: "correctness",
   autofix: "safe",
   limitations: [
-    "The legacy boolean-result advisory recognizes local status and payload names; those names do not prove that partial-success outcomes are forbidden. Review the domain before changing its representation.",
+    "Names, Boolean counts and optional-field counts never establish a finding. A producer's direct literal writes establish either tag-specific payload presence or a pair of required Boolean fields with two or three distinct combinations, with both fields varying. All four combinations, constant dimensions and expression-valued flags are excluded. At most eight Boolean fields are compared. Only one relationship is reported per contract; payload evidence takes precedence.",
     "Producer analysis requires a finite literal tag, every declared tag syntactically witnessed, exhaustive simple return paths without literal constant conditions, plain object returns, and consistent optional-field presence for each tag. It resolves only unmerged local aliases/interfaces without inheritance or generics, and the built-in Promise around async returns. This is syntax-only evidence of field presence; explicit undefined, void and null payloads are skipped, while expression value types are not inferred. Dynamic returns, spreads, computed keys, accessors, loops and try statements are deliberately skipped.",
     "A switch producer is supported only for a non-overloaded function declaration when its sole body statement switches on an unchanged direct string or number parameter, has unique same-kind literal labels and a default, and every nonempty case body is a sole object return or throw, optionally inside sole blocks. Empty labels may share the next terminating body; nested conditions, conditional returns, statement prefixes, breaks, other fallthrough, captured/closed inputs and switches under preceding control flow abstain. Broad parameter domains establish input witnesses for each label and the default; this does not infer branch-specific runtime effects or expression value types. Path visits, depth and returned objects are bounded conservatively.",
-    "Returned variants prove this producer's key relationships, not all legal consumers of a shared type. Automatic fixes are limited to an unused private nongeneric synchronous function with a direct inline contract and one literal-object conditional return; they preserve original member types and all runtime code. Shared/observed contracts and generated/declaration/test files remain excluded."
+    "These are refactoring advisories, not proven defects or proof that other writers cannot produce more states. Historical observations, partial results, unknown states and independently completing operations may need the broader contract. Review all readers and writers before migrating a shared contract; preserve every valid combination. A union of existing literal flag pairs is the smallest type-only replacement; a named disposition is a reviewed domain migration.",
+    "Automatic fixes are limited to an unused private nongeneric synchronous function with a direct inline contract and one conditional return containing at most four literal objects. They narrow only the existing discriminator or implicated Boolean pair and preserve other member types and all runtime code, including condition evaluation, object creation, identity and exceptions. Nested conditionals are supported. Shared/observed contracts, aliases, exports, async functions, comments, expression payloads and generated/declaration/test files remain excluded. Public interfaces, serialization and cancellation are never rewritten."
   ],
   references: ["https://functional-architecture.org/make_illegal_states_unrepresentable/", "https://www.typescriptlang.org/docs/handbook/2/narrowing.html#discriminated-unions"],
   examples: [
     { id: "explicit-result-branches", title: "Use explicit result branches", outcome: "no-match", files: [{ path: "src/result.ts", source: "type Result = { ok: true; data: string } | { ok: false; error: string };" }], focusPath: "src/result.ts", expectedCount: 0, public: true },
-    { id: "optional-result-payloads", title: "Review optional result payloads", outcome: "match", files: [{ path: "src/result.ts", source: "type Result = { ok: boolean; data?: string; error?: string };" }], focusPath: "src/result.ts", expectedCount: 1, public: true },
+    { id: "optional-result-payloads", title: "A producer establishes the status-to-payload relationship", outcome: "match", files: [{ path: "src/result.ts", source: 'function result(ok: boolean): { ok: boolean; data?: string; error?: string } { return ok ? { ok: true, data: "value" } : { ok: false, error: "failed" }; }' }], focusPath: "src/result.ts", expectedCount: 1, public: true },
+    { id: "failure-dispositions", scenarioId: "boolean-state", title: "A producer returns retry, terminal and saved-partial combinations", outcome: "match", files: [{ path: "src/failure.ts", source: "function failure(retry: boolean, saved: boolean): { retriable: boolean; persisted: boolean } { return saved ? { retriable: false, persisted: true } : retry ? { retriable: true, persisted: false } : { retriable: false, persisted: false }; }" }], focusPath: "src/failure.ts", expectedCount: 1, public: true },
+    { id: "independent-observations", scenarioId: "boolean-state", title: "Independent observations retain all four combinations", outcome: "no-match", files: [{ path: "src/observations.ts", source: "function observations(a: boolean, b: boolean): { started: boolean; reported: boolean } { return a ? b ? { started: true, reported: true } : { started: true, reported: false } : b ? { started: false, reported: true } : { started: false, reported: false }; }" }], focusPath: "src/observations.ts", expectedCount: 0, public: true },
     { id: "flat-produced-variants", scenarioId: "produced-variants", title: "Preserve producer variant relationships", outcome: "match", files: [{ path: "src/job.ts", source: 'function job(done: boolean): { phase: "queued" | "complete"; ticket?: string } { return done ? { phase: "complete" } : { phase: "queued", ticket: "t" }; }' }], focusPath: "src/job.ts", expectedCount: 1, public: true },
     { id: "explicit-produced-variants", scenarioId: "produced-variants", title: "Give each produced variant its payload", outcome: "no-match", files: [{ path: "src/job.ts", source: 'function job(done: boolean): { phase: "queued"; ticket: string } | { phase: "complete" } { return done ? { phase: "complete" } : { phase: "queued", ticket: "t" }; }' }], focusPath: "src/job.ts", expectedCount: 0, public: true },
     { id: "flat-switch-producer", scenarioId: "switch-producer", title: "A complete dispatcher preserves each returned variant", outcome: "match", files: [{ path: "src/job.ts", source: 'function job(command: string): { phase: "queued" | "complete"; ticket?: string } { switch (command) { case "start": return { phase: "queued", ticket: "t" }; default: return { phase: "complete" }; } }' }], focusPath: "src/job.ts", expectedCount: 1, public: true },

package/dist/{chunk-JBAPB4JX.js → chunk-OX5DMK42.js}

@@ -21504,8 +21504,30 @@ var NAME91 = "prefer-coded-error-result";
 var MAX_DEPTH = 16;
 var MAX_VARIANTS = 64;
 var MAX_TYPE_STEPS = 256;
-var STATUS_NAMES = ["ok", "success"];
+var BOOLEAN_STATUS_NAMES = ["ok", "success"];
+var STRING_STATUS_NAMES = ["status", "state", "kind", "type", "tag"];
+var STATUS_NAMES = [
+  ...BOOLEAN_STATUS_NAMES,
+  ...STRING_STATUS_NAMES
+];
 var CODE_NAMES = ["code", "kind", "type", "tag"];
+var SUCCESS_TAGS = /* @__PURE__ */ new Set(["ok", "success"]);
+var FAILURE_TAGS = /* @__PURE__ */ new Set([
+  "err",
+  "error",
+  "failure",
+  "failed"
+]);
+var NATIVE_ERRORS = /* @__PURE__ */ new Set([
+  "Error",
+  "EvalError",
+  "RangeError",
+  "ReferenceError",
+  "SyntaxError",
+  "TypeError",
+  "URIError",
+  "AggregateError"
+]);
 function view(node) {
   return { node, origin: node, bindings: /* @__PURE__ */ new Map() };
 }
@@ -21515,7 +21537,7 @@ function resolve2(value, source, depth = 0) {
   if (node.type !== "TSTypeReference") return value;
   if (node.typeName.type !== "Identifier") return null;
   const variable = typeBinding(source, node.typeName);
-  if (variable === null) return null;
+  if (variable === null || variable.defs.length === 0) return value;
   const bound = value.bindings.get(variable);
   if (bound !== void 0) return resolve2(bound, source, depth + 1);
   const declaration = variable.defs.length === 1 ? variable.defs[0]?.node : void 0;
@@ -21577,30 +21599,40 @@ function propertyView(property, owner) {
   const node = property.typeAnnotation?.typeAnnotation;
   return node === void 0 ? null : { node, origin: node, bindings: owner.bindings };
 }
-function booleanTag(property, owner, source) {
+function outcomeTag(property, owner, source, name) {
   if (property === void 0 || property.optional) return null;
   const type = propertyView(property, owner);
   const resolved = type === null ? null : resolve2(type, source);
   const node = resolved?.node;
-  return node?.type === "TSLiteralType" && node.literal.type === "Literal" && typeof node.literal.value === "boolean" ? node.literal.value : null;
+  return node?.type === "TSLiteralType" && node.literal.type === "Literal" ? outcomeValue(name, node.literal.value) : null;
+}
+function outcomeValue(name, value) {
+  if (BOOLEAN_STATUS_NAMES.some((candidate2) => candidate2 === name))
+    return typeof value === "boolean" ? value : null;
+  if (!STRING_STATUS_NAMES.some((candidate2) => candidate2 === name) || typeof value !== "string")
+    return null;
+  const tag = value.toLowerCase();
+  return SUCCESS_TAGS.has(tag) ? true : FAILURE_TAGS.has(tag) ? false : null;
 }
-function hasCode(fields2, owner, source) {
+function hasCode(fields2, owner, source, ignoredCodes = []) {
   return CODE_NAMES.some((name) => {
+    if (ignoredCodes.includes(name)) return false;
     const property = fields2.get(name);
     if (property === void 0 || property.optional) return false;
     const type = propertyView(property, owner);
-    return type !== null && openString(type, source) === null;
+    return type !== null && openScalar(type, source) === null;
   });
 }
-function openString(value, source, depth = 0, budget = { remaining: MAX_TYPE_STEPS }) {
+function openScalar(value, source, depth = 0, budget = { remaining: MAX_TYPE_STEPS }) {
   if (depth >= MAX_DEPTH || --budget.remaining < 0) return null;
   const resolved = resolve2(value, source);
   if (resolved === null) return null;
-  if (resolved.node.type === "TSStringKeyword") return resolved.origin;
+  if (resolved.node.type === "TSStringKeyword" || resolved.node.type === "TSUnknownKeyword")
+    return resolved.origin;
   if (resolved.node.type !== "TSUnionType" || resolved.node.types.length > MAX_VARIANTS)
     return null;
   for (const member3 of resolved.node.types) {
-    const broad = openString(
+    const broad = openScalar(
       { ...resolved, node: member3 },
       source,
       depth + 1,
@@ -21614,7 +21646,9 @@ function weakError(value, source, depth = 0, budget = { remaining: MAX_TYPE_STEP
   if (depth >= MAX_DEPTH || --budget.remaining < 0) return null;
   const resolved = resolve2(value, source);
   if (resolved === null) return null;
-  if (resolved.node.type === "TSStringKeyword") return resolved.origin;
+  if (resolved.node.type === "TSStringKeyword" || resolved.node.type === "TSUnknownKeyword")
+    return resolved.origin;
+  if (nativeErrorType(resolved.node, source)) return resolved.origin;
   if (resolved.node.type === "TSUnionType") {
     if (resolved.node.types.length > MAX_VARIANTS) return null;
     for (const member3 of resolved.node.types) {
@@ -21632,22 +21666,44 @@ function weakError(value, source, depth = 0, budget = { remaining: MAX_TYPE_STEP
   if (fields2 === null || hasCode(fields2, resolved, source)) return null;
   return weakObject(fields2, resolved, source, depth, budget);
 }
-function weakObject(fields2, owner, source, depth, budget) {
-  const code = openStringField(fields2, owner, source, CODE_NAMES, budget);
+function nativeErrorType(node, source) {
+  if (node.type !== "TSTypeReference" || node.typeName.type !== "Identifier" || !NATIVE_ERRORS.has(node.typeName.name) || (node.typeArguments?.params.length ?? 0) !== 0)
+    return false;
+  const binding3 = typeBinding(source, node.typeName);
+  return binding3 === null || binding3.defs.length === 0;
+}
+function weakObject(fields2, owner, source, depth, budget, ignoredCodes = []) {
+  const code = openStringField(
+    fields2,
+    owner,
+    source,
+    CODE_NAMES.filter((name) => !ignoredCodes.includes(name)),
+    budget
+  );
   if (code !== null) return code;
   const error = fields2.get("error");
   if (error !== void 0) {
     const inner = propertyView(error, owner);
     return inner === null || error.optional ? null : weakError(inner, source, depth + 1, budget);
   }
+  const carriers = [...fields2].filter(([name]) => errorCarrier(name));
+  if (carriers.length > 1) return null;
+  const carrier = carriers[0]?.[1];
+  if (carrier !== void 0) {
+    const inner = propertyView(carrier, owner);
+    return inner === null || carrier.optional ? null : weakError(inner, source, depth + 1, budget);
+  }
   return openStringField(fields2, owner, source, ["message", "reason"], budget);
 }
+function errorCarrier(name) {
+  return name === "error" || name === "errorMessage" || name.endsWith("Error");
+}
 function openStringField(fields2, owner, source, names, budget) {
   for (const name of names) {
     const property = fields2.get(name);
     if (property === void 0 || property.optional) continue;
     const inner = propertyView(property, owner);
-    const broad = inner === null ? null : openString(inner, source, 0, budget);
+    const broad = inner === null ? null : openScalar(inner, source, 0, budget);
     if (broad !== null) return broad;
   }
   return null;
@@ -21660,26 +21716,70 @@ function failureMessages(value, source) {
     fields: properties(member3)
   }));
   if (objects.some((object) => object.fields === null)) return [];
+  let selected = null;
+  const discriminators = [];
   for (const status of STATUS_NAMES) {
-    const tags = objects.map(
-      (object) => booleanTag(object.fields?.get(status), object.member, source)
+    const tags2 = objects.map(
+      (object) => outcomeTag(object.fields?.get(status), object.member, source, status)
     );
-    if (tags.some((tag) => tag === null) || !tags.includes(true) || !tags.includes(false))
+    if (tags2.some((tag) => tag === null) || !tags2.includes(true) || !tags2.includes(false))
       continue;
-    if (objects.some(
-      (object, index) => tags[index] === true && ["error", "errors"].some((name) => object.fields?.has(name))
-    ))
-      continue;
-    return objects.flatMap((object, index) => {
-      if (tags[index] !== false || object.fields === null || hasCode(object.fields, object.member, source))
-        return [];
-      if (["data", "value", "result"].some((name) => object.fields?.has(name)))
-        return [];
-      const error = weakError(object.member, source);
-      return error === null ? [] : [error];
-    });
+    if (selected !== null && tags2.some((tag, index) => tag !== selected?.[index]))
+      return [];
+    discriminators.push(status);
+    if (selected === null) {
+      selected = tags2;
+    }
   }
-  return [];
+  if (selected === null) return presenceFailures(objects, source);
+  const tags = selected;
+  if (objects.some(
+    (object, index) => tags[index] === true && [...object.fields?.keys() ?? []].some(
+      (name) => name === "errors" || errorCarrier(name)
+    )
+  ))
+    return [];
+  return objects.flatMap((object, index) => {
+    if (tags[index] !== false || object.fields === null || hasCode(object.fields, object.member, source, discriminators) || ["data", "value", "result"].some((name) => object.fields?.has(name)))
+      return [];
+    const error = weakObject(
+      object.fields,
+      object.member,
+      source,
+      0,
+      { remaining: MAX_TYPE_STEPS },
+      discriminators
+    );
+    return error === null ? [] : [error];
+  });
+}
+function presenceFailures(objects, source) {
+  const failed2 = objects.filter((object) => object.fields?.has("error"));
+  const successful = objects.filter((object) => !object.fields?.has("error"));
+  if (failed2.length === 0 || successful.length === 0) return [];
+  let successKey = null;
+  for (const object of successful) {
+    if (object.fields === null || object.fields.size !== 1) return [];
+    const property = [...object.fields][0];
+    if (property === void 0 || property[1].optional || errorCarrier(property[0]) || property[0] === "errors" || STATUS_NAMES.includes(property[0]) || CODE_NAMES.some((name) => name === property[0]))
+      return [];
+    if (successKey !== null && successKey !== property[0]) return [];
+    successKey = property[0];
+  }
+  if (successKey === null) return [];
+  const key = successKey;
+  if (failed2.some(
+    (object) => object.fields?.get("error")?.optional || object.fields?.has(key)
+  ))
+    return [];
+  return failed2.flatMap((object) => {
+    if (object.fields === null || hasCode(object.fields, object.member, source))
+      return [];
+    const error = object.fields.get("error");
+    const inner = error === void 0 ? null : propertyView(error, object.member);
+    const weak = inner === null ? null : weakError(inner, source);
+    return weak === null ? [] : [weak];
+  });
 }
 function variants(value, source, depth = 0, budget = { remaining: MAX_TYPE_STEPS }) {
   if (--budget.remaining < 0) return null;
@@ -21701,18 +21801,37 @@ function variants(value, source, depth = 0, budget = { remaining: MAX_TYPE_STEPS
   return result;
 }
 function libraryError(reference, source) {
-  if (reference.typeName.type !== "Identifier" || reference.typeArguments?.params.length !== 2)
+  if (reference.typeArguments?.params.length !== 2) return null;
+  if (!["Result", "ResultAsync"].includes(
+    libraryName(reference.typeName, source, true) ?? ""
+  ))
     return null;
-  const variable = typeBinding(source, reference.typeName);
+  const error = reference.typeArguments.params[1];
+  return error === void 0 ? null : weakError(view(error), source);
+}
+function libraryName(node, source, typeSpace) {
+  const reference = libraryReference(node);
+  if (reference === null) return null;
+  const { root, member: member3 } = reference;
+  const variable = typeSpace ? typeBinding(source, root) : findVariable(source.getScope(root), root.name);
   const definition = variable?.defs.length === 1 ? variable.defs[0]?.node : void 0;
-  if (definition?.type !== "ImportSpecifier") return null;
+  if (definition?.type !== "ImportSpecifier" && definition?.type !== "ImportNamespaceSpecifier")
+    return null;
+  if (variable === null || !stableValueBinding(variable)) return null;
   const declaration = parentOf(definition);
   if (declaration?.type !== "ImportDeclaration" || declaration.source.value !== "neverthrow")
     return null;
-  if (!["Result", "ResultAsync"].includes(importSpecifierName(definition) ?? ""))
+  if (!typeSpace && (declaration.importKind === "type" || definition.type === "ImportSpecifier" && definition.importKind === "type"))
     return null;
-  const error = reference.typeArguments.params[1];
-  return error === void 0 ? null : weakError(view(error), source);
+  return member3 === null && definition.type === "ImportSpecifier" ? importSpecifierName(definition) : member3 !== null && definition.type === "ImportNamespaceSpecifier" ? member3 : null;
+}
+function libraryReference(node) {
+  if (node.type === "Identifier") return { root: node, member: null };
+  if (node.type === "TSQualifiedName" && node.left.type === "Identifier" && node.right.type === "Identifier")
+    return { root: node.left, member: node.right.name };
+  if (node.type === "MemberExpression" && !node.computed && !node.optional && node.object.type === "Identifier" && node.property.type === "Identifier")
+    return { root: node.object, member: node.property.name };
+  return null;
 }
 function weakAnnotation(node, source, depth = 0, budget = { remaining: MAX_TYPE_STEPS }) {
   if (depth >= MAX_DEPTH || --budget.remaining < 0) return false;
@@ -21724,23 +21843,65 @@ function weakAnnotation(node, source, depth = 0, budget = { remaining: MAX_TYPE_
   const argument = node.typeArguments.params[0];
   return argument !== void 0 && weakAnnotation(argument, source, depth + 1, budget);
 }
-function renderedFailure(node) {
-  const outer = objectFields(unwrapExpression(node));
-  if (outer === null || !STATUS_NAMES.some((name) => {
+function renderedFailure(node, source) {
+  let value = unwrapExpression(node);
+  if (value.type === "AwaitExpression")
+    value = unwrapExpression(value.argument);
+  if (value.type === "CallExpression" || value.type === "NewExpression") {
+    if (value.type === "CallExpression" && value.optional || value.arguments.length !== 1)
+      return null;
+    const name = libraryName(value.callee, source, false);
+    if (value.type === "NewExpression" ? name !== "Err" : name !== "err" && name !== "errAsync")
+      return null;
+    const argument = value.arguments[0];
+    if (argument === void 0 || argument.type === "SpreadElement")
+      return null;
+    return renderedPayload(argument, source);
+  }
+  const outer = objectFields(value);
+  if (outer === null) return null;
+  const discriminators = STATUS_NAMES.filter((name) => {
+    const status = outer.get(name);
+    return status?.type === "Literal" && outcomeValue(name, status.value) === false;
+  });
+  if (discriminators.length === 0) return null;
+  if (STATUS_NAMES.some((name) => {
     const status = outer.get(name);
-    return status?.type === "Literal" && status.value === false;
-  }))
+    return status?.type === "Literal" && outcomeValue(name, status.value) === true;
+  }) || ["data", "value", "result"].some((name) => outer.has(name)))
     return null;
   const error = outer.get("error");
-  const fields2 = error === void 0 ? outer : objectFields(unwrapExpression(error));
-  if (fields2 === null || !CODE_NAMES.some((name) => {
+  return renderedPayload(
+    error ?? value,
+    source,
+    error === void 0 ? discriminators : []
+  );
+}
+function renderedPayload(node, source, ignoredCodes = []) {
+  if (renderedString(node, source))
+    return { node, messageId: "preferCodedErrorResult" };
+  const fields2 = objectFields(unwrapExpression(node));
+  if (fields2 === null) return null;
+  const codes = CODE_NAMES.filter(
+    (name) => !ignoredCodes.includes(name) && fields2.has(name)
+  );
+  const coded = codes.some((name) => {
     const code = fields2.get(name);
     return code?.type === "Literal" && typeof code.value === "string";
-  }))
-    return null;
-  for (const name of ["message", "reason"]) {
-    const value = fields2.get(name);
-    if (value !== void 0 && renderedString(value)) return value;
+  });
+  if (codes.length !== 0 && !coded) return null;
+  const primary = fields2.get("error");
+  const carriers = [...fields2].filter(([name]) => errorCarrier(name));
+  if (primary === void 0 && carriers.length > 1) return null;
+  const carrier = primary ?? carriers[0]?.[1];
+  if (!coded && carrier !== void 0)
+    return renderedString(carrier, source) ? { node: carrier, messageId: "preferCodedErrorResult" } : null;
+  for (const [name, value] of fields2) {
+    if ((name === "message" || name === "reason" || errorCarrier(name)) && renderedString(value, source))
+      return {
+        node: value,
+        messageId: coded ? "formatAtConsumer" : "preferCodedErrorResult"
+      };
   }
   return null;
 }
@@ -21756,14 +21917,36 @@ function objectFields(node) {
   }
   return fields2;
 }
-function renderedString(node, depth = 0) {
-  const value = unwrapExpression(node);
-  if (depth >= MAX_DEPTH) return false;
-  if (value.type === "TemplateLiteral") return value.expressions.length > 0;
-  if (value.type !== "BinaryExpression" || value.operator !== "+") return false;
-  return [value.left, value.right].some(
-    (part) => part.type === "Literal" && typeof part.value === "string" || renderedString(part, depth + 1)
-  );
+function renderedString(node, source) {
+  let remaining = MAX_TYPE_STEPS;
+  function literalComposition(input, depth) {
+    if (depth >= MAX_DEPTH || --remaining < 0) return null;
+    const value = unwrapExpression(input);
+    if (value.type === "Identifier") {
+      const initializer = stableConstInitializer(source, value);
+      return initializer === null ? false : literalComposition(initializer.value, depth + 1);
+    }
+    if (value.type === "Literal")
+      return value.value === null || ["string", "number", "boolean", "bigint"].includes(typeof value.value);
+    const children = value.type === "TemplateLiteral" ? value.expressions : value.type === "BinaryExpression" && value.operator === "+" ? [value.left, value.right] : null;
+    if (children === null) return false;
+    for (const child of children) {
+      const constant = literalComposition(child, depth + 1);
+      if (constant !== true) return constant;
+    }
+    return true;
+  }
+  function rendered(input, depth) {
+    if (depth >= MAX_DEPTH || --remaining < 0) return false;
+    const value = unwrapExpression(input);
+    if (value.type === "TemplateLiteral") return value.expressions.length > 0;
+    if (value.type !== "BinaryExpression" || value.operator !== "+")
+      return false;
+    return [value.left, value.right].some(
+      (part) => part.type === "Literal" && typeof part.value === "string" || rendered(part, depth + 1)
+    );
+  }
+  return literalComposition(node, 0) === false && rendered(node, 0);
 }
 var prefer_coded_error_result_default = defineRule({
   meta: {
@@ -21774,7 +21957,7 @@ var prefer_coded_error_result_default = defineRule({
     },
     schema: [],
     messages: {
-      preferCodedErrorResult: "This Result failure carries only a rendered string or an open string code. Return a finite error code with the typed context needed by the caller, and format the message at the consumer. Keep an intentional presentation boundary explicit.",
+      preferCodedErrorResult: "This Result failure hides its identity in a broad string, unknown, or generic Error channel. Expose expected failures as finite domain error codes with the typed context needed by the caller, and format the message at the consumer. Review intentional infrastructure and presentation boundaries explicitly.",
       formatAtConsumer: "This coded failure formats context into a message at the producer. Return the code and typed context, and let the consumer format the message. Preserve an intentional presentation boundary explicitly."
     }
   },
@@ -21794,13 +21977,13 @@ var prefer_coded_error_result_default = defineRule({
     }
     function checkProducer(owner, value) {
       if (owner === null) return;
-      const rendered = renderedFailure(value);
-      if (rendered === null || reported.has(rendered)) return;
+      const rendered = renderedFailure(value, context.sourceCode);
+      if (rendered === null || reported.has(rendered.node)) return;
       const contract = owner.returnType?.typeAnnotation;
       if (contract !== void 0 && weakAnnotation(contract, context.sourceCode))
         return;
-      reported.add(rendered);
-      context.report({ node: rendered, messageId: "formatAtConsumer" });
+      reported.add(rendered.node);
+      context.report(rendered);
     }
     return {
       before() {
@@ -22099,11 +22282,43 @@ function discriminatedUnionReturns(node, sourceCode2) {
     if (member3.optional) continue;
     const domain = tagDomain(member3.typeAnnotation?.typeAnnotation);
     if (domain !== void 0 && hasTagSpecificPayload(name, domain, shape.optional, returned2)) {
-      return { reportNode: contract.reportNode, tag: name, members: shape.members, returned: returned2 };
+      return { reportNode: contract.reportNode, relationship: { kind: "presence", tag: name }, members: shape.members, returned: returned2 };
+    }
+  }
+  const fields2 = correlatedBooleanFields(shape, returned2);
+  return fields2 === void 0 ? void 0 : {
+    reportNode: contract.reportNode,
+    relationship: { kind: "boolean-pair", fields: fields2 },
+    members: shape.members,
+    returned: returned2
+  };
+}
+function correlatedBooleanFields(shape, returned2) {
+  const fields2 = [...shape.members].filter(([, member3]) => !member3.optional && member3.typeAnnotation?.typeAnnotation.type === "TSBooleanKeyword").map(([name]) => name);
+  if (fields2.length > 8) return void 0;
+  for (const [index, left] of fields2.entries()) {
+    for (const right of fields2.slice(index + 1)) {
+      const combinations = booleanCombinations(left, right, returned2);
+      if (combinations !== void 0 && restrictedVaryingPair(combinations)) return { left, right };
     }
   }
   return void 0;
 }
+function booleanCombinations(left, right, returned2) {
+  const combinations = /* @__PURE__ */ new Set();
+  for (const properties2 of returned2) {
+    const a = properties2.get(left);
+    const b = properties2.get(right);
+    if (a?.type !== "Literal" || typeof a.value !== "boolean" || b?.type !== "Literal" || typeof b.value !== "boolean") return void 0;
+    combinations.add(`${Number(a.value)}${Number(b.value)}`);
+  }
+  return combinations;
+}
+function restrictedVaryingPair(combinations) {
+  if (combinations.size < 2 || combinations.size === 4) return false;
+  const values = [...combinations];
+  return [0, 1].every((index) => values.some((value) => value[index] === "0") && values.some((value) => value[index] === "1"));
+}
 function returnContract(node, sourceCode2) {
   const annotation = node.returnType;
   if (!isPresent(annotation)) return void 0;
@@ -22148,7 +22363,7 @@ function objectContract(elements) {
     members2.set(name, member3);
     if (member3.optional) optional.add(name);
   }
-  return optional.size === 0 ? void 0 : { members: members2, optional };
+  return { members: members2, optional };
 }
 function returnedProperties(objects, contract) {
   const returned2 = [];
@@ -22334,102 +22549,18 @@ function literalTag(node) {
 
 // src/rules/prefer-discriminated-union.ts
 var NAME94 = "prefer-discriminated-union";
-var STATUS_MEMBER_NAMES = /* @__PURE__ */ new Set([
-  "success",
-  "ok"
-]);
-var FAILURE_MEMBER_NAMES = /* @__PURE__ */ new Set([
-  "error",
-  "errors",
-  "reason",
-  "cause"
-]);
-var SUCCESS_PAYLOAD_MEMBER_NAMES = /* @__PURE__ */ new Set([
-  "data",
-  "events",
-  "payload",
-  "response",
-  "result",
-  "value"
-]);
-var REQUIRED_STATUS_MEMBER_COUNT = 1;
-var FUNCTION_RETURN_OWNER_TYPES = /* @__PURE__ */ new Set([
-  "ArrowFunctionExpression",
-  "FunctionDeclaration",
-  "FunctionExpression",
-  "TSDeclareFunction",
-  "TSEmptyBodyFunctionExpression",
-  "TSFunctionType",
-  "TSMethodSignature"
-]);
-function looksLikeMutuallyExclusiveState(typeLiteral) {
-  let statusMemberCount = 0;
-  let hasFailurePayload = false;
-  let hasSuccessPayload = false;
-  let hasUnrecognizedMember = false;
-  for (const member3 of typeLiteral.members) {
-    if (member3.type !== "TSPropertySignature") {
-      hasUnrecognizedMember = true;
-      continue;
-    }
-    const name = getMemberName(member3);
-    if (name !== null && STATUS_MEMBER_NAMES.has(name) && isBooleanTyped(member3) && !member3.optional) {
-      statusMemberCount += 1;
-      continue;
-    }
-    if (!member3.optional || isBooleanTyped(member3) || name === null) {
-      hasUnrecognizedMember = true;
-      continue;
-    }
-    if (FAILURE_MEMBER_NAMES.has(name)) {
-      hasFailurePayload = true;
-    } else if (SUCCESS_PAYLOAD_MEMBER_NAMES.has(name)) {
-      hasSuccessPayload = true;
-    } else {
-      hasUnrecognizedMember = true;
-    }
-  }
-  return statusMemberCount === REQUIRED_STATUS_MEMBER_COUNT && hasFailurePayload && (hasSuccessPayload || !hasUnrecognizedMember);
-}
-function getMemberName(member3) {
-  if (member3.type !== "TSPropertySignature" || member3.computed) {
-    return null;
-  }
-  const { key } = member3;
-  if (key.type === "Identifier") {
-    return key.name;
-  }
-  if (key.type === "Literal" && typeof key.value === "string") {
-    return key.value;
-  }
-  return null;
-}
-function isBooleanTyped(member3) {
-  return member3.typeAnnotation?.typeAnnotation.type === "TSBooleanKeyword";
-}
-function inlineReturnTypeLiteral(node) {
-  let annotation = null;
-  if (node.parent.type === "TSTypeAnnotation") {
-    annotation = node.parent;
-  } else if (node.parent.type === "TSTypeParameterInstantiation" && node.parent.params.length === 1 && node.parent.params[0] === node && node.parent.parent.type === "TSTypeReference" && node.parent.parent.typeName.type === "Identifier" && node.parent.parent.typeName.name === "Promise" && node.parent.parent.parent.type === "TSTypeAnnotation") {
-    annotation = node.parent.parent.parent;
-  }
-  if (annotation === null) return null;
-  const owner = annotation.parent;
-  return FUNCTION_RETURN_OWNER_TYPES.has(owner.type) && "returnType" in owner && owner.returnType === annotation ? annotation : null;
-}
 var prefer_discriminated_union_default = defineRule({
   meta: {
     type: "suggestion",
     fixable: "code",
     docs: {
-      description: "Prefer discriminated unions for result contracts and locally proven tag-specific return payloads.",
+      description: "Preserve producer-proven tag/payload and Boolean state relationships in return types.",
       url: docsUrl(NAME94)
     },
     schema: [],
     messages: {
       preferProducedVariants: "This producer returns tag-specific payloads for `{{tag}}`, but its flat return contract makes them optional. If these variants define the domain, use a discriminated union with each variant's required payload, or give this producer a precise return type separate from the broader contract.",
-      preferDiscriminatedUnion: "This object type combines a boolean status with optional payloads. If success and failure are mutually exclusive, consider a discriminated union such as `{ ok: true; data: T } | { ok: false; error: E }`."
+      preferProducedState: "This producer returns a restricted set of literal combinations for `{{fields}}`, while its Boolean fields permit all four. Review a union preserving every returned combination, or a typed disposition if these are domain phases. Other writers and readers of a shared contract require review."
     }
   },
   createOnce(context) {
@@ -22443,30 +22574,13 @@ var prefer_discriminated_union_default = defineRule({
       if (result === void 0 || reportedContracts.has(result.reportNode)) return;
       reportedContracts.add(result.reportNode);
       const fix = privateVariantReturn(context.sourceCode, context.filename, node, result);
+      const relationship = result.relationship;
       context.report({
         node: result.reportNode,
-        messageId: "preferProducedVariants",
         ...fix !== null && { fix },
-        data: { tag: result.tag }
+        ...relationship.kind === "presence" ? { messageId: "preferProducedVariants", data: { tag: relationship.tag } } : { messageId: "preferProducedState", data: { fields: [relationship.fields.left, relationship.fields.right].join("`, `") } }
       });
     }
-    function checkTypeLiteral(typeLiteral, reportNode) {
-      if (looksLikeMutuallyExclusiveState(typeLiteral) && !reportedContracts.has(reportNode)) {
-        reportedContracts.add(reportNode);
-        const fix = inlineProducerFix(reportNode);
-        context.report({
-          node: reportNode,
-          messageId: "preferDiscriminatedUnion",
-          ...fix !== null && { fix }
-        });
-      }
-    }
-    function inlineProducerFix(reportNode) {
-      if (reportNode.type !== "TSTypeAnnotation" || reportNode.parent.type !== "FunctionDeclaration") return null;
-      const owner = reportNode.parent;
-      const result = discriminatedUnionReturns(owner, context.sourceCode);
-      return result === void 0 ? null : privateVariantReturn(context.sourceCode, context.filename, owner, result);
-    }
     return {
       before() {
         reportedContracts.clear();
@@ -22480,34 +22594,23 @@ var prefer_discriminated_union_default = defineRule({
       FunctionExpression: rememberProducer,
       "Program:exit"() {
         for (const producer of producers) checkProducer(producer);
-      },
-      TSInterfaceDeclaration(node) {
-        if (node.extends.length > 0) {
-          return;
-        }
-        checkTypeLiteral({ members: node.body.body }, node);
-      },
-      TSTypeLiteral(node) {
-        if (node.parent.type === "TSTypeAliasDeclaration") checkTypeLiteral(node, node.parent);
-        const annotation = inlineReturnTypeLiteral(node);
-        if (annotation !== null) checkTypeLiteral(node, annotation);
       }
     };
   }
 });
 function privateVariantReturn(sourceCode2, filename, owner, result) {
   const annotation = owner.returnType?.typeAnnotation;
-  if (owner.type !== "FunctionDeclaration" || owner.id === null || !returnsOnlyConditionalObject(owner) || annotation?.type !== "TSTypeLiteral" || result.reportNode !== owner.returnType || result.returned.length !== 2 || sourceCode2.getCommentsInside(owner).length > 0 || !isUnusedPrivateBinding(sourceCode2, owner, owner.id, filename) || !retainsNamedTypeUses(sourceCode2, annotation)) return null;
+  if (owner.type !== "FunctionDeclaration" || owner.id === null || !returnsOnlyConditionalObject(owner) || annotation?.type !== "TSTypeLiteral" || result.reportNode !== owner.returnType || result.returned.length > 4 || sourceCode2.getCommentsInside(owner).length > 0 || !isUnusedPrivateBinding(sourceCode2, owner, owner.id, filename) || !retainsNamedTypeUses(sourceCode2, annotation)) return null;
   const variants2 = result.returned.map((properties2) => privateVariantType(properties2, result, sourceCode2));
   if (variants2.some((variant) => variant === null)) return null;
-  const text = `${variants2.join(" | ")}${sourceCode2.getText(annotation).replace(/[^\r\n]/gu, "")}`;
+  const text = `${variants2.join(" | ")}${sourceCode2.getText(annotation).replace(/[^\r\n\u2028\u2029]/gu, "")}`;
   return (fixer) => fixer.replaceText(annotation, text);
 }
 function returnsOnlyConditionalObject(fn) {
   if (fn.async || fn.generator || isPresent(fn.typeParameters)) return false;
   const statements = fn.body?.body ?? [];
   const [returned2] = statements;
-  return statements.length === 1 && returned2?.type === "ReturnStatement" && returned2.argument?.type === "ConditionalExpression" && returned2.argument.consequent.type === "ObjectExpression" && returned2.argument.alternate.type === "ObjectExpression";
+  return statements.length === 1 && returned2?.type === "ReturnStatement" && returned2.argument?.type === "ConditionalExpression";
 }
 function privateVariantType(properties2, result, sourceCode2) {
   if ([...properties2.values()].some((value) => value.type !== "Literal" || typeof value.value === "object" && value.value !== null || typeof value.value === "number" && !Number.isFinite(value.value))) return null;
@@ -22517,7 +22620,8 @@ function privateVariantType(properties2, result, sourceCode2) {
     if (value === void 0) continue;
     const annotation = member3.typeAnnotation?.typeAnnotation;
     if (annotation === void 0) return null;
-    const type = name === result.tag ? sourceCode2.getText(value) : sourceCode2.getText(annotation);
+    const narrow = result.relationship.kind === "presence" ? name === result.relationship.tag : name === result.relationship.fields.left || name === result.relationship.fields.right;
+    const type = narrow ? sourceCode2.getText(value) : sourceCode2.getText(annotation);
     fields2.push(`${member3.readonly ? "readonly " : ""}${sourceCode2.getText(member3.key)}: ${type}`);
   }
   return `{ ${fields2.join("; ")} }`;

package/dist/index.js

@@ -1,6 +1,6 @@
 import {
   src_default
-} from "./chunk-JBAPB4JX.js";
+} from "./chunk-OX5DMK42.js";
 export {
   src_default as default
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sarj/eslint-plugin",
-  "version": "19.2.0",
+  "version": "19.7.0",
   "packageManager": "npm@12.2.1",
   "description": "Custom Oxlint rules for hypermodern TypeScript / React / Next.js projects",
   "type": "module",