@starci/eslint-canon-fe 9.10.0 → 9.12.0

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 9.12.0 - 2026-11-03
+
+- Changed: the runtime copies carry R368's acceptance of the module-definition helpers, the module-per-transport confinement of the helpers and the `@starci/nest-kit` and `@starci/next-i18n` pins; `i18n-stack-in-one-module` refuses every product-source call of a next-intl layer builder (the stack is `@starci/next-i18n`'s).
+- Added: `starciFePackagesConfig`, `loadPackagesHfs` and `scopeToPackages`: the rules of the front end over `packages/<pkg>/src/workbench/**` and `src/public/**` of the root workspace packages, over the package view of the app root, for the managed root `eslint.config.mjs`; the workbench contract stays with the back-end canon and the project-graph rules with the side folders.
+- Changed: the runtime copy of the slot manifest carries the slots `app.packages`, `app.module-registry` and `app.packages-lint`.
+
+## 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.

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

@@ -43,7 +43,8 @@ export declare const rules: Record<string, Rule>;
 export declare const recommended: Record<string, "error" | "warn">;
 /** Flat-config options that make inline directives ineffective rather than merely forbidden. */
 export { linterOptions } from "./lib/config.js";
-export { loadHfs } from "./lib/hfs.js";
+export { loadHfs, loadPackagesHfs } from "./lib/hfs.js";
+export { scopeToPackages } from "./lib/config.js";
 /**
  * The Vietnamese why of each rule that carries a catalogue code: `{ code, vi, fixVi }`.
  *
@@ -81,6 +82,18 @@ export declare const reactHooksRules: (reactHooks: unknown) => Record<string, "e
 export declare const starciFeConfig: ({ hfs }?: {
     readonly hfs?: unknown;
 }) => Linter.Config[];
+/**
+ * The flat config of the front-end subpaths of an app's root workspace packages (`packages/<pkg>/src/workbench/**` and `src/public/**`), for the
+ * managed root `eslint.config.mjs`: `starciFePackagesConfig({ hfs: loadPackagesHfs(import.meta.url) })`, composed with the Grammar family's
+ * `...PackagesConfig`. The very rules of `starciFeConfig` over the package view, but the project-graph rules, which judge the import graph of a
+ * side folder that a package is not part of.
+ *
+ * @param input - The package view of the app root.
+ * @returns The flat config.
+ */
+export declare const starciFePackagesConfig: ({ hfs }?: {
+    readonly hfs?: unknown;
+}) => Linter.Config[];
 /**
  * The flat config of a TypeScript front-end tree that is no HFS app (a runtime package, the harness UI):
  * `export default starciPlainSourceConfig({ root: import.meta.dirname })`. It lints the tree's `src/` with types, with the inline-directive fence, the

package/dist/index.js

@@ -49,7 +49,7 @@ import { recommended as typeSafetyRecommended, rules as typeSafetyRules } from "
 import { recommended as projectGraphRecommended, rules as projectGraphRules } from "./project-graph.js";
 import { recommended as sonarParityRecommended, rules as sonarParityRules } from "./sonar-parity.js";
 import { recommended as spacingRecommended, rules as spacingRules } from "./spacing.js";
-import { buildFeConfig, buildPlainSourceConfig, COUNTING } from "./lib/config.js";
+import { buildFeConfig, buildPlainSourceConfig, COUNTING, scopeToPackages } from "./lib/config.js";
 import { why } from "./lib/why.js";
 import { recommended as uiRulingsRecommended, rules as uiRulingsRules } from "./ui-rulings.js";
 /** Each law's contribution, kept separate so a duplicate name is detectable rather than silent. */
@@ -134,7 +134,8 @@ export const rules = Object.fromEntries(CONTRIBUTIONS.flatMap((entry) => Object.
 export const recommended = Object.fromEntries(CONTRIBUTIONS.flatMap((entry) => Object.entries(entry.recommended)));
 /** Flat-config options that make inline directives ineffective rather than merely forbidden. */
 export { linterOptions } from "./lib/config.js";
-export { loadHfs } from "./lib/hfs.js";
+export { loadHfs, loadPackagesHfs } from "./lib/hfs.js";
+export { scopeToPackages } from "./lib/config.js";
 /**
  * The Vietnamese why of each rule that carries a catalogue code: `{ code, vi, fixVi }`.
  *
@@ -246,6 +247,21 @@ export const starciFeConfig = ({ hfs } = {}) => {
         source: { ...recommended, ...reactHooksRules(reactHooks) },
     });
 };
+/**
+ * The flat config of the front-end subpaths of an app's root workspace packages (`packages/<pkg>/src/workbench/**` and `src/public/**`), for the
+ * managed root `eslint.config.mjs`: `starciFePackagesConfig({ hfs: loadPackagesHfs(import.meta.url) })`, composed with the Grammar family's
+ * `...PackagesConfig`. The very rules of `starciFeConfig` over the package view, but the project-graph rules, which judge the import graph of a
+ * side folder that a package is not part of.
+ *
+ * @param input - The package view of the app root.
+ * @returns The flat config.
+ */
+export const starciFePackagesConfig = ({ hfs } = {}) => {
+    const reactHooks = loadReactHooks();
+    const graph = new Set(Object.keys(projectGraphRecommended));
+    const source = { ...Object.fromEntries(Object.entries(recommended).filter(([name]) => !graph.has(name))), ...reactHooksRules(reactHooks) };
+    return scopeToPackages(buildFeConfig({ hfs, plugin, reactHooks, tsPlugin: loadTsPlugin(), sonar: loadSonarPlugins(), source }));
+};
 /**
  * The flat config of a TypeScript front-end tree that is no HFS app (a runtime package, the harness UI):
  * `export default starciPlainSourceConfig({ root: import.meta.dirname })`. It lints the tree's `src/` with types, with the inline-directive fence, the

package/dist/lib/config.d.ts

@@ -88,3 +88,16 @@ export declare const buildPlainSourceConfig: ({ root, plugin, hooks, reactHooks,
     readonly sonar: SonarPlugins;
     readonly canon?: boolean;
 }) => Linter.Config[];
+/** The front-end subpaths of a root workspace package: its workbench (drawn with Grammar) and its public face; the React-free workbench contract stays back end. */
+export declare const PACKAGE_SOURCE_FILES: readonly string[];
+/** What a package folder never lints: installed packages, build output, generated wire types. */
+export declare const PACKAGE_IGNORED: readonly string[];
+/**
+ * A front-end flat config (the canon's or a Grammar family's) narrowed to the front-end subpaths of the root workspace packages of an app:
+ * the very rules of the fe side, over `packages/<pkg>/src/workbench/**` and `src/public/**` of the app root, the workbench contract left to the
+ * back-end canon. The global ignore block becomes the package one. The config is read, never changed.
+ *
+ * @param config - The flat config of a front end built over the package view.
+ * @returns The same blocks with `files` narrowed to the package subpaths.
+ */
+export declare const scopeToPackages: (config: readonly Linter.Config[]) => Linter.Config[];

package/dist/lib/config.js

@@ -148,3 +148,21 @@ export const buildPlainSourceConfig = ({ root, plugin, hooks, reactHooks, tsPlug
         { files: [...PLAIN_SOURCE_FILES], ignores: [...OUTSIDE_THE_SCAN_FILES], plugins: { sonarjs: sonar.sonarjs, unicorn: sonar.unicorn }, rules: sonarWayRules(sonar.sonarjs, "fe").rules },
     ];
 };
+/** The front-end subpaths of a root workspace package: its workbench (drawn with Grammar) and its public face; the React-free workbench contract stays back end. */
+export const PACKAGE_SOURCE_FILES = Object.freeze(["packages/*/src/workbench/**/*.{ts,tsx}", "packages/*/src/public/**/*.{ts,tsx}"]);
+const PACKAGE_CONTRACT = Object.freeze(["packages/*/src/workbench/contract/**"]);
+/** What a package folder never lints: installed packages, build output, generated wire types. */
+export const PACKAGE_IGNORED = Object.freeze(["**/node_modules/**", "**/.next/**", "**/dist/**", "**/coverage/**", "**/__generated__/**"]);
+/**
+ * A front-end flat config (the canon's or a Grammar family's) narrowed to the front-end subpaths of the root workspace packages of an app:
+ * the very rules of the fe side, over `packages/<pkg>/src/workbench/**` and `src/public/**` of the app root, the workbench contract left to the
+ * back-end canon. The global ignore block becomes the package one. The config is read, never changed.
+ *
+ * @param config - The flat config of a front end built over the package view.
+ * @returns The same blocks with `files` narrowed to the package subpaths.
+ */
+export const scopeToPackages = (config) => config.map((block) => {
+    if (block.files === undefined)
+        return { ...block, ignores: [...PACKAGE_IGNORED] };
+    return { ...block, files: [...PACKAGE_SOURCE_FILES], ignores: [...(block.ignores ?? []), ...PACKAGE_CONTRACT] };
+});

package/dist/lib/hfs.d.ts

@@ -16,6 +16,22 @@ export declare const loadHfs: (configUrl: string | URL) => HfsView;
  * @returns The frozen HFS view.
  */
 export declare const hfsFromDeclaration: (declaration: unknown, repoRoot: string) => HfsView;
+/**
+ * The HFS view of the root workspace packages of an app, judged by the laws of the fe side: the managed root `eslint.config.mjs`
+ * (`packages/*` of the app root) calls this. Paths are the app's own; a package file is of the tier `package`.
+ *
+ * @param configUrl - `import.meta.url` of the app root's `eslint.config.mjs`.
+ * @returns The frozen HFS view (profile fe over the paths of the app root).
+ */
+export declare const loadPackagesHfs: (configUrl: string | URL) => HfsView;
+/**
+ * The HFS view of the root packages of an in-memory app declaration, for rule tests.
+ *
+ * @param declaration - An app `hfs.json` object.
+ * @param repoRoot - The absolute app root the linted filenames live under.
+ * @returns The frozen HFS view.
+ */
+export declare const packagesHfsFromDeclaration: (declaration: unknown, repoRoot: string) => HfsView;
 /** True for a value that carries the view's resolver (`slotOf`), the test the canon has always made of `settings.starci.hfs`. */
 export declare const isHfsView: (value: unknown) => value is HfsView;
 /**

package/dist/lib/hfs.js

@@ -13,7 +13,7 @@
  */
 import { dirname } from "node:path";
 import { fileURLToPath } from "node:url";
-import { declaredHfsView, openHfsView } from "#runtime/scripts/hfs/view.mjs";
+import { declaredHfsView, declaredPackagesHfsView, openHfsView, openPackagesHfsView } from "#runtime/scripts/hfs/view.mjs";
 import { RUNTIME_ROOT } from "./package-root.js";
 const RUNTIME = RUNTIME_ROOT;
 /**
@@ -31,6 +31,22 @@ export const loadHfs = (configUrl) => openHfsView({ runtimeRoot: RUNTIME, repoRo
  * @returns The frozen HFS view.
  */
 export const hfsFromDeclaration = (declaration, repoRoot) => declaredHfsView({ runtimeRoot: RUNTIME, declaration, repoRoot, side: "fe" });
+/**
+ * The HFS view of the root workspace packages of an app, judged by the laws of the fe side: the managed root `eslint.config.mjs`
+ * (`packages/*` of the app root) calls this. Paths are the app's own; a package file is of the tier `package`.
+ *
+ * @param configUrl - `import.meta.url` of the app root's `eslint.config.mjs`.
+ * @returns The frozen HFS view (profile fe over the paths of the app root).
+ */
+export const loadPackagesHfs = (configUrl) => openPackagesHfsView({ runtimeRoot: RUNTIME, repoRoot: dirname(fileURLToPath(configUrl)), side: "fe" });
+/**
+ * The HFS view of the root packages of an in-memory app declaration, for rule tests.
+ *
+ * @param declaration - An app `hfs.json` object.
+ * @param repoRoot - The absolute app root the linted filenames live under.
+ * @returns The frozen HFS view.
+ */
+export const packagesHfsFromDeclaration = (declaration, repoRoot) => declaredPackagesHfsView({ runtimeRoot: RUNTIME, declaration, repoRoot, side: "fe" });
 /** True for a value that carries the view's resolver (`slotOf`), the test the canon has always made of `settings.starci.hfs`. */
 export const isHfsView = (value) => typeof value === "object" && value !== null && "slotOf" in value && typeof value.slotOf === "function";
 /** The `starci.hfs` entry of a settings object, read without trusting its shape. */

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

@@ -392,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

@@ -384,14 +384,19 @@ export const why = {
     },
     "i18n-stack-in-one-module": {
         code: "FE_I18N_PLACEMENT",
-        en: "`<file>` builds a layer of the next-intl stack itself (`defineRouting`, `createNavigation`, `getRequestConfig`, `createMiddleware`). The stack is written once for the whole repo.",
-        fix: "Use the shared i18n factory; a single app keeps routing/request config in modules/i18n and navigation in modules/routes. The proxy imports routing without navigation.",
+        en: "`<file>` builds a layer of the next-intl stack itself (`defineRouting`, `createNavigation`, `getRequestConfig`, `createMiddleware`). The stack is written once, in `@starci/next-i18n`.",
+        fix: "Describe the languages with `defineI18n` and call `createProxy`, `createI18nNavigation`, `createRequestConfig` and `createReadLocaleSegment` of `@starci/next-i18n`; the proxy imports no navigation.",
     },
     "no-app-relative-clock": {
         code: "FE_SIZE_AND_STATE_BUDGET",
         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/next-conventions.d.ts

@@ -30,13 +30,13 @@ export declare const noNativeAnchor: import("./lib/rule.js").Rule<"internal" | "
 /** No route written by hand outside `modules/routes`. */
 export declare const noHardcodedRoute: import("./lib/rule.js").Rule<"route", []>;
 /**
- * The next-intl stack is written once per repository.
+ * The next-intl stack is written once, in `@starci/next-i18n`.
  *
  * `defineRouting` (`next-intl/routing`), `createNavigation` (`next-intl/navigation`), `getRequestConfig` (`next-intl/server`) and
  * `createMiddleware` (`next-intl/middleware`), resolved by the import that binds the called name (a renamed import or a namespace
- * member counts), have one owner. A shared i18n package owns its stack. In a one-app repository, routing and request
- * config belong to modules/i18n while createNavigation belongs to modules/routes. The proxy imports routing without
- * evaluating navigation: next-intl's navigation module selects React runtime exports unavailable in the proxy.
+ * member counts), are called by that package and by no product source: an app describes its languages with `defineI18n` and builds
+ * the proxy, the navigation, the request config and the layout's locale read with the package's factories. The proxy imports the
+ * routing without evaluating navigation: next-intl's navigation module selects React runtime exports unavailable in the proxy.
  *
  * It does not replace `no-second-i18n-stack`: that rule refuses another i18n LIBRARY at its import, this one refuses a second copy of
  * next-intl's own stack. Different evidence, different remedy.

package/dist/next-conventions.js

@@ -374,13 +374,13 @@ const stackFactoryOf = (context, callee) => {
     return stackFactory(definition, importedName(definition.node));
 };
 /**
- * The next-intl stack is written once per repository.
+ * The next-intl stack is written once, in `@starci/next-i18n`.
  *
  * `defineRouting` (`next-intl/routing`), `createNavigation` (`next-intl/navigation`), `getRequestConfig` (`next-intl/server`) and
  * `createMiddleware` (`next-intl/middleware`), resolved by the import that binds the called name (a renamed import or a namespace
- * member counts), have one owner. A shared i18n package owns its stack. In a one-app repository, routing and request
- * config belong to modules/i18n while createNavigation belongs to modules/routes. The proxy imports routing without
- * evaluating navigation: next-intl's navigation module selects React runtime exports unavailable in the proxy.
+ * member counts), are called by that package and by no product source: an app describes its languages with `defineI18n` and builds
+ * the proxy, the navigation, the request config and the layout's locale read with the package's factories. The proxy imports the
+ * routing without evaluating navigation: next-intl's navigation module selects React runtime exports unavailable in the proxy.
  *
  * It does not replace `no-second-i18n-stack`: that rule refuses another i18n LIBRARY at its import, this one refuses a second copy of
  * next-intl's own stack. Different evidence, different remedy.
@@ -388,20 +388,15 @@ const stackFactoryOf = (context, callee) => {
 export const i18nStackInOneModule = defineRule({
     meta: {
         type: "problem",
-        docs: { description: "A shared i18n package owns the stack; one app keeps routing/request config in i18n and navigation in routes, with a routing-only proxy entry." },
+        docs: { description: "The next-intl stack is built by @starci/next-i18n; an app calls its factories and never next-intl's own, and its proxy never evaluates the navigation." },
         schema: [],
         messages: {
-            stack: "`{{name}}` builds the next-intl stack outside its owner. Keep {{where}} and import the owned result through its public entry.",
-            proxyNavigation: "The proxy imports navigation runtime through {{source}}. Import routing from the i18n public entry, or use the shared package's routing-only proxy export; the proxy must not evaluate the routes/navigation barrel.",
+            stack: "`{{name}}` builds the next-intl stack in the app. Describe the languages with `defineI18n` and build the proxy, the navigation, the request config and the locale read of the layout with `createProxy`, `createI18nNavigation`, `createRequestConfig` and `createReadLocaleSegment` of `@starci/next-i18n` (FE-I18N-1).",
+            proxyNavigation: "The proxy imports navigation runtime through {{source}}. Build the proxy with `createProxy` of `@starci/next-i18n/proxy` over the i18n description; the proxy must not evaluate the routes/navigation barrel.",
         },
     },
     create(context) {
-        const hfs = hfsOf(context);
-        const slot = slotOfFile(context);
-        const single = hfs.apps.length === 1;
-        const proxy = single && slot === "fe.source-root-pinned" && roleOfFile(context) === "proxy";
-        const proxyFile = slot === "fe.source-root-pinned" && roleOfFile(context) === "proxy";
-        const where = single ? "routing/request config in modules/i18n and navigation in modules/routes" : "the stack in the shared i18n package that every app calls";
+        const proxyFile = slotOfFile(context) === "fe.source-root-pinned" && roleOfFile(context) === "proxy";
         const safeProxyImport = (node) => {
             if (!proxyFile || !node.source || (node.type === "ImportDeclaration" ? node.importKind === "type" : node.exportKind === "type"))
                 return;
@@ -419,18 +414,8 @@ export const i18nStackInOneModule = defineRule({
             ExportAllDeclaration: safeProxyImport,
             CallExpression(node) {
                 const factory = stackFactoryOf(context, node.callee);
-                // In a one-app repository the proxy (role `proxy`) mounts the locale middleware built from the one routing; a shared repository
-                // builds it in the i18n package and the proxy re-exports it.
-                if (factory?.name === "createMiddleware" && proxy)
-                    return;
-                if (slot === "fe.package.i18n")
-                    return;
-                if (single && factory?.name === "createNavigation" && slot === "fe.modules.routes")
-                    return;
-                if (single && factory?.name !== "createNavigation" && slot === "fe.modules.i18n")
-                    return;
                 if (factory)
-                    context.report({ node, messageId: "stack", data: { name: factory.name, where } });
+                    context.report({ node, messageId: "stack", data: { name: factory.name } });
             },
         };
     },

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/docs/next-conventions.md

@@ -207,9 +207,7 @@ router.push(routes.newWorkspace())
 
 ## `starci-fe/i18n-stack-in-one-module`
 
-The shared i18n package owns a multi-app stack. A single app keeps routing/request config in `modules/i18n` and navigation in the `modules/routes` public entry.
-
-`defineRouting` and `getRequestConfig` remain in the i18n owner. `createNavigation` belongs to a shared `fe.package.i18n` owner or the single app's `fe.modules.routes` owner. A single app's proxy mounts locale middleware using the routing-only public i18n entry. A shared package exposes its routing-only proxy entry as a declared package export. The proxy does not import `next-intl/navigation` or the app's routes/navigation barrel. Named import aliases and namespace imports keep their factory identity.
+The next-intl stack is built by `@starci/next-i18n`, never by a product source. `defineRouting`, `createNavigation`, `getRequestConfig` and `createMiddleware` are called by no file of an app or of a shared package, wherever it sits. An app states its languages with `defineI18n` and builds the proxy, the navigation, the request config and the layout's locale read with `createProxy`, `createI18nNavigation`, `createRequestConfig` and `createReadLocaleSegment`. The proxy does not import `next-intl/navigation` or the app's routes/navigation barrel. Named import aliases and namespace imports keep their factory identity.
 
 **Invalid** (`apps/web/src/modules/i18n/request.ts`, a repository with two apps)
 
@@ -218,15 +216,17 @@ import { getRequestConfig } from "next-intl/server"
 export default getRequestConfig(async () => ({ locale: "vi", messages: {} }))
 ```
 
-**Valid** (`apps/web/src/modules/i18n/index.ts`)
+**Valid** (`apps/web/src/modules/i18n/request.ts`)
 
 ```ts
-import { createAppI18n } from "@acme/i18n"
-export const i18n = createAppI18n({ locales: ["vi"] })
+import { createRequestConfig } from "@starci/next-i18n/request"
+import { i18n } from "./routing"
+
+export default createRequestConfig(i18n, { app: "web", loadMessages: (locale) => import(`./messages/${locale}.json`) })
 ```
 
 **Finding code:** `FE_I18N_PLACEMENT`
 
-**Why:** `<file>` builds a layer of the next-intl stack itself (`defineRouting`, `createNavigation`, `getRequestConfig`, `createMiddleware`). The stack may be written only once per repo.
+**Why:** `<file>` builds a layer of the next-intl stack itself (`defineRouting`, `createNavigation`, `getRequestConfig`, `createMiddleware`). The stack is written once, in `@starci/next-i18n`.
 
-**Fix:** Use the shared i18n factory, or keep routing/request configuration in the single app's i18n module and navigation in its public routes entry. Keep navigation imports out of the proxy.
+**Fix:** Describe the languages with `defineI18n` and call `createProxy`, `createI18nNavigation`, `createRequestConfig` and `createReadLocaleSegment` of `@starci/next-i18n`. Keep navigation imports out of the proxy.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@starci/eslint-canon-fe",
-  "version": "9.10.0",
+  "version": "9.12.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

@@ -101,6 +101,7 @@
     "scripts/hfs/architecture/render-graph.mjs",
     "scripts/hfs/architecture/render-prop-across-server.mjs",
     "scripts/hfs/architecture/required-files.mjs",
+    "scripts/hfs/architecture/root-packages.mjs",
     "scripts/hfs/architecture/route-files-thin.mjs",
     "scripts/hfs/architecture/schema-owner.mjs",
     "scripts/hfs/architecture/server-action.mjs",