@danieljvdm/dev-kit 0.17.0 → 0.18.0

package/README.md

@@ -493,7 +493,7 @@ Pin the compatible packages in the consuming project:
 {
   "devDependencies": {
     "@danieljvdm/dev-kit": "^0.2.0",
-    "@effect/tsgo": "0.33.0",
+    "@effect/tsgo": "0.36.4",
     "typescript": "7.0.2",
   },
 }
@@ -701,14 +701,25 @@ export default defineConfig({
 });
 ```
 
-The Oxlint preset enables `stylistic/padding-line-between-statements`: adjacent
+The Oxlint preset vendors and enables every rule from
+[dmmulroy/anti-slop](https://github.com/dmmulroy/anti-slop) at upstream commit
+`9b80d9a5c317d3af94d88a577bdbde4d9a45f7be`. These opinionated rules reject
+low-evidence patterns such as broad `unknown` contracts, runtime `typeof`
+narrowing, module mocking, chained assertions, and assertions without a
+nearby `SAFETY:` justification. The package also exports the plugin from
+`@danieljvdm/dev-kit/oxlint-plugin-anti-slop`. Its vendored MIT license is
+retained beside the source.
+
+The TypeScript files under `src/oxlint-plugin-anti-slop/` are canonical. After
+updating them, run `vp run anti-slop:bundle` to regenerate the package-loadable
+JavaScript entry point without cleaning canonical source.
+
+The preset also enables `stylistic/padding-line-between-statements`: adjacent
 variable declarations remain grouped, while the next logical statement and
 all `return` statements require a separating blank line. The rule is fixable,
-so `vp lint --fix` repairs missing spacing automatically. Vite+ 0.2.6 forwards
-the preset's JavaScript-plugin declarations but its native Oxlint path does not
-execute their rules — run standalone Oxlint when `effect/*` or the padding rule
-must be enforced, until a supported Vite+ release executes configured JS
-plugins.
+so `vp lint --fix` repairs missing spacing automatically. With the matching
+Oxlint 1.78 peer installed, Vite+ 0.2.6 executes the preset's JavaScript-plugin
+rules through the normal `vp lint` command.
 
 The preset also registers the shared `effect` JavaScript plugin. Effect
 projects opt into its rules in path-specific overrides, for example

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danieljvdm/dev-kit",
-  "version": "0.17.0",
+  "version": "0.18.0",
   "private": false,
   "description": "Declarative project development toolkit with portable agent skills.",
   "license": "MIT",
@@ -19,6 +19,7 @@
     "skill-sources.jsonc",
     "skill-sources.lock.json",
     "src/",
+    "scripts/",
     "templates/"
   ],
   "type": "module",
@@ -46,6 +47,10 @@
       "types": "./src/oxlint-plugin-effect.d.ts",
       "default": "./src/oxlint-plugin-effect.js"
     },
+    "./oxlint-plugin-anti-slop": {
+      "types": "./src/oxlint-plugin-anti-slop/runtime.d.ts",
+      "default": "./src/oxlint-plugin-anti-slop/runtime.js"
+    },
     "./oxlint-plugin-style": {
       "types": "./src/oxlint-plugin-style.d.ts",
       "default": "./src/oxlint-plugin-style.js"
@@ -66,31 +71,34 @@
     "test:watch": "vitest --config vitest.config.ts",
     "tsgo:patch": "./bin/dev-kit.mjs tsgo patch",
     "catalog:refresh": "./bin/dev-kit.mjs catalog refresh",
-    "catalog:check": "./bin/dev-kit.mjs catalog verify"
+    "catalog:check": "./bin/dev-kit.mjs catalog verify",
+    "anti-slop:bundle": "vp pack src/oxlint-plugin-anti-slop/index.ts --out-dir .dev-kit/anti-slop-build --format esm --no-dts && node scripts/sync-anti-slop-runtime.mjs",
+    "anti-slop:check": "vp pack src/oxlint-plugin-anti-slop/index.ts --out-dir .dev-kit/anti-slop-build --format esm --no-dts && node scripts/sync-anti-slop-runtime.mjs --check"
   },
   "dependencies": {
-    "@effect/platform-bun": "4.0.0-beta.105",
+    "@effect/platform-bun": "4.0.0-beta.107",
+    "@oxlint/plugins": "1.78.0",
     "@stylistic/eslint-plugin": "5.10.0",
-    "effect": "4.0.0-beta.105",
+    "effect": "4.0.0-beta.107",
     "jsonc-parser": "3.3.1",
     "semver": "7.8.5"
   },
   "devDependencies": {
     "@changesets/cli": "3.0.0-next.10",
-    "@effect/platform-node": "4.0.0-beta.105",
-    "@effect/tsgo": "0.33.0",
-    "@effect/vitest": "4.0.0-beta.105",
+    "@effect/platform-node": "4.0.0-beta.107",
+    "@effect/tsgo": "0.36.4",
+    "@effect/vitest": "4.0.0-beta.107",
     "@types/node": "25.9.1",
     "@types/semver": "7.8.0",
     "oxfmt": "0.60.0",
-    "oxlint": "1.75.0",
+    "oxlint": "1.78.0",
     "typescript": "7.0.2",
     "vite-plus": "0.2.6",
     "vitest": "4.1.10"
   },
   "peerDependencies": {
     "oxfmt": ">=0.60.0 <0.61.0",
-    "oxlint": ">=1.75.0 <2.0.0",
+    "oxlint": ">=1.78.0 <2.0.0",
     "vite-plus": ">=0.2.6 <0.3.0"
   },
   "peerDependenciesMeta": {
@@ -104,6 +112,9 @@
       "optional": true
     }
   },
+  "overrides": {
+    "@effect/platform-node-shared": "4.0.0-beta.107"
+  },
   "engines": {
     "bun": ">=1.3.0"
   },

package/scripts/sync-anti-slop-runtime.mjs

@@ -0,0 +1,19 @@
+import { readFile, writeFile } from "node:fs/promises";
+
+const generatedUrl = new URL("../.dev-kit/anti-slop-build/index.mjs", import.meta.url);
+const runtimeUrl = new URL("../src/oxlint-plugin-anti-slop/runtime.js", import.meta.url);
+const generated = await readFile(generatedUrl, "utf8");
+const header =
+  "// Bundled from the vendored anti-slop source at commit 9b80d9a5c317d3af94d88a577bdbde4d9a45f7be.\n";
+const runtime = generated.replace(/^\/\/[#](?:end)?region.*\n/gmu, "");
+const expected = `${header}${runtime}`;
+
+if (process.argv.includes("--check")) {
+  const current = await readFile(runtimeUrl, "utf8");
+
+  if (current !== expected) {
+    throw new Error("anti-slop runtime is stale; run `vp run anti-slop:bundle`");
+  }
+} else {
+  await writeFile(runtimeUrl, expected);
+}

package/skills/dev-kit/SKILL.md

@@ -113,11 +113,10 @@ separate `check` and pure `typecheck` tasks; standalone Oxc projects import
 `recommendedOxlintConfig`/`recommendedOxfmtConfig` directly.
 
 Run the Effect-patched compiler separately with `vp run typecheck`; neither
-Oxlint's bundled `tsgolint` nor Vite+'s native lint path uses the Effect patch,
-and Vite+ 0.2.6 does not execute the preset's JavaScript-plugin rules — use
-standalone Oxlint when `effect/*` or
-`stylistic/padding-line-between-statements` must be enforced. The `effect`
-plugin's scope-sensitive rules stay consumer-scoped: enable them per path in
+Oxlint's bundled `tsgolint` nor Vite+'s native lint path uses the Effect patch.
+Keep Oxlint and `@oxlint/plugins` on the matching version expected by the
+preset so Vite+ can execute its JavaScript plugins. The `effect` plugin's
+scope-sensitive rules stay consumer-scoped: enable them per path in
 Effect-owned code, with exceptions for tests and host boundaries.
 
 `setup.vitePlus.hooks` converges the Git-ignored `.vite-hooks/_` dispatcher by

package/src/bin/dev-kit.ts

@@ -283,8 +283,8 @@ const catalogAddCommand = CliCommand.make(
     lockfile,
     repoDir,
     sources,
-  }) =>
-    addCatalogSource({
+  }) => {
+    const options = {
       repository,
       all,
       dryRun,
@@ -293,11 +293,15 @@ const catalogAddCommand = CliCommand.make(
       lockfilePath: lockfile,
       repoDir,
       sourcesPath: sources,
-      ...(id ? { id } : {}),
-      ...(license ? { licensePath: license } : {}),
-      ...(ref ? { ref } : {}),
-      ...(skillsPath ? { skillsPath } : {}),
-    }),
+    };
+
+    if (id) Object.assign(options, { id });
+    if (license) Object.assign(options, { licensePath: license });
+    if (ref) Object.assign(options, { ref });
+    if (skillsPath) Object.assign(options, { skillsPath });
+
+    return addCatalogSource(options);
+  },
 ).pipe(CliCommand.withDescription("Inspect a repository and approve selected skills."));
 
 const catalogListCommand = CliCommand.make(

package/src/catalog-manager.ts

@@ -122,11 +122,15 @@ const selectSkills = Effect.fn("selectCatalogSkills")(function* (
   }
   const selected = yield* Prompt.multiSelect({
     message: `Approve skills from ${inspection.id}`,
-    choices: inspection.skills.map((skill) => ({
-      title: skill.name,
-      value: skill.name,
-      ...(skill.description ? { description: compactDescription(skill.description) } : {}),
-    })),
+    choices: inspection.skills.map((skill) => {
+      const choice = { title: skill.name, value: skill.name };
+
+      if (skill.description) {
+        Object.assign(choice, { description: compactDescription(skill.description) });
+      }
+
+      return choice;
+    }),
     min: 1,
   });
 
@@ -196,13 +200,16 @@ export const addCatalogSource = Effect.fn("addCatalogSource")(function* (
     return yield* CatalogManagerError.make({ message: "use either --all or --skill, not both" });
   }
   const state = yield* readState(options);
-  const inspection = yield* inspectCatalogRepository({
+  const inspectOptions = {
     repository: options.repository,
     repoDir: state.repoDir,
-    ...(options.id ? { id: options.id } : {}),
-    ...(options.ref ? { ref: options.ref } : {}),
-    ...(options.skillsPath ? { skillsPath: options.skillsPath } : {}),
-  });
+  };
+
+  if (options.id) Object.assign(inspectOptions, { id: options.id });
+  if (options.ref) Object.assign(inspectOptions, { ref: options.ref });
+  if (options.skillsPath) Object.assign(inspectOptions, { skillsPath: options.skillsPath });
+
+  const inspection = yield* inspectCatalogRepository(inspectOptions);
   const selection = yield* selectSkills(inspection, options.skills ?? [], options.all ?? false);
   const sources = state.sources.value.sources;
   const byId = sources.findIndex((source) => source.id === inspection.id);
@@ -256,15 +263,13 @@ export const addCatalogSource = Effect.fn("addCatalogSource")(function* (
       ref: inspection.ref,
       skillsPath: inspection.skillsPath,
       include: selection.include,
-      ...(options.licensePath
-        ? { licensePath: options.licensePath }
-        : inspection.licensePath
-          ? { licensePath: inspection.licensePath }
-          : {}),
-      ...(options.stripFrontmatter?.length
-        ? { stripFrontmatter: [...new Set(options.stripFrontmatter)] }
-        : {}),
     };
+    const licensePath = options.licensePath || inspection.licensePath;
+
+    if (licensePath) Object.assign(source, { licensePath });
+    if (options.stripFrontmatter?.length) {
+      Object.assign(source, { stripFrontmatter: [...new Set(options.stripFrontmatter)] });
+    }
 
     next = applyEdits(
       next,

package/src/catalog.ts

@@ -185,7 +185,7 @@ export const loadSkillCatalog = Effect.fn("loadSkillCatalog")(function* (
       message: `duplicate catalog family: ${duplicateFamily[0]}`,
     });
   }
-  const families: Readonly<Record<string, ReadonlyArray<string>>> = {
+  const families = {
     effect: [
       "effect-ts",
       "effect-architecture-audit",
@@ -194,13 +194,16 @@ export const loadSkillCatalog = Effect.fn("loadSkillCatalog")(function* (
       "build-effect-clis",
     ],
     ...Object.fromEntries(externalFamilies),
-  };
+  } satisfies Readonly<Record<string, ReadonlyArray<string>>>;
 
-  return {
+  const catalog: SkillCatalog = {
     skills: skills.sort((left, right) => left.selector.localeCompare(right.selector)),
     families,
-    ...(lock ? { lock } : {}),
-  } satisfies SkillCatalog;
+  };
+
+  if (lock) Object.assign(catalog, { lock });
+
+  return catalog;
 });
 
 const stripFrontmatterKeys = (text: string, keys: ReadonlyArray<string>): string => {

package/src/cli-ui.ts

@@ -12,12 +12,12 @@ const ANSI = {
 
 type StatusKind = "success" | "info" | "plan" | "error";
 
-const statusAppearance: Readonly<Record<StatusKind, readonly [string, string]>> = {
+const statusAppearance = {
   success: ["✓", ANSI.green],
   info: ["•", ANSI.cyan],
   plan: ["→", ANSI.yellow],
   error: ["✗", ANSI.red],
-};
+} satisfies Readonly<Record<StatusKind, readonly [string, string]>>;
 
 const terminalCapabilities = Effect.fn("terminalCapabilities")(function* () {
   const terminal = yield* Terminal.Terminal;

package/src/effect-tsgo.ts

@@ -5,7 +5,7 @@ import { printStatus, withSpinner } from "./cli-ui.ts";
 import { acquireProjectProcessLock } from "./project-process-lock.ts";
 import { isTypeScriptPackageName } from "./typescript-package-name.ts";
 
-export const EFFECT_TSGO_VERSION = "0.33.0";
+export const EFFECT_TSGO_VERSION = "0.36.4";
 export const EFFECT_TSGO_TYPESCRIPT_VERSION = "7.0.2";
 export const EFFECT_TSGO_PLUGIN_NAME = "@effect/language-service";
 
@@ -262,11 +262,15 @@ export const planEffectTsgoPatch = Effect.fn("planEffectTsgoPatch")(function* (
   const typescriptPackageArgs =
     typescriptPackage === "typescript" ? [] : ["--typescript-package", typescriptPackage];
 
-  return {
+  const plan = {
     alreadyPatched: patchState.alreadyPatched,
-    ...(patchState.hasBackup && !patchState.alreadyPatched
-      ? { unpatchArgs: ["unpatch", "--typescript", ...typescriptPackageArgs] }
-      : {}),
+  };
+
+  if (patchState.hasBackup && !patchState.alreadyPatched) {
+    Object.assign(plan, { unpatchArgs: ["unpatch", "--typescript", ...typescriptPackageArgs] });
+  }
+
+  return Object.assign(plan, {
     projectDir,
     executable,
     args: [
@@ -278,7 +282,7 @@ export const planEffectTsgoPatch = Effect.fn("planEffectTsgoPatch")(function* (
     effectTsgoVersion,
     typescriptPackage,
     typescriptVersion,
-  } satisfies EffectTsgoPatchPlan;
+  }) satisfies EffectTsgoPatchPlan;
 });
 
 const runEffectTsgoCommand = Effect.fn("runEffectTsgoCommand")(function* (

package/src/gitignore.ts

@@ -50,15 +50,18 @@ type PlannedGitignorePatch = GitignorePatch & {
   readonly previousContents: string;
 };
 
+type GitignoreContentsPatch = {
+  readonly contents: string;
+  readonly added: ReadonlyArray<string>;
+};
+
 const publicPatch = (patch: PlannedGitignorePatch): GitignorePatch => ({
   path: patch.path,
   changed: patch.changed,
   added: patch.added,
 });
 
-export const patchGitignoreContents = (
-  current: string,
-): { readonly contents: string; readonly added: ReadonlyArray<string> } => {
+export const patchGitignoreContents = (current: string): GitignoreContentsPatch => {
   const lines = current.split(/\r?\n/);
   const added = DEV_KIT_GITIGNORE_ENTRIES.filter((entry) => !lines.includes(entry));
 

package/src/manifest.ts

@@ -146,13 +146,21 @@ export type NormalizedManifest = {
   readonly targets: Readonly<Record<HarnessTarget, NormalizedTargetConfig>>;
 };
 
-const DEFAULT_TARGET_PATHS: Readonly<Record<HarnessTarget, string>> = {
+type DefaultTargetPaths = {
+  readonly [Target in HarnessTarget]: string;
+};
+
+type DefaultTargets = {
+  readonly [Target in HarnessTarget]: NormalizedTargetConfig;
+};
+
+const DEFAULT_TARGET_PATHS: DefaultTargetPaths = {
   agents: ".agents/skills",
   claude: ".claude/skills",
   opencode: ".opencode/skills",
 };
 
-const DEFAULT_TARGETS: Readonly<Record<HarnessTarget, NormalizedTargetConfig>> = {
+const DEFAULT_TARGETS: DefaultTargets = {
   agents: { enabled: true, mode: "copy", path: DEFAULT_TARGET_PATHS.agents },
   claude: { enabled: false, mode: "symlink", path: DEFAULT_TARGET_PATHS.claude },
   opencode: { enabled: false, mode: "symlink", path: DEFAULT_TARGET_PATHS.opencode },

package/src/oxlint-plugin-anti-slop/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Dillon Mulroy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/src/oxlint-plugin-anti-slop/index.ts

@@ -0,0 +1,43 @@
+// Vendored from dmmulroy/anti-slop commit 9b80d9a5c317d3af94d88a577bdbde4d9a45f7be.
+// The upstream MIT notice is retained in LICENSE.
+import { definePlugin } from "@oxlint/plugins";
+
+import { noChainedTypeAssertionsRule } from "./rules/no-chained-type-assertions.ts";
+import { noConditionalEmptyObjectSpreadRule } from "./rules/no-conditional-empty-object-spread.ts";
+import { noKnownValueWideningRule } from "./rules/no-known-value-widening.ts";
+import { noModuleMockingRule } from "./rules/no-module-mocking.ts";
+import { noObjectParametersRule } from "./rules/no-object-parameters.ts";
+import { noReflectApplyRule } from "./rules/no-reflect-apply.ts";
+import { noReflectGetRule } from "./rules/no-reflect-get.ts";
+import { noRuntimeTypeofRule } from "./rules/no-runtime-typeof.ts";
+import { noForbiddenTermInSymbolNamesRule } from "./rules/no-shape-in-symbol-names.ts";
+import { noUnknownParametersRule } from "./rules/no-unknown-parameters.ts";
+import { noUnknownReturnsRule } from "./rules/no-unknown-returns.ts";
+import { noUnknownTypeAliasesRule } from "./rules/no-unknown-type-aliases.ts";
+import { noUnsafeDictionaryTypeRule } from "./rules/no-unsafe-dictionary-type.ts";
+import { noWidenThenAssertRule } from "./rules/no-widen-then-assert.ts";
+import { requireSafetyCommentForTypeAssertionRule } from "./rules/require-safety-comment-for-type-assertion.ts";
+
+/** Generic Oxlint rules that reject low-evidence and low-signal implementation patterns. */
+const antiSlopPlugin = definePlugin({
+  meta: { name: "anti-slop" },
+  rules: {
+    "no-chained-type-assertions": noChainedTypeAssertionsRule,
+    "no-conditional-empty-object-spread": noConditionalEmptyObjectSpreadRule,
+    "no-known-value-widening": noKnownValueWideningRule,
+    "no-module-mocking": noModuleMockingRule,
+    "no-object-parameters": noObjectParametersRule,
+    "no-reflect-apply": noReflectApplyRule,
+    "no-reflect-get": noReflectGetRule,
+    "no-runtime-typeof": noRuntimeTypeofRule,
+    "no-unsafe-dictionary-type": noUnsafeDictionaryTypeRule,
+    "no-shape-in-symbol-names": noForbiddenTermInSymbolNamesRule,
+    "no-unknown-parameters": noUnknownParametersRule,
+    "no-unknown-returns": noUnknownReturnsRule,
+    "no-unknown-type-aliases": noUnknownTypeAliasesRule,
+    "no-widen-then-assert": noWidenThenAssertRule,
+    "require-safety-comment-for-type-assertion": requireSafetyCommentForTypeAssertionRule,
+  },
+});
+
+export default antiSlopPlugin;

package/src/oxlint-plugin-anti-slop/rules/no-chained-type-assertions.ts

@@ -0,0 +1,79 @@
+import { defineRule, type ESTree } from "@oxlint/plugins";
+
+type TypeAssertionExpression = ESTree.TSAsExpression | ESTree.TSTypeAssertion;
+
+function isTypeAssertionExpression(node: ESTree.Node): node is TypeAssertionExpression {
+  return node.type === "TSAsExpression" || node.type === "TSTypeAssertion";
+}
+
+function unwrapParenthesizedExpression(expression: ESTree.Expression): ESTree.Expression {
+  let current = expression;
+
+  while (current.type === "ParenthesizedExpression") {
+    current = current.expression;
+  }
+
+  return current;
+}
+
+function isConstAssertion(node: TypeAssertionExpression): boolean {
+  const { typeAnnotation } = node;
+
+  return (
+    typeAnnotation.type === "TSTypeReference" &&
+    typeAnnotation.typeName.type === "Identifier" &&
+    typeAnnotation.typeName.name === "const"
+  );
+}
+
+function isOutermostAssertionInChain(node: TypeAssertionExpression): boolean {
+  let current: ESTree.Expression = node;
+  let parent = node.parent;
+
+  while (parent.type === "ParenthesizedExpression" && parent.expression === current) {
+    current = parent;
+    parent = parent.parent;
+  }
+
+  return !isTypeAssertionExpression(parent) || parent.expression !== current;
+}
+
+function isForbiddenAssertionChain(node: TypeAssertionExpression): boolean {
+  let assertionCount = 0;
+  let hasNonConstAssertion = false;
+  let current: ESTree.Expression = node;
+
+  while (isTypeAssertionExpression(current)) {
+    assertionCount += 1;
+    hasNonConstAssertion ||= !isConstAssertion(current);
+    current = unwrapParenthesizedExpression(current.expression);
+  }
+
+  return assertionCount > 1 && hasNonConstAssertion;
+}
+
+/** Disallow nested TypeScript type assertions, while permitting chains made only of const assertions. */
+export const noChainedTypeAssertionsRule = defineRule({
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "Disallow chained TypeScript as and angle-bracket assertions, including parenthesized chains.",
+    },
+    messages: {
+      chained:
+        "This assertion chain discards type evidence. Keep the original precise type, or parse untrusted input at its boundary before narrowing it.",
+    },
+  },
+  create(context) {
+    const checkTypeAssertion = (node: TypeAssertionExpression) => {
+      if (!isOutermostAssertionInChain(node) || !isForbiddenAssertionChain(node)) return;
+      context.report({ node, messageId: "chained" });
+    };
+
+    return {
+      TSAsExpression: checkTypeAssertion,
+      TSTypeAssertion: checkTypeAssertion,
+    };
+  },
+});

package/src/oxlint-plugin-anti-slop/rules/no-conditional-empty-object-spread.ts

@@ -0,0 +1,51 @@
+import { defineRule, type ESTree } from "@oxlint/plugins";
+
+function unwrapParentheses(node: ESTree.Expression): ESTree.Expression {
+  let current = node;
+
+  while (current.type === "ParenthesizedExpression") {
+    current = current.expression;
+  }
+
+  return current;
+}
+
+function isEmptyObjectExpression(node: ESTree.Expression): boolean {
+  return node.type === "ObjectExpression" && node.properties.length === 0;
+}
+
+function isConditionalEmptyObjectSpread(node: ESTree.Expression): boolean {
+  const conditional = unwrapParentheses(node);
+
+  return (
+    conditional.type === "ConditionalExpression" &&
+    (isEmptyObjectExpression(conditional.consequent) ||
+      isEmptyObjectExpression(conditional.alternate))
+  );
+}
+
+/** Ban conditional empty-object spreads without changing their omission semantics. */
+export const noConditionalEmptyObjectSpreadRule = defineRule({
+  meta: {
+    type: "suggestion",
+    docs: {
+      description:
+        "Disallow object spreads that conditionally spread an empty object to omit fields.",
+    },
+    messages: {
+      avoid:
+        "This conditional spread hides property omission behind an empty object. Build the object in separate statements and add the property only when present.",
+    },
+  },
+  create(context) {
+    return {
+      SpreadElement(node) {
+        if (node.parent.type !== "ObjectExpression") return;
+
+        if (isConditionalEmptyObjectSpread(node.argument)) {
+          context.report({ node, messageId: "avoid" });
+        }
+      },
+    };
+  },
+});