@jskit-ai/config-eslint 0.1.241 → 0.1.243

package/plugin/packageSources.js

@@ -0,0 +1,133 @@
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import path from "node:path";
+
+// The source files of one package, for the rules that compare a file with its
+// package: the nearest directory with a package.json, or a pattern's example
+// directory (an `example` directory beside a PATTERN.md), which is an
+// application of its own.
+
+// Directories that hold no package source: dependencies, builds, tests, client
+// code, scaffolding templates, and pattern examples with their generated copies.
+const SKIPPED_DIRECTORIES = new Set([
+  "node_modules", ".git", "dist", "coverage", "test", "tests", "client", "components", "pages", "templates", "patterns"
+]);
+const SOURCE_FILE = /\.m?js$/u;
+const TEST_FILE = /\.test\./u;
+// Client code: modules and Vue components, in every directory of the package but its dependencies, builds, tests,
+// scaffolding templates and pattern examples.
+const CLIENT_SKIPPED_DIRECTORIES = new Set([
+  "node_modules", ".git", ".jskit", ".vite", "dist", "coverage", "test", "tests", "test-results", "templates", "patterns"
+]);
+const CLIENT_SOURCE_FILE = /\.(m?js|vue)$/u;
+// The agent skill bundle's generated copies of package-owned patterns; their
+// sources are checked.
+const GENERATED_MIRROR = /(^|\/)skills\/jskit\/references\/patterns(\/|$)/u;
+
+function toPosixPath(file) {
+  return file.split(path.sep).join("/");
+}
+
+function isGeneratedMirror(file) {
+  return GENERATED_MIRROR.test(toPosixPath(file));
+}
+
+function isPackageDirectory(directory) {
+  return existsSync(path.join(directory, "package.json")) ||
+    (path.basename(directory) === "example" && existsSync(path.join(path.dirname(directory), "PATTERN.md")));
+}
+
+function packageRootOf(file) {
+  const start = path.dirname(file);
+  for (let directory = start; ; directory = path.dirname(directory)) {
+    if (isPackageDirectory(directory)) {
+      return directory;
+    }
+    if (directory === path.dirname(directory)) {
+      return start;
+    }
+  }
+}
+
+// The source files under a directory of a package, without entering another
+// package.
+function packageSourceFiles(directory, files = []) {
+  let entries;
+  try {
+    entries = readdirSync(directory, { withFileTypes: true });
+  } catch {
+    return files;
+  }
+  for (const entry of entries) {
+    const next = path.join(directory, entry.name);
+    if (entry.isDirectory()) {
+      if (!SKIPPED_DIRECTORIES.has(entry.name) && !isPackageDirectory(next)) {
+        packageSourceFiles(next, files);
+      }
+    } else if (entry.isFile() && SOURCE_FILE.test(entry.name) && !TEST_FILE.test(entry.name)) {
+      files.push(next);
+    }
+  }
+  return files;
+}
+
+// Every source file of a package, client modules and Vue components included, without entering another package: what a
+// client file is compared with, since a client helper may repeat a server or shared one.
+function clientSourceFiles(directory, files = []) {
+  let entries;
+  try {
+    entries = readdirSync(directory, { withFileTypes: true });
+  } catch {
+    return files;
+  }
+  for (const entry of entries) {
+    const next = path.join(directory, entry.name);
+    if (entry.isDirectory()) {
+      if (!CLIENT_SKIPPED_DIRECTORIES.has(entry.name) && !isPackageDirectory(next)) {
+        clientSourceFiles(next, files);
+      }
+    } else if (entry.isFile() && CLIENT_SOURCE_FILE.test(entry.name) && !TEST_FILE.test(entry.name)) {
+      files.push(next);
+    }
+  }
+  return files;
+}
+
+// Whether a file of a package is server or shared code, which typedFeaturesConfig reads, as opposed to client code.
+function isServerOrSharedFile(file, packageDirectory) {
+  return /(^|\/)(server|shared)\//u.test(toPosixPath(path.relative(packageDirectory, file)));
+}
+
+/**
+ * What a rule reads from each other file of a lint run, by path, read again
+ * when the file changes. A file that does not read or parse gives `unreadable`;
+ * its own lint run reports it.
+ * @template T
+ * @param {(text: string, file: string, context: import("eslint").Rule.RuleContext) => T} read
+ * @param {T} unreadable
+ * @returns {(file: string, context: import("eslint").Rule.RuleContext) => T}
+ */
+function createSourceMemo(read, unreadable) {
+  const byFile = new Map();
+  return function readSource(file, context) {
+    let stats;
+    try {
+      stats = statSync(file);
+    } catch {
+      return unreadable;
+    }
+    const cached = byFile.get(file);
+    if (cached && cached.mtimeMs === stats.mtimeMs && cached.size === stats.size) {
+      return cached.value;
+    }
+    let value;
+    try {
+      value = read(readFileSync(file, "utf8"), file, context);
+    } catch {
+      value = unreadable;
+    }
+    byFile.set(file, { mtimeMs: stats.mtimeMs, size: stats.size, value });
+    return value;
+  };
+}
+
+export { clientSourceFiles, createSourceMemo, isGeneratedMirror, isServerOrSharedFile, packageRootOf, packageSourceFiles, toPosixPath };

package/plugin/rules/actionCreator.js

@@ -0,0 +1,55 @@
+import { createReporter, functionName, isWrittenActionDefinition, keyName, ruleMeta } from "../support.js";
+
+const ACTIONS_CREATOR = /^create[A-Z]\w*Actions$/u;
+const FUNCTION_TYPES = new Set(["FunctionDeclaration", "FunctionExpression", "ArrowFunctionExpression"]);
+// The members of a CRUD custom action's one argument; its definitions belong to the CRUD declaration.
+const CRUD_ACTION_MEMBERS = new Set(["input", "service", "repository"]);
+
+function isCrudCustomAction(definition) {
+  const execute = definition.properties.find((property) => keyName(property) === "execute");
+  const first = execute?.value?.params?.[0];
+  return first?.type === "ObjectPattern" && first.properties.some((property) => CRUD_ACTION_MEMBERS.has(keyName(property)));
+}
+
+// A feature's actions come from one create<Name>Actions({ … }) that receives the capabilities they call, destructured,
+// and returns each definition as a literal: a reader finds every action, and the service it reaches, in one place.
+const actionCreator = Object.freeze({
+  meta: ruleMeta("Require action definitions to be written inside a create<Name>Actions({ … }) creator.", {
+    outsideCreator: "Action {{action}} is defined outside a create<Name>Actions creator. Write it as a literal inside create<Name>Actions({ <capability> }).",
+    positionalCreator: "{{name}} receives its capabilities positionally. Destructure them: {{name}}({ <capability> })."
+  }, "action-creators"),
+  create(context) {
+    const sourceCode = context.sourceCode;
+    const report = createReporter(context, "action-creator");
+    function checkCreator(fn) {
+      const name = functionName(fn);
+      const first = fn.params[0];
+      if (!ACTIONS_CREATOR.test(name) || !first) {
+        return;
+      }
+      const parameter = first.type === "AssignmentPattern" ? first.left : first;
+      if (parameter.type !== "ObjectPattern") {
+        report(first, "positional-creator", "positionalCreator", { name });
+      }
+    }
+    return {
+      FunctionDeclaration: checkCreator,
+      FunctionExpression: checkCreator,
+      ArrowFunctionExpression: checkCreator,
+      ObjectExpression(node) {
+        if (!isWrittenActionDefinition(node) || isCrudCustomAction(node)) {
+          return;
+        }
+        const insideCreator = sourceCode.getAncestors(node).some((ancestor) => FUNCTION_TYPES.has(ancestor.type) &&
+          ACTIONS_CREATOR.test(functionName(ancestor)));
+        if (!insideCreator) {
+          const id = node.properties.find((property) => keyName(property) === "id");
+          const text = id.value.type === "Literal" ? `"${id.value.value}"` : sourceCode.getText(id.value);
+          report(node, "outside-creator", "outsideCreator", { action: text.length > 60 ? `${text.slice(0, 57)}...` : text });
+        }
+      }
+    };
+  }
+});
+
+export { actionCreator };

package/plugin/rules/actionExecuteShape.js

@@ -0,0 +1,75 @@
+import { createReporter, isActionExecute, keyName, ruleMeta } from "../support.js";
+
+// A callee a reader follows in one step: a name or a member chain, with no
+// call inside it.
+function isPlainCallee(node) {
+  if (node.type === "Identifier" || node.type === "ThisExpression") {
+    return true;
+  }
+  return node.type === "MemberExpression" && isPlainCallee(node.object);
+}
+
+function unwrapCall(node) {
+  const value = node.type === "AwaitExpression" ? node.argument : node;
+  return value.type === "ChainExpression" ? value.expression : value;
+}
+
+// The shape problem of an action's execute, or null for
+// `execute: (input, context) => service.method(…)`. Its parameters may
+// destructure what must not reach the service (`({ workspaceSlug, ...payload },
+// context)`), and a CRUD custom action destructures its declaration's
+// `({ input, context, service })`. Async and unfrozen definitions are
+// one-line-action's to report.
+function shapeProblem(value) {
+  // A catalogue that normalizes definitions hands each one's execute on as it is.
+  if (value.type === "MemberExpression" && !value.computed && value.property.name === "execute") {
+    return null;
+  }
+  if (value.type === "CallExpression") {
+    return "wrappedExecute";
+  }
+  if (value.type === "FunctionExpression" || (value.type === "ArrowFunctionExpression" && value.body.type === "BlockStatement")) {
+    return "blockBody";
+  }
+  if (value.type !== "ArrowFunctionExpression") {
+    return "notArrow";
+  }
+  const body = unwrapCall(value.body);
+  if (body.type !== "CallExpression" || !isPlainCallee(body.callee)) {
+    return "notOneCall";
+  }
+  return null;
+}
+
+// An action's execute is one expression-bodied arrow that makes one call, so
+// each action shows the one service method it reaches.
+const actionExecuteShape = Object.freeze({
+  meta: ruleMeta("Require an action's execute to be one arrow whose body is one call.", {
+    wrappedExecute: "The execute of action {{action}} is built by {{helper}}(). Write the arrow literally: execute: (input, context) => service.method(input, { context }).",
+    blockBody: "The execute of action {{action}} has a body. Move the work into the service and make execute one call: (input, context) => service.method(input, { context }).",
+    notArrow: "The execute of action {{action}} is not an arrow. Write execute: (input, context) => service.method(input, { context }).",
+    notOneCall: "The execute of action {{action}} does not make exactly one call. Return what one service method returns: (input, context) => service.method(input, { context })."
+  }, "one-line-execute"),
+  create(context) {
+    const sourceCode = context.sourceCode;
+    const report = createReporter(context, "action-execute-shape");
+    return {
+      Property(node) {
+        if (!isActionExecute(node, node.parent)) {
+          return;
+        }
+        const messageId = shapeProblem(node.value);
+        if (!messageId) {
+          return;
+        }
+        const id = node.parent.properties.find((property) => keyName(property) === "id");
+        const idText = id.value.type === "Literal" ? `"${id.value.value}"` : sourceCode.getText(id.value);
+        const action = idText.length > 60 ? `${idText.slice(0, 57)}...` : idText;
+        const helper = node.value.type === "CallExpression" ? sourceCode.getText(node.value.callee) : "";
+        report(node, "execute-shape", messageId, { action, helper });
+      }
+    };
+  }
+});
+
+export { actionExecuteShape };

package/plugin/rules/allowCommentForm.js

@@ -0,0 +1,145 @@
+import { ruleMeta } from "../support.js";
+
+const ALLOW_MARK = "readable-check: allow";
+const ALLOW_FORM = /readable-check: allow (\S+) - (.+?)\s*$/u;
+
+// A comment that describes the vocabulary itself names its rule as a
+// placeholder: "readable-check: allow <rule> - <reason>".
+const PLACEHOLDER = /readable-check: allow <[^>]+>/u;
+
+// The fixed reason prefixes, each followed by what is true of the code.
+const REASON_PREFIXES = Object.freeze([
+  /^input validation: \S/u,
+  /^data: \S/u,
+  /^platform object: \S/u,
+  /^optional operation: \S/u,
+  /^safety invariant: \S/u,
+  /^not a slot: \S/u,
+  /^cycle: \S.* requires \S/u,
+  /^deferred until boot: \S/u,
+  /^filled by \S.*; convert with its supplier/u,
+  /^cross-repository slot \S/u,
+  /^shared resource: \S/u
+]);
+// A guard once kept because a test asserted its error now says what goes wrong
+// without it, under safety invariant:.
+const RETIRED_PREFIX = /^test asserts error:/u;
+
+// A reason describes the code, never its tests or the state of a project.
+const CITES_TESTS = /\b(tests?|testing|test doubles?|mock(?:s|ed)?|stub(?:s|bed)?|fixtures?|spies|spy)\b|\.test\./iu;
+const PROJECT_WORK = "(?:converted|ported|migrated|typed|moved|split|removed|fixed)";
+const CITES_STATUS = new RegExp(`\\b(?:not (?:yet )?${PROJECT_WORK}|un(?:converted|ported|migrated)|stays? unchanged|left as is|for now|later pass|` +
+  `until (?:\\S+ ){1,3}(?:is|are) ${PROJECT_WORK}|pending (?:conversion|review|migration)|still pending|is pending|project status)\\b`, "iu");
+const MARKER = /\b(?:TODO|FIXME|XXX)\b/u;
+// data: excuses a field or value that is data, never a function. A parameter default is excused at its function,
+// so the default rules' data: reasons may stand on one.
+const DATA_PREFIX = /^data: /u;
+const PARAMETER_RULES = new Set(["dependency-default", "required-collaborators"]);
+const FUNCTION_TYPES = new Set(["FunctionDeclaration", "FunctionExpression", "ArrowFunctionExpression"]);
+
+/**
+ * Whether a node is a function, or declares or holds one: a function or arrow, an exported function, a variable
+ * initialised with one, or a property, class field or method whose value is one.
+ * @param {any} node
+ */
+function holdsFunction(node) {
+  if (FUNCTION_TYPES.has(node.type)) {
+    return true;
+  }
+  if (node.type === "ExportNamedDeclaration" || node.type === "ExportDefaultDeclaration") {
+    return Boolean(node.declaration) && holdsFunction(node.declaration);
+  }
+  if (node.type === "VariableDeclaration") {
+    return node.declarations.some((declarator) => declarator.init && FUNCTION_TYPES.has(declarator.init.type));
+  }
+  if (node.type === "Property" || node.type === "PropertyDefinition" || node.type === "MethodDefinition") {
+    return Boolean(node.value) && FUNCTION_TYPES.has(node.value.type);
+  }
+  return false;
+}
+
+/**
+ * The construct a comment on its own line excuses: the outermost node that starts at the next token. Null for a
+ * comment that trails code on its line or ends the file.
+ * @param {any} sourceCode
+ * @param {any} comment
+ */
+function excusedNode(sourceCode, comment) {
+  const before = sourceCode.getTokenBefore(comment, { includeComments: true });
+  if (before && before.loc.end.line === comment.loc.start.line) {
+    return null;
+  }
+  const next = sourceCode.getTokenAfter(comment, { includeComments: false });
+  if (!next) {
+    return null;
+  }
+  let node = sourceCode.getNodeByRangeIndex(next.range[0]);
+  while (node?.parent && node.parent.type !== "Program" && node.parent.range[0] === next.range[0]) {
+    node = node.parent;
+  }
+  return node;
+}
+
+// Each line of a comment that carries an allow mark, with its position; `opening` is the length of the comment's
+// opening mark (`//` or `/*`, or a template's `<!--`).
+function allowLines(comment, opening = 2) {
+  return comment.value.split(/\r?\n/u).flatMap((text, index) => {
+    const column = text.indexOf(ALLOW_MARK);
+    if (column < 0 || PLACEHOLDER.test(text)) {
+      return [];
+    }
+    const line = comment.loc.start.line + index;
+    const startColumn = index === 0 ? comment.loc.start.column + opening + column : column;
+    const body = text.slice(column).trimEnd();
+    return [{ body, loc: { start: { line, column: startColumn }, end: { line, column: startColumn + body.length } } }];
+  });
+}
+
+// Every "readable-check: allow <rule> - <reason>" comment names a rule or
+// finding, then a reason that starts with one of the fixed prefixes and says
+// what is true of the code; a component template's HTML comments are read too.
+const allowCommentForm = Object.freeze({
+  meta: ruleMeta("Require readable-check allow comments to give a reason with a fixed prefix that describes the code.", {
+    allowForm: "Write the exception as \"readable-check: allow <rule> - <reason>\".",
+    allowPrefix: "\"{{reason}}\" starts with no reason prefix. Start it with input validation:, data:, platform object:, optional operation:, safety invariant:, not a slot:, cycle: <supplier> requires <owner>, deferred until boot:, filled by <repository>; convert with its supplier, cross-repository slot <token>, or shared resource:.",
+    retiredPrefix: "\"{{reason}}\" uses the retired test asserts error:. Say what goes wrong without the guard under safety invariant: <what goes wrong>, or remove the guard.",
+    citesTests: "\"{{reason}}\" cites tests. Describe the code; a guard that protects an internal invariant says what goes wrong without it under safety invariant:.",
+    citesStatus: "\"{{reason}}\" cites the state of a project. Describe what is true of the code.",
+    dataOnFunction: "\"{{reason}}\" excuses a function with data:, which is only for data. Give the function's real reason, or remove its duplicate."
+  }, "exceptions"),
+  create(context) {
+    return {
+      Program() {
+        const templateComments = (context.sourceCode.ast.templateBody?.comments || [])
+          .filter((comment) => comment.type === "HTMLComment")
+          .map((comment) => ({ comment, opening: 4 }));
+        const scriptComments = context.sourceCode.getAllComments().map((comment) => ({ comment, opening: 2 }));
+        for (const { comment, opening } of [...scriptComments, ...templateComments]) {
+          for (const { body, loc } of allowLines(comment, opening)) {
+            const match = ALLOW_FORM.exec(body);
+            const reason = match?.[2] || "";
+            const data = { reason: reason.length > 60 ? `${reason.slice(0, 57)}...` : reason };
+            if (!match) {
+              context.report({ loc, messageId: "allowForm" });
+            } else if (RETIRED_PREFIX.test(reason)) {
+              context.report({ loc, messageId: "retiredPrefix", data });
+            } else if (!REASON_PREFIXES.some((prefix) => prefix.test(reason))) {
+              context.report({ loc, messageId: "allowPrefix", data });
+            } else if (CITES_TESTS.test(reason)) {
+              context.report({ loc, messageId: "citesTests", data });
+            } else if (CITES_STATUS.test(reason) || MARKER.test(reason)) {
+              context.report({ loc, messageId: "citesStatus", data });
+            } else if (DATA_PREFIX.test(reason) && !PARAMETER_RULES.has(match[1]) && opening === 2) {
+              const node = excusedNode(context.sourceCode, comment);
+              if (node && holdsFunction(node)) {
+                context.report({ loc, messageId: "dataOnFunction", data });
+              }
+            }
+          }
+        }
+      }
+    };
+  }
+});
+
+export { allowCommentForm };

package/plugin/rules/appErrorCode.js

@@ -0,0 +1,169 @@
+import { createReporter, keyName, ruleMeta } from "../support.js";
+
+// The kernel's error classes and where each takes its options: AppError and DomainError take (status, message,
+// options), ConflictError and NotFoundError (message, options). Their default codes ("APP_ERROR", "domain_error",
+// "conflict", "not_found") would be shared by every sentence that leaves its code out.
+const KERNEL_ERRORS = Object.freeze({
+  AppError: { message: 1, options: 2 },
+  DomainError: { message: 1, options: 2 },
+  ConflictError: { message: 0, options: 1 },
+  NotFoundError: { message: 0, options: 1 }
+});
+
+function objectHasKey(node, name) {
+  return node?.type === "ObjectExpression" && node.properties.some((property) => property.type === "Property" && keyName(property) === name);
+}
+
+function hasSpread(node) {
+  return node?.type === "ObjectExpression" && node.properties.some((property) => property.type === "SpreadElement");
+}
+
+// Whether a class body fixes its own code: a `code:` property whose value is a literal, or `this.code = …`. A code
+// that only falls back to a default (`code: options.code || "x"`) is not its own.
+function setsOwnCode(classBody, sourceCode) {
+  const text = sourceCode.getText(classBody);
+  return /\bcode\s*:\s*["'`]/u.test(text) || /this\.code\s*=/u.test(text);
+}
+
+function parameterIndex(parameters, name) {
+  return parameters.findIndex((parameter) => (parameter.type === "AssignmentPattern" ? parameter.left : parameter).name === name);
+}
+
+// The constructor's `super(…)` call, made as a statement of its own.
+function superCall(constructor) {
+  const statement = constructor?.value.body.body.find((member) => member.type === "ExpressionStatement" &&
+    member.expression.type === "CallExpression" && member.expression.callee.type === "Super");
+  return statement?.expression ?? null;
+}
+
+// Whether a destructured parameter's rest element (`{ approval, ...options }`) reaches `super` as the options it passes
+// on, as they are (`options`) or spread (`{ ...options, details }`). The caller's code is then among them.
+function forwardsRest(target, superOptions) {
+  const rest = target.type === "ObjectPattern" ? target.properties.find((property) => property.type === "RestElement") : null;
+  const name = rest?.argument.type === "Identifier" ? rest.argument.name : "";
+  if (!name || !superOptions) {
+    return false;
+  }
+  if (superOptions.type === "Identifier") {
+    return superOptions.name === name;
+  }
+  return superOptions.type === "ObjectExpression" && superOptions.properties.some((property) => property.type === "SpreadElement" &&
+    property.argument.type === "Identifier" && property.argument.name === name);
+}
+
+// The parameter that holds a call's options: one named `options`, one that destructures `code` (`{ code }`), or one
+// whose rest element the constructor forwards to `super` as its options (`superOptions`, the argument `super` takes
+// them in).
+function optionsIndex(parameters, superOptions) {
+  return parameters.findIndex((parameter) => {
+    const target = parameter.type === "AssignmentPattern" ? parameter.left : parameter;
+    return target.name === "options" ||
+      (target.type === "ObjectPattern" && target.properties.some((property) => property.type === "Property" && keyName(property) === "code")) ||
+      forwardsRest(target, superOptions);
+  });
+}
+
+// The error classes this module declares over a kernel error class, by name: whether each fixes its own code, and
+// where a call passes a code (a `code` parameter) or the options that hold one. A class without a constructor takes
+// its parent's arguments.
+function localErrorClasses(program, sourceCode) {
+  const classes = new Map();
+  const declarations = program.body.map((statement) => (statement.type === "ExportNamedDeclaration" || statement.type === "ExportDefaultDeclaration")
+    ? statement.declaration
+    : statement);
+  for (let grew = true; grew;) {
+    grew = false;
+    for (const declaration of declarations) {
+      const name = declaration?.type === "ClassDeclaration" ? declaration.id?.name : "";
+      const parentName = declaration?.superClass?.type === "Identifier" ? declaration.superClass.name : "";
+      const parent = KERNEL_ERRORS[parentName] ? { ownCode: false, code: -1, options: KERNEL_ERRORS[parentName].options } : classes.get(parentName);
+      if (!name || classes.has(name) || !parent) {
+        continue;
+      }
+      const constructor = declaration.body.body.find((member) => member.type === "MethodDefinition" && member.kind === "constructor");
+      const parameters = constructor?.value.params;
+      classes.set(name, {
+        ownCode: setsOwnCode(declaration.body, sourceCode) || parent.ownCode,
+        code: parameters ? parameterIndex(parameters, "code") : parent.code,
+        options: parameters ? optionsIndex(parameters, superCall(constructor)?.arguments[parent.options] ?? null) : parent.options
+      });
+      grew = true;
+    }
+  }
+  return classes;
+}
+
+// Whether a call passes a code where the class takes one: the options argument holds `code` (or may, as a variable
+// or a spread), or a `code` parameter receives an argument.
+function passesCode(node, { code, options }) {
+  if (code >= 0 && node.arguments.length > code) {
+    return true;
+  }
+  if (options < 0) {
+    return false;
+  }
+  const argument = node.arguments[options];
+  return Boolean(argument) && (argument.type !== "ObjectExpression" || objectHasKey(argument, "code") || hasSpread(argument));
+}
+
+function literalText(node) {
+  if (node?.type === "Literal" && typeof node.value === "string") {
+    return node.value;
+  }
+  if (node?.type === "TemplateLiteral" && node.expressions.length === 0) {
+    return node.quasis[0].value.cooked;
+  }
+  return null;
+}
+
+// A refusal meant for the caller is an AppError with its own code: one code per distinct sentence, so a client can
+// tell refusals apart and show each in the user's language. The kernel's classes, and this module's subclasses of
+// them, are checked; a subclass that fixes its own code needs none at the call.
+const appErrorCode = Object.freeze({
+  meta: ruleMeta("Require each AppError refusal to carry its own code.", {
+    missingCode: "new {{name}}(…) has no code, so it shares {{name}}'s default code with every other refusal. Give it its own code: { code: \"<package>.<area>.<refusal>\" }.",
+    sharedCode: "Code \"{{code}}\" already names another sentence on line {{line}}. Give each refusal its own code, or keep the shared code and add messageCode."
+  }, "refusals-carry-their-own-code"),
+  create(context) {
+    const sourceCode = context.sourceCode;
+    const report = createReporter(context, "app-error-code");
+    const localClasses = localErrorClasses(sourceCode.ast, sourceCode);
+    const sentences = new Map();
+    function checkSharedCode(node, options, message) {
+      const codeProperty = options?.type === "ObjectExpression"
+        ? options.properties.find((property) => property.type === "Property" && keyName(property) === "code")
+        : null;
+      const code = literalText(codeProperty?.value);
+      const sentence = literalText(message);
+      if (code === null || sentence === null || objectHasKey(options, "messageCode")) {
+        return;
+      }
+      const first = sentences.get(code);
+      if (!first) {
+        sentences.set(code, { sentence, line: node.loc.start.line });
+      } else if (first.sentence !== sentence) {
+        report(node, "shared-code", "sharedCode", { code, line: first.line });
+      }
+    }
+    return {
+      NewExpression(node) {
+        const name = node.callee.type === "Identifier" ? node.callee.name : "";
+        const kernel = KERNEL_ERRORS[name];
+        const local = localClasses.get(name);
+        if (kernel) {
+          if (!passesCode(node, { code: -1, options: kernel.options })) {
+            report(node, "missing-code", "missingCode", { name });
+            return;
+          }
+          checkSharedCode(node, node.arguments[kernel.options], node.arguments[kernel.message]);
+          return;
+        }
+        if (local && !local.ownCode && !passesCode(node, local)) {
+          report(node, "missing-code", "missingCode", { name });
+        }
+      }
+    };
+  }
+});
+
+export { appErrorCode };