@starci/eslint-canon-fe 1.3.2 → 1.4.1

package/lint-adoption.mjs

@@ -1,116 +1,116 @@
-/**
- * Repository-level audit for effective StarCi FE lint adoption.
- *
- * An ESLint config can import a plugin, copy a plugin, or call itself StarCi while still leaving
- * canonical rules switched off. The only useful evidence is the effective config ESLint applies
- * to a real production file. This audit compares that printed config with this canon.
- */
-/**
- * Where the component tree sits, per supported repository shape.
- *
- * ONE BRANCH, IN ONE PLACE. The difference between a monorepo and a single app is not a difference
- * of law - the rules, their severities and the inline-config refusal are identical. It is only
- * WHERE the law applies. Written out in each repository's config, that fact became two hand-kept
- * lists, and the lists did what hand-kept lists do: one enabled 43 rules, the other 53, and canon
- * had 49. Neither repository was wrong on purpose; nothing told either of them.
- *
- * The candidate path is included deliberately. A Preview candidate is the exact source Apply later
- * ports into production, and leaving it ungoverned means the one file that becomes production was
- * judged by nothing.
- */
-const LAYOUT_GLOBS = {
-    monorepo: [
-        "packages/ui/src/**/*.{ts,tsx}",
-        "apps/*/src/**/*.{ts,tsx}",
-        "**/candidate/src/**/*.{ts,tsx}",
-    ],
-    "single-app": [
-        "src/**/*.{ts,tsx}",
-        "**/candidate/src/**/*.{ts,tsx}",
-    ],
-}
-
-/** The repository shapes this canon knows how to govern. */
-export const LAYOUTS = Object.keys(LAYOUT_GLOBS)
-
-/**
- * The one flat-config block that attaches this canon to a repository.
- *
- * A consuming `eslint.config.mjs` spreads the result and owns nothing else about the rules: not
- * which are on, not their severity, not whether an inline comment may switch one off. Its own
- * plugins, its own ignores and its own language options stay its own business - what it may not
- * keep is a second opinion about the law.
- *
- * @param {object} input - Attachment options.
- * @param {"monorepo" | "single-app"} input.layout - Which shape this repository has.
- * @param {object} input.plugin - The plugin object, imported from this canon.
- * @param {object} input.recommended - The recommendation, imported from this canon.
- * @param {object} input.linterOptions - The linter options, imported from this canon.
- * @returns {object} One flat-config block.
- */
-export const starciFeConfig = ({ layout, plugin, recommended, linterOptions }) => {
-    const files = LAYOUT_GLOBS[layout]
-    if (!files) {
-        throw new Error(`unknown layout "${layout}" - expected one of: ${LAYOUTS.join(", ")}`)
-    }
-    /*
-     * `recommended` is a FLAT rule map here, not a config object with a `rules` key - and reaching
-     * for `.rules` on it is the mistake this line exists to stop repeating. Spread that way it
-     * yields `undefined`, the block ends up with zero rules, and the repository lints clean while
-     * being governed by nothing. That is the worst possible failure for this file: green, silent,
-     * and indistinguishable from success. Both spellings are accepted so neither shape can produce
-     * an empty block.
-     */
-    const rules = recommended?.rules ?? recommended
-    if (!rules || Object.keys(rules).length === 0) {
-        throw new Error("starciFeConfig received an empty recommendation - a config with no rules is not adoption")
-    }
-    return {
-        files,
-        linterOptions,
-        plugins: { "starci-fe": plugin },
-        rules: { ...rules },
-    }
-}
-
-/** Convert every flat-config severity spelling to its numeric meaning. */
-const severityOf = (setting) => {
-  const severity = Array.isArray(setting) ? setting[0] : setting
-  if (severity === "error") return 2
-  if (severity === "warn") return 1
-  if (severity === "off") return 0
-  return severity
-}
-
-/**
- * Compare an `eslint --print-config` result with the canonical recommendation.
- *
- * @param {object} printedConfig - Parsed effective ESLint config for one production probe file.
- * @param {Record<string, string | number | unknown[]>} expectedRules - Canonical rule levels.
- */
-export const auditLintAdoption = (printedConfig, expectedRules) => {
-  const actualRules = printedConfig?.rules ?? {}
-  const missing = []
-  const nonError = []
-
-  for (const name of Object.keys(expectedRules).sort()) {
-    if (actualRules[name] === undefined) {
-      missing.push(name)
-      continue
-    }
-    if (severityOf(actualRules[name]) !== 2) nonError.push(name)
-  }
-
-  const refusesInlineConfig = printedConfig?.linterOptions?.noInlineConfig === true
-  return {
-    ok: missing.length === 0 && nonError.length === 0 && refusesInlineConfig,
-    missing,
-    nonError,
-    refusesInlineConfig,
-  }
-}
-
-/** Repository audits are gathered beside rules, but are not ESLint AST rules themselves. */
-export const audits = { "effective-config": auditLintAdoption }
-export const rules = {}
-export const recommended = {}
+/**
+ * Repository-level audit for effective StarCi FE lint adoption.
+ *
+ * An ESLint config can import a plugin, copy a plugin, or call itself StarCi while still leaving
+ * canonical rules switched off. The only useful evidence is the effective config ESLint applies
+ * to a real production file. This audit compares that printed config with this canon.
+ */
+/**
+ * Where the component tree sits, per supported repository shape.
+ *
+ * ONE BRANCH, IN ONE PLACE. The difference between a monorepo and a single app is not a difference
+ * of law - the rules, their severities and the inline-config refusal are identical. It is only
+ * WHERE the law applies. Written out in each repository's config, that fact became two hand-kept
+ * lists, and the lists did what hand-kept lists do: one enabled 43 rules, the other 53, and canon
+ * had 49. Neither repository was wrong on purpose; nothing told either of them.
+ *
+ * The candidate path is included deliberately. A Preview candidate is the exact source Apply later
+ * ports into production, and leaving it ungoverned means the one file that becomes production was
+ * judged by nothing.
+ */
+const LAYOUT_GLOBS = {
+    monorepo: [
+        "packages/ui/src/**/*.{ts,tsx}",
+        "apps/*/src/**/*.{ts,tsx}",
+        "**/candidate/src/**/*.{ts,tsx}",
+    ],
+    "single-app": [
+        "src/**/*.{ts,tsx}",
+        "**/candidate/src/**/*.{ts,tsx}",
+    ],
+}
+
+/** The repository shapes this canon knows how to govern. */
+export const LAYOUTS = Object.keys(LAYOUT_GLOBS)
+
+/**
+ * The one flat-config block that attaches this canon to a repository.
+ *
+ * A consuming `eslint.config.mjs` spreads the result and owns nothing else about the rules: not
+ * which are on, not their severity, not whether an inline comment may switch one off. Its own
+ * plugins, its own ignores and its own language options stay its own business - what it may not
+ * keep is a second opinion about the law.
+ *
+ * @param {object} input - Attachment options.
+ * @param {"monorepo" | "single-app"} input.layout - Which shape this repository has.
+ * @param {object} input.plugin - The plugin object, imported from this canon.
+ * @param {object} input.recommended - The recommendation, imported from this canon.
+ * @param {object} input.linterOptions - The linter options, imported from this canon.
+ * @returns {object} One flat-config block.
+ */
+export const starciFeConfig = ({ layout, plugin, recommended, linterOptions }) => {
+    const files = LAYOUT_GLOBS[layout]
+    if (!files) {
+        throw new Error(`unknown layout "${layout}" - expected one of: ${LAYOUTS.join(", ")}`)
+    }
+    /*
+     * `recommended` is a FLAT rule map here, not a config object with a `rules` key - and reaching
+     * for `.rules` on it is the mistake this line exists to stop repeating. Spread that way it
+     * yields `undefined`, the block ends up with zero rules, and the repository lints clean while
+     * being governed by nothing. That is the worst possible failure for this file: green, silent,
+     * and indistinguishable from success. Both spellings are accepted so neither shape can produce
+     * an empty block.
+     */
+    const rules = recommended?.rules ?? recommended
+    if (!rules || Object.keys(rules).length === 0) {
+        throw new Error("starciFeConfig received an empty recommendation - a config with no rules is not adoption")
+    }
+    return {
+        files,
+        linterOptions,
+        plugins: { "starci-fe": plugin },
+        rules: { ...rules },
+    }
+}
+
+/** Convert every flat-config severity spelling to its numeric meaning. */
+const severityOf = (setting) => {
+  const severity = Array.isArray(setting) ? setting[0] : setting
+  if (severity === "error") return 2
+  if (severity === "warn") return 1
+  if (severity === "off") return 0
+  return severity
+}
+
+/**
+ * Compare an `eslint --print-config` result with the canonical recommendation.
+ *
+ * @param {object} printedConfig - Parsed effective ESLint config for one production probe file.
+ * @param {Record<string, string | number | unknown[]>} expectedRules - Canonical rule levels.
+ */
+export const auditLintAdoption = (printedConfig, expectedRules) => {
+  const actualRules = printedConfig?.rules ?? {}
+  const missing = []
+  const nonError = []
+
+  for (const name of Object.keys(expectedRules).sort()) {
+    if (actualRules[name] === undefined) {
+      missing.push(name)
+      continue
+    }
+    if (severityOf(actualRules[name]) !== 2) nonError.push(name)
+  }
+
+  const refusesInlineConfig = printedConfig?.linterOptions?.noInlineConfig === true
+  return {
+    ok: missing.length === 0 && nonError.length === 0 && refusesInlineConfig,
+    missing,
+    nonError,
+    refusesInlineConfig,
+  }
+}
+
+/** Repository audits are gathered beside rules, but are not ESLint AST rules themselves. */
+export const audits = { "effective-config": auditLintAdoption }
+export const rules = {}
+export const recommended = {}

package/package.json

@@ -1,38 +1,38 @@
-{
-  "name": "@starci/eslint-canon-fe",
-  "version": "1.3.2",
-  "description": "The StarCi front-end lint canon: every rule its laws publish, gathered as one flat-config plugin.",
-  "type": "module",
-  "license": "UNLICENSED",
-  "private": false,
-  "exports": {
-    ".": "./index.mjs",
-    "./contracts": "./contracts.ts",
-    "./props": "./props.ts"
-  },
-  "main": "./index.mjs",
-  "files": [
-    "*.mjs",
-    "*.ts",
-    "!*.test.mjs",
-    "README.md"
-  ],
-  "engines": {
-    "node": ">=20.9.0"
-  },
-  "peerDependencies": {
-    "eslint": ">=9"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "scripts": {
-    "test": "node --test \"*.test.mjs\""
-  },
-  "keywords": [
-    "eslint",
-    "eslintplugin",
-    "starci",
-    "canon"
-  ]
-}
+{
+  "name": "@starci/eslint-canon-fe",
+  "version": "1.4.1",
+  "description": "The StarCi front-end lint canon: every rule its laws publish, gathered as one flat-config plugin.",
+  "type": "module",
+  "license": "UNLICENSED",
+  "private": false,
+  "exports": {
+    ".": "./index.mjs",
+    "./contracts": "./contracts.ts",
+    "./props": "./props.ts"
+  },
+  "main": "./index.mjs",
+  "files": [
+    "*.mjs",
+    "*.ts",
+    "!*.test.mjs",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20.9.0"
+  },
+  "peerDependencies": {
+    "eslint": ">=9"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "test": "node --test \"*.test.mjs\""
+  },
+  "keywords": [
+    "eslint",
+    "eslintplugin",
+    "starci",
+    "canon"
+  ]
+}

package/props-and-slots.mjs

@@ -12,7 +12,7 @@
  * a shape is findable.
  */
 
-import { COMPONENT_ROOTS, isContractTableFile, isInComponentTier, isTestFile } from "./contract.mjs"
+import { COMPONENT_ROOTS, isContractTableFile, isInComponentTier } from "./contract.mjs"
 
 /** True when a parameter type contains an anonymous object shape, including inside intersections. */
 const isInlineObjectType = (node) => {
@@ -58,6 +58,9 @@ export const noInlineParameterType = {
 
 // -- SLOTS-4 ---------------------------------------------------------------------------------------
 
+/** The only three components where a React `children` hole is lawful. */
+const CHILDREN_SHELLS = ["ModalShell", "DrawerShell", "DropdownShell", "RouteShell"]
+
 /**
  * True for a component file the slot fence governs.
  *
@@ -71,11 +74,15 @@ export const noInlineParameterType = {
  * NAMED CHILD GRAMMAR that replaces one. Reporting it asks the file that abolished the anonymous
  * slot to stop describing what it admits instead.
  *
+ * The three shells stay exempt for the reason canon already gives them: they pass real children
+ * through and arrange nothing.
+ *
  * @param filename - the file being linted.
  */
 const isGoverned = (filename) => {
   const path = String(filename || "").replace(/\\/g, "/")
   if (isContractTableFile(path)) return false
+  if (CHILDREN_SHELLS.some((shell) => isInComponentTier(path, `shells/${shell}`))) return false
   /*
    * The bare `src` root is dropped here, and only here. `COMPONENT_ROOTS` carries it as a
    * catch-all so a reader that walks up from any file still finds the table; used as a FENCE it
@@ -85,69 +92,6 @@ const isGoverned = (filename) => {
   return COMPONENT_ROOTS.filter((root) => root !== "src").some((root) => path.includes(`/${root}/`))
 }
 
-/**
- * True when a function's whole body does nothing but turn `children` into a component
- * reference and hand that reference to exactly one other component under a named prop.
- *
- * THIS IS SLOTS-4'S OWN EXCEPTION, READ FROM SHAPE, NOT FROM A NAME. The rule's message
- * already promises it: a framework route layout may receive `ReactNode` outside the
- * component tier, but must close it into a named projection before a component sees it.
- * A shell that crosses `children` over a client/server boundary - wrapping it in
- * `useCallback` so it survives as a function reference rather than an unserialisable
- * inline component - IS that closing act; there is no contract key to name because the
- * shell is deliberately generic across callers. What makes the exception SAFE to keep
- * narrow is that the shape disqualifies itself the moment the body does one more thing:
- * a second return, a conditional, a data read, an element of its own, or a forwarded
- * value that never passes through the closure all fall through to the ordinary report.
- *
- * - Every statement but the last is a `const x = ...` naming either a plain member/param
- *   read (`const Frame = input.frame`) or a `useCallback(...)` call - nothing else.
- * - The last statement is the only `return`, and it returns exactly one JSX element.
- * - That element's attributes only spread or forward existing bindings, and at least one
- *   of them carries the `useCallback` result - the children-derived reference - by name.
- */
-const isChildrenBoundaryConverter = (fn) => {
-  if (!fn || fn.body?.type !== "BlockStatement") return false
-  const statements = fn.body.body
-  let closureVar = null
-  let returnNode = null
-
-  for (const statement of statements) {
-    if (statement.type === "ReturnStatement") {
-      if (returnNode) return false // a second return means this does more than one thing
-      returnNode = statement.argument
-      continue
-    }
-    if (statement.type !== "VariableDeclaration" || statement.declarations.length !== 1) return false
-    const [declarator] = statement.declarations
-    const init = declarator.init
-    if (declarator.id.type !== "Identifier" || !init) return false
-    if (init.type === "MemberExpression" || init.type === "Identifier") continue // a plain prop read
-    if (init.type === "CallExpression" && init.callee?.type === "Identifier" && init.callee.name === "useCallback") {
-      const callback = init.arguments[0]
-      if (!callback || (callback.type !== "ArrowFunctionExpression" && callback.type !== "FunctionExpression")) {
-        return false
-      }
-      closureVar = declarator.id.name
-      continue
-    }
-    return false // any other statement is the component doing something of its own
-  }
-
-  if (!closureVar || !returnNode || returnNode.type !== "JSXElement") return false
-
-  let carriesClosure = false
-  for (const attribute of returnNode.openingElement.attributes || []) {
-    if (attribute.type === "JSXSpreadAttribute") continue
-    if (attribute.type !== "JSXAttribute" || !attribute.value) return false
-    const raw = attribute.value.type === "JSXExpressionContainer" ? attribute.value.expression : attribute.value
-    const value = raw?.type === "TSAsExpression" ? raw.expression : raw
-    if (value?.type !== "Identifier") return false
-    if (value.name === closureVar) carriesClosure = true
-  }
-  return carriesClosure
-}
-
 /**
  * A container takes `contract` and `render`, never `children`.
  *
@@ -155,65 +99,25 @@ const isChildrenBoundaryConverter = (fn) => {
  * aliases it defines, but nothing stops a file declaring its own props shape by hand and putting
  * `children` in it. What the alias makes unrepresentable, a hand-written interface makes ordinary.
  *
- * Vendor mechanics branches still take a named contract/render projection. Framework route
- * layouts sit outside the component tier and close their ReactNode into that projection before it
- * reaches a component.
- *
- * ONE CLOSED EXCEPTION LIVES INSIDE THE COMPONENT TIER: a boundary-converter shell whose
- * whole body matches {@link isChildrenBoundaryConverter}. It is closed by shape, checked
- * against the actual function the props type belongs to, never by filename or export name
- * - so nothing can opt in by being called `RouteShell`, and nothing loses the exemption by
- * being renamed.
+ * ModalShell, DrawerShell and DropdownShell are exempt because they ignore the interior shape and
+ * pass it directly to the vendor body. No folder-wide exemption exists.
  */
 export const noChildrenSlot = {
   meta: {
     type: "problem",
-    docs: { description: "Every component container takes contract and render, never children." },
+    docs: { description: "A container takes contract and render; only the three closed shells may take children." },
     schema: [],
     messages: {
       slot:
-        "`children` accepts markup that has already been built, so its shape cannot be checked. Take contract + render instead. A framework route layout may receive ReactNode outside the component tier, but it must close that value into a named contract projection before handing it to a component.",
+        "`children` accepts markup that has already been built, so its shape cannot be checked. Take contract + render instead. Only ModalShell, DrawerShell, DropdownShell and RouteShell may take one - the first three pass an interior straight to vendor mechanics, and RouteShell converts the children a framework layout is handed.",
     },
   },
   create(context) {
     if (!isGoverned(context.filename || context.getFilename())) return {}
-
-    // Deferred to Program:exit so the boundary-converter exemption - which has to look at
-    // the whole file to find the function a props type belongs to - can clear a candidate
-    // before it is ever reported.
-    const candidates = []
-    const componentsByPropsType = new Map()
-
-    const enclosingFunction = (node) => {
-      for (let current = node.parent; current; current = current.parent) {
-        if (["ArrowFunctionExpression", "FunctionExpression", "FunctionDeclaration"].includes(current.type)) {
-          return current
-        }
-      }
-      return null
-    }
-
-    const enclosingTypeName = (node) => {
-      for (let current = node.parent; current; current = current.parent) {
-        if (current.type === "TSInterfaceDeclaration" || current.type === "TSTypeAliasDeclaration") {
-          return current.id?.name || null
-        }
-      }
-      return null
-    }
-
-    /** The name of the type a function's single parameter is annotated with, if any. */
-    const parameterTypeName = (fn) => {
-      const annotation = fn.params?.[0]?.typeAnnotation?.typeAnnotation
-      return annotation?.type === "TSTypeReference" && annotation.typeName?.type === "Identifier"
-        ? annotation.typeName.name
-        : null
-    }
-
     return {
       TSPropertySignature(node) {
         if (node.key && node.key.type === "Identifier" && node.key.name === "children") {
-          candidates.push({ node: node.key, typeName: enclosingTypeName(node) })
+          context.report({ node: node.key, messageId: "slot" })
         }
       },
       Property(node) {
@@ -221,173 +125,9 @@ export const noChildrenSlot = {
         if (node.parent && node.parent.type !== "ObjectPattern") return
         if (node.parent.parent && node.parent.parent.type === "VariableDeclarator") return
         if (node.key && node.key.type === "Identifier" && node.key.name === "children") {
-          candidates.push({ node: node.key, fn: enclosingFunction(node) })
-        }
-      },
-      ":function"(fn) {
-        const typeName = parameterTypeName(fn)
-        if (typeName) componentsByPropsType.set(typeName, fn)
-      },
-      "Program:exit"() {
-        for (const candidate of candidates) {
-          const fn = candidate.fn || (candidate.typeName && componentsByPropsType.get(candidate.typeName))
-          if (fn && isChildrenBoundaryConverter(fn)) continue
-          context.report({ node: candidate.node, messageId: "slot" })
-        }
-      },
-    }
-  },
-}
-
-/** Name of a plain TypeScript property key. */
-const propertyName = (node) => {
-  const key = node?.key ?? node?.property
-  if (!key) return null
-  if (key.type === "Identifier") return key.name
-  if (key.type === "Literal" && typeof key.value === "string") return key.value
-  return null
-}
-
-/** Product source inside a supported component root. */
-const isComponentSource = (filename) => {
-  const path = String(filename || "").replace(/\\/g, "/")
-  return COMPONENT_ROOTS.filter((root) => root !== "src").some((root) => path.includes(`/${root}/`))
-}
-
-// -- SLOTS-5 · SLOTS-6 ---------------------------------------------------------------------------
-
-/** A caller cannot reach into one named internal part and style it. */
-export const noPerPartClassNameProp = {
-  meta: {
-    type: "problem",
-    docs: { description: "No <part>ClassName prop exposes a component's internal nodes." },
-    schema: [],
-    messages: {
-      perPart:
-        "`{{prop}}` lets a caller restyle a node it does not own. Replace the CSS door with a named semantic prop, and keep the appearance decision inside the component or its contract.",
-    },
-  },
-  create(context) {
-    const filename = context.filename || context.getFilename()
-    if (isTestFile(filename) || !isComponentSource(filename)) return {}
-    return {
-      TSPropertySignature(node) {
-        const name = propertyName(node)
-        if (!name || name === "className" || !/^[a-z][A-Za-z0-9]*ClassName$/.test(name)) return
-        context.report({ node, messageId: "perPart", data: { prop: name } })
-      },
-    }
-  },
-}
-
-/** Public house components never expose className/classNames placement doors. */
-export const noPublicClassNameProp = {
-  meta: {
-    type: "problem",
-    docs: { description: "House components own appearance and expose no public className/classNames prop." },
-    schema: [],
-    messages: {
-      declaration:
-        "Public component prop `{{prop}}` is a CSS placement door. Expose a semantic variant or a named contract instead.",
-      usage:
-        "Do not pass `{{prop}}` to house component `{{component}}`; its owner or parent contract decides appearance.",
-    },
-  },
-  create(context) {
-    const filename = context.filename || context.getFilename()
-    if (isTestFile(filename)) return {}
-    const inComponent = isComponentSource(filename)
-    const bindings = new Set()
-    return {
-      ImportDeclaration(node) {
-        const source = String(node.source?.value || "").replace(/\\/g, "/")
-        if (!/(?:^|\/)components\//.test(source)) return
-        for (const specifier of node.specifiers || []) {
-          if (specifier.local?.name) bindings.add(specifier.local.name)
+          context.report({ node: node.key, messageId: "slot" })
         }
       },
-      TSPropertySignature(node) {
-        if (!inComponent) return
-        const name = propertyName(node)
-        if (name === "className" || name === "classNames") {
-          context.report({ node, messageId: "declaration", data: { prop: name } })
-        }
-      },
-      JSXOpeningElement(node) {
-        const component = node.name?.type === "JSXIdentifier" ? node.name.name : null
-        if (!component || !bindings.has(component)) return
-        for (const attribute of node.attributes || []) {
-          if (attribute.type !== "JSXAttribute") continue
-          const prop = attribute.name?.type === "JSXIdentifier" ? attribute.name.name : null
-          if (prop === "className" || prop === "classNames") {
-            context.report({ node: attribute, messageId: "usage", data: { prop, component } })
-          }
-        }
-      },
-    }
-  },
-}
-
-/** CSS-shaped layout props are not public API above the atomic leaf tier. */
-const FRAME_CSS_PROPS = new Set(["gap", "padding", "align", "justify", "className", "classNames", "style", "inline", "nested"])
-
-export const noPublicFrameCssProps = {
-  meta: {
-    type: "problem",
-    docs: { description: "Non-leaf component contracts expose semantic decisions, not CSS-shaped frame props." },
-    schema: [],
-    messages: {
-      css:
-        "`{{prop}}` is a public CSS/frame decision above the leaf tier. Move the arrangement into a named contract or expose the semantic state that selects one.",
-    },
-  },
-  create(context) {
-    const filename = context.filename || context.getFilename()
-    if (isTestFile(filename) || !isComponentSource(filename) || isInComponentTier(filename, "leaves")) return {}
-    return {
-      TSPropertySignature(node) {
-        const name = propertyName(node)
-        if (name && FRAME_CSS_PROPS.has(name)) context.report({ node, messageId: "css", data: { prop: name } })
-      },
-    }
-  },
-}
-
-/** String literal keys named by Omit/Pick/Exclude. */
-const typeKeys = (node, out = []) => {
-  if (!node) return out
-  if (node.type === "TSUnionType") {
-    for (const member of node.types || []) typeKeys(member, out)
-    return out
-  }
-  if (node.type === "TSLiteralType" && node.literal?.type === "Literal" && typeof node.literal.value === "string") {
-    out.push(node.literal.value)
-  }
-  return out
-}
-
-/** Hiding a CSS door with a utility type is not closing the owner that exposed it. */
-export const noCssDoorTypeLaundering = {
-  meta: {
-    type: "problem",
-    docs: { description: "Omit/Pick/Exclude cannot hide className/classNames/style doors." },
-    schema: [],
-    messages: {
-      utility:
-        "`{{utility}}` of `{{prop}}` launders a CSS door instead of closing it. Remove the prop from the owning public contract and every consumer.",
-    },
-  },
-  create(context) {
-    const file = String(context.filename || context.getFilename()).replace(/\\/g, "/")
-    if (isTestFile(file) || !file.includes("/src/")) return {}
-    return {
-      TSTypeReference(node) {
-        const utility = node.typeName?.type === "Identifier" ? node.typeName.name : null
-        if (!utility || !["Omit", "Pick", "Exclude"].includes(utility)) return
-        const params = node.typeArguments?.params || node.typeParameters?.params || []
-        const prop = typeKeys(params[1]).find((key) => key === "className" || key === "classNames" || key === "style")
-        if (prop) context.report({ node, messageId: "utility", data: { utility, prop } })
-      },
     }
   },
 }
@@ -436,10 +176,6 @@ export const noSurfaceListItemsSlot = {
 export const rules = {
   "no-inline-parameter-type": noInlineParameterType,
   "no-children-slot": noChildrenSlot,
-  "no-per-part-classname-prop": noPerPartClassNameProp,
-  "no-public-classname-prop": noPublicClassNameProp,
-  "no-public-frame-css-props": noPublicFrameCssProps,
-  "no-css-door-type-laundering": noCssDoorTypeLaundering,
   "no-surface-list-items-slot": noSurfaceListItemsSlot,
 }