@joshuafolkken/kit 1.1178.0 → 1.1229.0

package/dist/version/index.d.ts

@@ -37,6 +37,11 @@ declare const kit_package_descriptor: UpstreamDescriptor;
 
 type InstalledVersions = ReadonlyMap<string, string | undefined>;
 
+interface UpgradeCommand {
+    text: string;
+    steps: ReadonlyArray<ReadonlyArray<string>>;
+}
+
 interface VersionSnapshot {
     global_version: string | undefined;
     project_version: string | undefined;
@@ -76,8 +81,8 @@ declare function read_snapshot(config: VersionCommandConfig): VersionSnapshot;
 declare function build_extras(config: VersionCommandConfig): VersionOutputExtras;
 declare function read_upstream_reports(config: VersionCommandConfig, snapshot: VersionSnapshot, is_hold_wanted?: boolean): Array<UpstreamReport>;
 declare function run_check(config: VersionCommandConfig): void;
-declare function run_upgrade_command(command: string): number;
-declare function run_all_upgrade_commands(commands: ReadonlyArray<string>): number;
+declare function run_upgrade_command(command: UpgradeCommand): number;
+declare function run_all_upgrade_commands(commands: ReadonlyArray<UpgradeCommand>): number;
 declare function run_upgrade(config: VersionCommandConfig): number;
 declare const version_commands: {
     read_snapshot: typeof read_snapshot;

package/dist/version/index.js

@@ -64,7 +64,24 @@ function create_version_command_config(options) {
 // scripts/version/effective-upstream.ts
 import { existsSync, readFileSync } from "node:fs";
 import { createRequire } from "node:module";
+import path2 from "node:path";
+
+// scripts/lib/ancestor-directories.ts
 import path from "node:path";
+var MAX_DEPTH = 64;
+function list(start_directory) {
+  const directories = [];
+  let current = path.resolve(start_directory);
+  while (directories.length < MAX_DEPTH && !directories.includes(current)) {
+    directories.push(current);
+    current = path.dirname(current);
+  }
+  return directories;
+}
+function nearest(start_directory, is_match) {
+  return list(start_directory).find((directory) => is_match(directory));
+}
+var ancestor_directories = { list, nearest };
 
 // scripts/lib/json-value.ts
 function parse_or_undefined(text) {
@@ -113,7 +130,6 @@ var string_record_schema = z.record(z.string(), z.string());
 
 // scripts/version/effective-upstream.ts
 var PACKAGE_JSON = "package.json";
-var MAX_WALK_DEPTH = 64;
 function read_matching_version(manifest_path, package_name) {
   if (!existsSync(manifest_path)) return void 0;
   const parsed = package_named_version_schema.safeParse(
@@ -123,20 +139,9 @@ function read_matching_version(manifest_path, package_name) {
   if (parsed.data.name !== package_name) return void 0;
   return parsed.data.version;
 }
-function ancestor_directories(start_directory) {
-  const directories = [];
-  let current = start_directory;
-  for (let depth = 0; depth < MAX_WALK_DEPTH; depth += 1) {
-    directories.push(current);
-    const parent = path.dirname(current);
-    if (parent === current) break;
-    current = parent;
-  }
-  return directories;
-}
 function walk_up_for_version(start_directory, package_name) {
-  for (const directory of ancestor_directories(start_directory)) {
-    const version = read_matching_version(path.join(directory, PACKAGE_JSON), package_name);
+  for (const directory of ancestor_directories.list(start_directory)) {
+    const version = read_matching_version(path2.join(directory, PACKAGE_JSON), package_name);
     if (version !== void 0) return version;
   }
   return void 0;
@@ -151,28 +156,67 @@ function resolve_from_base(base_url, package_name, resolve_marker) {
 function resolve_effective_upstream_version(base_url, package_name, options = {}) {
   const resolved = resolve_from_base(base_url, package_name, options.resolve_marker);
   if (resolved === void 0) return void 0;
-  return walk_up_for_version(path.dirname(resolved), package_name);
+  return walk_up_for_version(path2.dirname(resolved), package_name);
 }
 
+// scripts/lib/timeouts.ts
+var FETCH_TIMEOUT_MS = 1e4;
+var COMMAND_TIMEOUT_MS = 3e4;
+var INSTALL_TIMEOUT_MS = 6e5;
+
 // scripts/version/version-commands.ts
 import { execaSync as execaSync4 } from "execa";
 
 // scripts/version/release-age.ts
 import { readFileSync as readFileSync2 } from "node:fs";
-import path2 from "node:path";
+import path3 from "node:path";
+
+// scripts/lib/yaml-document.ts
+import { load, loadAll, YAMLException } from "js-yaml";
+var EMPTY_YAML_REASON = "expected a document, but the input is empty";
+function load_yaml_or_empty(content) {
+  try {
+    return load(content);
+  } catch (error) {
+    if (error instanceof YAMLException && error.reason === EMPTY_YAML_REASON) return {};
+    throw error;
+  }
+}
+function parse_yaml(content) {
+  const raw = load_yaml_or_empty(content);
+  if (raw === null || raw === void 0) return {};
+  return json_object_schema.parse(raw);
+}
+function is_mapping_document(value) {
+  return json_value.is_record(value);
+}
+function parse_yaml_documents(content) {
+  if (content.trim().length === 0) return [];
+  return loadAll(content).filter(is_mapping_document);
+}
+var yaml_document = { is_mapping_document, parse_yaml, parse_yaml_documents };
+
+// scripts/version/release-age.ts
 import semver from "semver";
 import { z as z2 } from "zod";
-var MINIMUM_RELEASE_AGE_RE = /^minimum-release-age\s*=\s*(\d+)\s*$/mu;
 var NO_QUARANTINE_MINUTES = 0;
-var NPMRC_PATH = ".npmrc";
+var WORKSPACE_PATH = "pnpm-workspace.yaml";
+var workspace_age_schema = z2.object({ minimumReleaseAge: z2.number().int().nonnegative() });
 var release_times_schema = z2.record(z2.string(), z2.string());
 var MS_PER_MINUTE = 6e4;
-function parse_declared_minimum_release_age(npmrc_content) {
-  const raw = MINIMUM_RELEASE_AGE_RE.exec(npmrc_content)?.[1];
-  return raw === void 0 ? void 0 : Number(raw);
+function parse_workspace(workspace_content) {
+  try {
+    return yaml_document.parse_yaml(workspace_content);
+  } catch {
+    return void 0;
+  }
 }
-function parse_minimum_release_age(npmrc_content) {
-  return parse_declared_minimum_release_age(npmrc_content) ?? NO_QUARANTINE_MINUTES;
+function parse_declared_minimum_release_age(workspace_content) {
+  const parsed = workspace_age_schema.safeParse(parse_workspace(workspace_content));
+  return parsed.success ? parsed.data.minimumReleaseAge : void 0;
+}
+function parse_minimum_release_age(workspace_content) {
+  return parse_declared_minimum_release_age(workspace_content) ?? NO_QUARANTINE_MINUTES;
 }
 function is_on_major(version, major) {
   return major === void 0 || String(semver.major(version)) === major;
@@ -189,25 +233,25 @@ function select_aged_version(times, major, minimum_age_minutes, now_ms) {
   const eligible = Object.entries(times).filter(([version, published_at]) => is_eligible(version, published_at, major, cutoff_ms)).map(([version]) => version).toSorted(semver.rcompare);
   return eligible[0];
 }
-function read_declared_minimum_release_age(npmrc_path) {
+function read_declared_minimum_release_age(workspace_path) {
   try {
-    return parse_declared_minimum_release_age(readFileSync2(npmrc_path, "utf8"));
+    return parse_declared_minimum_release_age(readFileSync2(workspace_path, "utf8"));
   } catch {
     return void 0;
   }
 }
-function read_minimum_release_age(npmrc_path = NPMRC_PATH) {
-  return read_declared_minimum_release_age(npmrc_path) ?? NO_QUARANTINE_MINUTES;
+function read_minimum_release_age(workspace_path = WORKSPACE_PATH) {
+  return read_declared_minimum_release_age(workspace_path) ?? NO_QUARANTINE_MINUTES;
 }
 function find_declared_minimum_release_age(start, boundary) {
-  const declared = read_declared_minimum_release_age(path2.join(start, NPMRC_PATH));
+  const declared = read_declared_minimum_release_age(path3.join(start, WORKSPACE_PATH));
   if (declared !== void 0) return declared;
   if (start === boundary) return void 0;
-  const parent = path2.dirname(start);
+  const parent = path3.dirname(start);
   return parent === start ? void 0 : find_declared_minimum_release_age(parent, boundary);
 }
 function read_nearest_minimum_release_age(start, boundary) {
-  return find_declared_minimum_release_age(path2.resolve(start), boundary) ?? NO_QUARANTINE_MINUTES;
+  return find_declared_minimum_release_age(path3.resolve(start), boundary) ?? NO_QUARANTINE_MINUTES;
 }
 var release_age = {
   release_times_schema,
@@ -270,14 +314,14 @@ var release_hold = {
 
 // scripts/version/running-binary.ts
 import { existsSync as existsSync2, readFileSync as readFileSync3 } from "node:fs";
-import path3 from "node:path";
+import path4 from "node:path";
 var PACKAGE_JSON2 = "package.json";
 var SCRIPT_DEPTH_FROM_ROOT = ["..", ".."];
 function resolve_self_package_path(self_directory) {
-  return path3.join(self_directory, ...SCRIPT_DEPTH_FROM_ROOT, PACKAGE_JSON2);
+  return path4.join(self_directory, ...SCRIPT_DEPTH_FROM_ROOT, PACKAGE_JSON2);
 }
 function running_package_directory(self_directory) {
-  return path3.resolve(self_directory, ...SCRIPT_DEPTH_FROM_ROOT);
+  return path4.resolve(self_directory, ...SCRIPT_DEPTH_FROM_ROOT);
 }
 function read_running_version(self_directory) {
   const package_path = resolve_self_package_path(self_directory);
@@ -311,16 +355,26 @@ function is_no_op_upgrade_command(command, installed) {
 }
 
 // scripts/version/upgrade-shell-command.ts
+var STEP_SEPARATOR = " && ";
 function update_scope_flag(is_local) {
   return is_local ? "-D" : "-g";
 }
+function update_argv(latest, is_local, config) {
+  return ["pnpm", "add", update_scope_flag(is_local), `${config.package_name}@${latest}`];
+}
 function format_update_command(latest, is_local, config) {
-  return `pnpm add ${update_scope_flag(is_local)} ${config.package_name}@${latest}`;
+  return update_argv(latest, is_local, config).join(" ");
+}
+function build_upgrade_command(latest, is_local, config) {
+  const steps = [update_argv(latest, is_local, config)];
+  if (is_local) steps.push(["node_modules/.bin/tsx", config.fix_gh_packages_path]);
+  return { text: steps.map((step) => step.join(" ")).join(STEP_SEPARATOR), steps };
+}
+function shell_upgrade_command(command) {
+  return { text: command, steps: [["sh", "-c", command]] };
 }
 function build_upgrade_shell_command(latest, is_local, config) {
-  const add_command = format_update_command(latest, is_local, config);
-  if (!is_local) return add_command;
-  return `${add_command} && node_modules/.bin/tsx ${config.fix_gh_packages_path}`;
+  return build_upgrade_command(latest, is_local, config).text;
 }
 
 // scripts/version/version-check-logic.ts
@@ -376,7 +430,7 @@ function resolve_effective_upgrade_hint(report) {
 function build_effective_upgrade_commands(report) {
   const hint = resolve_effective_upgrade_hint(report);
   if (hint === void 0 || hint.is_no_op) return [];
-  return [hint.command];
+  return [shell_upgrade_command(hint.command)];
 }
 function build_effective_upgrade_notes(report) {
   const hint = resolve_effective_upgrade_hint(report);
@@ -399,7 +453,7 @@ function format_upstream_lines(report) {
   ];
 }
 function unique_upgrade_commands(commands) {
-  return [...new Set(commands)];
+  return [...new Map(commands.map((command) => [command.text, command])).values()];
 }
 function format_unchanged_outcome(report, version) {
   const name = report.config.package_name;
@@ -417,7 +471,7 @@ function format_effective_outcome(report, after) {
 }
 function build_project_upgrade_commands(report) {
   if (!is_target_stale(report.project_version, report.latest)) return [];
-  return [build_upgrade_shell_command(report.latest, true, report.config)];
+  return [build_upgrade_command(report.latest, true, report.config)];
 }
 function build_upstream_upgrade_commands(reports) {
   return reports.flatMap((report) => [
@@ -429,10 +483,10 @@ function build_dual_upgrade_commands(snapshot, config) {
   const { global_version, project_version, latest } = snapshot;
   const commands = [];
   if (is_target_stale(global_version, latest)) {
-    commands.push(build_upgrade_shell_command(latest, false, config));
+    commands.push(build_upgrade_command(latest, false, config));
   }
   if (is_target_stale(project_version, latest)) {
-    commands.push(build_upgrade_shell_command(latest, true, config));
+    commands.push(build_upgrade_command(latest, true, config));
   }
   return commands;
 }
@@ -454,7 +508,7 @@ function format_dual_version_output(snapshot, config, extras = {}, upstreams = [
   const hints = unique_upgrade_commands([
     ...build_dual_upgrade_commands(snapshot, config),
     ...build_upstream_upgrade_commands(upstreams)
-  ]).map((command) => `Run: ${command}`);
+  ]).map((command) => `Run: ${command.text}`);
   if (hints.length > 0) lines.push("", ...hints);
   if (extras.warning !== void 0) lines.push("", extras.warning);
   return lines.join("\n");
@@ -576,9 +630,6 @@ var error_text = { message_of, trace_swallowed };
 // scripts/gh/git-gh-exec.ts
 import { execa as execa2, execaSync } from "execa";
 
-// scripts/lib/timeouts.ts
-var COMMAND_TIMEOUT_MS = 3e4;
-
 // scripts/gh/git-gh-check.ts
 import { execa } from "execa";
 var GH_NOT_INSTALLED_MSG = "gh CLI is not installed. Install it from https://cli.github.com/";
@@ -710,20 +761,20 @@ function parse_status_line(output) {
 function status_of_failure(error) {
   return has_stdout_field(error) ? parse_status_line(error.stdout) : void 0;
 }
-async function exec_gh_api_status(path5, timeout_ms) {
+async function exec_gh_api_status(path6, timeout_ms) {
   const options = to_spawn_options(timeout_ms);
   try {
     await check_gh_installed();
-    const { stdout } = await execa2("gh", ["api", "--include", "--silent", path5], options);
+    const { stdout } = await execa2("gh", ["api", "--include", "--silent", path6], options);
     return parse_status_line(stdout);
   } catch (error) {
     return status_of_failure(error);
   }
 }
-function exec_gh_api_status_sync(path5, timeout_ms) {
+function exec_gh_api_status_sync(path6, timeout_ms) {
   const options = to_spawn_options(timeout_ms);
   try {
-    const { stdout } = execaSync("gh", ["api", "--include", "--silent", path5], options);
+    const { stdout } = execaSync("gh", ["api", "--include", "--silent", path6], options);
     return parse_status_line(stdout);
   } catch (error) {
     return status_of_failure(error);
@@ -793,7 +844,7 @@ var git_gh_exec = {
 };
 
 // scripts/gh/fix-gh-packages-logic.ts
-import { loadAll } from "js-yaml";
+import { loadAll as loadAll2 } from "js-yaml";
 import { z as z4 } from "zod";
 var GH_PACKAGES_HOST = "npm.pkg.github.com";
 var RESOLUTION_BLOCK = "\n    resolution:\n";
@@ -815,7 +866,7 @@ var lockfile_document_schema = z4.looseObject({
 });
 function parse_lockfile_packages(raw) {
   const merged = {};
-  for (const document of loadAll(raw)) {
+  for (const document of loadAll2(raw)) {
     const { packages } = lockfile_document_schema.parse(document);
     if (packages !== void 0) Object.assign(merged, packages);
   }
@@ -1105,11 +1156,11 @@ var migrate_logic = {
 
 // scripts/version/npm-registry.ts
 import { execaSync as execaSync2 } from "execa";
+import semver3 from "semver";
 import { z as z5 } from "zod";
 var PUBLIC_REGISTRY2 = "https://registry.npmjs.org";
 var ABBREVIATED_ACCEPT = "application/vnd.npm.install-v1+json";
 var FULL_ACCEPT = "application/json";
-var REQUEST_TIMEOUT_MS = 1e4;
 var SCOPE_SEPARATOR = "/";
 var ENCODED_SCOPE_SEPARATOR = "%2f";
 var SCOPE_PATTERN = /^@[^/]+(?=\/)/u;
@@ -1121,7 +1172,8 @@ var FETCH_SCRIPT = [
   "if (!response.ok) process.exit(1)",
   "process.stdout.write(await response.text())"
 ].join("\n");
-var latest_schema = z5.looseObject({ "dist-tags": z5.looseObject({ latest: z5.string() }) });
+var version_schema = z5.string().refine((value) => semver3.valid(value) === value);
+var latest_schema = z5.looseObject({ "dist-tags": z5.looseObject({ latest: version_schema }) });
 var times_schema = z5.looseObject({ time: release_age.release_times_schema });
 function packument_url(package_name) {
   return `${PUBLIC_REGISTRY2}/${package_name.replace(SCOPE_SEPARATOR, () => ENCODED_SCOPE_SEPARATOR)}`;
@@ -1130,7 +1182,7 @@ function read_packument(package_name, accept) {
   const result = execaSync2(
     process.execPath,
     ["--input-type=module", "-e", FETCH_SCRIPT, packument_url(package_name), accept],
-    { reject: false, timeout: REQUEST_TIMEOUT_MS }
+    { reject: false, timeout: FETCH_TIMEOUT_MS }
   );
   if (result.exitCode !== 0) return void 0;
   return json_value.parse_or_undefined(result.stdout);
@@ -1140,7 +1192,7 @@ function is_github_scope(scope) {
   if (is_cached_github !== void 0) return is_cached_github;
   const result = execaSync2("pnpm", ["config", "get", `${scope}${SCOPE_REGISTRY_SUFFIX}`], {
     reject: false,
-    timeout: REQUEST_TIMEOUT_MS
+    timeout: FETCH_TIMEOUT_MS
   });
   const is_github = result.exitCode === 0 && migrate_logic.is_github_tarball(result.stdout.trim());
   github_scopes.set(scope, is_github);
@@ -1164,7 +1216,16 @@ function has_public_version(package_name, version) {
   const parsed = times_schema.safeParse(read_packument(package_name, FULL_ACCEPT));
   return parsed.success && parsed.data.time[version] !== void 0;
 }
-var npm_registry = { has_public_version, packument_url, read_latest, read_release_times };
+function valid_version(value) {
+  return version_schema.safeParse(value).success ? value : void 0;
+}
+var npm_registry = {
+  has_public_version,
+  packument_url,
+  read_latest,
+  read_release_times,
+  valid_version
+};
 
 // scripts/version/version-remote.ts
 var TIMES_PAGE_SIZE = 100;
@@ -1175,10 +1236,7 @@ function require_endpoint(versions_endpoint, package_name) {
     `Could not derive a versions endpoint for ${package_name}; check its version-command config.`
   );
 }
-function fetch_latest_version(versions_endpoint, package_name) {
-  const endpoint = require_endpoint(versions_endpoint, package_name);
-  const public_latest = npm_registry.read_latest(package_name);
-  if (public_latest !== void 0) return public_latest;
+function read_github_name(endpoint, package_name) {
   try {
     return git_gh_exec.exec_gh_api_sync({ path: endpoint, jq_filter: ".[0].name" }).trim();
   } catch (error) {
@@ -1191,6 +1249,18 @@ function fetch_latest_version(versions_endpoint, package_name) {
     );
   }
 }
+function read_github_latest(endpoint, package_name) {
+  const name = read_github_name(endpoint, package_name);
+  const version = npm_registry.valid_version(name);
+  if (version !== void 0) return version;
+  throw new Error(
+    `Refused latest version for ${package_name} via ${endpoint}: ${JSON.stringify(name)} is not a semver version`
+  );
+}
+function fetch_latest_version(versions_endpoint, package_name) {
+  const endpoint = require_endpoint(versions_endpoint, package_name);
+  return npm_registry.read_latest(package_name) ?? read_github_latest(endpoint, package_name);
+}
 function with_page_size(endpoint, page_size) {
   const separator = endpoint.indexOf("?");
   const path_part = separator === -1 ? endpoint : endpoint.slice(0, separator);
@@ -1211,7 +1281,7 @@ function fetch_release_times(versions_endpoint, package_name) {
 }
 
 // scripts/version/version-targets.ts
-import path4 from "node:path";
+import path5 from "node:path";
 
 // scripts/lib/read-file.ts
 import { readFileSync as readFileSync4 } from "node:fs";
@@ -1219,20 +1289,20 @@ var ABSENT_CODE = "ENOENT";
 function is_absent(error) {
   return error instanceof Error && "code" in error && error.code === ABSENT_CODE;
 }
-function read_optional(path5) {
+function read_optional(path6) {
   try {
-    return readFileSync4(path5, "utf8");
+    return readFileSync4(path6, "utf8");
   } catch (error) {
     if (is_absent(error)) return void 0;
     throw error;
   }
 }
-function read_file_or_empty(path5) {
-  return read_optional(path5) ?? "";
+function read_file_or_empty(path6) {
+  return read_optional(path6) ?? "";
 }
-function read_if_readable(path5) {
+function read_if_readable(path6) {
   try {
-    return readFileSync4(path5, "utf8");
+    return readFileSync4(path6, "utf8");
   } catch {
     return void 0;
   }
@@ -1261,7 +1331,7 @@ function read_global_version(package_name) {
   return parse_global_version(result.stdout, package_name);
 }
 function project_package_path(cwd, package_name) {
-  return path4.join(cwd, NODE_MODULES2, package_name, PACKAGE_JSON3);
+  return path5.join(cwd, NODE_MODULES2, package_name, PACKAGE_JSON3);
 }
 function read_project_version(cwd, package_name) {
   const package_path = project_package_path(cwd, package_name);
@@ -1269,7 +1339,7 @@ function read_project_version(cwd, package_name) {
   return parse_project_version(raw);
 }
 function read_workspace_version(cwd) {
-  const package_path = path4.join(cwd, PACKAGE_JSON3);
+  const package_path = path5.join(cwd, PACKAGE_JSON3);
   const raw = file_reader.read_optional(package_path);
   return parse_project_version(raw);
 }
@@ -1291,7 +1361,6 @@ var version_targets = {
 var FAILURE_EXIT_CODE = 1;
 var ALREADY_UP_TO_DATE = "Already up to date";
 var NO_QUARANTINE_MINUTES2 = 0;
-var UPGRADE_TIMEOUT_MS = 6e5;
 function read_release_hold(package_config, latest, versions) {
   if (versions.every((version) => version === void 0 || version === latest)) return void 0;
   const minimum_age_minutes = release_age.read_nearest_minimum_release_age(process.cwd());
@@ -1375,14 +1444,22 @@ function run_check(config) {
     )
   );
 }
-function run_upgrade_command(command) {
-  const result = execaSync4("sh", ["-c", command], {
+function run_upgrade_step(step) {
+  const [executable = "", ...rest] = step;
+  const result = execaSync4(executable, rest, {
     stdio: "inherit",
     reject: false,
-    timeout: UPGRADE_TIMEOUT_MS
+    timeout: INSTALL_TIMEOUT_MS
   });
   return result.exitCode ?? FAILURE_EXIT_CODE;
 }
+function run_upgrade_command(command) {
+  for (const step of command.steps) {
+    const code = run_upgrade_step(step);
+    if (code !== 0) return code;
+  }
+  return 0;
+}
 function run_all_upgrade_commands(commands) {
   let exit_code = 0;
   const failed_commands = [];
@@ -1390,7 +1467,7 @@ function run_all_upgrade_commands(commands) {
     const code = run_upgrade_command(command);
     if (code === 0) continue;
     exit_code = code;
-    failed_commands.push(command);
+    failed_commands.push(command.text);
   }
   if (failed_commands.length > 0) {
     console.error(

package/eslint/base.js

@@ -13,6 +13,7 @@ import ts from 'typescript-eslint'
 import { checkout_rooted_parser } from './checkout-rooted-parser.js'
 import { config_fingerprint } from './config-fingerprint.js'
 import { code_quality_rules } from './rules/code-quality.js'
+import { early_return_one_liner_rule } from './rules/early-return-one-liner.js'
 import { formatting_rules } from './rules/formatting.js'
 import { import_rules } from './rules/import.js'
 import { namespace_object_export_rule } from './rules/namespace-object-export.js'
@@ -40,6 +41,14 @@ const FILE_PATTERNS = {
 	// file that was failing anyway.
 	tests: ['**/*.test.ts', '**/*.e2e.ts'],
 	eslint_rules: ['eslint/**/*.ts', 'eslint/rules/**/*.js'],
+	// joshuafolkken/kit#3294: the SvelteKit convention files, whose named exports — route handlers,
+	// `load`, `handle`, `match` — are typed through a const annotation (`export const GET:
+	// RequestHandler = …`). That idiom is the one place `func-style` allows an arrow const.
+	sveltekit_typed_exports: [
+		'**/src/routes/**/+*.{ts,js}',
+		'**/src/hooks{.server,.client,}.{ts,js}',
+		'**/src/params/**/*.{ts,js}',
+	],
 }
 
 // One test-filename ban block. Both bans differ only in their glob and their message, so the shape
@@ -128,12 +137,18 @@ export function create_base_config({ gitignore_path, tsconfig_root_dir }) {
 			// way the test-filename bans are.
 			plugins: {
 				'@stylistic': stylistic,
-				local: { rules: { 'namespace-object-export': namespace_object_export_rule } },
+				local: {
+					rules: {
+						'namespace-object-export': namespace_object_export_rule,
+						'early-return-one-liner': early_return_one_liner_rule,
+					},
+				},
 			},
 			languageOptions: { globals: { ...globals.browser, ...globals.node } },
 			rules: {
 				'no-undef': 'off',
 				'local/namespace-object-export': 'error',
+				'local/early-return-one-liner': 'error',
 				...naming_convention_rules,
 				...typescript_rules,
 				...code_quality_rules,
@@ -145,6 +160,10 @@ export function create_base_config({ gitignore_path, tsconfig_root_dir }) {
 			},
 		},
 		{ files: FILE_PATTERNS.d_ts, rules: { 'import/no-default-export': 'off' } },
+		{
+			files: FILE_PATTERNS.sveltekit_typed_exports,
+			rules: { 'func-style': ['error', 'declaration', { allowTypeAnnotation: true }] },
+		},
 		{
 			files: FILE_PATTERNS.typescript,
 			ignores: ['**/*.svelte.ts'],
@@ -178,6 +197,9 @@ export function create_base_config({ gitignore_path, tsconfig_root_dir }) {
 				'no-console': ['error', { allow: ['warn', 'error', 'info'] }],
 				// vi mock/stub patterns require explicit undefined (mockResolvedValue/stubGlobal)
 				'unicorn/no-useless-undefined': 'off',
+				// A fixture helper's parameter names the axis a test varies, even while every current
+				// call passes the same value; inlining it hides that axis until the next case re-adds it.
+				'unicorn/no-unnecessary-parameters': 'off',
 				// describe-scoped `let` assigned in beforeEach is the standard vitest fixture shape;
 				// the declaration cannot be initialized where it is declared.
 				'init-declarations': 'off',

package/eslint/rules/code-quality.js

@@ -11,6 +11,9 @@ export const code_quality_rules = {
 	'prefer-const': 'error',
 	// アロー関数を優先（名前付き関数式はスタックトレース可読性のため許可）
 	'prefer-arrow-callback': ['error', { allowNamedFunctions: true }],
+	// 関数は function 宣言で書く（joshuafolkken/kit#3294）。SvelteKit の型付き const export は
+	// eslint/base.js が該当ファイルだけ allowTypeAnnotation で許可する
+	'func-style': ['error', 'declaration'],
 	// テンプレートリテラルを優先
 	'prefer-template': 'error',
 	// 等価演算子は厳密等価を使用