@geonosis/oxlint-plugin-biological-architecture 0.2.0 → 0.3.0

package/corpus/.oxlintrc.json

@@ -35,6 +35,7 @@
       }
     ],
     "biological-architecture/effect-hook-naming": "error",
+    "biological-architecture/emit-declares-attempts": "error",
     "biological-architecture/layer-walls": [
       "error",
       {

package/corpus/admin/order-widget.tsx

@@ -0,0 +1,13 @@
+// A file in no tier folder at all — a Medusa admin widget, a Next route, a one-off surface. The
+// atom exists there too, so no-raw-html-atoms still has something to say.
+import { Card } from '@kit/ui/atoms/card'
+
+export function OrderWidget({ onRefresh }: { onRefresh: () => void }) {
+  return (
+    <Card>
+      <button onClick={onRefresh} type="button">
+        Refresh
+      </button>
+    </Card>
+  )
+}

package/corpus/atoms-discovery/generic-only.tsx

@@ -0,0 +1,9 @@
+import { useMemo } from 'react'
+
+const weights: Record<string, number> = { bold: 700, regular: 400 }
+
+export function Spacer({ weight = 'regular' }: { weight?: string }) {
+  const value = useMemo<number>(() => weights[weight] ?? 400, [weight])
+
+  return <div style={{ fontWeight: value }} />
+}

package/corpus/atoms-discovery/html-attributes-select.tsx

@@ -0,0 +1,15 @@
+import type { HTMLAttributes } from 'react'
+
+interface NativeSelectProps extends Omit<HTMLAttributes<HTMLSelectElement>, 'onChange'> {
+  onPick?: (value: string) => void
+}
+
+export function NativeSelect({ onPick, children, ...props }: NativeSelectProps) {
+  return (
+    <div className="relative">
+      <select onChange={(event) => onPick?.(event.target.value)} {...props}>
+        {children}
+      </select>
+    </div>
+  )
+}

package/corpus/atoms-discovery/icon-check.tsx

@@ -0,0 +1,7 @@
+export function CheckIcon({ size = 16 }: { size?: number }) {
+  return (
+    <svg fill="none" height={size} viewBox="0 0 24 24" width={size}>
+      <path d="M20 6 9 17l-5-5" stroke="currentColor" strokeWidth="2" />
+    </svg>
+  )
+}

package/corpus/atoms-discovery/label.tsx

@@ -0,0 +1,3 @@
+export function Label({ children }: { children?: unknown }) {
+  return <label className="text-sm">{children}</label>
+}

package/corpus/atoms-discovery/props-button.tsx

@@ -0,0 +1,27 @@
+import { cva, type VariantProps } from 'class-variance-authority'
+import { Slot } from 'radix-ui'
+import type { ComponentProps, Ref } from 'react'
+
+const buttonVariants = cva('inline-flex', {
+  variants: { size: { medium: 'px-7', small: 'px-5' } },
+})
+
+type ButtonSize = NonNullable<VariantProps<typeof buttonVariants>['size']>
+
+const labels: Record<string, string> = { medium: 'Medium', small: 'Small' }
+
+interface ButtonProps extends ComponentProps<'button'>, VariantProps<typeof buttonVariants> {
+  asChild?: boolean
+  ref?: Ref<HTMLButtonElement>
+}
+
+export function Button({ asChild = false, size, children, ...props }: ButtonProps) {
+  const Comp = asChild ? Slot.Root : 'button'
+  const resolved: ButtonSize = size ?? 'medium'
+
+  return (
+    <Comp aria-label={labels[resolved]} {...props}>
+      {children}
+    </Comp>
+  )
+}

package/corpus/atoms-discovery/props-without-ref-textarea.tsx

@@ -0,0 +1,11 @@
+import type { ComponentPropsWithoutRef } from 'react'
+
+type TextAreaProps = ComponentPropsWithoutRef<'textarea'> & { invalid?: boolean }
+
+export function TextArea({ invalid = false, ...props }: TextAreaProps) {
+  return (
+    <div className="relative">
+      <textarea data-invalid={invalid} {...props} />
+    </div>
+  )
+}

package/corpus/atoms-discovery/react-namespaced-input.tsx

@@ -0,0 +1,13 @@
+import * as React from 'react'
+
+interface TextInputProps extends React.InputHTMLAttributes<HTMLInputElement> {
+  invalid?: boolean
+}
+
+export function TextInput({ invalid = false, ...props }: TextInputProps) {
+  return (
+    <div className="relative">
+      <input data-invalid={invalid} {...props} />
+    </div>
+  )
+}

package/corpus/atoms-discovery/slot-anchor.stories.tsx

@@ -0,0 +1,9 @@
+import { LinkAtom } from './slot-anchor'
+
+export default { component: LinkAtom, title: 'Atoms/LinkAtom' }
+
+export const Loading = () => (
+  <figure>
+    <progress max={100} value={40} />
+  </figure>
+)

package/corpus/atoms-discovery/slot-anchor.tsx

@@ -0,0 +1,15 @@
+import { Slot } from 'radix-ui'
+
+import { cn } from '#lib/utils'
+
+interface LinkAtomProps {
+  asChild?: boolean
+  children?: unknown
+  className?: string
+}
+
+export function LinkAtom({ asChild = false, children, className }: LinkAtomProps) {
+  const Comp = asChild ? Slot.Root : 'a'
+
+  return <Comp className={cn('underline', className)}>{children}</Comp>
+}

package/corpus/emits/bad-no-options.ts

@@ -0,0 +1,7 @@
+import { emitEventStep } from '@medusajs/medusa/core-flows'
+
+export const emitMilestone = (data: { tracking_number: string }) =>
+  emitEventStep({
+    data,
+    eventName: 'shipment.milestone',
+  })

package/corpus/emits/bad-priority-only.ts

@@ -0,0 +1,11 @@
+import { EventPriority } from '@medusajs/framework/utils'
+import { emitEventStep } from '@medusajs/medusa/core-flows'
+
+// An options bag that names a priority and no attempts: configured to the eye, droppable to the
+// worker, which reads only `attempts > 1` as "a retry was asked for".
+export const emitSampleRequested = (data: { order_id: string }) =>
+  emitEventStep({
+    data,
+    eventName: 'sample.requested',
+    options: { priority: EventPriority.CRITICAL },
+  }).config({ name: 'emit-sample-requested' })

package/corpus/emits/bad-single-attempt.ts

@@ -0,0 +1,8 @@
+import { emitEventStep } from '@medusajs/medusa/core-flows'
+
+export const emitConverted = (data: { order_id: string }) =>
+  emitEventStep({
+    data,
+    eventName: 'sample.converted',
+    options: { attempts: 1 },
+  })

package/corpus/emits/good-retry-budget.ts

@@ -0,0 +1,9 @@
+import { EventPriority } from '@medusajs/framework/utils'
+import { emitEventStep } from '@medusajs/medusa/core-flows'
+
+export const emitOrderPlaced = (data: { id: string }) =>
+  emitEventStep({
+    data,
+    eventName: 'order.placed',
+    options: { attempts: 3, priority: EventPriority.CRITICAL },
+  }).config({ name: 'emit-order-placed' })

package/corpus/emits/good-shared-constant.ts

@@ -0,0 +1,10 @@
+import { emitEventStep } from '@medusajs/medusa/core-flows'
+
+import { RETRY_BACKGROUND } from './retry'
+
+export const emitProofReady = (data: { proof_id: string }) =>
+  emitEventStep({
+    data,
+    eventName: 'proof.ready',
+    options: { attempts: RETRY_BACKGROUND.attempts },
+  })

package/corpus/emits/retry.ts

@@ -0,0 +1,3 @@
+// The shared retry budgets. One place, so a change to what "background" means reaches every emit.
+export const RETRY_BACKGROUND = { attempts: 5, backoff: 2000 }
+export const RETRY_CRITICAL = { attempts: 9, backoff: 500 }

package/corpus/manifest.json

@@ -13,6 +13,7 @@
     "biological-architecture/document-sagas-are-generic",
     "biological-architecture/documents-share-one-table",
     "biological-architecture/effect-hook-naming",
+    "biological-architecture/emit-declares-attempts",
     "biological-architecture/layer-walls",
     "biological-architecture/max-comment-density",
     "biological-architecture/molecule-atoms-only",

package/corpus/molecules/raw-button.tsx

@@ -0,0 +1,10 @@
+// A molecule hand-rolling the element an atom already wraps: level 2, where the rule bites.
+import { Icon } from '../atoms/icon'
+
+export function IconAction({ onPress }: { onPress: () => void }) {
+  return (
+    <button onClick={onPress} type="button">
+      <Icon name="plus" />
+    </button>
+  )
+}

package/dist/{chunk-HXBZSOIU.js → chunk-55NK7NJN.js}

@@ -52,7 +52,7 @@ var BACKEND_WORKFLOWS = [
 ];
 var BACKEND_D1 = ["no-d1-transaction", "worker-handles-are-scoped"];
 var BACKEND_SAGAFLOW_CF = ["step-opens-its-own-cell"];
-var BACKEND_MEDUSA = ["store-route-scopes-tenant-data"];
+var BACKEND_MEDUSA = ["emit-declares-attempts", "store-route-scopes-tenant-data"];
 var TENANT_SCOPING = [
   "queries-require-org-scope",
   "store-route-scopes-tenant-data",

package/dist/discover-atoms.d.ts

@@ -34,6 +34,18 @@ declare function buildAtomRuleRestrictions(atomsDir: string, importPathPrefix?:
  * Variants are kept as alternatives in the error message.
  */
 declare function scanAtomMappings(atomsDir: string): AtomMapping[];
+/**
+ * The native element an atom wraps, read from the one place every atom says so: its props type.
+ *
+ * `ComponentProps<'button'>`, `ComponentPropsWithoutRef<'textarea'>`,
+ * `HTMLAttributes<HTMLSelectElement>` and `React.ButtonHTMLAttributes<HTMLButtonElement>` all name
+ * the element outright, and an atom that types its props any other way is an atom nobody can
+ * compose. The Radix `asChild ? Slot.Root : 'button'` form comes next, and the JSX-tag scan is
+ * only the fallback — it was the whole detector once, and on a real tree it returned `string`,
+ * `typeof` and `path` while missing every shadcn button in the repo.
+ *
+ * The name is kept because consumers import it.
+ */
 declare function detectFirstNativeJsxElement(source: string): null | string;
 
 export { buildAtomRestrictions, buildAtomRuleRestrictions, detectFirstNativeJsxElement, scanAtomMappings };

package/dist/discover-atoms.js

@@ -2,6 +2,164 @@
 import { readdirSync, readFileSync } from "fs";
 import { basename, join } from "path";
 var GENERIC_ELEMENTS = /* @__PURE__ */ new Set(["div", "span"]);
+var HTML_ELEMENTS = /* @__PURE__ */ new Set([
+  "a",
+  "abbr",
+  "address",
+  "area",
+  "article",
+  "aside",
+  "audio",
+  "b",
+  "bdi",
+  "bdo",
+  "blockquote",
+  "br",
+  "button",
+  "canvas",
+  "caption",
+  "cite",
+  "code",
+  "col",
+  "colgroup",
+  "data",
+  "datalist",
+  "dd",
+  "del",
+  "details",
+  "dfn",
+  "dialog",
+  "div",
+  "dl",
+  "dt",
+  "em",
+  "embed",
+  "fieldset",
+  "figcaption",
+  "figure",
+  "footer",
+  "form",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "header",
+  "hgroup",
+  "hr",
+  "i",
+  "iframe",
+  "img",
+  "input",
+  "ins",
+  "kbd",
+  "label",
+  "legend",
+  "li",
+  "main",
+  "map",
+  "mark",
+  "menu",
+  "meter",
+  "nav",
+  "noscript",
+  "object",
+  "ol",
+  "optgroup",
+  "option",
+  "output",
+  "p",
+  "picture",
+  "pre",
+  "progress",
+  "q",
+  "rp",
+  "rt",
+  "ruby",
+  "s",
+  "samp",
+  "search",
+  "section",
+  "select",
+  "small",
+  "source",
+  "span",
+  "strong",
+  "sub",
+  "summary",
+  "sup",
+  "table",
+  "tbody",
+  "td",
+  "template",
+  "textarea",
+  "tfoot",
+  "th",
+  "thead",
+  "time",
+  "tr",
+  "track",
+  "u",
+  "ul",
+  "var",
+  "video",
+  "wbr"
+]);
+var TAG_OF_DOM_INTERFACE = {
+  HTMLAnchorElement: "a",
+  HTMLAreaElement: "area",
+  HTMLAudioElement: "audio",
+  HTMLBRElement: "br",
+  HTMLButtonElement: "button",
+  HTMLCanvasElement: "canvas",
+  HTMLDListElement: "dl",
+  HTMLDataElement: "data",
+  HTMLDataListElement: "datalist",
+  HTMLDetailsElement: "details",
+  HTMLDialogElement: "dialog",
+  HTMLDivElement: "div",
+  HTMLEmbedElement: "embed",
+  HTMLFieldSetElement: "fieldset",
+  HTMLFormElement: "form",
+  HTMLHRElement: "hr",
+  HTMLIFrameElement: "iframe",
+  HTMLImageElement: "img",
+  HTMLInputElement: "input",
+  HTMLLIElement: "li",
+  HTMLLabelElement: "label",
+  HTMLLegendElement: "legend",
+  HTMLMapElement: "map",
+  HTMLMenuElement: "menu",
+  HTMLMeterElement: "meter",
+  HTMLOListElement: "ol",
+  HTMLObjectElement: "object",
+  HTMLOptGroupElement: "optgroup",
+  HTMLOptionElement: "option",
+  HTMLOutputElement: "output",
+  HTMLParagraphElement: "p",
+  HTMLPictureElement: "picture",
+  HTMLPreElement: "pre",
+  HTMLProgressElement: "progress",
+  HTMLSelectElement: "select",
+  HTMLSourceElement: "source",
+  HTMLSpanElement: "span",
+  HTMLTableCaptionElement: "caption",
+  HTMLTableColElement: "col",
+  HTMLTableElement: "table",
+  HTMLTableRowElement: "tr",
+  HTMLTextAreaElement: "textarea",
+  HTMLTimeElement: "time",
+  HTMLTrackElement: "track",
+  HTMLUListElement: "ul",
+  HTMLVideoElement: "video"
+};
+var TAG_OF_ATTRIBUTES_PREFIX = { anchor: "a" };
+var NOT_AN_ATOM = /\.(?:stories|test|spec)\.tsx$/;
+var COMPONENT_PROPS = /(?:React\.)?ComponentProps(?:WithoutRef|WithRef)?\s*<\s*['"]([a-z][a-z0-9]*)['"]\s*>/g;
+var HTML_ATTRIBUTES = /(?:React\.)?([A-Z][A-Za-z]*?)?HTMLAttributes\s*<\s*(HTML[A-Za-z]*Element)\s*>/g;
+var SLOT_FALLBACK = /Slot(?:\.Root)?\s*:\s*['"]([a-z][a-z0-9]*)['"]/;
+var JSX_TAG = /(?<![A-Za-z0-9_$])<([a-z][a-z0-9]*)(?=[\s/>])/g;
 function buildAtomRestrictions(atomsDir, importPathPrefix = "@kit/ui/atoms") {
   const mappings = scanAtomMappings(atomsDir);
   return mappings.map(({ atomName, nativeElement }) => ({
@@ -23,6 +181,7 @@ function scanAtomMappings(atomsDir) {
   for (const entry of entries) {
     if (!entry.isFile()) continue;
     if (!entry.name.endsWith(".tsx")) continue;
+    if (NOT_AN_ATOM.test(entry.name)) continue;
     const atomFile = entry.name;
     const atomName = basename(atomFile, ".tsx");
     const content = readFileSync(join(atomsDir, atomFile), "utf8");
@@ -42,11 +201,44 @@ function scanAtomMappings(atomsDir) {
   return mappings;
 }
 function detectFirstNativeJsxElement(source) {
-  const slotMatch = source.match(/Slot\s*:\s*['"]([a-z][a-z0-9]*)['"]/);
-  if (slotMatch?.[1]) return slotMatch[1];
-  const cleaned = source.replaceAll(/\/\/.*$/gm, "").replaceAll(/\/\*[\s\S]*?\*\//g, "").replaceAll(/(["'`])(?:\\.|(?!\1)[^\\])*\1/g, '""');
-  const match = cleaned.match(/<([a-z][a-z0-9]*)\b/);
-  return match?.[1] ?? null;
+  const withoutComments = stripComments(source);
+  const declared = elementFromPropsType(withoutComments);
+  if (declared) return declared;
+  const slot = SLOT_FALLBACK.exec(withoutComments)?.[1];
+  if (slot && HTML_ELEMENTS.has(slot)) return slot;
+  return elementFromJsx(withoutComments);
+}
+function elementFromPropsType(source) {
+  const found = [];
+  for (const match of source.matchAll(COMPONENT_PROPS)) {
+    const element = match[1];
+    if (element && HTML_ELEMENTS.has(element)) found.push({ at: match.index, element });
+  }
+  for (const match of source.matchAll(HTML_ATTRIBUTES)) {
+    const element = elementOfAttributes(match[1], match[2]);
+    if (element) found.push({ at: match.index, element });
+  }
+  return found.toSorted((a, b) => a.at - b.at)[0]?.element ?? null;
+}
+function elementOfAttributes(prefix, domInterface) {
+  if (prefix !== void 0) {
+    const lower = prefix.toLowerCase();
+    const named = TAG_OF_ATTRIBUTES_PREFIX[lower] ?? lower;
+    if (HTML_ELEMENTS.has(named)) return named;
+  }
+  const mapped = domInterface === void 0 ? void 0 : TAG_OF_DOM_INTERFACE[domInterface];
+  return mapped !== void 0 && HTML_ELEMENTS.has(mapped) ? mapped : null;
+}
+function elementFromJsx(withoutComments) {
+  const cleaned = withoutComments.replaceAll(/(["'`])(?:\\.|(?!\1)[^\\])*\1/g, '""');
+  for (const match of cleaned.matchAll(JSX_TAG)) {
+    const tag = match[1];
+    if (tag && HTML_ELEMENTS.has(tag)) return tag;
+  }
+  return null;
+}
+function stripComments(source) {
+  return source.replaceAll(/\/\*[\s\S]*?\*\//g, "").replaceAll(/(?<!:)\/\/.*$/gm, "");
 }
 function toPascalCase(kebab) {
   return kebab.split("-").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");

package/dist/index.js

@@ -1,7 +1,7 @@
 import {
   PRESETS,
   rulesOfPreset
-} from "./chunk-HXBZSOIU.js";
+} from "./chunk-55NK7NJN.js";
 
 // src/index.ts
 import { createRequire } from "module";
@@ -743,6 +743,80 @@ file and the export together \u2014 half the pair still fires.`,
 };
 var effect_hook_naming_default = effectHookNaming;
 
+// src/rules/emit-declares-attempts.ts
+var RULE = "emit-declares-attempts";
+var DEFAULT_EMITTERS = ["emitEventStep"];
+var OPTIONS = "options";
+var ATTEMPTS = "attempts";
+var EVENT_NAME = "eventName";
+var NO_RETRY = 1;
+var objectOf = (node) => node?.type === "ObjectExpression" ? node : null;
+var propertiesOf = (object) => {
+  const properties = object.properties ?? [];
+  return properties.every((one) => one.type === "Property") ? properties : null;
+};
+var valueOf = (properties, name) => properties.find((one) => one.key?.type === "Identifier" && one.key.name === name)?.value;
+var emitDeclaresAttempts = {
+  create(context) {
+    const emitters = new Set(
+      requireOption(RULE, context.options?.[0]?.emitters ?? DEFAULT_EMITTERS, "emitters")
+    );
+    return {
+      CallExpression(node) {
+        if (node.callee?.type !== "Identifier") return;
+        const emitter = node.callee.name ?? "";
+        if (!emitters.has(emitter)) return;
+        const payload = objectOf(node.arguments?.[0]);
+        if (payload === null) return;
+        const properties = propertiesOf(payload);
+        if (properties === null) return;
+        const named = valueOf(properties, EVENT_NAME);
+        const site = named?.type === "Literal" && typeof named.value === "string" ? named.value : emitter;
+        const options = valueOf(properties, OPTIONS);
+        if (options !== void 0 && objectOf(options) === null) return;
+        const bag = options === void 0 ? [] : propertiesOf(objectOf(options));
+        if (bag === null) return;
+        const attempts = valueOf(bag, ATTEMPTS);
+        if (attempts === void 0) {
+          context.report({ data: { emitter, site }, messageId: "noBudget", node });
+          return;
+        }
+        if (attempts.type !== "Literal" || typeof attempts.value !== "number") return;
+        if (attempts.value > NO_RETRY) return;
+        context.report({
+          data: { attempts: String(attempts.value), emitter, site },
+          messageId: "tooFew",
+          node
+        });
+      }
+    };
+  },
+  fixShape: `Every emit carries a retry budget: \`options.attempts\`, taken from the shared retry constants rather
+than written as a number at the call site. \`attempts\` defaults to 1 and the worker reads only
+\`attempts > 1\` as "a retry was configured", so an emit with \`{ priority }\` and no \`attempts\` is
+droppable while looking deliberate. Pass \`options: { attempts: RETRY_BACKGROUND.attempts, priority }\`.
+A budget the rule cannot evaluate \u2014 a constant, a computed value \u2014 passes: it says nothing rather
+than pushing the number back inline. Configure \`emitters\` if the repo wraps the emit under another name.`,
+  meta: {
+    docs: {
+      description: "An emit declares how many times it may be retried. Medusa's `emitEventStep` defaults `attempts` to 1 and the worker treats only `attempts > 1` as retry-configured, so an options bag without one is a droppable event that reads as a deliberate one. `emitters` is an option; a literal `attempts` is judged, anything else passes."
+    },
+    messages: {
+      noBudget: '`{{emitter}}` emits "{{site}}" with no `options.attempts`. `attempts` defaults to 1 and the worker treats only `attempts > 1` as a configured retry, so this event is dropped on its first failure. Give it a budget from the shared retry constants.',
+      tooFew: '`{{emitter}}` emits "{{site}}" with `attempts: {{attempts}}`, which is the default spelled out \u2014 one attempt is no retry. Take the budget from the shared retry constants instead.'
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: { emitters: { items: { type: "string" }, type: "array" } },
+        type: "object"
+      }
+    ],
+    type: "problem"
+  }
+};
+var emit_declares_attempts_default = emitDeclaresAttempts;
+
 // src/rules/layer-walls.ts
 import * as path2 from "path";
 var REQUIRE = "require";
@@ -2112,14 +2186,34 @@ below the seam, and a caller that names it has crossed it.`,
 };
 var no_orm_outside_db_default = noOrmOutsideDb;
 
+// src/rules/lib/tiers.ts
+var TIERS = ["atoms", "molecules", "compounds", "organelles", "cells", "tissues"];
+var PATTERNS = {
+  atoms: /(?:^|\/)(?:features\/[^/]+\/)?atoms\//,
+  cells: /(?:^|\/)(?:features\/[^/]+\/)?cells\//,
+  compounds: /(?:^|\/)(?:features\/[^/]+\/)?compounds\//,
+  molecules: /(?:^|\/)(?:features\/[^/]+\/)?molecules\//,
+  organelles: /(?:^|\/)(?:features\/[^/]+\/)?organelles\//,
+  tissues: /(?:^|\/)(?:features\/[^/]+\/)?tissues\//
+};
+var inTier = (filename, tier) => PATTERNS[tier].test(filename.replaceAll("\\", "/"));
+var requireTiers = (rule, names) => names.map((name) => {
+  if (TIERS.includes(name)) return name;
+  throw new Error(
+    `biological-architecture/${rule} is scoped to "${name}", which is not a tier, so that scope can never match a file. The tiers are ${TIERS.join(", ")}.`
+  );
+});
+
 // src/rules/no-raw-html-atoms.ts
+var RULE2 = "no-raw-html-atoms";
+var WHERE_RAW_HTML_IS_THE_POINT = "atoms";
 var noRawHtmlAtoms = {
   create(context) {
-    const restrictions = requireOption(
-      "no-raw-html-atoms",
-      context.options[0],
-      "element\u2192atom map"
-    );
+    const restrictions = requireOption(RULE2, context.options[0], "element\u2192atom map");
+    const scope = context.options[1]?.scope;
+    const filename = context.filename;
+    const inScope = scope === void 0 ? !inTier(filename, WHERE_RAW_HTML_IS_THE_POINT) : requireTiers(RULE2, scope).some((tier) => inTier(filename, tier));
+    if (!inScope) return {};
     const elementMap = /* @__PURE__ */ new Map();
     for (const r of restrictions) {
       elementMap.set(r.element, r);
@@ -2144,15 +2238,17 @@ var noRawHtmlAtoms = {
     };
   },
   fixShape: `A native element that already has an atom wrapper (\`<button>\`, \`<input>\`, \`<td>\`, \`<header>\`, \u2026) is
-written as the atom in levels 2-6. Import the atom named in the rule's options and use it. Configure the element\u2192atom map per repo;
-enabled without one the rule refuses the run, because a rule with no map to check reads exactly like
-a tree with no raw elements in it.`,
+written as the atom everywhere above the atom tier. Import the atom named in the rule's options and use it.
+Inside \`atoms/\` the raw element is the point of the file, so the rule says nothing there; every other
+file is in scope, tier folder or not, and \`scope\` narrows it to named tiers when a repo wants that.
+Configure the element\u2192atom map per repo; enabled without one the rule refuses the run, because a rule
+with no map to check reads exactly like a tree with no raw elements in it.`,
   meta: {
     docs: {
-      description: "Forbid raw native HTML elements when an atom wrapper exists. Use the atom the options name instead."
+      description: "Forbid raw native HTML elements when an atom wrapper exists. Use the atom the options name instead. Silent inside the atom tier, where the raw element is the point; `scope` narrows it to named tiers."
     },
     messages: {
-      forbidden: 'Use <{{atom}}> from "{{importPath}}" instead of raw <{{element}}>. Native HTML elements that have an atom wrapper must not be used directly in molecules/compounds/cells/tissues - use the atom to preserve consistent styling and behavior.'
+      forbidden: 'Use <{{atom}}> from "{{importPath}}" instead of raw <{{element}}>. Native HTML elements that have an atom wrapper must not be used directly above the atom tier - use the atom to preserve consistent styling and behavior.'
     },
     schema: [
       {
@@ -2166,6 +2262,13 @@ a tree with no raw elements in it.`,
           type: "object"
         },
         type: "array"
+      },
+      {
+        additionalProperties: false,
+        properties: {
+          scope: { items: { enum: [...TIERS], type: "string" }, type: "array" }
+        },
+        type: "object"
       }
     ],
     type: "problem"
@@ -3132,14 +3235,14 @@ can be misspelled and a second default nobody agreed to.`,
 var ssot_no_process_env_default = ssotNoProcessEnv;
 
 // src/rules/step-opens-its-own-cell.ts
-var RULE = "step-opens-its-own-cell";
+var RULE3 = "step-opens-its-own-cell";
 var STEP = "step";
 var readable = (pattern) => pattern.replaceAll("\\", "").replace(/\$$/, "");
 var stepOpensItsOwnCell = {
   create(context) {
     const { wrapper } = context.options?.[0] ?? {};
-    const engine = requireOption(RULE, context.options?.[0]?.engine, "engine");
-    const within = requireOption(RULE, context.options?.[0]?.within, "within");
+    const engine = requireOption(RULE3, context.options?.[0]?.engine, "engine");
+    const within = requireOption(RULE3, context.options?.[0]?.within, "within");
     const filename = context.filename.replaceAll("\\", "/");
     if (!new RegExp(within).test(filename)) return {};
     if (wrapper !== void 0 && new RegExp(wrapper).test(filename)) return {};
@@ -4002,6 +4105,7 @@ var rules = {
   "document-sagas-are-generic": document_sagas_are_generic_default,
   "documents-share-one-table": documents_share_one_table_default,
   "effect-hook-naming": effect_hook_naming_default,
+  "emit-declares-attempts": emit_declares_attempts_default,
   "layer-walls": layer_walls_default,
   "max-comment-density": max_comment_density_default,
   "molecule-atoms-only": molecule_atoms_only_default,

package/dist/presets.js

@@ -1,7 +1,7 @@
 import {
   PRESETS,
   rulesOfPreset
-} from "./chunk-HXBZSOIU.js";
+} from "./chunk-55NK7NJN.js";
 export {
   PRESETS,
   rulesOfPreset

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geonosis/oxlint-plugin-biological-architecture",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Biological tier architecture as lint — the union of the dielime and during.day rule sets, shipped as presets.",
   "keywords": [
     "oxlint",
@@ -33,7 +33,7 @@
     "oxlint": ">=1.77"
   },
   "devDependencies": {
-    "@geonosis/lint-parity": "0.2.0"
+    "@geonosis/lint-parity": "0.3.0"
   },
   "engines": {
     "node": ">=22"