@starci/eslint-canon-be 1.8.1 → 2.0.0

package/idempotency.mjs

@@ -1,90 +1,121 @@
 /**
  * The rule that holds inbox dedupe (catalog R80 `BE_INBOX_DEDUPE_MISSING`).
  *
- * A sender that gets no timely reply resends: a payment provider retries a webhook, a queue
- * redelivers a message it never saw acknowledged. The standard is one inbox table keyed by
- * `(source, event id)` in front of every door delivery can repeat through, so a repeat is a no-op
- * instead of a second charge, a second email or a second state transition.
+ * A sender that gets no timely reply resends: a payment provider retries a webhook, a queue redelivers a message it
+ * never saw acknowledged. The standard is one inbox table keyed by `(source, event id)` in front of every door
+ * delivery can repeat through, so a repeat is a no-op instead of a second charge, a second email or a second state
+ * transition.
  *
- *   - `inbox-dedupe-required` refuses a `@Public()` webhook controller method, or an outbox/queue
- *     consumer, whose file shows no reference to an inbox or dedupe port. A consumer is recognized
- *     by more than its filename: `<event>.consumer.ts` under `transport/message/` (the
- *     `be.transport.message` slot) still counts, and so does a method decorated `@EventPattern`,
- *     `@MessagePattern`, `@OnEvent` or `@Process`, or a class whose name ends `Consumer` or
- *     `OutboxConsumer`, wherever that file sits. A class that only PUBLISHES - the producer half of
- *     an outbox, typically `*-outbox.service.ts` / `*OutboxService` - carries none of those shapes
- *     and is not flagged: it has no repeat delivery to dedupe unless it also consumes.
+ *   - `inbox-dedupe-required` judges every DELIVERY method of a service. Doors (consumers, `SignedWebhook` controllers) are
+ *     thin (R88): they map the delivery and dispatch one message, so the claim lives in the `*.service.ts` the handler calls,
+ *     inside its transaction. A delivery method is a public method of a `<name>.service.ts` whose FIRST parameter has an
+ *     `eventId` property, read by the parameter's TYPE. The FIRST awaited expression of such a method must be
+ *     `claim(source, eventId)` on a receiver whose type is the `Inbox` port of `platform/inbox`, and the method must return
+ *     early when the claim answers `false`. A lookalike `Inbox` declared by another owner, a renamed receiver and a
+ *     property injection are all judged by the receiver's type, so only the real port satisfies the rule; a keyword or a
+ *     class name never does.
  *
- * This reads one file's text for the shape of a claim (`inbox`, `dedupe`, `idempoten*` naming a
- * port, a field or a call) - it cannot see whether the call actually runs before the side effect,
- * which needs the call graph and stays a review question, same as `no-outer-manager-in-transaction`
- * says for its own undecidable half.
+ * Accepted shapes of "claim, then return on false":
+ *   if (!(await this.inbox.claim(source, id))) return
+ *   if ((await this.inbox.claim(source, id)) === false) { return }
+ *   const fresh = await this.inbox.claim(source, id)
+ *   if (!fresh) return
+ * Whether the handler has side effects BEFORE its first await stays a review question (the call graph is not read).
  */
-import { decoratorName, keyName, staticText } from "./lib/ast.mjs"
-import { isTestLane, normalizePath } from "./lib/path.mjs"
+import { hfsOf } from "./lib/hfs.mjs"
+import { walk } from "./lib/ast.mjs"
+import { baseName, isOwnedType } from "./lib/ports.mjs"
+import { typed } from "./lib/types.mjs"
 
-const INBOX_REFERENCE = /inbox|dedupe|idempoten/i
-const CONSUMER_FILE = /\/transport\/message\/[^/]+\.consumer\.ts$/
-const WEBHOOK_FILE = /\/transport\/http\/[^/]*webhook[^/]*\.controller\.ts$/i
-/** A class whose name alone says it consumes a delivery, regardless of where the file sits. */
-const CONSUMER_CLASS_NAME = /(?:Outbox)?Consumer$/
-/** A method decorator that binds a handler to an incoming message or event, not just a filename convention. */
-const CONSUMER_DECORATORS = new Set(["EventPattern", "MessagePattern", "OnEvent", "Process"])
+/** The `Inbox` port of `platform/inbox`. */
+const isInboxType = (context, node) => isOwnedType(context, node, { name: "Inbox", capability: "inbox", tier: "platform" })
 
-/** The route or reason text a `@Public()` decorator's argument carries, lower-cased. */
-const publicReason = (node) => {
-    const expression = node.expression
-    const argument = expression.type === "CallExpression" ? expression.arguments[0] : undefined
-    if (argument?.type !== "ObjectExpression") return ""
-    const property = argument.properties.find((item) => item.type === "Property" && keyName(item.key) === "reason")
-    return (property ? staticText(property.value) : null)?.toLowerCase() ?? ""
+/** A `return` statement, or a block that ends in one. */
+const returns = (statement) =>
+    statement?.type === "ReturnStatement"
+    || (statement?.type === "BlockStatement" && statement.body.at(-1)?.type === "ReturnStatement")
+
+/** Whether `test` is `!<expression>` or `<expression> === false` around `target` (the awaited claim, or the identifier holding it). */
+const refusesOn = (test, target) => {
+    if (test.type === "UnaryExpression" && test.operator === "!") return test.argument === target || (test.argument.type === "Identifier" && target.type === "Identifier" && test.argument.name === target.name)
+    if (test.type === "BinaryExpression" && (test.operator === "===" || test.operator === "==")) {
+        const [left, right] = [test.left, test.right]
+        const isFalse = (node) => node.type === "Literal" && node.value === false
+        return (left === target && isFalse(right)) || (right === target && isFalse(left))
+    }
+    return false
 }
 
-/** A webhook door: the file is named for one, the open door names its reason, or the route itself does. */
-const isWebhookController = (filename, sourceText, publicDecorators) =>
-    WEBHOOK_FILE.test(filename)
-    || publicDecorators.some((node) => /webhook/.test(publicReason(node)))
-    || /@Controller\(\s*["'`][^"'`]*webhook/i.test(sourceText)
+/** Where the awaited claim sits: the statement that tests it, or the declaration that stores it followed by that test. */
+const returnsOnFalse = (awaited) => {
+    const node = awaited
+    const parent = node.parent
+    if (parent.type === "UnaryExpression" || parent.type === "BinaryExpression") {
+        const statement = parent.parent
+        return statement.type === "IfStatement" && statement.test === parent && refusesOn(parent, node) && returns(statement.consequent)
+    }
+    if (parent.type === "VariableDeclarator" && parent.id.type === "Identifier") {
+        const declaration = parent.parent
+        const siblings = declaration.parent?.body
+        if (!Array.isArray(siblings)) return false
+        const next = siblings[siblings.indexOf(declaration) + 1]
+        return next?.type === "IfStatement" && refusesOn(next.test, parent.id) && returns(next.consequent)
+    }
+    return false
+}
 
-/** Delivery this instance can receive more than once shows a claim against the inbox before it acts. */
+/** The awaited expression that completes first in a body, ignoring nested functions; null when the body awaits nothing. */
+const firstAwait = (body) => {
+    let first = null
+    walk(body, (node) => {
+        if (node.type === "AwaitExpression" && (first === null || node.range[1] < first.range[1])) first = node
+    }, { intoFunctions: false })
+    return first
+}
+
+/** Whether a parameter's type has an `eventId` property: the shape of a delivery. */
+const isDeliveryParam = (context, param) => {
+    const target = param.type === "TSParameterProperty" ? param.parameter : param.type === "AssignmentPattern" ? param.left : param
+    const { checker, toTs } = typed(context)
+    const tsNode = toTs(target)
+    if (!tsNode) return false
+    const type = checker.getTypeAtLocation(tsNode)
+    return (type.isUnion() ? type.types : [type]).some((part) => checker.getPropertyOfType(part, "eventId") !== undefined)
+}
+
+/** A service method that takes a delivery claims the event through the shared inbox before it acts. */
 export const inboxDedupeRequired = {
     meta: {
         type: "problem",
-        docs: { description: "A `@Public()` webhook handler and an outbox/queue consumer claim the event through the shared inbox before they act." },
+        docs: { description: "A public service method whose first parameter carries an `eventId` claims `(source, eventId)` on the `Inbox` port first and returns early when it answers `false`." },
         schema: [],
         messages: {
-            webhook: "This webhook controller has no reference to an inbox or dedupe port. A sender that gets no timely reply resends the same event; claim `(source, event id)` in the shared inbox before acting, so a repeat delivery is a no-op.",
-            consumer: "This consumer has no reference to an inbox or dedupe port. A queue redelivers a message it never saw acknowledged; claim `(source, event id)` in the shared inbox before acting, so a redelivery is a no-op.",
+            noClaim: "This delivery method's first awaited expression is not `claim(source, eventId)` on the `Inbox` port of `platform/inbox` (`@InjectInbox() private readonly inbox: Inbox`). A sender that gets no timely reply resends the same event: claim it before anything else so a repeat delivery is a no-op.",
+            noEarlyReturn: "This delivery method claims the event but does not return when the claim answers `false`. Write `if (!(await this.inbox.claim(source, eventId))) return` (or store the answer and return on `!fresh` straight after), so a repeat does none of the work again.",
         },
     },
     create(context) {
-        const filename = normalizePath(context.filename || context.getFilename())
-        if (isTestLane(filename)) return {}
-        let isConsumer = CONSUMER_FILE.test(filename)
-        const publicDecorators = []
+        const hfs = hfsOf(context)
+        const filename = context.filename || context.getFilename()
+        const slot = hfs.slotOf(filename)
+        if (!baseName(filename).endsWith(".service.ts") || !slot || slot.startsWith("be.tests.")) return {}
         return {
-            Decorator(node) {
-                const name = decoratorName(node)
-                if (name === "Public") publicDecorators.push(node)
-                else if (CONSUMER_DECORATORS.has(name)) isConsumer = true
-            },
-            ClassDeclaration(node) {
-                if (node.id && CONSUMER_CLASS_NAME.test(node.id.name)) isConsumer = true
-            },
-            ClassExpression(node) {
-                if (node.id && CONSUMER_CLASS_NAME.test(node.id.name)) isConsumer = true
-            },
-            "Program:exit"(node) {
-                const sourceCode = context.sourceCode || context.getSourceCode()
-                const text = sourceCode.getText()
-                if (INBOX_REFERENCE.test(text)) return
-                if (isConsumer) {
-                    context.report({ node, messageId: "consumer" })
-                    return
-                }
-                if (publicDecorators.length && isWebhookController(filename, text, publicDecorators)) {
-                    context.report({ node, messageId: "webhook" })
-                }
+            MethodDefinition(node) {
+                if (node.kind !== "method" || node.static || node.key.type === "PrivateIdentifier" || !node.value.body) return
+                if (node.accessibility === "private" || node.accessibility === "protected") return
+                const first = node.value.params[0]
+                if (!first || !isDeliveryParam(context, first)) return
+                const awaited = firstAwait(node.value.body)
+                const call = awaited?.argument
+                const claims = call?.type === "CallExpression"
+                    && call.callee.type === "MemberExpression"
+                    && !call.callee.computed
+                    && call.callee.property.type === "Identifier"
+                    && call.callee.property.name === "claim"
+                    && call.arguments.length >= 2
+                    && isInboxType(context, call.callee.object)
+                if (!claims) context.report({ node: node.key, messageId: "noClaim" })
+                else if (!returnsOnFalse(awaited)) context.report({ node: node.key, messageId: "noEarlyReturn" })
             },
         }
     },

package/index.mjs

@@ -16,62 +16,79 @@
  * every conversation about the failure. Aliasing one here to match a target's older spelling would
  * leave two names for one rule and no way to tell which a message came from.
  */
+import { buildBeConfig } from "./lib/config.mjs"
 import { recommended as asyncDisciplineRecommended, rules as asyncDisciplineRules } from "./async-discipline.mjs"
 import { recommended as authorizationRecommended, rules as authorizationRules } from "./authorization.mjs"
+import { recommended as buildersRecommended, rules as buildersRules } from "./builders.mjs"
 import { recommended as commentsRecommended, rules as commentsRules } from "./comments.mjs"
 import { recommended as configOwnerRecommended, rules as configOwnerRules } from "./config-owner.mjs"
+import { recommended as connectionsRecommended, rules as connectionsRules } from "./connections.mjs"
 import { recommended as cqrsRecommended, rules as cqrsRules } from "./cqrs.mjs"
 import { recommended as dataAccessRecommended, rules as dataAccessRules } from "./data-access.mjs"
 import { recommended as defaultDenyRecommended, rules as defaultDenyRules } from "./default-deny.mjs"
 import { recommended as e2eFlowRecommended, rules as e2eFlowRules } from "./e2e-flow.mjs"
 import { recommended as errorHandlingRecommended, rules as errorHandlingRules } from "./error-handling.mjs"
 import { recommended as idempotencyRecommended, rules as idempotencyRules } from "./idempotency.mjs"
+import { recommended as infraOwnerRecommended, rules as infraOwnerRules } from "./infra-owner.mjs"
+import { recommended as injectionRecommended, rules as injectionRules } from "./injection.mjs"
 import { recommended as inputBoundsRecommended, rules as inputBoundsRules } from "./input-bounds.mjs"
 import { recommended as logSafetyRecommended, rules as logSafetyRules } from "./log-safety.mjs"
 import { recommended as moduleLayeringRecommended, rules as moduleLayeringRules } from "./module-layering.mjs"
 import { recommended as moduleShapeRecommended, rules as moduleShapeRules } from "./module-shape.mjs"
 import { recommended as namingRecommended, rules as namingRules } from "./naming.mjs"
 import { recommended as observabilityRecommended, rules as observabilityRules } from "./observability.mjs"
+import { recommended as operationsRecommended, rules as operationsRules } from "./operations.mjs"
 import { recommended as querySafetyRecommended, rules as querySafetyRules } from "./query-safety.mjs"
 import { recommended as resilienceRecommended, rules as resilienceRules } from "./resilience.mjs"
 import { recommended as schemaAuthorityRecommended, rules as schemaAuthorityRules } from "./schema-authority.mjs"
 import { recommended as sizeBudgetRecommended, rules as sizeBudgetRules } from "./size-budget.mjs"
+import { recommended as specNoSkipRecommended, rules as specNoSkipRules } from "./spec-no-skip.mjs"
 import { recommended as specQualityRecommended, rules as specQualityRules } from "./spec-quality.mjs"
 import { recommended as suppressionRecommended, rules as suppressionRules } from "./suppression.mjs"
 import { recommended as temporalRecommended, rules as temporalRules } from "./temporal.mjs"
 import { recommended as testingRecommended, rules as testingRules } from "./testing.mjs"
+import { recommended as testWorldRecommended, rules as testWorldRules } from "./test-world.mjs"
 import { recommended as transportRecommended, rules as transportRules } from "./transport.mjs"
 import { recommended as typeSafetyRecommended, rules as typeSafetyRules } from "./type-safety.mjs"
+import { recommended as unitSpecRecommended, rules as unitSpecRules } from "./unit-spec.mjs"
 import { recommended as userCopyRecommended, rules as userCopyRules } from "./user-copy.mjs"
 
 /** Each law's contribution, kept separate so a duplicate name is detectable rather than silent. */
 const CONTRIBUTIONS = [
     { law: "async-discipline", rules: asyncDisciplineRules, recommended: asyncDisciplineRecommended },
     { law: "authorization", rules: authorizationRules, recommended: authorizationRecommended },
+    { law: "builders", rules: buildersRules, recommended: buildersRecommended },
     { law: "comments", rules: commentsRules, recommended: commentsRecommended },
     { law: "config-owner", rules: configOwnerRules, recommended: configOwnerRecommended },
+    { law: "connections", rules: connectionsRules, recommended: connectionsRecommended },
     { law: "cqrs", rules: cqrsRules, recommended: cqrsRecommended },
     { law: "data-access", rules: dataAccessRules, recommended: dataAccessRecommended },
     { law: "default-deny", rules: defaultDenyRules, recommended: defaultDenyRecommended },
     { law: "e2e-flow", rules: e2eFlowRules, recommended: e2eFlowRecommended },
     { law: "error-handling", rules: errorHandlingRules, recommended: errorHandlingRecommended },
     { law: "idempotency", rules: idempotencyRules, recommended: idempotencyRecommended },
+    { law: "infra-owner", rules: infraOwnerRules, recommended: infraOwnerRecommended },
+    { law: "injection", rules: injectionRules, recommended: injectionRecommended },
     { law: "input-bounds", rules: inputBoundsRules, recommended: inputBoundsRecommended },
     { law: "log-safety", rules: logSafetyRules, recommended: logSafetyRecommended },
     { law: "module-layering", rules: moduleLayeringRules, recommended: moduleLayeringRecommended },
     { law: "module-shape", rules: moduleShapeRules, recommended: moduleShapeRecommended },
     { law: "naming", rules: namingRules, recommended: namingRecommended },
     { law: "observability", rules: observabilityRules, recommended: observabilityRecommended },
+    { law: "operations", rules: operationsRules, recommended: operationsRecommended },
     { law: "query-safety", rules: querySafetyRules, recommended: querySafetyRecommended },
     { law: "resilience", rules: resilienceRules, recommended: resilienceRecommended },
     { law: "schema-authority", rules: schemaAuthorityRules, recommended: schemaAuthorityRecommended },
     { law: "size-budget", rules: sizeBudgetRules, recommended: sizeBudgetRecommended },
+    { law: "spec-no-skip", rules: specNoSkipRules, recommended: specNoSkipRecommended },
     { law: "spec-quality", rules: specQualityRules, recommended: specQualityRecommended },
     { law: "suppression", rules: suppressionRules, recommended: suppressionRecommended },
     { law: "temporal", rules: temporalRules, recommended: temporalRecommended },
     { law: "testing", rules: testingRules, recommended: testingRecommended },
+    { law: "test-world", rules: testWorldRules, recommended: testWorldRecommended },
     { law: "transport", rules: transportRules, recommended: transportRecommended },
     { law: "type-safety", rules: typeSafetyRules, recommended: typeSafetyRecommended },
+    { law: "unit-spec", rules: unitSpecRules, recommended: unitSpecRecommended },
     { law: "user-copy", rules: userCopyRules, recommended: userCopyRecommended },
 ]
 
@@ -112,22 +129,28 @@ export const rules = Object.fromEntries(
 )
 
 /**
- * The levels this canon asks for, as the plugin's own opinion.
- *
- * Unlike the front end, this axis allows `warn`, and the allowance is the burn-down playbook rather
- * than a softer standard: a rule measured with debt arrives at `warn` with a ledger entry naming the
- * offenders, and flips to `error` the day that entry closes. Switching a rule on over existing
- * offenders is what teaches an author to scroll past it, and a reader who has learned to scroll past
- * one rule reads none of them.
+ * The levels this canon asks for: every rule at `error`. There is no `warn` and no burn-down level; a rule with
+ * debt is fixed in the repositories before it ships, never published weaker.
  */
 export const recommended = Object.fromEntries(
     CONTRIBUTIONS.flatMap((entry) => Object.entries(entry.recommended)),
 )
 
 /** The plugin object, shaped the way a flat config expects it. */
-export default {
+const plugin = {
     meta: { name: "eslint-plugin-starci-be" },
     rules,
 }
 
-export { starciBeConfig, linterOptions } from "./lib/config.mjs"
+export default plugin
+
+/**
+ * The whole flat config of a back end: `export default starciBeConfig({ hfs: loadHfs(import.meta.url) })`.
+ *
+ * @param {{ hfs: object }} input - The HFS view of the repository.
+ * @returns {Promise<Array<object>>} The flat config.
+ */
+export const starciBeConfig = ({ hfs }) => buildBeConfig({ hfs, plugin, recommended })
+
+export { linterOptions } from "./lib/config.mjs"
+export { loadHfs } from "./lib/hfs.mjs"

package/infra-owner.mjs

@@ -0,0 +1,96 @@
+/**
+ * The rule that holds BE-CONVENTION 1.10-1.14 (R90 `BE_INFRA_OWNER`).
+ *
+ * Every raw infrastructure library (HTTP, cache, queue, scheduler, logger, date, config, in-process events) has exactly
+ * one owning platform or integration capability, and only files of that capability may import it or reach for it as a
+ * global. The table lives in the slot manifest (`ruleParams.be.infraOwners`: specifier -> owners, `[]` for "nowhere"),
+ * so the rule holds no library name of its own and the messages and the check read one source.
+ *
+ * "Owning capability" is asked of the slot view (`ownerOf(filename)`), never of a path pattern. A reference is an
+ * import (static, dynamic, `require`, `export ... from`) of the specifier or of a subpath of it, or a value reference to
+ * an unresolved global (`fetch`, `setTimeout`, `globalThis.setInterval`) whose name is a key of the table. Specs are
+ * included: they use the fake clock and the doubles the owning capability provides.
+ *
+ * The test world (slot `be.tests.world`, `src/tests/world`) is an infrastructure owner like the platform capabilities: it is
+ * the TEST COMPOSITION ROOT that starts docker, polls readiness, serves the network-edge fakes over `node:http` and drives the
+ * apps over HTTP with a raw client, and it has no Nest container to inject a port from. It may use every library the
+ * table gives an owner; a library the table owns by nobody (`[]`, `nowhere`) is still refused there. A spec does not
+ * compose: specs stay refused and reach infrastructure through `useTestWorld(...)`.
+ *
+ * `no-framework-logger` (R40) and `no-ambient-clock` (R79) judge Nest `Logger` and `Date`; the table holds neither.
+ */
+import { hfsOf, inTestWorld } from "./lib/hfs.mjs"
+import { moduleReferences } from "./lib/import-source.mjs"
+
+/** The owner id of a file: the last two segments of its owner root (`platform/http`), or null when no owner holds it. */
+const ownerIdOf = (hfs, filename) => {
+    const root = hfs.ownerOf(filename)
+    return root === null ? null : root.split("/").slice(-2).join("/")
+}
+
+/** The table key a module specifier falls under (the specifier itself or a subpath of it, with or without `node:`), or null. */
+const keyOf = (table, specifier) => {
+    const variants = [specifier, specifier.startsWith("node:") ? specifier.slice(5) : `node:${specifier}`]
+    let best = null
+    for (const variant of variants) {
+        for (const key of Object.keys(table)) {
+            if ((variant === key || variant.startsWith(`${key}/`)) && (best === null || key.length > best.length)) best = key
+        }
+    }
+    return best
+}
+
+/** A raw infrastructure library is used only inside the capability that owns it. */
+export const infraImportOwner = {
+    meta: {
+        type: "problem",
+        docs: { description: "A raw infrastructure library (HTTP, cache, queue, scheduler, logger, date, config, events) is imported or referenced only by its owning capability." },
+        schema: [],
+        messages: {
+            foreign: "`{{name}}` is owned by {{owners}}. Use that capability's port (injected with its `Inject*()` decorator) instead of the raw library, or move this code into the owner.",
+            nowhere: "`{{name}}` is not used in a back end: its job belongs to a platform port (config through the typed `<c>.config.ts`, events through the outbox, schedules through `platform/scheduling`). Remove it.",
+        },
+    },
+    create(context) {
+        const hfs = hfsOf(context)
+        const table = hfs.ruleParams.infraOwners
+        const here = ownerIdOf(hfs, context.filename)
+        const isWorld = inTestWorld(hfs, context.filename)
+        const check = (node, name, key) => {
+            const owners = table[key]
+            if (owners.includes(here) || (isWorld && owners.length > 0)) return
+            if (owners.length === 0) context.report({ node, messageId: "nowhere", data: { name } })
+            else context.report({ node, messageId: "foreign", data: { name, owners: owners.map((owner) => `\`${owner}\``).join(", ") } })
+        }
+        return {
+            ...moduleReferences(({ source, value }) => {
+                const key = keyOf(table, value)
+                if (key !== null) check(source, value, key)
+            }),
+            MemberExpression(node) {
+                if (node.computed || node.object.type !== "Identifier" || node.object.name !== "globalThis" || node.property.type !== "Identifier") return
+                if (Object.hasOwn(table, node.property.name)) check(node, `globalThis.${node.property.name}`, node.property.name)
+            },
+            "Program:exit"() {
+                const globalScope = context.sourceCode.scopeManager.globalScope
+                if (!globalScope) return
+                const references = [...globalScope.through, ...globalScope.variables.filter((variable) => variable.defs.length === 0).flatMap((variable) => variable.references)]
+                for (const reference of references) {
+                    if (reference.isValueReference === false) continue
+                    const name = reference.identifier.name
+                    if (Object.hasOwn(table, name)) check(reference.identifier, name, name)
+                }
+            },
+        }
+    },
+}
+
+/** The rules this law contributes to the plugin. */
+export const rules = {
+    "infra-import-owner": infraImportOwner,
+}
+
+/** Every rule of this law at `error`. */
+export const recommended = {
+    "starci-be/infra-import-owner": "error",
+}