oxlint-plugin-arch 0.13.1 → 0.13.2

package/dist/preset/groups/top.d.ts

@@ -0,0 +1,2 @@
+import type { PresetBuilder } from '../../types/preset.types.ts';
+export declare const topGroup: PresetBuilder<'top'>;

package/dist/preset/preset-sets.d.ts

@@ -0,0 +1,2 @@
+import type * as PresetTypes from '../types/preset.types.ts';
+export declare function presetSets(folders: PresetTypes.PresetFolders, sets?: Record<string, PresetTypes.PresetSet>): PresetTypes.PresetFolders;

package/dist/preset/preset.constants.d.ts

@@ -80,7 +80,6 @@ export declare const presetEffectServerImports: {
 export declare const presetRecipeMark: unique symbol;
 export declare const presetDetectBackend: string[];
 export declare const presetDetectSkip: string[];
-export declare const presetStylesheetNames: string[];
 export declare const presetRegistryFiles: string[];
 export declare const presetRegistrySkip: string[];
 export declare const presetServerEntries: string[];

package/dist/preset/preset.js

@@ -399,6 +399,7 @@ var presetGroupOrder = [
   "kit",
   "limits",
   "deny",
+  "top",
   "externals"
 ];
 var presetDefaultGroups = [
@@ -412,6 +413,7 @@ var presetDefaultGroups = [
   "imports",
   "tests",
   "deny",
+  "top",
   "externals"
 ];
 var presetExternals = [
@@ -432,7 +434,7 @@ var presetGroupOptions = {
   limits: { level: "error", lines: 400, types: 1000, complexity: 32 },
   style: { level: "error", quotes: "single", semicolons: true, multiline: true, padding: true, dashes: true },
   basics: { level: "error", trivial: true, state: true, switch: true, negation: true },
-  naming: { level: "error", files: true, exports: true, folders: true, unique: undefined },
+  naming: { level: "error", files: true, exports: true, folders: true, unique: undefined, imports: {} },
   comments: { level: "error", directives: true },
   types: { level: "error", placement: true, safety: true, colocated: [] },
   imports: { level: "error", sort: true, boundaries: true, aliases: {}, internal: undefined },
@@ -449,9 +451,10 @@ var presetGroupOptions = {
   schemas: { level: "error" },
   forms: { level: "error" },
   sql: { level: "error" },
-  effect: { level: "error", code: true, width: 140, exports: undefined, skip: undefined, entries: [] },
+  effect: { level: "error", code: true, width: 140, exports: undefined, skip: undefined, entries: [], files: [], strict: true },
   console: { level: "error" },
-  deny: { level: "error", imports: {}, calls: {} },
+  deny: { level: "error", imports: {}, calls: {}, only: [] },
+  top: { level: "error", allow: undefined, deny: undefined, message: undefined, stem: undefined, singularize: undefined, roles: undefined, separators: undefined, file: undefined, placeholder: undefined },
   externals: { level: "error" }
 };
 var presetQueryWrites = ["insertInto", "updateTable", "deleteFrom", "mergeInto", "replaceInto", "dispatch", "send"];
@@ -518,7 +521,6 @@ var presetEffectServerImports = {
 var presetRecipeMark = Symbol("recipe");
 var presetDetectBackend = ["@orpc/server", "hono", "kysely", "drizzle-orm", "express", "fastify", "elysia"];
 var presetDetectSkip = ["node_modules", "dist", "build", "coverage", "public", ".output", ".next", ".vinext", ".turbo", ".wrangler", "target"];
-var presetStylesheetNames = ["styles", "globals", "global", "app", "index", "main", "style", "tailwind"];
 var presetRegistryFiles = ["core/core.services.ts", "service.ts"];
 var presetRegistrySkip = ["brand", "database", "db", "math", "security", "tools"];
 var presetServerEntries = ["rpc", "server", "security", "services"];
@@ -790,7 +792,8 @@ function presetSource(root, directory, configured) {
 }
 function presetFilled(conventions, exists) {
   return Object.fromEntries(Object.entries(conventions).filter(([path, folder]) => {
-    const empty = folder instanceof Object && folder.deny instanceof Object && Object.keys(folder.deny.imports ?? {}).length === 0;
+    const denied = folder instanceof Object && folder.deny instanceof Object ? { ...folder.deny.imports, ...folder.deny.calls } : undefined;
+    const empty = denied !== undefined && Object.keys(denied).length === 0;
     return exists(path) && !empty;
   }));
 }
@@ -814,8 +817,27 @@ function presetMerge(base, top) {
   const merged = presetMergeObject(base, top, 2);
   const before = base.layout instanceof Object ? base.layout.files : undefined;
   const after = top.layout instanceof Object ? top.layout.files : undefined;
+  const owned = [base.deny, top.deny].flatMap((deny) => deny instanceof Object ? deny.only ?? [] : []);
+  if (owned.length > 0 && merged.deny instanceof Object) {
+    merged.deny = { ...merged.deny, only: owned };
+  }
   return before && after && merged.layout instanceof Object ? { ...merged, layout: { ...merged.layout, files: [...before, ...after] } } : merged;
 }
+function presetNames(inherited, entries, option) {
+  if (!Array.isArray(entries) || !entries.every((entry) => typeof entry === "string" && presetLayoutFileName.test(entry))) {
+    throw new PresetError(`${option} takes file names such as \`*.prompts.ts\`; \`!*.utils.ts\` removes one.`);
+  }
+  const names = [...inherited];
+  for (const entry of entries) {
+    const index = names.indexOf(entry.startsWith("!") ? entry.slice(1) : entry);
+    if (entry.startsWith("!") && index !== -1) {
+      names.splice(index, 1);
+    } else if (!entry.startsWith("!") && index === -1) {
+      names.push(entry);
+    }
+  }
+  return names;
+}
 
 // src/preset/preset-effect.ts
 var presetEffectQueryWrites = Object.fromEntries(presetQueryWrites.map((name) => [name, "A queries file only reads; write in an actions file."]));
@@ -823,8 +845,11 @@ var presetEffectWorkflowCalls = Object.fromEntries(["selectFrom", ...presetQuery
 var presetEffectFrameworks = Object.fromEntries(["@tanstack/*", "react-dom", "react-dom/**", "next", "next/**", "vite"].map((name) => [name, "The server imports no web framework."]));
 var presetEffectRouters = ["@tanstack/react-router", "next/link", "next/navigation", "next/router", "expo-router"];
 var presetEffectErrors = ["Schema.TaggedError", "Schema.ErrorClass", "Data.TaggedError", "Data.Error"];
-var presetEffectContractNames = "^[a-z0-9]+(?:-[a-z0-9]+)*(?:[.]schemas|[.]admin[.]schemas|[.]contract|[.]admin[.]contract|[.]errors|[.]layer[.]types)[.]ts$";
-var presetEffectContractMessage = "Contract files use <d>.schemas.ts, <d>-<part>.schemas.ts, <d>.admin.schemas.ts, <d>.contract.ts, <d>.admin.contract.ts, <d>.errors.ts or <d>.layer.types.ts.";
+var presetEffectContractKinds = ["*.schemas.ts", "*.admin.schemas.ts", "*.contract.ts", "*.admin.contract.ts", "*.errors.ts", "*.layer.types.ts", "*.service.ts"];
+var presetEffectSpans = [
+  "error",
+  { labels: [{ callee: "Effect.fn", name: "{name}", drop: ["Action", "Query"], loose: true }] }
+];
 var presetEffectSchemaUses = {
   namespaces: ["Schema"],
   methods: ["Array", "Union", "Record", "Tuple"],
@@ -897,17 +922,18 @@ function presetEffectServerKeys(at) {
     },
     [at("domains/*/*.actions.ts")]: {
       limits: { lines: 1000 },
-      rules: { "arch/files-exports": ["error", { stem: "folder", patterns: ["{domain}Action[A-Z]\\w*"], types: true }] }
+      rules: { "arch/files-exports": ["error", { stem: "folder", patterns: ["{domain}Action[A-Z]\\w*"], types: true }], "arch/naming-labels": presetEffectSpans }
     },
     [at("domains/*/*.queries.ts")]: {
       limits: { lines: 1000 },
       deny: { calls: presetEffectQueryWrites, imports: { "./*.actions{,.ts}": "A queries file imports no actions." } },
-      rules: { "arch/files-exports": ["error", { stem: "folder", patterns: ["{domain}Query[A-Z]\\w*"], types: true }] }
+      rules: { "arch/files-exports": ["error", { stem: "folder", patterns: ["{domain}Query[A-Z]\\w*"], types: true }], "arch/naming-labels": presetEffectSpans }
     },
     [at("domains/*/*.constants.ts")]: { rules: { "arch/files-no-functions": ["error", { reexports: false }] } },
     [at("domains/*/*.layer.ts")]: { rules: { "arch/effect-layer-file": ["error", { suffix: "Layer" }] } },
     [at("domains/*/*.driver.ts")]: { rules: { "arch/effect-layer-file": ["error", { suffix: "Layer" }] } },
     [at("domains/*/*.workflows.ts")]: {
+      rules: { "arch/naming-labels": ["error", { labels: [{ callee: "Workflow.make", name: "{name}", drop: "Workflow$" }] }] },
       deny: {
         calls: presetEffectWorkflowCalls,
         imports: {
@@ -926,7 +952,14 @@ function presetEffectServerKeys(at) {
     [at("rpc")]: { rules: { "arch/code-delegate": "error" } }
   };
 }
-function presetEffectContractKeys(at) {
+function presetEffectContractKeys(at, files) {
+  const kinds = presetNames(presetEffectContractKinds, files ?? [], "effect.files");
+  if (kinds.some((kind) => !/^\*\.[a-z0-9.-]+\.ts$/.test(kind))) {
+    throw new PresetError("effect.files takes contract file kinds such as `*.service.ts`.");
+  }
+  const pattern = `^[a-z0-9]+(?:-[a-z0-9]+)*(?:${kinds.map((kind) => kind.slice(1, -3).replaceAll(".", "[.]")).join("|")})[.]ts$`;
+  const listed = kinds.flatMap((kind) => kind === "*.schemas.ts" ? ["<d>.schemas.ts", "<d>-<part>.schemas.ts"] : [`<d>${kind.slice(1)}`]);
+  const message = `Contract files use ${listed.slice(0, -1).join(", ")} or ${listed.at(-1)}.`;
   const schemas = {
     rules: {
       "arch/files-constants-only": ["error", { types: true, functions: true }],
@@ -939,7 +972,7 @@ function presetEffectContractKeys(at) {
   return {
     [at("*/*.ts")]: {
       rules: {
-        "arch/naming-file": ["error", { pattern: presetEffectContractNames, message: presetEffectContractMessage }],
+        "arch/naming-file": ["error", { pattern, message }],
         "arch/naming-folder": ["error", { singularize: "none", separators: [".", "-"] }],
         "arch/files-exports": ["error", { stem: "folder", singularize: "trailing-s", patterns: ["{Domain}\\w*"] }]
       }
@@ -949,6 +982,7 @@ function presetEffectContractKeys(at) {
     [at("*/*.contract.ts")]: schemas,
     [at("*/*.errors.ts")]: noFunctions,
     [at("*/*.layer.types.ts")]: noFunctions,
+    [at("*/*.service.ts")]: noFunctions,
     [at("shared/*.ts")]: {
       rules: {
         "arch/naming-file": "off",
@@ -967,17 +1001,113 @@ function presetEffectContractKeys(at) {
     }
   };
 }
-function presetEffectUnit(root, key, value) {
+function presetEffectTop(allow) {
+  return { top: { allow, stem: "folder" } };
+}
+function presetEffectStrictServer(at, service) {
+  const operations = presetEffectTop([{ kind: "const", exported: true, from: "^Effect\\.fn" }, { kind: "const", names: "^decode[A-Z]" }]);
+  const layerKeys = service === undefined ? {} : { "arch/effect-layer-keys": ["error", { service }] };
+  return {
+    [at(".")]: {
+      rules: {
+        "arch/effect-yield-name": "error",
+        "arch/effect-yields-first": "error",
+        "arch/code-inside": ["error", { inside: [{ callee: "*.transaction", calls: { "*Workflow.execute": "Start the workflow after the commit." } }] }]
+      }
+    },
+    [at("domains")]: { naming: { imports: { "./{file}.ts": "{File}" } } },
+    [at("domains/*/*.actions.ts")]: operations,
+    [at("domains/*/*.queries.ts")]: operations,
+    [at("domains/*/*.utils.ts")]: {
+      ...operations,
+      rules: { "arch/naming-labels": ["error", { labels: [{ callee: "Effect.fn", name: "{name}", loose: true }] }] }
+    },
+    [at("domains/*/*.layer.ts")]: {
+      rules: { "arch/naming-keys": ["error", { callees: ["*.bind", "*.of"], name: "^{folder}(?:Action|Query){Path}$", inline: false }], ...layerKeys }
+    },
+    [at("domains/*/*.workflows.ts")]: {
+      ...presetEffectTop([{ kind: "const", from: "(?:^Workflow\\.make|\\.toLayer|^Layer\\.\\w+|^Schedule\\.\\w+)$" }]),
+      rules: {
+        "arch/files-exports": ["error", { stem: "folder", patterns: ["{Domain}\\w*Workflow", "{Domain}WorkflowsLayer", "{domain}Schedule[A-Z]\\w*"] }],
+        "arch/naming-labels": [
+          "error",
+          {
+            labels: [
+              { callee: "Workflow.make", name: "{name}", drop: "Workflow$" },
+              { callee: "Effect.fn", name: "{name}", within: "*.toLayer", loose: true }
+            ]
+          }
+        ]
+      }
+    },
+    [at("domains/*/*.constants.ts")]: presetEffectTop([{ kind: "const", exported: true, names: "^{DOMAIN}_" }]),
+    [at("domains/*/*.config.ts")]: presetEffectTop([{ kind: "const", exported: true, names: "^{domain}\\w*Config$" }]),
+    [at("domains/*/*.prompts.ts")]: { rules: { "arch/files-exports": ["error", { stem: "folder", patterns: ["{domain}Prompt[A-Z]\\w*"], types: true }] } },
+    [at("rpc/*/*.ts")]: {
+      ...presetEffectTop([{ kind: "const", exported: true }]),
+      rules: {
+        "arch/naming-file": ["error", { template: "{group}/rpc.{group}.{area}.ts", message: "Handlers use rpc/<group>/rpc.<group>.<area>.ts." }],
+        "arch/files-exports": ["error", { file: "rpc.{group}.{area}.ts", names: ["rpc{Group}{Area}"] }],
+        "arch/naming-keys": ["error", { exports: "^rpc[A-Z]", delegate: true }]
+      }
+    },
+    [at("mails/*.mail.tsx")]: { rules: { "arch/files-exports": ["error", { file: "{name}.mail.tsx", names: ["{name}Mail", "{Name}Email"], types: true }] } }
+  };
+}
+function presetEffectStrictContract(at, name, files) {
+  const key = name === undefined ? [] : [{ callee: "Context.Service", name: `${name}/{folder}/{file}/{name}` }];
+  const labels = key.length > 0 ? { "arch/naming-labels": ["error", { labels: key }] } : {};
+  const service = presetNames(presetEffectContractKinds, files ?? [], "effect.files").includes("*.service.ts");
+  const sibling = service ? { "arch/files-siblings": ["error", { require: "{folder}.service.ts", message: "A domain is reached through its service." }] } : {};
+  return {
+    [at("*/*.schemas.ts")]: presetEffectTop(["type", "interface", "namespace", { kind: "const", exported: true }]),
+    [at("*/*.contract.ts")]: {
+      ...presetEffectTop(["type", { kind: "const", exported: true }, { kind: "const", exported: false, from: "^[A-Z]\\w*\\." }]),
+      deny: { calls: { "Schema.Struct": "Name the Schema in <d>.schemas.ts." } },
+      rules: sibling
+    },
+    [at("*/*.service.ts")]: {
+      ...presetEffectTop(["interface", "type", "class", "namespace"]),
+      rules: { ...labels, "arch/effect-service-params": "error" }
+    },
+    [at("*/*.errors.ts")]: {
+      ...presetEffectTop([{ kind: "class", exported: true }]),
+      rules: {
+        "arch/naming-labels": [
+          "error",
+          {
+            labels: [
+              { callee: ["Schema.TaggedErrorClass", "Schema.TaggedError", "Data.TaggedError"], name: "{name}" },
+              { callee: "*.Tagged", property: "tag", name: "{name}" },
+              { callee: "*.Tagged", property: "code", pattern: "^[A-Z][A-Z0-9_]*$" }
+            ]
+          }
+        ]
+      }
+    }
+  };
+}
+var presetEffectStrictTests = { top: { allow: ["describe*", "it*", "test*", "layer*"] } };
+function presetEffectUnit(root, key, value, contract) {
   if (!value.effect) {
     return {};
   }
   const at = presetEffectAt(root, key, value);
-  const contract = presetEffectContract(root, key, value);
+  const own = presetEffectContract(root, key, value);
   const server = presetEffectDomains(root, key, value);
-  const keys = server || contract ? presetFilled(server ? presetEffectServerKeys(at) : presetEffectContractKeys(at), presetEffectExists(root, key)) : {};
+  const options = value.effect instanceof Object ? value.effect : {};
+  const service = contract && `${posix2.join(root, contract.source)}/{folder}/{folder}.service.ts`;
+  const base = server ? presetEffectServerKeys(at) : presetEffectContractKeys(at, options.files);
+  const tests = { "tests/**/*.test.ts": presetEffectStrictTests, "test/**/*.test.ts": presetEffectStrictTests };
+  const strict = server ? { ...presetEffectStrictServer(at, service), ...tests } : presetEffectStrictContract(at, presetManifest(root, key).name, options.files);
+  const locked = options.strict === false ? {} : strict;
+  const paths = [...new Set([...Object.keys(base), ...Object.keys(locked)])];
+  const merged = (path) => (path in base) && (path in locked) ? presetMerge(base[path], locked[path]) : base[path] ?? locked[path];
+  const conventions = Object.fromEntries(paths.map((path) => [path, merged(path)]));
+  const keys = server || own ? presetFilled(conventions, presetEffectExists(root, key)) : {};
   const errors = Object.fromEntries(presetEffectErrors.map((name) => [name, "Tagged errors live in <d>.errors.ts."]));
-  const placement = server || contract ? { types: { placement: false } } : {};
-  const imports = server || contract ? { ...presetEffectImports, ...presetEffectServerImports } : presetEffectImports;
+  const placement = server || own ? { types: { placement: false } } : {};
+  const imports = server || own ? { ...presetEffectImports, ...presetEffectServerImports } : presetEffectImports;
   return {
     ...keys,
     ".": presetMerge({ ...placement, deny: { imports, calls: errors } }, keys["."] ?? {}),
@@ -1037,9 +1167,13 @@ function presetEffectKit(root, key, value, units) {
   return { ".": { deny: { imports: Object.fromEntries(names.flatMap((name) => [[name, message], [`${name}/**`, message]])) } } };
 }
 function presetEffectConventions(root, key, value, units) {
-  const contracts = units.flatMap(([other, folder]) => presetEffectContract(root, other, folder) ? presetManifest(root, other).name ?? [] : []);
+  const packages = units.flatMap(([other, folder]) => {
+    const name = presetEffectContract(root, other, folder) ? presetManifest(root, other).name : undefined;
+    return name === undefined ? [] : [{ name, source: presetSource(root, other, folder instanceof Object ? folder.source : undefined) }];
+  });
+  const contracts = packages.map((item) => item.name);
   return [
-    ...Object.entries(presetEffectUnit(root, key, value)),
+    ...Object.entries(presetEffectUnit(root, key, value, packages.at(0))),
     ...Object.entries(presetEffectFrontend(root, key, value)),
     ...Object.entries(presetEffectWeb(root, key, value, contracts)),
     ...Object.entries(presetEffectKit(root, key, value, units))
@@ -1444,8 +1578,9 @@ var denyGroup = (project, settings) => {
   const imports = kept(settings.imports);
   const calls = kept(settings.calls);
   const overrides = [];
-  if (Object.keys(imports).length > 0 || Object.keys(calls).length > 0) {
-    overrides.push(presetOverride([`**/${presetExtensions}`], { "arch/boundaries-deny": ["error", { imports, calls }] }));
+  const only = settings.only.length > 0 ? { only: settings.only } : {};
+  if (Object.keys(imports).length > 0 || Object.keys(calls).length > 0 || settings.only.length > 0) {
+    overrides.push(presetOverride([`**/${presetExtensions}`], { "arch/boundaries-deny": ["error", { imports, calls, ...only }] }));
   }
   const reads = Object.fromEntries(presetQueryWrites.map((name) => [name, "Query files only read; move writes to an action."]));
   for (const unit of project.units.filter((item) => item.kind === "backend")) {
@@ -1453,7 +1588,7 @@ var denyGroup = (project, settings) => {
       ...presetServiceScopes(project.serviceFolders, [unit.source], "**/*-query.*.ts"),
       ...presetServiceScopes(project.serviceFolders, project.operations.filter((path) => path === unit.source), "*/queries/*.ts")
     ];
-    overrides.push(presetOverride(files, { "arch/boundaries-deny": ["error", { imports, calls: kept({ ...reads, ...settings.calls }) }] }));
+    overrides.push(presetOverride(files, { "arch/boundaries-deny": ["error", { imports, calls: kept({ ...reads, ...settings.calls }), ...only }] }));
   }
   return overrides;
 };
@@ -1869,6 +2004,10 @@ var namingGroup = (project, settings, owner) => {
     }
   }
   add("exports", presetServiceScopes(project.serviceFolders, web, "**/*.rsc.{ts,tsx}"), { "arch/naming-exports": ["error", namingFrontendPrefix, { mode: "pattern", pattern: "^[a-z][a-z0-9]*Rsc[A-Z][a-zA-Z0-9]*$" }] }, ["**/*-{action,query}.*.rsc.{ts,tsx}", ...testFiles]);
+  const imports = Object.entries(settings.imports).flatMap(([source, name]) => name === false ? [] : [{ source, name }]);
+  if (imports.length > 0) {
+    overrides.push(presetOverride([`**/${presetExtensions}`], { "arch/naming-imports": ["error", { imports }] }));
+  }
   if (typeof exportsPattern === "string") {
     overrides.push(presetOverride([`**/${presetExtensions}`], { "arch/naming-exports": ["error", { mode: "pattern", pattern: exportsPattern, types: true }] }));
   }
@@ -2109,6 +2248,9 @@ function optionsAssertMockingApis(patterns) {
 function optionsEscape(value) {
   return value.replaceAll(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
+function optionsWildcards(names) {
+  return [names ?? []].flat().map((name) => new RegExp(`^${name.split("*").map(optionsEscape).join(".*")}$`));
+}
 
 // src/preset/groups/tests.ts
 var testsGroup = (project, settings) => {
@@ -2155,6 +2297,16 @@ var testsGroup = (project, settings) => {
   ];
 };
 
+// src/preset/groups/top.ts
+var topGroup = (_project, { level: _level, allow, ...rest }) => {
+  if (allow === undefined && rest.deny === undefined) {
+    return [];
+  }
+  const listed = allow === undefined || allow.includes("import") ? allow : ["import", ...allow];
+  const options = Object.fromEntries(Object.entries({ allow: listed, ...rest }).filter(([, value]) => value !== undefined));
+  return [presetOverride([`**/${presetExtensions}`], { "arch/files-top-level": ["error", options] })];
+};
+
 // src/preset/groups/types.ts
 var typesGroup = (project, settings) => {
   const { web, backend, packageSources, app, appFiles, services, utilities, types, ui, testFiles, components, hooks } = project;
@@ -2215,9 +2367,69 @@ var typesGroup = (project, settings) => {
 import { existsSync as existsSync5, readdirSync as readdirSync5, realpathSync as realpathSync2 } from "node:fs";
 import { posix as posix8, resolve as resolve8 } from "node:path";
 
+// src/preset/preset-sets.ts
+var presetSetsReserved = ["domain", "stem", "file", "folder", "parent", "name", "key", "value"];
+function presetSets(folders, sets = {}) {
+  const names = Object.keys(sets);
+  const reserved = names.find((name) => presetSetsReserved.includes(name) || !/^[a-z][A-Za-z0-9]*$/.test(name));
+  if (reserved) {
+    throw new PresetError(`Set \`${reserved}\` needs another name: start with a lowercase letter, use letters and digits, and avoid ${presetSetsReserved.join(", ")}.`);
+  }
+  if (names.length === 0) {
+    return folders;
+  }
+  const token = new RegExp(`\\{(${names.join("|")})\\}`);
+  const pairs = (name) => {
+    if (!Object.hasOwn(sets, name)) {
+      throw new PresetError(`Unknown set \`${name}\`.`);
+    }
+    const set = sets[name];
+    return Array.isArray(set) ? set.map((item) => [item, item]) : Object.entries(set);
+  };
+  const text = (value, key, item) => value.replaceAll("{key}", key).replaceAll("{value}", item);
+  const fill = (value, key, item) => {
+    if (typeof value === "string") {
+      return text(value, key, item);
+    }
+    if (Array.isArray(value)) {
+      return value.map((entry) => fill(entry, key, item));
+    }
+    return value instanceof Object ? Object.fromEntries(Object.entries(value).map(([name, entry]) => [text(name, key, item), fill(entry, key, item)])) : value;
+  };
+  const spread = (value) => {
+    const match = token.exec(value);
+    return match ? pairs(match[1]).flatMap(([key]) => spread(value.replace(match[0], key))) : [value];
+  };
+  const expandEntries = (value) => Object.entries(value).flatMap(([name, entry]) => {
+    const match = token.exec(name);
+    return match ? pairs(match[1]).flatMap(([key, item]) => expandEntries({ [name.replace(match[0], key)]: fill(entry, key, item) })) : [[name, name === "message" ? entry : expand(entry)]];
+  });
+  const expand = (value) => {
+    if (typeof value === "string") {
+      return token.test(value) ? spread(value) : value;
+    }
+    if (!Array.isArray(value)) {
+      const marks = value instanceof Object ? Object.getOwnPropertySymbols(value).map((mark) => [mark, Reflect.get(value, mark)]) : [];
+      return value instanceof Object ? Object.assign(Object.fromEntries(expandEntries(value)), Object.fromEntries(marks)) : value;
+    }
+    return value.flatMap((entry) => {
+      if (typeof entry === "string") {
+        return spread(entry);
+      }
+      if (!(entry instanceof Object) || Array.isArray(entry) || typeof entry.each !== "string") {
+        return [expand(entry)];
+      }
+      const { each, ...rest } = entry;
+      return pairs(each).map(([key, item]) => expand(fill(rest, key, item)));
+    });
+  };
+  return expand(folders);
+}
+
 // src/preset/preset-stylesheet.ts
 import { readdirSync as readdirSync3, readFileSync as readFileSync3, realpathSync } from "node:fs";
 import { posix as posix6, resolve as resolve6 } from "node:path";
+var presetStylesheetNames = ["styles", "globals", "global", "app", "index", "main", "style", "tailwind"];
 function presetTailwindEntry(css) {
   const code = css.replaceAll(/\/\*[\s\S]*?\*\//g, "");
   return /(?:^|[;{}])\s*@(?:import\s+(?:url\(\s*(["']?)tailwindcss(?:\/[^"')\s]*)?\1\s*\)|(["'])tailwindcss(?:\/[^"']*)?\2)|tailwind\s)/.test(code);
@@ -2267,7 +2479,7 @@ function presetUnitSource(root, key, kind, source) {
   }
   return kind === "console" || !existsSync4(resolve7(root, key, "src")) ? key : posix7.join(key, "src");
 }
-function presetSets(folder, name) {
+function presetSets2(folder, name) {
   return folder[name] !== undefined && folder[name] !== false;
 }
 function presetKind(key, enabled) {
@@ -2303,8 +2515,8 @@ function presetUnit(root, key, scope) {
   const { effective } = scope;
   const wildcard = scope.parent && scope.parent.depth === scope.depth && scope.parent.key.includes("*") ? scope.parent.folder : {};
   const folder = { ...wildcard, ...scope.folder };
-  const own = presetKindGroups.some((name) => presetSets(folder, name)) || presetHasManifest(root, key);
-  const { kind, framework } = presetKind(key, (name) => own ? presetSets(folder, name) : Boolean(effective[name]));
+  const own = presetKindGroups.some((name) => presetSets2(folder, name)) || presetHasManifest(root, key);
+  const { kind, framework } = presetKind(key, (name) => own ? presetSets2(folder, name) : Boolean(effective[name]));
   const layout = {};
   const settings = effective.layout;
   if (settings) {
@@ -2327,7 +2539,7 @@ function presetUnits(root, scopes, ignored) {
   const candidates = [];
   for (const scope of scopes) {
     const manifest = presetHasManifest(root, scope.key);
-    const own = presetKindGroups.some((name) => presetSets(scope.folder, name)) || manifest;
+    const own = presetKindGroups.some((name) => presetSets2(scope.folder, name)) || manifest;
     const top = scope.parent?.key === "." && (rootKind === "library" || own);
     const sibling = scope.parent !== null && candidates.includes(scope.parent) && scope.parent.depth === scope.depth && !scope.key.includes("*");
     const workspace = scope.parent !== null && scope.parent.key !== "." && manifest;
@@ -2434,20 +2646,16 @@ function presetDenyEntries(inherited, changes) {
     return [key, message];
   }));
 }
-function presetLayoutNames(inherited, entries) {
-  if (!Array.isArray(entries) || !entries.every((entry) => typeof entry === "string" && presetLayoutFileName.test(entry))) {
-    throw new PresetError("layout.files takes file names such as `*.prompts.ts`; `!*.utils.ts` removes one.");
+function presetDenyOnly(inherited, entries = []) {
+  const each = entries.find((entry) => entry.each !== undefined)?.each;
+  if (each !== undefined) {
+    throw new PresetError(`Unknown set \`${each}\`.`);
   }
-  const names = [...inherited];
-  for (const entry of entries) {
-    const index = names.indexOf(entry.startsWith("!") ? entry.slice(1) : entry);
-    if (entry.startsWith("!") && index !== -1) {
-      names.splice(index, 1);
-    } else if (!entry.startsWith("!") && index === -1) {
-      names.push(entry);
-    }
+  const known = (entry) => ("in" in entry) && (("imports" in entry) || ("calls" in entry)) && Object.keys(entry).every((key) => ["imports", "calls", "in", "message"].includes(key));
+  if (!Array.isArray(entries) || !entries.every((entry) => entry instanceof Object && known(entry))) {
+    throw new PresetError("deny.only takes entries such as `{ imports: [...], in: [...], message }`, with `imports` or `calls` and the places that may use them.");
   }
-  return names;
+  return [...inherited, ...entries];
 }
 function presetEffective(folder, parent) {
   const resolveGroup = (name) => {
@@ -2461,13 +2669,14 @@ function presetEffective(folder, parent) {
     effective.deny = {
       ...effective.deny,
       imports: presetDenyEntries(inherited.imports, deny.imports),
-      calls: presetDenyEntries(inherited.calls, deny.calls)
+      calls: presetDenyEntries(inherited.calls, deny.calls),
+      only: presetDenyOnly(inherited.only, deny.only)
     };
   }
   const layout = folder.layout;
   if (effective.layout && layout instanceof Object && layout.files !== undefined) {
     const inherited = (parent ? parent.layout?.files : null) ?? presetGroupOptions.layout.files;
-    effective.layout = { ...effective.layout, files: presetLayoutNames(inherited, layout.files) };
+    effective.layout = { ...effective.layout, files: presetNames(inherited, layout.files, "layout.files") };
   }
   return effective;
 }
@@ -2488,7 +2697,7 @@ function presetFolder(key, value) {
   if (folder.severity !== undefined && !["error", "warn"].includes(folder.severity)) {
     throw new PresetError(`Folder \`${key}\` severity must be 'error' or 'warn'.`);
   }
-  return folder;
+  return Array.isArray(folder.top) ? { ...folder, top: { allow: folder.top } } : folder;
 }
 function presetScopesTree(root, folders) {
   const entries = Object.entries(folders).map(([key, value]) => [presetNormalizeKey(key), value]);
@@ -2533,7 +2742,7 @@ function presetScopesTree(root, folders) {
 function presetProject(config) {
   const given = resolve8(config.root ?? process.cwd());
   const root = existsSync5(given) ? realpathSync2(given) : given;
-  const expanded = Object.entries(config.folders ?? {}).flatMap(([key, value]) => presetBraces(key).map((path) => [presetPortableKey(path), value, key.includes("{")]));
+  const expanded = Object.entries(presetSets(config.folders ?? {}, config.sets)).flatMap(([key, value]) => presetBraces(key).map((path) => [presetPortableKey(path), value, key.includes("{")]));
   const files = expanded.filter(([key]) => presetIsFileKey(root, key));
   const listed = expanded.filter((entry) => !files.includes(entry)).map(([key, value, fromList]) => [presetNormalizeKey(key), value, fromList]);
   const twice = listed.find(([key, , fromList], index) => listed.some(([other, , otherFromList], at) => at < index && other === key && !fromList && !otherFromList));
@@ -2742,6 +2951,7 @@ var presetBuilders = {
   shadcn: shadcnGroup,
   limits: limitsGroup,
   deny: denyGroup,
+  top: topGroup,
   externals: externalsGroup
 };
 function presetLevel(scope) {

package/dist/preset/preset.utils.d.ts

@@ -21,3 +21,4 @@ export declare function presetIsFile(path: string): boolean;
 export declare function presetSource(root: string, directory: string, configured?: string): string;
 export declare function presetFilled(conventions: PresetTypes.PresetFolders, exists: (path: string) => boolean): PresetTypes.PresetFolders;
 export declare function presetMerge(base: boolean | PresetTypes.PresetFolder | undefined, top: boolean | PresetTypes.PresetFolder): boolean | PresetTypes.PresetFolder;
+export declare function presetNames(inherited: string[], entries: unknown, option: string): string[];

package/dist/rules/code/code-inside.d.ts

@@ -0,0 +1 @@
+export declare const codeInside: import("@oxlint/plugins").Rule;

package/dist/rules/effect/effect-layer-keys.d.ts

@@ -0,0 +1 @@
+export declare const effectLayerKeys: import("@oxlint/plugins").Rule;

package/dist/rules/effect/effect-service-params.d.ts

@@ -0,0 +1 @@
+export declare const effectServiceParams: import("@oxlint/plugins").Rule;

package/dist/rules/effect/effect-yield-name.d.ts

@@ -0,0 +1 @@
+export declare const effectYieldName: import("@oxlint/plugins").Rule;

package/dist/rules/effect/effect-yields-first.d.ts

@@ -0,0 +1 @@
+export declare const effectYieldsFirst: import("@oxlint/plugins").Rule;

package/dist/rules/files/files-siblings.d.ts

@@ -0,0 +1 @@
+export declare const filesSiblings: import("@oxlint/plugins").Rule;

package/dist/rules/files/files-top-level.d.ts

@@ -0,0 +1 @@
+export declare const filesTopLevel: import("@oxlint/plugins").Rule;

package/dist/rules/naming/naming-imports.d.ts

@@ -0,0 +1 @@
+export declare const namingImports: import("@oxlint/plugins").Rule;

package/dist/rules/naming/naming-keys.d.ts

@@ -0,0 +1 @@
+export declare const namingKeys: import("@oxlint/plugins").Rule;

package/dist/rules/naming/naming-labels.d.ts

@@ -0,0 +1 @@
+export declare const namingLabels: import("@oxlint/plugins").Rule;

package/dist/rules/naming/naming-pairs.d.ts

@@ -0,0 +1 @@
+export declare const namingPairs: import("@oxlint/plugins").Rule;

package/dist/types/boundaries.types.d.ts

@@ -99,7 +99,14 @@ export interface BoundariesRpcDatabaseOptions {
     message?: string;
     methods?: string[];
 }
+export interface BoundariesDenyOnly {
+    imports?: string | string[];
+    calls?: string | string[];
+    in: string | string[];
+    message?: string;
+}
 export interface BoundariesDenyOptions {
     imports?: Record<string, string>;
     calls?: Record<string, string>;
+    only?: BoundariesDenyOnly[];
 }

package/dist/types/code.types.d.ts

@@ -89,3 +89,14 @@ export interface CodeTracedOptions {
     skip?: OptionsPattern;
     message?: string;
 }
+export interface CodeInsideEntry {
+    callee: OptionsPattern;
+    calls: Record<string, string>;
+}
+export interface CodeInsideOptions {
+    inside: CodeInsideEntry[];
+}
+export interface CodeInsideCompiled {
+    callees: RegExp[];
+    calls: [RegExp, string][];
+}

package/dist/types/effect.types.d.ts

@@ -40,8 +40,28 @@ export interface EffectSchemaFirstDerived {
 export interface EffectSchemaFirstOptions {
     member?: string;
     keep?: OptionsPattern;
+    allow?: OptionsPattern;
     runtime?: string[];
     rows?: EffectSchemaFirstRows;
     order?: (EffectSchemaFirstSection | EffectSchemaFirstSection[])[];
     derived?: EffectSchemaFirstDerived;
 }
+export interface EffectYieldNameOptions {
+    names?: Record<string, string | string[]>;
+    allow?: OptionsPattern;
+}
+export interface EffectLayerKeysOptions {
+    service: string;
+    callees?: string[];
+    declaration?: string;
+}
+export interface EffectLayerKeysFrame {
+    open: string;
+    key?: string;
+    members: number;
+}
+export interface EffectServiceParamsOptions {
+    name?: OptionsPattern;
+    allow?: OptionsPattern;
+    declaration?: string;
+}