@yasainet/eslint 0.0.73 → 0.0.75

package/src/common/local-plugins/form-state-naming.mjs

@@ -1,13 +1,3 @@
-/**
- * Enforce {Verb}{Subject}FormState pattern for FormState type names.
- *
- * Targets TSInterfaceDeclaration and TSTypeAliasDeclaration whose name ends
- * with "FormState". Requires at least two PascalCase words before FormState
- * (e.g. SignInFormState, CreateCommentFormState) so the verb prefix is never
- * omitted. Single-noun names like "ContactFormState" are forbidden — rename
- * to "CreateContactFormState" to make intent explicit.
- */
-
 const FORM_STATE_ALLOW = /^[A-Z][a-z]+[A-Z]\w*FormState$/;
 
 function reportIfInvalid(context, idNode) {
@@ -26,7 +16,7 @@ export const formStateNamingRule = {
     type: "problem",
     messages: {
       invalidName:
-        "FormState type '{{ name }}' must follow {Verb}{Subject}FormState pattern (e.g. CreateCommentFormState, SignInFormState). At least two PascalCase words are required.",
+        "FormState 型 '{{ name }}' は {Verb}{Subject}FormState 形式にする (例 CreateCommentFormState, SignInFormState)。PascalCase 2 語以上が必須。",
     },
     schema: [],
   },

package/src/common/local-plugins/form-state-shape.mjs

@@ -1,37 +1,3 @@
-/**
- * Enforce the canonical `{ data, error: { message } }` shape for FormState types.
- *
- * Targets `TSInterfaceDeclaration` and `TSTypeAliasDeclaration` whose name ends
- * with `FormState`. Required shape:
- *
- * ```ts
- * interface XxxFormState {
- *   data: T | null;            // T may be any type; `data: null` literal also OK
- *   error: { message: string } | null;
- * }
- * ```
- *
- * Why this shape:
- *
- * - Single uniform shape lets entry / hook / UI be templated and lint-checked.
- * - Forbids `code` / `status` / similar discriminator fields that tend to grow
- *   defensive branches (e.g. `error.code === "unauthenticated"`) which usually
- *   indicate a missing upstream guard (route gate, button conditional render),
- *   not a legitimate need for in-action discrimination.
- * - Discriminated unions (`{ data: T; error: null } | { data: null; error: ... }`)
- *   are rejected for the same reason — they leak shape complexity into hooks
- *   (`useActionState<T | null>`), components (`state?.error`), and entries.
- *
- * Future extension when Stripe / payment libraries actually need `code` / `status`:
- *
- * - a) Add a `// allow-error-code: <reason>` comment opt-out to this rule, so
- *      individual FormStates can justify their extra field on the previous line.
- * - b) Change the rule to whitelist a fixed set of allowed extra fields (enum
- *      of standard error codes shared across the codebase).
- *
- * Until that need materializes, this rule is strict (no opt-out) per YAGNI.
- */
-
 const FORM_STATE_SUFFIX = "FormState";
 
 function isNullLiteralType(node) {
@@ -168,21 +134,21 @@ export const formStateShapeRule = {
     },
     messages: {
       dataMissing:
-        "FormState '{{ name }}' must have a `data` property (use `data: null` if there is no payload).",
+        "FormState '{{ name }}' に `data` プロパティが必須 (payload が無ければ `data: null`)。",
       dataNotNullable:
-        "FormState '{{ name }}' `data` must allow null (e.g. `data: T | null` or `data: null`).",
+        "FormState '{{ name }}' の `data` は null 許容にする (例: `data: T | null` / `data: null`)。",
       errorMissing:
-        "FormState '{{ name }}' must have an `error: { message: string } | null` property.",
+        "FormState '{{ name }}' に `error: { message: string } | null` プロパティが必須。",
       errorNotNullable:
-        "FormState '{{ name }}' `error` must be nullable (`{ message: string } | null`).",
+        "FormState '{{ name }}' の `error` は nullable にする (`{ message: string } | null`)。",
       errorWrongShape:
-        "FormState '{{ name }}' `error` must be exactly `{ message: string } | null`.",
+        "FormState '{{ name }}' の `error` は厳密に `{ message: string } | null`。",
       errorExtraField:
-        "FormState '{{ name }}' `error` object must contain only `message: string`. Forbidden field: '{{ field }}'. See form-state-shape rule docstring for the rationale and the future opt-out plan for Stripe-like cases.",
+        "FormState '{{ name }}' の `error` は `message: string` のみ許可。禁止フィールド: '{{ field }}'。",
       extraProperty:
-        "FormState '{{ name }}' must contain only `data` and `error`. Forbidden property: '{{ field }}'.",
+        "FormState '{{ name }}' は `data` と `error` のみ。禁止プロパティ: '{{ field }}'。",
       discriminatedUnion:
-        "FormState '{{ name }}' must be a single interface or type literal, not a discriminated union.",
+        "FormState '{{ name }}' は単一の interface か type literal にする。discriminated union 不可。",
     },
     schema: [],
   },

package/src/common/local-plugins/import-path-style.mjs

@@ -1,18 +1,13 @@
 import path from "path";
 
-/**
- * Enforce import path style within features:
- * - Same-feature imports must use relative paths
- * - Cross-feature imports must use @/ alias
- */
 export const importPathStyleRule = {
   meta: {
     type: "problem",
     messages: {
       useRelative:
-        "Same-feature import must use a relative path instead of '{{ importPath }}'.",
+        "同一 feature の import は相対パスにする ('{{ importPath }}' を使わない)。",
       useAlias:
-        "Cross-feature import must use '@/' instead of relative path '{{ importPath }}'.",
+        "feature を跨ぐ import は '@/' にする (相対パス '{{ importPath }}' を使わない)。",
     },
     schema: [
       {
@@ -48,7 +43,6 @@ export const importPathStyleRule = {
       if (!source || typeof source.value !== "string") return;
       const importPath = source.value;
 
-      // Same-feature alias should be a relative path for consistency.
       if (
         importPath.startsWith(sameFeaturePrefix) ||
         importPath === sameFeatureExact
@@ -61,7 +55,6 @@ export const importPathStyleRule = {
         return;
       }
 
-      // Cross-feature relative path should use @/ alias for clarity.
       if (importPath.startsWith(".")) {
         const resolved = path.resolve(path.dirname(filename), importPath);
         if (

package/src/common/local-plugins/index.mjs

@@ -7,13 +7,13 @@ import { importPathStyleRule } from "./import-path-style.mjs";
 import { layoutMainStructuralOnlyRule } from "./layout-main-structural-only.mjs";
 import { namespaceImportNameRule } from "./namespace-import-name.mjs";
 import { noAnyReturnRule } from "./no-any-return.mjs";
+import { noColocatedTestRule } from "./no-colocated-test.mjs";
 import { queriesExportRule } from "./queries-export.mjs";
 import { queriesNamespaceImportRule } from "./queries-namespace-import.mjs";
 import { schemaNamingRule } from "./schema-naming.mjs";
 import { supabaseColumnsSatisfiesRule } from "./supabase-columns-satisfies.mjs";
 import { supabaseSelectTypedColumnsRule } from "./supabase-select-typed-columns.mjs";
 
-/** Single plugin object to avoid ESLint "Cannot redefine plugin" errors. */
 export const localPlugin = {
   rules: {
     "entry-single-service-call": entrySingleServiceCallRule,
@@ -25,6 +25,7 @@ export const localPlugin = {
     "layout-main-structural-only": layoutMainStructuralOnlyRule,
     "namespace-import-name": namespaceImportNameRule,
     "no-any-return": noAnyReturnRule,
+    "no-colocated-test": noColocatedTestRule,
     "queries-export": queriesExportRule,
     "queries-namespace-import": queriesNamespaceImportRule,
     "schema-naming": schemaNamingRule,

package/src/common/local-plugins/layout-main-structural-only.mjs

@@ -1,24 +1,3 @@
-/**
- * Forbid decoration utility classes on the `<main>` element.
- *
- * Design philosophy: `app/**\/layout.tsx` の `<main>` は Header / Footer の
- * 縦積みを受け持つ構造スロット。装飾（余白・間隔）は page.tsx 側の Container 等が
- * 持つべき。main に padding / margin / gap を直接当てると、page 全体に暗黙の
- * オフセットが生まれ、page ごとの調整余地が失われる。
- *
- * Disallowed Tailwind token prefixes (case-sensitive):
- *
- * - `p`, `m`, `py`, `px`, `pt`, `pb`, `pl`, `pr`, `my`, `mx`, `mt`, `mb`, `ml`, `mr` — padding / margin
- * - `space-x`, `space-y` — sibling spacing
- * - `gap` — flex / grid gap
- *
- * Allowed: structural utilities (`flex`, `flex-1`, `flex-col`, `min-h-*`,
- * `block`, `relative`, etc.)
- *
- * className value forms supported: string Literal, TemplateLiteral,
- * `cn(...)` / `clsx(...)` style CallExpression args (string args only).
- */
-
 const DISALLOWED_TOKEN = /^(?:[pm][xytrbl]?-|space-[xy]-|gap-)/;
 
 function collectStringLiterals(node, out) {
@@ -68,7 +47,7 @@ export const layoutMainStructuralOnlyRule = {
     type: "problem",
     messages: {
       invalidToken:
-        "<main> in layout.tsx must be structural-only. Move spacing/decoration ({{ tokens }}) to page.tsx (e.g. <Container className=\"py-8\">).",
+        "layout.tsx の <main> は構造のみ。spacing/装飾 ({{ tokens }}) は page.tsx へ移す (例 <Container className=\"py-8\">)。",
     },
     schema: [],
   },

package/src/common/local-plugins/namespace-import-name.mjs

@@ -1,13 +1,3 @@
-/**
- * Enforce consistent naming for `import * as` namespace imports
- * within feature-based architecture.
- *
- * Convention: import * as {featureName}{Scope}{Layer} from "{path}/{layerDir}/{scope}"
- *
- * Layer はファイル名 suffix ではなくディレクトリ名 (`queries/` / `services/` 等) から識別する。
- */
-
-/** @type {Record<string, string>} */
 const LAYER_DIR_MAP = {
   queries: "Query",
   services: "Service",
@@ -19,39 +9,27 @@ const LAYER_DIR_MAP = {
   constants: "Constant",
 };
 
-/** Convert a snake_case or kebab-case string to camelCase. */
 function toCamelCase(str) {
   return str.replace(/[-_]+(.)/g, (_, c) => c.toUpperCase());
 }
 
-/** Convert a snake_case or kebab-case string to PascalCase. */
 function toPascalCase(str) {
   const camel = toCamelCase(str);
   return camel.charAt(0).toUpperCase() + camel.slice(1);
 }
 
-/**
- * Parse import source to extract featureName, scope, and layer:
- *
- * - feature root 内の path のみを対象とする (外部 lib / shared / 相対インポートで feature 外に行くものは無視)
- * - segments は `[feature, layerDir, ..., file]` の形式を想定し、末尾要素を scope として取り出す
- * - layerDir が LAYER_DIR_MAP に無い場合は対象外
- */
 function parseImportSource(importPath, featureRoot) {
-  // Normalize alias: @/features/... → features/...
   let normalized = importPath;
   const aliasBase = featureRoot.replace(/^src\//, "@/");
   if (normalized.startsWith(aliasBase + "/")) {
     normalized = featureRoot + normalized.slice(aliasBase.length);
   }
 
-  // Only process paths within the feature root
   const rootPrefix = featureRoot + "/";
   const rootIdx = normalized.indexOf(rootPrefix);
   if (rootIdx === -1) return null;
 
   const afterRoot = normalized.slice(rootIdx + rootPrefix.length);
-  // Expected: {feature}/{layerDir}/{scope}
   const segments = afterRoot.split("/");
   if (segments.length < 3) return null;
 
@@ -65,7 +43,6 @@ function parseImportSource(importPath, featureRoot) {
   return { featureDir, scope, layer };
 }
 
-/** Build the expected namespace import name. */
 function buildExpectedName(featureDir, scope, layer) {
   const featureCamel = toCamelCase(featureDir);
   const scopePascal = toPascalCase(scope);
@@ -78,7 +55,7 @@ export const namespaceImportNameRule = {
     type: "suggestion",
     messages: {
       mismatch:
-        "Namespace import should be named '{{ expected }}' instead of '{{ actual }}'.",
+        "namespace import は '{{ expected }}' と命名する ('{{ actual }}' ではなく)。",
     },
     schema: [
       {
@@ -96,7 +73,6 @@ export const namespaceImportNameRule = {
 
     return {
       ImportDeclaration(node) {
-        // Only check namespace imports: import * as Name
         const nsSpecifier = node.specifiers.find(
           (s) => s.type === "ImportNamespaceSpecifier",
         );
@@ -104,7 +80,6 @@ export const namespaceImportNameRule = {
 
         const importPath = node.source.value;
 
-        // Skip external/built-in imports (only check relative and alias)
         if (
           !importPath.startsWith("./") &&
           !importPath.startsWith("../") &&
@@ -113,7 +88,6 @@ export const namespaceImportNameRule = {
           return;
         }
 
-        // For relative imports, resolve to an absolute-like path for parsing
         let resolvedPath = importPath;
         if (importPath.startsWith(".")) {
           const fileDir = context.filename.replace(/\/[^/]+$/, "");

package/src/common/local-plugins/no-any-return.mjs

@@ -1,12 +1,5 @@
 import ts from "typescript";
 
-/**
- * Exported function の return type が any を含んでいる場合に error:
- *
- * - typescript-eslint の type checker を使って inferred type まで見る
- * - queries / services の API 境界を any 汚染から守ることで、domain shape が型で保証される
- * - Promise<any>, Promise<{ data: any }>, Array<any> など nested も展開して検査する
- */
 export const noAnyReturnRule = {
   meta: {
     type: "problem",
@@ -16,7 +9,7 @@ export const noAnyReturnRule = {
     },
     messages: {
       anyInReturn:
-        "Exported function's inferred return type contains `any`: {{ typeText }}. Annotate with a known type or narrow from the source — public layer APIs must have known shapes.",
+        "export 関数の推論された返り値型に `any` が含まれる: {{ typeText }}。既知の型を注釈するか絞り込む (public な層の API は型を確定させる)。",
     },
     schema: [],
   },
@@ -41,7 +34,6 @@ export const noAnyReturnRule = {
       return checker.getReturnTypeOfSignature(signature);
     };
 
-    // `any` を type tree 全体で検出する (Promise<any>, { a: any }, any[] 等を展開)
     const containsAny = (type, seen = new Set()) => {
       if (!type) return false;
       if (seen.has(type)) return false;

package/src/common/local-plugins/no-colocated-test.mjs

@@ -0,0 +1,26 @@
+/**
+ * orchestration layer (services / queries / entries) での co-located test を禁止する:
+ *
+ * - これらは Supabase 等への配線で、unit 化すると mock の echo になる
+ * - 検証は e2e に委ね、純粋ロジックは utils へ抽出してそちらを unit する
+ */
+export const noColocatedTestRule = {
+  meta: {
+    type: "problem",
+    messages: {
+      forbidden:
+        "orchestration layer (services/queries/entries) に test を置かない。" +
+        "mock の echo になる:\n" +
+        "- 配線の検証は e2e に委ねる\n" +
+        "- 純粋ロジックは utils へ抽出し、そちらを unit する",
+    },
+    schema: [],
+  },
+  create(context) {
+    return {
+      Program(node) {
+        context.report({ node, messageId: "forbidden" });
+      },
+    };
+  },
+};

package/src/common/local-plugins/queries-export.mjs

@@ -1,11 +1,3 @@
-/**
- * Enforce verb allow list for `queries/*.ts` exports:
- *
- * - The queries layer is the TS-idiomatic translation of Rails 5 actions
- *   (index/show -> get, create, update, destroy -> delete)
- * - Auth ceremonies (signUp / signIn / signOut) are admitted as industry-standard exceptions
- */
-
 const QUERIES_ALLOW = /^(get|create|update|delete|signUp|signIn|signOut)([A-Z]|$)/;
 
 function isFunctionLike(initNode) {
@@ -37,7 +29,7 @@ export const queriesExportRule = {
     type: "problem",
     messages: {
       invalidName:
-        "queries export '{{ name }}' must start with one of: get, create, update, delete, signUp, signIn, signOut. (Rails 5 actions translated to TS idiom)",
+        "queries の export '{{ name }}' は get, create, update, delete, signUp, signIn, signOut のいずれかで始める。",
     },
     schema: [],
   },

package/src/common/local-plugins/queries-namespace-import.mjs

@@ -1,13 +1,3 @@
-/**
- * Enforce namespace imports for files under `queries/`:
- *
- * - Value imports must use `import * as xxxQuery from "..."` so that the
- *   `naming/namespace-import-name` rule can guarantee a single canonical
- *   binding (e.g. `comicsServerQuery.getComics`)
- * - Type-only imports are exempted because they have no runtime presence
- * - 検出は path に `/queries/<name>` が含まれることのみで行い、suffix には依存しない
- */
-
 const QUERIES_PATH = /\/queries\/[^/]+$/;
 
 export const queriesNamespaceImportRule = {
@@ -15,7 +5,7 @@ export const queriesNamespaceImportRule = {
     type: "problem",
     messages: {
       useNamespace:
-        'Use `import * as xxxQuery from "{{ source }}"` instead of named imports for queries layer. Type-only imports (`import type {}`) are allowed.',
+        'queries 層は named import でなく `import * as xxxQuery from "{{ source }}"` を使う (`import type {}` は可)。',
     },
     schema: [],
   },

package/src/common/local-plugins/schema-naming.mjs

@@ -1,17 +1,11 @@
-/**
- * Enforce that exported variables in schema files use camelCase with a "Schema" suffix.
- * e.g., `export const userSchema = z.object(...)` is valid.
- *       `export const UserSchema = ...` or `export const user = ...` are invalid.
- * `export type` declarations are ignored (used for `z.infer` types).
- */
 export const schemaNamingRule = {
   meta: {
     type: "problem",
     messages: {
       missingSuffix:
-        "Exported variable '{{ name }}' in a schema file must end with 'Schema'.",
+        "schema file の export 変数 '{{ name }}' は 'Schema' で終える。",
       invalidCasing:
-        "Exported variable '{{ name }}' must be camelCase (start with a lowercase letter).",
+        "export 変数 '{{ name }}' は camelCase にする (小文字始まり)。",
     },
     schema: [],
   },

package/src/common/local-plugins/supabase-columns-satisfies.mjs

@@ -1,27 +1,3 @@
-/**
- * Enforce `<string literal> as const` for `*_COLUMNS` constant declarations.
- *
- * Apply to `**\/queries/*.ts` and `**\/constants/*.ts`.
- *
- * `*_COLUMNS` 定数は Supabase の `.select()` に直接渡される。`as const` を
- * 外すと TypeScript が `string` に widen し、Supabase の `.select<Query>()`
- * が literal を parse できなくなって row 型推論が壊れる（戻り値が
- * `GenericStringError` になる）。
- *
- * Allowed:
- *   const POST_DETAIL_COLUMNS = "id,url,platform" as const;
- *
- * Banned:
- *   const POST_DETAIL_COLUMNS = "id,url,platform";              // string に widen
- *   const POST_DETAIL_COLUMNS = ["id", "url"] as const;         // 配列
- *   const POST_DETAIL_COLUMNS = [...] as const satisfies ...;   // 配列 + satisfies
- *   const POST_DETAIL_COLUMNS = `id,${col}`;                    // template literal
- *
- * Why: シンプルな string literal を `as const` で保つだけで、Supabase の
- * 型推論（row 型 / column 名タイポ検出）はすべて自動で効く。runtime helper
- * （`joinColumns` 等）は不要。
- */
-
 const COLUMNS_NAME = /^[A-Z][A-Z0-9_]*_COLUMNS$/;
 
 function isStringAsConst(initNode) {
@@ -41,7 +17,7 @@ export const supabaseColumnsSatisfiesRule = {
     type: "problem",
     messages: {
       shape:
-        'Column constant `{{ name }}` must be `"<comma-separated columns>" as const`. `as const` を外すと Supabase の `.select()` 型推論が壊れる。配列 / template literal も不可。',
+        'column 定数 `{{ name }}` は `"<comma-separated columns>" as const` にする。`as const` を外すと Supabase の `.select()` 型推論が壊れる。配列 / template literal も不可。',
     },
     schema: [],
   },

package/src/common/local-plugins/supabase-select-typed-columns.mjs

@@ -1,35 +1,3 @@
-/**
- * Enforce explicit column lists for Supabase `.select()` calls.
- *
- * Apply to `**\/queries/*.ts`. `.select()` の引数は次のいずれかでなければならない:
- *
- * - inline string literal（例: `.select("id,url,platform")`）
- * - `*_COLUMNS` という UPPER_SNAKE 命名の identifier（例: `.select(POST_DETAIL_COLUMNS)`）
- *
- * `*_COLUMNS` 定数は companion rule `supabase-columns-satisfies` で
- * `<string literal> as const` の形が強制される。これにより:
- *
- * - Supabase の `.select()` は literal string を parse して row 型を推論できる
- * - 存在しない column 名は Supabase の型推論が `SelectQueryError` として弾く（compile time）
- * - runtime helper（`joinColumns`）は不要
- *
- * Banned:
- *   .select()                    implicit "all columns"
- *   .select("*")                 silent exposure of new schema columns
- *   .select(`${x},y`)            dynamic concatenation
- *   .select(cols.join(","))      runtime expression
- *   .select(someVar)             non-conforming variable
- *
- * Allowed:
- *   .select("id,url,platform")        inline literal
- *   .select(POST_DETAIL_COLUMNS)      *_COLUMNS named constant
- *
- * Why: column lists must be (1) statically analyzable for grep / review,
- * (2) literal so Supabase can infer the row shape, (3) never silently grow
- * on schema additions. For column-level access control, use Postgres views
- * (`from("posts_public")`).
- */
-
 const COLUMNS_NAME = /^[A-Z][A-Z0-9_]*_COLUMNS$/;
 
 export const supabaseSelectTypedColumnsRule = {
@@ -37,15 +5,15 @@ export const supabaseSelectTypedColumnsRule = {
     type: "problem",
     messages: {
       noArgs:
-        "Empty `.select()` returns all columns implicitly. Pass a string literal or a `*_COLUMNS` constant.",
+        "空の `.select()` は全列を暗黙取得する。文字列リテラルか `*_COLUMNS` 定数を渡す。",
       wildcard:
-        '`.select("*")` exposes new schema columns silently. Enumerate columns explicitly.',
+        '`.select("*")` はスキーマ拡張時に列を暗黙露出する。列を明示列挙する。',
       template:
-        "Template literal in `.select()` defeats type inference. Use a string literal or a `*_COLUMNS` constant.",
+        "`.select()` の template literal は型推論を壊す。文字列リテラルか `*_COLUMNS` 定数を使う。",
       shapeArg:
-        "`.select()` argument must be a string literal or a `*_COLUMNS` identifier.",
+        "`.select()` の引数は文字列リテラルか `*_COLUMNS` 識別子にする。",
       naming:
-        "Column constant `{{ name }}` must be UPPER_SNAKE_CASE ending with `_COLUMNS` (e.g. POST_DETAIL_COLUMNS).",
+        "column 定数 `{{ name }}` は `_COLUMNS` で終わる UPPER_SNAKE_CASE にする (例 POST_DETAIL_COLUMNS)。",
     },
     schema: [],
   },

package/src/deno/CLAUDE.md

@@ -0,0 +1,10 @@
+# src/deno/CLAUDE.md
+
+Supabase Edge Functions (Deno) 固有 rule の置き場所判断:
+
+- `boundaries/<surface>.mjs` — Deno 固有の boundary (外界 → features の入口)
+  - 種類: lib / utils / entry-point
+- `local-plugins/` — Deno 固有の local plugin
+- `index.mjs` — Deno entry。common の rule + 上記 file を合成
+
+Deno entry 横断の共通 rule は `src/common/` に追加する。

package/src/deno/boundaries/entry-point.mjs

@@ -0,0 +1,44 @@
+import { denoLocalPlugin } from "../local-plugins/index.mjs";
+
+const FUNCTIONS_ROOT = "supabase/functions";
+
+export const denoEntryPointConfigs = [
+  {
+    name: "deno/entry-point",
+    files: [`${FUNCTIONS_ROOT}/**/*.ts`],
+    ignores: [`${FUNCTIONS_ROOT}/_*/**`],
+    rules: {
+      "no-restricted-imports": [
+        "error",
+        {
+          patterns: [
+            {
+              group: ["**/services/*", "**/services"],
+              message:
+                "top-level file は services を直接 import 不可。entries 経由で使う。",
+            },
+            {
+              group: ["**/queries/*", "**/queries"],
+              message:
+                "top-level file は queries を直接 import 不可。entries 経由で使う。",
+            },
+            {
+              group: ["*/_lib/*", "*/_lib/**"],
+              message:
+                "top-level file は _lib/ を直接 import 不可。entries 経由で使う。",
+            },
+          ],
+        },
+      ],
+    },
+  },
+  {
+    name: "deno/flat-entry-point",
+    files: [`${FUNCTIONS_ROOT}/**/*.ts`],
+    ignores: [`${FUNCTIONS_ROOT}/_*/**`],
+    plugins: { "deno-local": denoLocalPlugin },
+    rules: {
+      "deno-local/flat-entry-point": "error",
+    },
+  },
+];

package/src/deno/boundaries/lib.mjs

@@ -0,0 +1,28 @@
+const FUNCTIONS_ROOT = "supabase/functions";
+const FEATURE_ROOT = "supabase/functions/_features";
+
+export const denoLibBoundaryConfigs = [
+  {
+    name: "deno/lib-boundary",
+    files: [`${FUNCTIONS_ROOT}/**/*.ts`],
+    ignores: [
+      `${FUNCTIONS_ROOT}/_lib/**`,
+      `${FEATURE_ROOT}/**/queries/**`,
+      `${FEATURE_ROOT}/**/types/**`,
+    ],
+    rules: {
+      "no-restricted-imports": [
+        "error",
+        {
+          patterns: [
+            {
+              group: ["*/_lib/*", "*/_lib/**"],
+              message:
+                "_lib/ は queries からのみ import 可。他層は queries 経由で使う。",
+            },
+          ],
+        },
+      ],
+    },
+  },
+];

package/src/deno/boundaries/utils.mjs

@@ -0,0 +1,25 @@
+const FUNCTIONS_ROOT = "supabase/functions";
+
+export const denoUtilsBoundaryConfigs = [
+  {
+    name: "deno/utils-boundary",
+    files: [`${FUNCTIONS_ROOT}/_utils/**/*.ts`],
+    rules: {
+      "no-restricted-imports": [
+        "error",
+        {
+          patterns: [
+            {
+              group: ["*/_features/*", "*/_features/**"],
+              message: "_utils/ は _features/ を import 不可。依存方向を守る。",
+            },
+            {
+              group: ["*/_lib/*", "*/_lib/**"],
+              message: "_utils/ は _lib/ を import 不可。依存方向を守る。",
+            },
+          ],
+        },
+      ],
+    },
+  },
+];

package/src/deno/index.mjs

@@ -1,29 +1,25 @@
-import { createEntryPointConfigs } from "../common/entry-points.mjs";
+import { createEntryPointConfigs } from "../common/boundaries/entry-point.mjs";
 import { createCommonConfigs } from "../common/index.mjs";
-import { denoImportsConfigs } from "./imports.mjs";
+
+import { denoEntryPointConfigs } from "./boundaries/entry-point.mjs";
+import { denoLibBoundaryConfigs } from "./boundaries/lib.mjs";
+import { denoUtilsBoundaryConfigs } from "./boundaries/utils.mjs";
 
 const FEATURE_ROOT = "supabase/functions/_features";
 
-const denoEntryPointConfigs = createEntryPointConfigs(
+const denoNamespaceImportConfigs = createEntryPointConfigs(
   ["supabase/functions/**/*.ts"],
   ["supabase/functions/_*/**"],
 );
 
-// Deno files are not covered by the consumer's project tsconfig
-// (Supabase functions live outside Next.js's tsconfig), so type-aware
-// rules cannot consult the type checker. Disable them here and rely on
-// `deno check` / `deno lint` for type-level guarantees.
-//
-// `rulesFiles` is narrowed so the override only affects Deno files. When this
-// entry is combined with `next`/`node`, those entries keep their type-aware
-// settings on their own files.
-/** Deno ESLint flat config entry point. */
 export const eslintConfig = [
   ...createCommonConfigs(FEATURE_ROOT, {
     banAliasImports: true,
     typeAware: false,
     rulesFiles: ["supabase/functions/**/*.ts"],
   }),
-  ...denoImportsConfigs,
+  ...denoLibBoundaryConfigs,
   ...denoEntryPointConfigs,
+  ...denoUtilsBoundaryConfigs,
+  ...denoNamespaceImportConfigs,
 ];