tackbox 0.1.0

package/js/rules/no-broad-notify.js

@@ -0,0 +1,47 @@
+const { hasMarkerAbove, walk, isTier1Notify, argFlows, isTestFile } = require('./_shared')
+
+// guarded: `call` sits under an additional condition strictly inside the catch
+// body - an if-branch (consequent/alternate) or a switch case. A notify
+// reachable without crossing such a construct is the unconditional sole
+// handling of the whole catch.
+function guarded(call, catchBody) {
+  for (let cur = call; cur && cur !== catchBody; cur = cur.parent) {
+    const p = cur.parent
+    if (!p) return false
+    if (p.type === 'IfStatement' && (cur === p.consequent || cur === p.alternate)) return true
+    if (p.type === 'SwitchCase') return true
+  }
+  return false
+}
+
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        'a notify terminating a catch must sit under an additional condition (if/switch), not handle the whole catch unconditionally - an unconditional notify routes every error to a toast and blinds telemetry (D006)',
+    },
+    messages: {
+      broad:
+        'notify handles this catch unconditionally, routing every error to the user lane and blinding telemetry: put it under a condition and report the complement with reportError/reportWarn, or capture instead; a new // no-report: marker needs user approval',
+    },
+    schema: [],
+  },
+  create(context) {
+    if (isTestFile(context)) return {}
+    return {
+      CatchClause(node) {
+        const errName = node.param && node.param.type === 'Identifier' ? node.param.name : null
+        if (errName == null) return
+        const body = node.body
+        if (!body || body.type !== 'BlockStatement') return
+        if (hasMarkerAbove(context, node.parent, 'no-report')) return
+        walk(body, call => {
+          if (call.type !== 'CallExpression') return
+          if (!isTier1Notify(context, call) || !argFlows(call, errName)) return
+          if (!guarded(call, body)) context.report({ node: call, messageId: 'broad' })
+        })
+      },
+    }
+  },
+}

package/js/rules/no-console-error.js

@@ -0,0 +1,23 @@
+const { isInDeclaredReporterBody } = require('./_shared')
+
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: { description: 'ban console.error in favor of reportError' },
+    messages: { use: 'console.error is banned; use reportError/reportSynth instead' },
+    schema: [],
+  },
+  create(context) {
+    return {
+      CallExpression(node) {
+        const c = node.callee
+        if (!c || c.type !== 'MemberExpression') return
+        if (c.object && c.object.type === 'Identifier' && c.object.name === 'console' &&
+            c.property && c.property.type === 'Identifier' && c.property.name === 'error') {
+          if (isInDeclaredReporterBody(context, node)) return
+          context.report({ node, messageId: 'use' })
+        }
+      },
+    }
+  },
+}

package/js/rules/no-focused-test.js

@@ -0,0 +1,22 @@
+const { matchesTestModifier } = require('./_shared')
+
+const BARE = new Set(['fit', 'fdescribe', 'ftest'])
+
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: { description: 'focused tests disable the rest of the suite; no escape hatch, remove them' },
+    messages: {
+      focused: 'focused test disables the rest of the suite: remove the `.only` / `f`-prefix so every test runs',
+    },
+    schema: [],
+  },
+  create(context) {
+    return {
+      CallExpression(node) {
+        if (!matchesTestModifier(node.callee, BARE, n => n === 'only')) return
+        context.report({ node, messageId: 'focused' })
+      },
+    }
+  },
+}

package/js/rules/no-parse-fallback.js

@@ -0,0 +1,150 @@
+const {
+  hasMarkerAbove,
+  enclosingFn,
+  fnReturnsResultLike,
+  errObjectFlows,
+  objectCarriesErr,
+  walk,
+} = require('./_shared')
+
+// isJsonParseCall: syntactic `JSON.parse(...)`. v1 scope is JSON.parse only -
+// syntactically unambiguous, so no name-trust is needed (plan F7c).
+function isJsonParseCall(n) {
+  const c = n.callee
+  return (
+    !!c &&
+    c.type === 'MemberExpression' &&
+    !c.computed &&
+    c.object.type === 'Identifier' &&
+    c.object.name === 'JSON' &&
+    c.property.type === 'Identifier' &&
+    c.property.name === 'parse'
+  )
+}
+
+// tryBlockParses: the try block directly contains a JSON.parse call. walk stops
+// at nested function boundaries, so a JSON.parse inside a callback (setTimeout,
+// .map) - which this try does not guard in the same tick - does not trigger.
+function tryBlockParses(block) {
+  let found = false
+  walk(block, n => {
+    if (n.type === 'CallExpression' && isJsonParseCall(n)) found = true
+  })
+  return found
+}
+
+// boundaryPropagates: `{ ok: false, cause|message: <err object> }` - a Result
+// boundary that carries the caught error as a live object. Stricter than
+// _shared.isBoundaryValue: F7c breaks on stringification (message: err.message),
+// so the value predicate is object-flow, not a bare ref.
+function boundaryPropagates(expr, errName) {
+  return objectCarriesErr(expr, errName, errObjectFlows)
+}
+
+// localCarrierRHS: the RHS of the last local assignment to `name` among stmts
+// (a `const/let name = rhs` declarator or a `name = rhs` assignment). Resolves a
+// two-step wrap (`const w = new Error(..., { cause: e }); throw w`), which F5
+// credits by checking the branch-local assignment.
+function localCarrierRHS(stmts, name) {
+  let rhs = null
+  for (const st of stmts) {
+    if (st.type === 'VariableDeclaration') {
+      for (const d of st.declarations) {
+        if (d.id.type === 'Identifier' && d.id.name === name && d.init) rhs = d.init
+      }
+    } else if (
+      st.type === 'ExpressionStatement' &&
+      st.expression.type === 'AssignmentExpression' &&
+      st.expression.operator === '=' &&
+      st.expression.left.type === 'Identifier' &&
+      st.expression.left.name === name
+    ) {
+      rhs = st.expression.right
+    }
+  }
+  return rhs
+}
+
+// containsExit: a return or throw anywhere in stmt (not descending into nested
+// functions). Used to fail closed on opaque constructs (switch/loop/try) whose
+// paths the analysis does not model.
+function containsExit(stmt) {
+  let found = false
+  walk(stmt, n => {
+    if (n.type === 'ReturnStatement' || n.type === 'ThrowStatement') found = true
+  })
+  return found
+}
+
+// catchPropagates: every path out of the catch must terminate by re-throwing
+// the caught error object or returning a Result boundary that carries it. A
+// fallback value, a throw that drops or stringifies the error, or a
+// report-and-continue is a swallow - no reporter credit (report+default =
+// finding) and no fall-through credit. Mirror of Go ERC002 restricted to
+// object-flow exits. States: 'ok' (path terminated chain-preservingly), 'bad'
+// (a path swallows), 'fall' (control falls past to the next statement).
+function catchPropagates(body, errName, allowBoundary) {
+  const topStmts = body.type === 'BlockStatement' ? body.body : []
+  // carrier resolves a bare local identifier to its assigned RHS (two-step
+  // wrap); other expressions pass through unchanged.
+  function carrier(expr) {
+    if (expr && expr.type === 'Identifier' && expr.name !== errName) {
+      const rhs = localCarrierRHS(topStmts, expr.name)
+      if (rhs) return rhs
+    }
+    return expr
+  }
+  function analyze(stmt) {
+    if (!stmt) return 'fall'
+    switch (stmt.type) {
+      case 'ThrowStatement':
+        return errObjectFlows(carrier(stmt.argument), errName) ? 'ok' : 'bad'
+      case 'ReturnStatement':
+        return allowBoundary && boundaryPropagates(carrier(stmt.argument), errName) ? 'ok' : 'bad'
+      case 'BlockStatement':
+        return analyzeList(stmt.body)
+      case 'IfStatement': {
+        const c = analyze(stmt.consequent)
+        if (c === 'bad') return 'bad'
+        const a = stmt.alternate ? analyze(stmt.alternate) : 'fall'
+        if (a === 'bad') return 'bad'
+        return c === 'ok' && a === 'ok' ? 'ok' : 'fall'
+      }
+      default:
+        return containsExit(stmt) ? 'bad' : 'fall'
+    }
+  }
+  function analyzeList(stmts) {
+    for (const stmt of stmts) {
+      const r = analyze(stmt)
+      if (r !== 'fall') return r
+    }
+    return 'fall'
+  }
+  return analyze(body) === 'ok'
+}
+
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: { description: 'a try containing JSON.parse must propagate the parse error on every catch path (throw the caught object, or a Result boundary carrying it). A fallback value, a stringified rethrow, or report-and-continue swallows it. Escape with a // parse-skip: marker.' },
+    messages: {
+      fallback: 'propagate the parse error: throw it or return a Result boundary carrying it',
+    },
+    schema: [],
+  },
+  create(context) {
+    return {
+      TryStatement(node) {
+        if (!tryBlockParses(node.block)) return
+        const handler = node.handler
+        if (!handler || !handler.body || handler.body.type !== 'BlockStatement') return
+        if (hasMarkerAbove(context, node, 'parse-skip')) return
+        const errName = handler.param && handler.param.type === 'Identifier' ? handler.param.name : null
+        const allowBoundary = fnReturnsResultLike(enclosingFn(node))
+        if (catchPropagates(handler.body, errName, allowBoundary)) return
+        context.report({ node: handler, messageId: 'fallback' })
+      },
+    }
+  },
+}

package/js/rules/no-skipped-test.js

@@ -0,0 +1,95 @@
+const { hasMarkerAbove, matchesTestModifier, isStaticString, staticStringValue, TEST_ROOTS } = require('./_shared')
+
+const SKIP_PROPS = new Set(['skip', 'todo', 'skipIf', 'fixme'])
+const BARE = new Set(['xit', 'xdescribe', 'xtest'])
+// Playwright's conditional forms carry (cond, 'reason'); skipIf/todo do not
+// take a reason argument in any framework, so they stay marker-only.
+const COND_REASON_PROPS = new Set(['skip', 'fixme'])
+
+// outermostCall climbs to the whole `it.skipIf(cond)('n', fn)` statement so the
+// marker sits above it; the skip property lives on the inner call, so reporting
+// there and anchoring the marker higher keeps chained forms to one finding.
+function outermostCall(node) {
+  let cur = node
+  while (cur.parent && cur.parent.type === 'CallExpression' && cur.parent.callee === cur) {
+    cur = cur.parent
+  }
+  return cur
+}
+
+function directProp(callee) {
+  if (callee.type === 'MemberExpression' && !callee.computed && callee.property.type === 'Identifier') {
+    return callee.property.name
+  }
+  return ''
+}
+
+function isFunctionExpr(n) {
+  return !!n && (n.type === 'FunctionExpression' || n.type === 'ArrowFunctionExpression')
+}
+
+// hasInCallReason: playwright `test.skip(cond, 'reason')` / `test.fixme(cond,
+// 'reason')` - at least two args with a non-empty string reason last. A
+// syntactic function there is the declaration form `(title, fn)` and earns
+// nothing; a non-literal reason expression is trusted (mirrors ERC008).
+function hasInCallReason(node) {
+  if (!COND_REASON_PROPS.has(directProp(node.callee))) return false
+  if (node.arguments.length < 2) return false
+  const last = node.arguments[node.arguments.length - 1]
+  if (isFunctionExpr(last)) return false
+  if (isStaticString(last)) return staticStringValue(last).trim().length > 0
+  return true
+}
+
+// skipValueVerdict classifies a node:test options `skip`/`todo` value:
+// 'pass' (non-empty string reason, or trusted non-literal), 'flag'
+// (reasonless: true, empty/whitespace string), null (falsy literal - the
+// test is not skipped at all).
+function skipValueVerdict(v) {
+  if (isStaticString(v)) return staticStringValue(v).trim().length > 0 ? 'pass' : 'flag'
+  if (v.type === 'Literal') return v.value ? 'flag' : null
+  return 'pass'
+}
+
+// optionsSkipVerdict scans the node:test options position (`test([name][,
+// options][, fn])` - first or second argument) for a skip/todo property.
+function optionsSkipVerdict(node) {
+  for (const arg of node.arguments.slice(0, 2)) {
+    if (!arg || arg.type !== 'ObjectExpression') continue
+    for (const p of arg.properties) {
+      if (p.type !== 'Property' || p.computed) continue
+      const key = p.key.type === 'Identifier' ? p.key.name : p.key.type === 'Literal' ? String(p.key.value) : ''
+      if (key !== 'skip' && key !== 'todo') continue
+      return skipValueVerdict(p.value)
+    }
+  }
+  return null
+}
+
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: { description: 'skipped tests silently drop coverage; unskip, state a framework-native reason in the call (node:test options skip/todo, playwright test.skip(cond, reason)), or justify with a // test-skip: <reason> marker above the statement' },
+    messages: {
+      skipped: 'skipped test silently drops coverage: unskip it or state a non-empty reason',
+    },
+    schema: [],
+  },
+  create(context) {
+    return {
+      CallExpression(node) {
+        if (matchesTestModifier(node.callee, BARE, n => SKIP_PROPS.has(n))) {
+          if (hasInCallReason(node)) return
+          if (hasMarkerAbove(context, outermostCall(node), 'test-skip')) return
+          context.report({ node, messageId: 'skipped' })
+          return
+        }
+        if (node.callee.type === 'Identifier' && TEST_ROOTS.has(node.callee.name)) {
+          if (optionsSkipVerdict(node) !== 'flag') return
+          if (hasMarkerAbove(context, outermostCall(node), 'test-skip')) return
+          context.report({ node, messageId: 'skipped' })
+        }
+      },
+    }
+  },
+}

package/js/rules/no-swallow-allsettled.js

@@ -0,0 +1,52 @@
+const { hasMarkerAbove, enclosingFn, someNode } = require('./_shared')
+
+// isAllSettledCall: syntactic `Promise.allSettled(...)`. Matched by shape, not
+// resolution - Promise is a global and allSettled is unambiguous.
+function isAllSettledCall(node) {
+  const c = node.callee
+  return (
+    !!c &&
+    c.type === 'MemberExpression' &&
+    !c.computed &&
+    c.object.type === 'Identifier' &&
+    c.object.name === 'Promise' &&
+    c.property.type === 'Identifier' &&
+    c.property.name === 'allSettled'
+  )
+}
+
+// refsReason: root's subtree contains a `.reason` access (dot or computed
+// string). Descends into nested functions - `.reason` is usually read inside a
+// .forEach / .filter callback over the settled results, so the scan must not
+// stop at function boundaries the way _shared.walk does.
+function refsReason(root) {
+  return someNode(
+    root,
+    n =>
+      n.type === 'MemberExpression' &&
+      ((!n.computed && n.property.type === 'Identifier' && n.property.name === 'reason') ||
+        (n.computed && n.property.type === 'Literal' && n.property.value === 'reason')),
+  )
+}
+
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: { description: 'every Promise.allSettled call needs at least one `.reason` access in the enclosing function, else rejected outcomes are silently dropped - allSettled never rejects, so a discarded result is the quietest swallow. Escape with a // no-report: marker.' },
+    messages: {
+      swallow: 'read `.reason` on the rejected entries in the enclosing function',
+    },
+    schema: [],
+  },
+  create(context) {
+    const sc = context.sourceCode || context.getSourceCode()
+    return {
+      CallExpression(node) {
+        if (!isAllSettledCall(node)) return
+        if (hasMarkerAbove(context, node, 'no-report')) return
+        if (refsReason(enclosingFn(node) || sc.ast)) return
+        context.report({ node, messageId: 'swallow' })
+      },
+    }
+  },
+}

package/js/rules/no-swallow-catch.js

@@ -0,0 +1,31 @@
+const {
+  hasMarkerAbove,
+  enclosingFn,
+  fnReturnsResultLike,
+  makeHandledAnalysis,
+} = require('./_shared')
+
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: { description: 'every path out of a catch must throw, call a reporter, convert to a Result boundary (return { ok: false, cause: err } when the function returns Result/Attempt), or the try must carry a // no-report: marker. Boundary conversion is kin to the policy layer (specs/general/error-policies.md).' },
+    messages: {
+      swallow: 'every catch path must throw, call a reporter, or convert to a Result boundary',
+    },
+    schema: [],
+  },
+  create(context) {
+    return {
+      CatchClause(node) {
+        const body = node.body
+        if (!body || body.type !== 'BlockStatement') return
+        const tryStmt = node.parent
+        if (tryStmt && hasMarkerAbove(context, tryStmt, 'no-report')) return
+        const errName = node.param && node.param.type === 'Identifier' ? node.param.name : null
+        const allowBoundary = fnReturnsResultLike(enclosingFn(node))
+        if (makeHandledAnalysis({ context, errName, allowBoundary }).handled(body)) return
+        context.report({ node, messageId: 'swallow' })
+      },
+    }
+  },
+}

package/js/rules/no-swallow-promise-catch.js

@@ -0,0 +1,38 @@
+const { hasMarkerAbove, makeHandledAnalysis } = require('./_shared')
+
+// rejectionHandler returns the rejection-handler argument of a promise
+// method: `.catch(onErr)` -> arg 0, `.then(onOk, onErr)` -> arg 1. A single-arg
+// `.then(onOk)` propagates the rejection naturally, so there is nothing to
+// check (null). Only `.catch` and `.then` are recognized.
+function rejectionHandler(node) {
+  const callee = node.callee
+  if (!callee || callee.type !== 'MemberExpression') return null
+  if (!callee.property || callee.property.type !== 'Identifier') return null
+  if (callee.property.name === 'catch') return node.arguments[0] || null
+  if (callee.property.name === 'then') return node.arguments.length >= 2 ? node.arguments[1] : null
+  return null
+}
+
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: { description: 'every path out of a promise rejection handler (.catch(onErr) or the second arg of .then(onOk, onErr)) must throw or call a reporter, or carry a // no-report: marker. Result-boundary conversion is not accepted in promise handlers.' },
+    messages: {
+      swallow: 'every rejection-handler path must throw or call a reporter',
+    },
+    schema: [],
+  },
+  create(context) {
+    return {
+      CallExpression(node) {
+        const handler = rejectionHandler(node)
+        if (!handler) return
+        if (handler.type !== 'ArrowFunctionExpression' && handler.type !== 'FunctionExpression') return
+        if (hasMarkerAbove(context, node, 'no-report')) return
+        const errName = handler.params[0] && handler.params[0].type === 'Identifier' ? handler.params[0].name : null
+        if (makeHandledAnalysis({ context, errName, allowBoundary: false, returnIdentity: true }).handled(handler.body)) return
+        context.report({ node, messageId: 'swallow' })
+      },
+    }
+  },
+}

package/js/rules/no-throw-and-report.js

@@ -0,0 +1,30 @@
+const { blockHasThrow, blockHasReport, notifyCaptureConflict, isTestFile } = require('./_shared')
+
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: { description: 'catch block must not both throw and call a reporter; nor both capture and notify on one path (D006 double-lane)' },
+    messages: {
+      both: 'catch block both throws and calls a reporter: pick one - upstream handler would re-capture',
+      doubleLane: 'catch path both captures and notifies: error/warn already reach the user lane, so the notify double-shows - drop the notify, or use only notify with no capture',
+    },
+    schema: [],
+  },
+  create(context) {
+    return {
+      CatchClause(node) {
+        const body = node.body
+        if (!body || body.type !== 'BlockStatement') return
+        const errName = node.param && node.param.type === 'Identifier' ? node.param.name : null
+        if (blockHasThrow(body) && blockHasReport(context, body, errName)) {
+          context.report({ node, messageId: 'both' })
+        }
+        // The double-lane arm is a new D006 rule and skips tests (parity with
+        // Go/Java); the `both` arm is pre-existing and keeps running in tests.
+        if (!isTestFile(context) && notifyCaptureConflict(context, body, errName)) {
+          context.report({ node, messageId: 'doubleLane' })
+        }
+      },
+    }
+  },
+}

package/js/rules/ts-exit-in-catch.js

@@ -0,0 +1,26 @@
+const { walk } = require('./_shared')
+
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: { description: 'process.exit(...) inside catch masks the exception' },
+    messages: {
+      exit: 'process.exit(...) inside catch masks the exception: let it propagate',
+    },
+    schema: [],
+  },
+  create(context) {
+    return {
+      CatchClause(node) {
+        walk(node.body, n => {
+          if (n.type !== 'CallExpression') return
+          const callee = n.callee
+          if (!callee || callee.type !== 'MemberExpression') return
+          if (!callee.object || callee.object.type !== 'Identifier' || callee.object.name !== 'process') return
+          if (!callee.property || callee.property.type !== 'Identifier' || callee.property.name !== 'exit') return
+          context.report({ node: n, messageId: 'exit' })
+        })
+      },
+    }
+  },
+}

package/js/rules/ts-rethrow-without-cause.js

@@ -0,0 +1,62 @@
+const { walk } = require('./_shared')
+
+// new AggregateError([...errors], msg) preserves the caught error in its
+// errors array, so it does not also need { cause }.
+function aggregateHoldsError(newExpr, errName) {
+  const callee = newExpr.callee
+  if (!callee || callee.type !== 'Identifier' || callee.name !== 'AggregateError') return false
+  const first = newExpr.arguments[0]
+  if (!first || first.type !== 'ArrayExpression') return false
+  return first.elements.some(el => {
+    if (!el) return false
+    if (el.type === 'Identifier') return el.name === errName
+    if (el.type === 'SpreadElement' && el.argument.type === 'Identifier') return el.argument.name === errName
+    return false
+  })
+}
+
+function optionsHasCause(newExpr, errName) {
+  for (const arg of newExpr.arguments) {
+    if (arg.type !== 'ObjectExpression') continue
+    for (const prop of arg.properties) {
+      if (prop.type !== 'Property' || prop.computed) continue
+      const key =
+        prop.key.type === 'Identifier'
+          ? prop.key.name
+          : prop.key.type === 'Literal'
+            ? prop.key.value
+            : null
+      if (key !== 'cause') continue
+      if (prop.value.type === 'Identifier' && prop.value.name === errName) return true
+    }
+  }
+  return false
+}
+
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: { description: 'throwing a new error in catch without { cause: <caught> } discards the original stack' },
+    messages: {
+      noCause: 'throw new Error in catch must pass { cause: <caught error> } to preserve the stack chain',
+    },
+    schema: [],
+  },
+  create(context) {
+    return {
+      CatchClause(node) {
+        const param = node.param
+        if (!param || param.type !== 'Identifier') return
+        const errName = param.name
+        walk(node.body, n => {
+          if (n.type !== 'ThrowStatement') return
+          const arg = n.argument
+          if (!arg || arg.type !== 'NewExpression') return
+          if (optionsHasCause(arg, errName)) return
+          if (aggregateHoldsError(arg, errName)) return
+          context.report({ node: n, messageId: 'noCause' })
+        })
+      },
+    }
+  },
+}

package/js/rules/ts-useless-catch.js

@@ -0,0 +1,25 @@
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: { description: 'catch that only re-throws the caught error is a no-op wrapper' },
+    messages: {
+      useless: 'catch only re-throws the caught error: remove the try/catch and let it propagate',
+    },
+    schema: [],
+  },
+  create(context) {
+    return {
+      CatchClause(node) {
+        const param = node.param
+        if (!param || param.type !== 'Identifier') return
+        const body = node.body && node.body.body
+        if (!body || body.length !== 1) return
+        const stmt = body[0]
+        if (stmt.type !== 'ThrowStatement') return
+        if (!stmt.argument || stmt.argument.type !== 'Identifier') return
+        if (stmt.argument.name !== param.name) return
+        context.report({ node, messageId: 'useless' })
+      },
+    }
+  },
+}

package/js/rules/valid-dedup-key.js

@@ -0,0 +1,50 @@
+const {
+  REPORTER_FULL, REPORTER_SYNTH,
+  tier1ReporterName, isTier1Notify, isStaticString, staticStringValue, DEDUP_KEY_RE, isTestFile,
+} = require('./_shared')
+
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: { description: 'dedupKey must be a static literal in `area.suffix[:identifier]` form' },
+    messages: {
+      notLiteral: '{{name}}: dedupKey must be a static string literal so the fingerprint is stable',
+      badFormat: '{{name}}: dedupKey must follow `area.suffix[:identifier]` format (got "{{value}}")',
+    },
+    schema: [],
+  },
+  create(context) {
+    if (isTestFile(context)) return {}
+    return {
+      CallExpression(node) {
+        let name = tier1ReporterName(context, node)
+
+        let keyIdx = -1
+        if (name) {
+          if (REPORTER_FULL.has(name)) keyIdx = 3
+          else if (REPORTER_SYNTH.has(name)) keyIdx = 2
+          else return
+        } else if (isTier1Notify(context, node)) {
+          // notify carries the full (msg, cause, tags, dedupKey) shape - its
+          // dedupKey is the same fingerprint/coalescing key (D008).
+          name = 'notify'
+          keyIdx = 3
+        } else {
+          return
+        }
+
+        const key = node.arguments[keyIdx]
+        if (!key) return // missing key is reported by valid-error-report
+
+        if (!isStaticString(key)) {
+          context.report({ node: key, messageId: 'notLiteral', data: { name } })
+          return
+        }
+        const v = staticStringValue(key)
+        if (!DEDUP_KEY_RE.test(v)) {
+          context.report({ node: key, messageId: 'badFormat', data: { name, value: v } })
+        }
+      },
+    }
+  },
+}