@starci/eslint-canon-fe 9.9.12 → 9.11.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 9.11.0 - 2026-11-03
+
+- Changed: `modules/auth` holds the front-end transport rules like `modules/api`: no auth door file takes axios or `fetch`, and no file keeps module-level mutable state (the access token lives in the `@starci/auth` client); the stack concern `auth` names `@starci/auth`.
+
+## 9.10.0
+
+- Added: `starci-fe/directive-first` (R369, `FE_DIRECTIVE_FIRST`) at error: a `"use client"` or `"use server"` directive is the first statement of its module; below an import it does nothing and `next build` refuses the file.
+- Added: `starci-fe/explicit-export-surface` (R368, `HFS_EXPLICIT_EXPORT_SURFACE`) at error: an exported function's return type, an exported variable's type and a parameter's type are written, not inferred from a body or from other files; a component that returns only JSX, `null` or `undefined` is explicit. It reports each export the isolated declaration emit cannot write, at the offending span, and says what to annotate. It reads the classifier the lint result cache reads.
+- Added: `projectGraphSnapshot`, the findings of the project graph the process has already built, which the ESLint child hands to the cache; `projectGraph` stays the fresh build.
+- Changed: carry the bundled runtime of @starci/hfs 5.1.0 (the classifier, the rule factory, the rule catalog with R368, the canon pins).
+- Fixed: `no-swr-default-array` (R367) judges a `?? []` inside a `useMemo` callback or a `slotOfReads` projector by the hook that holds it, so a slot carrying the read's status is no longer reported.
+
 ## 9.9.12
 
 - Changed: Carry the bundled runtime of @starci/hfs 5.0.8 (the rule texts name `app check`, the read-set helper of the rule memo) and its canon pins; the comments name `app check` for the removed lint verb.

package/README.md

@@ -62,6 +62,16 @@ canonical page renderer. Only those exact input members may take `children`; ord
 renderers and shape records containing rendered trees remain refused. The selected canonical Grammar catalog owns
 semantic renderer bindings; universal code carries no concrete renderer spelling.
 
+The [explicit exported surface](../../contexts/code/shared/typing.md) (R368, SHARED-TYPING-5) is `explicit-export-surface`
+(`HFS_EXPLICIT_EXPORT_SURFACE`): an exported function's return type, an exported variable's type and a parameter's type are
+written where they are exported, never inferred from a body or from other files; a component that returns only JSX, `null` or
+`undefined` is explicit. It reports each export TypeScript's isolated declaration emit cannot write, at the offending span, and says
+which annotation to add. It reads the classifier the lint result cache reads (`declarationSurface`, the bundled
+`runtime/scripts/lib/declaration-surface.mjs`), so it reports exactly the files the cache counts as open.
+
+`projectGraph` and `projectGraphSnapshot` are the cache's two readers of the project graph the graph rules share: the first builds it
+afresh, the second answers from the graph the process has already built, which is how the ESLint child hands its graph to the cache.
+
 Regression specs belong to this package. Application front ends and Grammar libraries have no specs.
 
 ## The runtime copy

package/dist/directive-first.d.ts

@@ -0,0 +1,16 @@
+/**
+ * A module directive is the first statement of its module (HFS R369, `FE_DIRECTIVE_FIRST`).
+ *
+ * `"use client"` and `"use server"` are directives only in the prologue, before any import or other statement. Below an import the string is an
+ * expression statement that does nothing, Prettier wraps it as `("use client")`, and `next build` stops with "The 'use client' directive must be placed
+ * before other expressions". ESLint's parser marks a real directive with `directive`, so a string statement of that text without one is misplaced.
+ */
+import { type Recommended } from "./lib/rule.js";
+/** A module directive stays in the prologue. */
+export declare const directiveFirst: import("./lib/rule.js").Rule<"misplaced", []>;
+/** The rules this law contributes to the plugin. */
+export declare const rules: {
+    "directive-first": import("./lib/rule.js").Rule<"misplaced", []>;
+};
+/** Every misplaced directive is a build error. */
+export declare const recommended: Recommended;

package/dist/directive-first.js

@@ -0,0 +1,37 @@
+/**
+ * A module directive is the first statement of its module (HFS R369, `FE_DIRECTIVE_FIRST`).
+ *
+ * `"use client"` and `"use server"` are directives only in the prologue, before any import or other statement. Below an import the string is an
+ * expression statement that does nothing, Prettier wraps it as `("use client")`, and `next build` stops with "The 'use client' directive must be placed
+ * before other expressions". ESLint's parser marks a real directive with `directive`, so a string statement of that text without one is misplaced.
+ */
+import { defineRule } from "./lib/rule.js";
+/** The directives Next.js reads from the prologue of a module. */
+const DIRECTIVES = new Set(["use client", "use server"]);
+/** A module directive stays in the prologue. */
+export const directiveFirst = defineRule({
+    meta: {
+        type: "problem",
+        docs: { description: "R369: a 'use client' or 'use server' directive is the first statement of its module." },
+        schema: [],
+        messages: {
+            misplaced: 'FE_DIRECTIVE_FIRST: "{{directive}}" is not at the top of the module, so it is an expression that does nothing and `next build` refuses the file. Move it above every import and other statement.',
+        },
+    },
+    create(context) {
+        return {
+            ExpressionStatement(node) {
+                if (node.parent.type !== "Program" || "directive" in node && typeof node.directive === "string")
+                    return;
+                const expression = node.expression;
+                if (expression.type !== "Literal" || typeof expression.value !== "string" || !DIRECTIVES.has(expression.value))
+                    return;
+                context.report({ node, messageId: "misplaced", data: { directive: expression.value } });
+            },
+        };
+    },
+});
+/** The rules this law contributes to the plugin. */
+export const rules = { "directive-first": directiveFirst };
+/** Every misplaced directive is a build error. */
+export const recommended = { "starci-fe/directive-first": "error" };

package/dist/explicit-surface.d.ts

@@ -0,0 +1,7 @@
+import type { Recommended } from "./lib/rule.js";
+/** The rules this law contributes to the plugin. */
+export declare const rules: {
+    "explicit-export-surface": import("@typescript-eslint/utils/ts-eslint").RuleModule<"inferred", readonly unknown[], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+};
+/** Every exported type is written out, at error. */
+export declare const recommended: Recommended;

package/dist/explicit-surface.js

@@ -0,0 +1,19 @@
+/**
+ * The explicit exported surface (HFS R368, `HFS_EXPLICIT_EXPORT_SURFACE`): an exported declaration states its type, in the file that exports it.
+ *
+ * A return type, variable type or parameter type left to inference is a surface importers read from the body and from the files the body uses, so
+ * the result cache of `starci app check --gate lint` lints every importer again whenever the file changes (check-cache.md, ESLint). The rule
+ * reports each export the isolated declaration emit (`ts.transpileDeclaration`) cannot write without inference, where it is written, and says
+ * what to annotate. A component that returns only JSX has the type the JSX namespace gives it and is not reported. It is the very classifier the
+ * cache reads (`declarationSurface` of the bundled runtime), so the rule reports exactly the files the cache counts as open.
+ */
+import ts from "typescript";
+import { explicitSurfaceRule } from "#runtime/scripts/hfs/explicit-surface-rule.mjs";
+/** The rules this law contributes to the plugin. */
+export const rules = {
+    "explicit-export-surface": explicitSurfaceRule({ ts }),
+};
+/** Every exported type is written out, at error. */
+export const recommended = {
+    "starci-fe/explicit-export-surface": "error",
+};

package/dist/fe-stack.d.ts

@@ -4,6 +4,11 @@ import { type Rules, type Recommended } from "./lib/rule.js";
  * No import (static, re-export, dynamic or `require`) of a package the fe-stack catalog forbids.
  */
 export declare const feStackImport: import("./lib/rule.js").Rule<"forbidden", []>;
+/**
+ * The SWR extension points belong to `@starci/next-data`: `pollingRestart` is the one middleware and `createViewerCache` the one
+ * binding of the viewer's cache, so an app that imports the `Middleware` or `ScopedMutator` type is writing a second one.
+ */
+export declare const swrExtensionFromPackage: import("./lib/rule.js").Rule<"own", []>;
 /** The rules this law contributes to the plugin. */
 export declare const rules: Rules;
 /** Every rule is an error: a second library for a concern is the defect, not a style. */

package/dist/fe-stack.js

@@ -59,9 +59,43 @@ export const feStackImport = defineRule({
         };
     },
 });
+/** The SWR types an app needs only to write its own middleware or to bind the writes of a viewer's cache by hand. */
+const PACKAGE_OWNED_SWR_TYPES = new Set(["Middleware", "ScopedMutator"]);
+/**
+ * The SWR extension points belong to `@starci/next-data`: `pollingRestart` is the one middleware and `createViewerCache` the one
+ * binding of the viewer's cache, so an app that imports the `Middleware` or `ScopedMutator` type is writing a second one.
+ */
+export const swrExtensionFromPackage = defineRule({
+    meta: {
+        type: "problem",
+        docs: { description: "An app writes no SWR middleware and no cache binding of its own." },
+        schema: [],
+        messages: {
+            own: "`{{name}}` of `swr` is the type of an SWR extension the stack already ships. Use `pollingRestart`, `viewerSwrConfig` and `createViewerCache` of `@starci/next-data` (FE-DATA-SWR, FE-DATA-KEY) instead of writing a second one.",
+        },
+    },
+    create(context) {
+        if (!isProductSource(context))
+            return {};
+        return {
+            ImportDeclaration(node) {
+                if (node.source.value !== "swr")
+                    return;
+                for (const specifier of node.specifiers) {
+                    if (specifier.type !== "ImportSpecifier")
+                        continue;
+                    const name = specifier.imported.type === "Identifier" ? specifier.imported.name : String(specifier.imported.value);
+                    if (PACKAGE_OWNED_SWR_TYPES.has(name))
+                        context.report({ node: specifier, messageId: "own", data: { name } });
+                }
+            },
+        };
+    },
+});
 /** The rules this law contributes to the plugin. */
 export const rules = {
     "fe-stack-import": feStackImport,
+    "swr-extension-from-package": swrExtensionFromPackage,
 };
 /** Every rule is an error: a second library for a concern is the defect, not a style. */
 export const recommended = Object.fromEntries(Object.keys(rules).map((name) => [`starci-fe/${name}`, "error"]));

package/dist/index.d.ts

@@ -106,5 +106,5 @@ export declare const starciTypedSourceConfig: ({ root }?: {
 }) => Linter.Config[];
 export { crossFileInputs } from "./lib/cross-file-inputs.js";
 export type { CrossFileInput } from "./lib/cross-file-inputs.js";
-export { projectGraph } from "./project-graph.js";
+export { projectGraph, projectGraphSnapshot } from "./project-graph.js";
 export type { ProjectGraphFinding, ProjectGraphSnapshot } from "./project-graph.js";

package/dist/index.js

@@ -27,6 +27,8 @@ import { recommended as hygieneRecommended, rules as hygieneRules } from "./hygi
 import { recommended as landmarkRecommended, rules as landmarkRules } from "./landmark.js";
 import { recommended as listsRecommended, rules as listsRules } from "./lists.js";
 import { recommended as loadingRecommended, rules as loadingRules } from "./loading.js";
+import { recommended as directiveFirstRecommended, rules as directiveFirstRules } from "./directive-first.js";
+import { recommended as explicitSurfaceRecommended, rules as explicitSurfaceRules } from "./explicit-surface.js";
 import { recommended as skeletonStatesRecommended, rules as skeletonStatesRules } from "./skeleton-states.js";
 import { recommended as lintEscapeRecommended, rules as lintEscapeRules } from "./lint-escape-hatch.js";
 import { recommended as namingRecommended, rules as namingRules } from "./naming.js";
@@ -74,6 +76,8 @@ const CONTRIBUTIONS = [
     { law: "landmark", rules: landmarkRules, recommended: landmarkRecommended },
     { law: "lists", rules: listsRules, recommended: listsRecommended },
     { law: "loading", rules: loadingRules, recommended: loadingRecommended },
+    { law: "directive-first", rules: directiveFirstRules, recommended: directiveFirstRecommended },
+    { law: "explicit-surface", rules: explicitSurfaceRules, recommended: explicitSurfaceRecommended },
     { law: "skeleton-states", rules: skeletonStatesRules, recommended: skeletonStatesRecommended },
     { law: "lint-escape-hatch", rules: lintEscapeRules, recommended: lintEscapeRecommended },
     { law: "naming", rules: namingRules, recommended: namingRecommended },
@@ -313,4 +317,4 @@ for (const addition of A14_CONTRIBUTIONS) {
 }
 // The result cache of `starci app check --gate lint` (contexts/project/check-cache.md) reads these two declarations of the installed canon.
 export { crossFileInputs } from "./lib/cross-file-inputs.js";
-export { projectGraph } from "./project-graph.js";
+export { projectGraph, projectGraphSnapshot } from "./project-graph.js";

package/dist/lib/config.js

@@ -105,7 +105,7 @@ export const SLOT_FREE_RULES = Object.freeze([
     "outcome-kinds-exhaustive", "no-await-in-loop", "prefer-code-point", "prefer-string-raw", "no-nested-conditional", "no-void-operator", "no-unused-import",
     "prefer-export-from", "no-unused-prop-types", "media-has-caption", "max-params",
     "no-list-panel-padding", "no-hand-built-panes", "no-table-in-card", "no-heading-above-card", "no-selectable-tag-group", "no-fill-command-in-header", "no-app-surface-paint", "divider-full-bleed", "control-height", "selection-fill-no-check", "no-grammar-shim",
-    "no-swr-default-array", "no-foreign-slot-status", "no-validating-as-loading", "no-placeholder-object", "no-hand-skeleton",
+    "no-swr-default-array", "no-foreign-slot-status", "no-validating-as-loading", "no-placeholder-object", "no-hand-skeleton", "explicit-export-surface", "directive-first",
     "button-intent-required", "destructive-confirm-in-dialog", "single-commit-per-render", "no-commit-in-collection-item",
 ]);
 /** The source of a plain front-end tree: its `src/`. */

package/dist/lib/scope.d.ts

@@ -39,14 +39,6 @@ export declare const isProductSource: (context: AnyContext) => boolean;
 export declare const isComponentFile: (context: AnyContext) => boolean;
 /** True when the given file (an absolute or repo-relative name, e.g. where an import resolves to) sits in a component layer of slot `fe.components` or `fe.package.ui`. */
 export declare const isComponentPath: (context: AnyContext, file: string) => boolean;
-/**
- * The one auth door of the session issuer's client: `modules/auth/auth-door.ts` (slot `fe.modules.auth`). It alone calls the app's
- * own back-end auth doors (login, signup, refresh, logout, password reset, resend verification) with the REST client, credentials
- * included; every other file of `modules/auth` and every other module stays outside the transport.
- */
-export declare const isAuthDoor: (context: AnyContext) => boolean;
-/** The in-memory access-token store of `modules/auth` (`modules/auth/token-store.ts`), the one module-level mutable state the auth client keeps. */
-export declare const isAuthTokenStore: (context: AnyContext) => boolean;
 /** The one place that may read the environment: slot `fe.modules.config`. */
 export declare const isConfigModule: (context: AnyContext) => boolean;
 /**

package/dist/lib/scope.js

@@ -48,16 +48,6 @@ export const isComponentPath = (context, file) => {
     const found = hfsOf(context).classify(file);
     return (found.slot === "fe.components" || found.slot === "fe.package.ui") && found.kind !== undefined;
 };
-/** The base name of the linted file. */
-const baseNameOf = (context) => (context.filename || context.getFilename()).split(/[\\/]/).at(-1) ?? "";
-/**
- * The one auth door of the session issuer's client: `modules/auth/auth-door.ts` (slot `fe.modules.auth`). It alone calls the app's
- * own back-end auth doors (login, signup, refresh, logout, password reset, resend verification) with the REST client, credentials
- * included; every other file of `modules/auth` and every other module stays outside the transport.
- */
-export const isAuthDoor = (context) => inSlot(context, "fe.modules.auth") && baseNameOf(context) === "auth-door.ts";
-/** The in-memory access-token store of `modules/auth` (`modules/auth/token-store.ts`), the one module-level mutable state the auth client keeps. */
-export const isAuthTokenStore = (context) => inSlot(context, "fe.modules.auth") && baseNameOf(context) === "token-store.ts";
 /** The one place that may read the environment: slot `fe.modules.config`. */
 export const isConfigModule = (context) => inSlot(context, "fe.modules.config");
 /**

package/dist/lib/why.d.ts

@@ -102,6 +102,16 @@ export declare const why: {
         en: string;
         fix: string;
     };
+    "directive-first": {
+        code: string;
+        en: string;
+        fix: string;
+    };
+    "explicit-export-surface": {
+        code: string;
+        en: string;
+        fix: string;
+    };
     "destructive-confirm-in-dialog": {
         code: string;
         en: string;
@@ -382,6 +392,11 @@ export declare const why: {
         en: string;
         fix: string;
     };
+    "swr-extension-from-package": {
+        code: string;
+        en: string;
+        fix: string;
+    };
     "fe-stack-import": {
         code: string;
         en: string;

package/dist/lib/why.js

@@ -102,6 +102,16 @@ export const why = {
         en: "`<file>` draws a skeleton by hand.",
         fix: "Pass isLoading to the Grammar component and let it draw its loading structure; the block hands it the same-shape placeholder (FE-ERROR-1).",
     },
+    "directive-first": {
+        code: "FE_DIRECTIVE_FIRST",
+        en: "`<file>` has a `<what>` directive below another statement.",
+        fix: "Put the directive on the first line of the module, above every import; Next.js reads it only there.",
+    },
+    "explicit-export-surface": {
+        code: "HFS_EXPLICIT_EXPORT_SURFACE",
+        en: "`<file>` exports `<what>` with a type left to inference.",
+        fix: "Write the type where it is exported: the return type after the parameter list, the type of the exported variable, or the type of the parameter.",
+    },
     "destructive-confirm-in-dialog": {
         code: "FE_DESTRUCTIVE_CONFIRM_IN_DIALOG",
         en: "`<file>` renders a final destructive press outside its confirmation dialog.",
@@ -382,6 +392,11 @@ export const why = {
         en: "`<file>` starts a recurring timer that reads the wall clock for live time labels.",
         fix: "Render Grammar RelativeTime with the target dateTime, locale and mode; its shared ticker owns live relative time and countdown updates.",
     },
+    "swr-extension-from-package": {
+        code: "FE_STACK_FORBIDDEN",
+        en: "`<file>` imports the `Middleware` or `ScopedMutator` type of `swr`, so it writes an SWR middleware or a cache binding the stack already ships.",
+        fix: "List `viewerSwrConfig` (it carries `pollingRestart`) in the app's SWRConfig and write through the `createViewerCache()` instance of `@starci/next-data`.",
+    },
     "fe-stack-import": {
         code: "FE_STACK_FORBIDDEN",
         en: "`<file>` imports `<what>`, a package or scoped package family the front-end stack forbids.",

package/dist/project-graph.d.ts

@@ -30,3 +30,17 @@ export declare const projectGraph: ({ repoRoot, injectedTypeScript }: {
     repoRoot: string;
     injectedTypeScript?: object;
 }) => ProjectGraphSnapshot;
+/**
+ * The same findings from the graph this process has already built, so a process that linted the side hands them out without building the graph again.
+ *
+ * The rules read one graph per process and per side, built when the first file is linted. The ESLint child of `starci app check --gate lint` calls
+ * this after its run and writes the result beside its report; the result cache keeps the graph findings from it instead of building the graph a
+ * second time in the CLI. A process that has not built the graph yet builds it here, once, exactly as `projectGraph` does, and the value is the
+ * same: `projectGraph` is a fresh build, this is the build the rules used.
+ *
+ * @param input - The side folder (`repoRoot`, the folder of the side's `eslint.config.mjs`).
+ * @returns The findings of the rules of `recommended`, keyed by path relative to the side folder.
+ */
+export declare const projectGraphSnapshot: ({ repoRoot }: {
+    repoRoot: string;
+}) => ProjectGraphSnapshot;

package/dist/project-graph.js

@@ -30,7 +30,22 @@ export const recommended = Object.fromEntries(mine.map((e) => [`starci-fe/${e.id
  */
 export const projectGraph = ({ repoRoot, injectedTypeScript }) => {
     resetProjectGraphs();
-    const graph = buildProjectGraph({ repoRoot, ...(injectedTypeScript === undefined ? {} : { injectedTypeScript }), runtimeRoot: RUNTIME });
+    return snapshotOf(buildProjectGraph({ repoRoot, ...(injectedTypeScript === undefined ? {} : { injectedTypeScript }), runtimeRoot: RUNTIME }));
+};
+/**
+ * The same findings from the graph this process has already built, so a process that linted the side hands them out without building the graph again.
+ *
+ * The rules read one graph per process and per side, built when the first file is linted. The ESLint child of `starci app check --gate lint` calls
+ * this after its run and writes the result beside its report; the result cache keeps the graph findings from it instead of building the graph a
+ * second time in the CLI. A process that has not built the graph yet builds it here, once, exactly as `projectGraph` does, and the value is the
+ * same: `projectGraph` is a fresh build, this is the build the rules used.
+ *
+ * @param input - The side folder (`repoRoot`, the folder of the side's `eslint.config.mjs`).
+ * @returns The findings of the rules of `recommended`, keyed by path relative to the side folder.
+ */
+export const projectGraphSnapshot = ({ repoRoot }) => snapshotOf(buildProjectGraph({ repoRoot, runtimeRoot: RUNTIME }));
+/** The findings of the rules of this canon in a built graph, by side-relative path, each list sorted by line, column, code and message. */
+const snapshotOf = (graph) => {
     const byFile = {};
     for (const [file, findings] of graph.byFile) {
         for (const finding of findings) {

package/dist/skeleton-states.js

@@ -29,12 +29,17 @@ const rootOf = (input) => {
     }
     return null;
 };
-const enclosingFunction = (node) => {
+/**
+ * The outermost function around a node: the hook itself. A fold inside a `useMemo` callback or a `slotOfReads` projector is judged by what the
+ * hook returns of the read's status and by the slot it builds, not by the callback alone, which holds neither.
+ */
+const hookFunction = (node) => {
+    let found = null;
     for (let current = node.parent; current; current = current.parent) {
         if (current.type === "ArrowFunctionExpression" || current.type === "FunctionDeclaration" || current.type === "FunctionExpression")
-            return current;
+            found = current;
     }
-    return null;
+    return found;
 };
 const nameOfKey = (key) => (key.type === "Identifier" ? key.name : key.type === "Literal" && typeof key.value === "string" ? key.value : null);
 // -- no-swr-default-array -----------------------------------------------------------------------------------
@@ -79,7 +84,7 @@ const noSwrDefaultArray = defineRule({
                 const root = rootOf(node.left);
                 if (!root || !isHookResult(context, node, root))
                     return;
-                const fn = enclosingFunction(node);
+                const fn = hookFunction(node);
                 if (!fn)
                     return;
                 const text = source.getText(fn);

package/dist/transport.d.ts

@@ -19,6 +19,7 @@
  * standing in for a status.
  */
 import { type Recommended, type Rules } from "./lib/rule.js";
+/** The HTTP methods of the REST client whose first argument is the request path. */
 /**
  * `fetch` is reached only in the API layer, each canonical transport library only in its home, and no other HTTP library exists.
  *
@@ -28,7 +29,7 @@ import { type Recommended, type Rules } from "./lib/rule.js";
  * `socket.io-client` only by `hooks/socketio/`. Native `WebSocket` is refused everywhere, including the API layer.
  * Every other file reaches the back end through an SWR hook over an operation.
  */
-export declare const fetchOnlyInApiClient: import("./lib/rule.js").Rule<"library" | "outside" | "channel" | "websocket" | "xhr" | "placed" | "authDoor", []>;
+export declare const fetchOnlyInApiClient: import("./lib/rule.js").Rule<"library" | "outside" | "channel" | "websocket" | "xhr" | "placed", []>;
 /** Every `fetch` of the API layer (a custom fetch handed to the Apollo http link, a raw call) carries an abort signal, so a hung backend cannot hang a reader. */
 export declare const clientFetchHasSignal: import("./lib/rule.js").Rule<"signal", []>;
 /** No module-level mutable state in the API layer: a token or locale in a `let` leaks across requests. */

package/dist/transport.js

@@ -23,7 +23,7 @@ import { isNode } from "./lib/ast.js";
 import { hfsOf } from "./lib/hfs.js";
 import { forbiddingConcern, packageNameOf } from "./lib/fe-stack.js";
 import { defineRule } from "./lib/rule.js";
-import { globalReferences, inSlot, isApiClient, isApiLayer, isApiRest, isAuthDoor, isAuthTokenStore, isOutcomeModule } from "./lib/scope.js";
+import { globalReferences, inSlot, isApiClient, isApiLayer, isApiRest, isOutcomeModule } from "./lib/scope.js";
 import { typed } from "./lib/types.js";
 /**
  * The canonical transport libraries and the one place each may be imported (fe-stack graphql, rest and realtime): Apollo in
@@ -31,7 +31,7 @@ import { typed } from "./lib/types.js";
  */
 const PLACED_TRANSPORTS = new Map([
     ["@apollo/client", { where: "the API layer (`modules/api`)", allowed: (context) => isApiLayer(context) }],
-    ["axios", { where: "the REST calls of the API layer (`modules/api/rest/`) and the auth door (`modules/auth/auth-door.ts`)", allowed: (context) => isApiRest(context) || isAuthDoor(context) }],
+    ["axios", { where: "the REST calls of the API layer (`modules/api/rest/`)", allowed: (context) => isApiRest(context) }],
     ["socket.io-client", { where: "`hooks/socketio/`", allowed: (context) => inSlot(context, "fe.hooks.socketio") }],
     ["graphql-ws", { where: "the Apollo clients of the API layer (`modules/api/graphql/clients/`, or the shared api package's `graphql/clients/`)", allowed: (context) => isApiClient(context) }],
 ]);
@@ -140,26 +140,6 @@ const transportUses = (context) => {
 };
 // -- FE-TRANSPORT-1 --------------------------------------------------------------------------------
 /** The HTTP methods of the REST client whose first argument is the request path. */
-const REST_METHODS = new Set(["get", "post", "put", "patch", "delete", "request"]);
-/** The static text of a path argument (a literal, or a template's fixed parts), or null when nothing about it is fixed. */
-const staticPath = (node) => {
-    if (node?.type === "Literal" && typeof node.value === "string")
-        return node.value;
-    if (node?.type === "TemplateLiteral")
-        return node.quasis.map((quasi) => quasi.value.cooked ?? "").join("<expression>");
-    return null;
-};
-/** A path segment `auth/`: the app's own back-end auth doors. */
-const AUTH_DOOR_PATH = /(?:^|\/)auth\//;
-/** In the auth door, a REST call whose path the rule can read must name an `/auth/` door; a fully dynamic path is left to review. */
-const judgeAuthDoorCall = (context, node) => {
-    if (node.callee.type !== "MemberExpression" || node.callee.computed || node.callee.property.type !== "Identifier" || !REST_METHODS.has(node.callee.property.name))
-        return;
-    const path = staticPath(node.arguments[0]);
-    if (path === null || AUTH_DOOR_PATH.test(path))
-        return;
-    context.report({ node, messageId: "authDoor", data: { call: `.${node.callee.property.name}()`, path } });
-};
 /**
  * `fetch` is reached only in the API layer, each canonical transport library only in its home, and no other HTTP library exists.
  *
@@ -180,13 +160,11 @@ export const fetchOnlyInApiClient = defineRule({
             library: "`{{name}}` is a second HTTP transport. The front end talks to its back end through Apollo (`modules/api/graphql`) and the axios REST calls (`modules/api/rest`); another library is another set of timeout, retry and error rules. Use an operation of `modules/api`.",
             placed: "`{{name}}` is imported outside {{where}}, the one place the front-end stack gives it. A component or hook that holds the transport itself skips the link chain (token, locale, retry, timeout) and the one result vocabulary. Call an operation of `modules/api` through its SWR hook (`hooks/swr/`), or listen through `hooks/socketio/`.",
             xhr: "`XMLHttpRequest` is a second transport. Use an operation of the API layer (`modules/api`).",
-            authDoor: "`{{call}}` calls `{{path}}` from the auth door. `modules/auth/auth-door.ts` calls only the app's own back-end auth doors (`/auth/...`: login, signup, refresh, logout, password reset, resend verification); every other REST call is `modules/api/rest/`.",
             websocket: "Native `WebSocket` is a second realtime transport. Use socket.io-client in `hooks/socketio/`, the front end's realtime owner.",
         },
     },
     create(context) {
         const layer = isApiLayer(context);
-        const authDoor = isAuthDoor(context);
         const library = (node, source) => {
             const name = packageNameOf(source);
             if (name === null || forbiddingConcern(source))
@@ -231,8 +209,6 @@ export const fetchOnlyInApiClient = defineRule({
                     library(node, node.source.value);
             },
             CallExpression(node) {
-                if (authDoor)
-                    judgeAuthDoorCall(context, node);
                 // `require("axios")` where `require` is the CommonJS global.
                 const [first] = node.arguments;
                 if (node.callee.type !== "Identifier" || node.callee.name !== "require" || first?.type !== "Literal")
@@ -290,14 +266,14 @@ const isTransportFile = (context) => isApiLayer(context) && !hfsOf(context).rela
 export const noSharedTransportState = defineRule({
     meta: {
         type: "problem",
-        docs: { description: "The API layer (`modules/api/**`) and `modules/auth` hold no module-level `let`/`var`, but the in-memory access-token store `modules/auth/token-store.ts`." },
+        docs: { description: "The API layer (`modules/api/**`) and `modules/auth` hold no module-level `let`/`var`." },
         schema: [],
         messages: {
             shared: "A module-level `{{kind}}` in the API layer. A token or locale kept there is shared by every request on the server and by every reader in one tab, so one reader's credential can answer another's request. Pass the credential as a parameter or read it from context.",
         },
     },
     create(context) {
-        if (!isTransportFile(context) && !(inSlot(context, "fe.modules.auth") && !isAuthTokenStore(context)))
+        if (!isTransportFile(context) && !inSlot(context, "fe.modules.auth"))
             return {};
         const check = (node) => {
             const declaration = node.type === "VariableDeclaration" ? node : node.type === "ExportNamedDeclaration" ? node.declaration : undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@starci/eslint-canon-fe",
-  "version": "9.9.12",
+  "version": "9.11.0",
   "description": "Universal front-end lint laws for TypeScript and Next.js, independent of the selected Grammar family.",
   "type": "module",
   "license": "MIT",

package/runtime/bundle.json

@@ -125,6 +125,7 @@
     "scripts/hfs/declaration-shape.mjs",
     "scripts/hfs/declaration-slots.mjs",
     "scripts/hfs/edition-slots.mjs",
+    "scripts/hfs/explicit-surface-rule.mjs",
     "scripts/hfs/linear-text.mjs",
     "scripts/hfs/param-names.mjs",
     "scripts/hfs/path-findings.mjs",
@@ -150,6 +151,7 @@
     "scripts/hfs/trailing-slashes.mjs",
     "scripts/hfs/typescript-programs.mjs",
     "scripts/hfs/view.mjs",
+    "scripts/lib/declaration-surface.mjs",
     "scripts/lib/dockerfile.mjs",
     "scripts/lib/env.mjs",
     "scripts/lib/event-contract.mjs",