fmt

.oxfmtrc.json

···
+{
+  "$schema": "./node_modules/oxfmt/configuration_schema.json",
+  "ignorePatterns": []
+}

PLAN.md

···
 # rough notes on how I think this should work
 
 - we start of with no accounts
-- ``/teal auth`` sends user a link to log in with atproto account
+- `/teal auth` sends user a link to log in with atproto account
 - after auth success, we take did and send http request to tap instance to start backfilling for repo
 - user can now use bot commands
 
 ## planned commands
 
-- ``teal auth`` sends user a link to log in with atproto account
-- ``top <artist>``: top 10 listeners for artist (total amount of plays across all songs / albums)
-- ``recent``: most recent play
+- `teal auth` sends user a link to log in with atproto account
+- `top <artist>`: top 10 listeners for artist (total amount of plays across all songs / albums)
+- `recent`: most recent play
 
 ## web interface for account management...maybe..?
 

apps/bot/commands/auth.ts

···
 import { logger } from "@tealfmbot/common/logger.ts";
 
 export default {
-  data: new SlashCommandBuilder().setName("auth").setDescription(
-    "Authenticate your account with the teal.fm bot to start tracking your listens",
-  ),
+  data: new SlashCommandBuilder()
+    .setName("auth")
+    .setDescription(
+      "Authenticate your account with the teal.fm bot to start tracking your listens",
+    ),
   async execute(interaction: CommandInteraction) {
     await interaction.reply("placeholder");
-    logger.info("auth command sent")
+    logger.info("auth command sent");
   },
 };

apps/bot/commands/ping.ts

···
 import { logger } from "@tealfmbot/common/logger.ts";
 
 export default {
-  data: new SlashCommandBuilder().setName("ping").setDescription(
-    "replies with pong",
-  ),
+  data: new SlashCommandBuilder().setName("ping").setDescription("replies with pong"),
   async execute(interaction: CommandInteraction) {
     await interaction.reply("pong lol");
-    logger.info("ping command sent")
+    logger.info("ping command sent");
   },
 };

apps/bot/commands/top.ts

···
 import { logger } from "@tealfmbot/common/logger.ts";
 
 export default {
-  data: new SlashCommandBuilder().setName("top").setDescription(
-    "Find the top listeners for the specified artist(s)",
-  ),
+  data: new SlashCommandBuilder()
+    .setName("top")
+    .setDescription("Find the top listeners for the specified artist(s)"),
   async execute(interaction: CommandInteraction) {
     await interaction.reply("placeholder");
-    logger.info("top command sent")
+    logger.info("top command sent");
   },
 };

apps/bot/deploy-commands.ts

···
 const commandPaths = fs.globSync("commands/**/*.ts");
 
 for await (const cmdPath of commandPaths) {
-  const absoluteCommandPath = path.join(import.meta.dirname, cmdPath)
-  const command = await import(absoluteCommandPath)
+  const absoluteCommandPath = path.join(import.meta.dirname, cmdPath);
+  const command = await import(absoluteCommandPath);
   if ("data" in command.default && "execute" in command.default) {
     commands.push(command.default.data);
   } else {
···
 
 (async () => {
   try {
-    console.log(
-      `Started refreshing ${commands.length} application (/) commands.`,
-    );
+    console.log(`Started refreshing ${commands.length} application (/) commands.`);
 
-    const data = await rest.put(
+    const data = (await rest.put(
       Routes.applicationGuildCommands(DISCORD_APPLICATION_ID, DISCORD_GUILD_ID),
       { body: commands },
-    ) as unknown[];
+    )) as unknown[];
 
-    console.log(
-      `Successfully reloaded ${data.length} application (/) commands.`,
-    );
+    console.log(`Successfully reloaded ${data.length} application (/) commands.`);
   } catch (error) {
     console.error(error);
   }

apps/bot/discord.d.ts

···
 
 declare module "discord.js" {
   export interface Client {
-    commands: Collection<unknown, any>
+    commands: Collection<unknown, any>;
   }
 }

apps/bot/main.ts

···
-import {
-  Client,
-  Collection,
-  Events,
-  GatewayIntentBits,
-  MessageFlags,
-} from "discord.js";
+import { Client, Collection, Events, GatewayIntentBits, MessageFlags } from "discord.js";
 import fs from "node:fs";
 import path from "node:path";
 import { DISCORD_BOT_TOKEN } from "@tealfmbot/common/constants.ts";

apps/bot/package.json

···
 {
   "name": "bot",
   "version": "0.0.1",
-  "type": "module",
   "private": true,
+  "type": "module",
   "scripts": {
     "dev": "tsx main.ts",
     "deploy-commands": "tsx deploy-commands.ts",

apps/bot/tsconfig.json

···
 {
   "extends": "@tealfmbot/tsconfig/tsconfig.node.json",
   "compilerOptions": {
-    "outDir": "./dist",
+    "outDir": "./dist"
   },
-  "exclude": [
-    "node_modules"
-  ]
+  "exclude": ["node_modules"]
 }

apps/tapper/index.ts

···
     //   track_name: evt?.record?.trackName,
     //   user_id: 4
     // }).execute()
-    console.log(evt.record)
+    console.log(evt.record);
   } else {
     console.log(`deleted: ${uri}`);
   }
-
 
   if (process.env.NODE_ENV === "development") {
     // we don't want to ack in development

apps/tapper/package.json

···
 {
   "name": "tapper",
   "version": "0.0.1",
-  "type": "module",
   "private": true,
+  "type": "module",
   "scripts": {
     "dev": "NODE_ENV=development tsx index.ts",
     "start": "NODE_ENV=production tsx index.ts",

apps/tapper/tsconfig.json

···
   "compilerOptions": {
     "outDir": "./dist"
   },
-  "exclude": [
-    "node_modules"
-  ]
+  "exclude": ["node_modules"]
 }

lefthook.yml

···
+pre-commit:
+  jobs:
+    - name: format
+      run: pnpm format {staged_files}
+      exclude:
+        - "**/node_modules"

package.json

···
   "version": "0.0.1",
   "private": true,
   "description": "A discord bot for teal.fm",
+  "keywords": [
+    "atprotocol",
+    "music",
+    "teal.fm"
+  ],
+  "license": "MIT",
+  "author": "Dane Miller <[e-mail]>",
+  "repository": {},
   "scripts": {
     "bot": "pnpm --filter bot dev",
     "tap": "pnpm --filter tapper dev",
     "dev": "pnpm --filter './apps/**' dev",
     "typecheck": "pnpm --filter './apps/**' typecheck",
-    "lint": "oxlint"
+    "lint": "oxlint",
+    "format": "oxfmt"
   },
-  "keywords": [
-    "teal.fm",
-    "atprotocol",
-    "music"
-  ],
-  "author": "Dane Miller <[e-mail]>",
-  "license": "MIT",
-  "packageManager": "pnpm@10.15.0",
-  "repository": {},
   "devDependencies": {
+    "lefthook": "^2.0.13",
+    "oxfmt": "^0.20.0",
     "oxlint": "^1.35.0",
     "typescript": "^5.9.3"
-  }
+  },
+  "packageManager": "pnpm@10.15.0"
 }

packages/common/constants.ts

···
-import { loadEnvFile } from "node:process"
-import path from "node:path"
+import { loadEnvFile } from "node:process";
+import path from "node:path";
 
-loadEnvFile(path.join(import.meta.dirname, "../../.env"))
+loadEnvFile(path.join(import.meta.dirname, "../../.env"));
 
 export const DISCORD_BOT_TOKEN = process.env.DISCORD_BOT_TOKEN as string;
 export const DISCORD_APPLICATION_ID = process.env.DISCORD_APPLICATION_ID as string;

packages/common/logger.ts

···
-import pino from "pino"
+import pino from "pino";
 
 export const logger = pino({
   transport: {
     target: "pino-pretty",
     options: {
-      colorize: true
-    }
-  }
-})
+      colorize: true,
+    },
+  },
+});

packages/common/package.json

···
 {
   "name": "@tealfmbot/common",
   "version": "0.0.0",
-  "type": "module",
   "private": true,
+  "type": "module",
   "exports": {
     "./*": "./*"
   },
   "scripts": {
     "typecheck": "tsc --noEmit"
   },
+  "dependencies": {
+    "pino": "^10.1.0"
+  },
   "devDependencies": {
     "@tealfmbot/tsconfig": "workspace:*",
     "@types/node": "^22.15.3",
-    "typescript": "5.9.2",
-    "pino-pretty": "^13.1.3"
-  },
-  "dependencies": {
-    "pino": "^10.1.0"
+    "pino-pretty": "^13.1.3",
+    "typescript": "5.9.2"
   }
 }

packages/common/tsconfig.json

···
 {
-  "extends": "@tealfmbot/tsconfig/tsconfig.node.json",
+  "extends": "@tealfmbot/tsconfig/tsconfig.node.json"
 }

packages/database/db.ts

···
-import type { DB } from "kysely-codegen"
-import { Pool } from "pg"
-import { Kysely, PostgresDialect } from "kysely"
-import { DATABASE_URL } from "@tealfmbot/common/constants.ts"
+import type { DB } from "kysely-codegen";
+import { Pool } from "pg";
+import { Kysely, PostgresDialect } from "kysely";
+import { DATABASE_URL } from "@tealfmbot/common/constants.ts";
 
 const dialect = new PostgresDialect({
   pool: new Pool({
-    connectionString: DATABASE_URL
-  })
-})
+    connectionString: DATABASE_URL,
+  }),
+});
 
 export const db = new Kysely<DB>({
-  dialect
-})
+  dialect,
+});

packages/database/migrations/schema.ts

···
-import { Kysely, sql } from "kysely"
+import { Kysely, sql } from "kysely";
 
 export async function up(db: Kysely<any>): Promise<void> {
   await db.schema
-    .createTable("users").ifNotExists()
+    .createTable("users")
+    .ifNotExists()
     .addColumn("id", "serial", (col) => col.primaryKey())
     .addColumn("did", "varchar", (col) => col.notNull().unique())
-    .addColumn('created_at', 'timestamp', (col) =>
-      col.defaultTo(sql`now()`).notNull(),
-    )
-    .execute()
+    .addColumn("created_at", "timestamp", (col) => col.defaultTo(sql`now()`).notNull())
+    .execute();
 
   await db.schema
-    .createTable("plays").ifNotExists()
+    .createTable("plays")
+    .ifNotExists()
     .addColumn("id", "serial", (col) => col.primaryKey())
     .addColumn("played_time", "timestamptz", (col) => col.notNull())
     .addColumn("release_name", "varchar", (col) => col.notNull())
-    .addColumn("track_name", 'varchar', (col) => col.notNull())
+    .addColumn("track_name", "varchar", (col) => col.notNull())
     .addColumn("indexed_at", "timestamp", (col) => col.defaultTo(sql`now()`).notNull())
-    .addColumn("user_id", "integer", (col) => col.references("users.id").onDelete("cascade").notNull())
-    .execute()
+    .addColumn("user_id", "integer", (col) =>
+      col.references("users.id").onDelete("cascade").notNull(),
+    )
+    .execute();
 
   await db.schema
-    .createTable("artists").ifNotExists()
+    .createTable("artists")
+    .ifNotExists()
     .addColumn("artist_name", "varchar", (col) => col.notNull())
-    .addColumn("play_id", "integer", (col) => col.references("plays.id").onDelete("cascade").notNull())
-    .execute()
+    .addColumn("play_id", "integer", (col) =>
+      col.references("plays.id").onDelete("cascade").notNull(),
+    )
+    .execute();
 }
 
 export async function down(db: Kysely<any>): Promise<void> {
-  await db.schema.dropTable("users").execute()
-  await db.schema.dropTable("plays").execute()
-  await db.schema.dropTable("artists").execute()
+  await db.schema.dropTable("users").execute();
+  await db.schema.dropTable("plays").execute();
+  await db.schema.dropTable("artists").execute();
 }

packages/database/migrator.ts

···
-import path from "node:path"
-import { Pool } from "pg"
-import fs from "node:fs/promises"
-import type { DB } from "kysely-codegen"
-import { Kysely, Migrator, PostgresDialect, FileMigrationProvider } from "kysely"
-import { DATABASE_URL } from "@tealfmbot/common/constants.ts"
+import path from "node:path";
+import { Pool } from "pg";
+import fs from "node:fs/promises";
+import type { DB } from "kysely-codegen";
+import { Kysely, Migrator, PostgresDialect, FileMigrationProvider } from "kysely";
+import { DATABASE_URL } from "@tealfmbot/common/constants.ts";
 
 async function migrateToLatest() {
   const db = new Kysely<DB>({
     dialect: new PostgresDialect({
       pool: new Pool({
-        connectionString: DATABASE_URL
-      })
-    })
-  })
+        connectionString: DATABASE_URL,
+      }),
+    }),
+  });
 
   const migrator = new Migrator({
     db,
     provider: new FileMigrationProvider({
       fs,
       path,
-      migrationFolder: path.join(import.meta.dirname, "../migrations")
-    })
-  })
-
+      migrationFolder: path.join(import.meta.dirname, "../migrations"),
+    }),
+  });
 
-  const { error, results } = await migrator.migrateToLatest()
+  const { error, results } = await migrator.migrateToLatest();
 
-  results?.forEach(result => {
+  results?.forEach((result) => {
     if (result.status === "Success") {
-      console.log(`migration ${result.migrationName} was executed successfully`)
+      console.log(`migration ${result.migrationName} was executed successfully`);
     } else if (result.status === "Error") {
-      console.error(`failed to execute migration: "${result.migrationName}" `)
+      console.error(`failed to execute migration: "${result.migrationName}" `);
     }
-  })
+  });
 
   if (error) {
-    console.error("failed to migrate")
-    console.error(error)
-    process.exit(1)
+    console.error("failed to migrate");
+    console.error(error);
+    process.exit(1);
   }
 
-  await db.destroy()
+  await db.destroy();
 }
 
-migrateToLatest().catch(err => console.error(err))
+migrateToLatest().catch((err) => console.error(err));

packages/database/package.json

···
 {
   "name": "@tealfmbot/database",
   "version": "0.0.0",
-  "type": "module",
   "private": true,
+  "type": "module",
   "exports": {
     "./db.ts": "./db.ts"
   },
···
     "seed": "tsx seed.ts",
     "typecheck": "tsc --noEmit"
   },
+  "dependencies": {
+    "@tealfmbot/common": "workspace:*",
+    "@tealfmbot/tsconfig": "workspace:*",
+    "kysely": "^0.28.9",
+    "pg": "^8.16.3"
+  },
   "devDependencies": {
     "@types/node": "^22.15.3",
     "@types/pg": "^8.16.0",
     "kysely-codegen": "^0.19.0",
     "tsx": "^4.21.0",
     "typescript": "5.9.2"
-  },
-  "dependencies": {
-    "@tealfmbot/common": "workspace:*",
-    "@tealfmbot/tsconfig": "workspace:*",
-    "kysely": "^0.28.9",
-    "pg": "^8.16.3"
   }
 }

packages/database/seed.ts

···
   // }).returning(['did', 'created_at'])
   //   .executeTakeFirst()
   // console.log({ result })
-
   // const users = await db.selectFrom("users").select(["id", "did"]).execute()
   // console.log({ users })
   // await db.deleteFrom("users").where("did", "=", "did:plc:qttsv4e7pu2jl3ilanfgc3zn").execute()
···
   // console.log({ plays })
 }
 
-main().catch(error => console.error(error))
+main().catch((error) => console.error(error));

packages/database/tsconfig.json

···
 {
   "extends": "@tealfmbot/tsconfig/tsconfig.node.json",
-  "exclude": [
-    "node_modules"
-  ]
+  "exclude": ["node_modules"]
 }

packages/database/types.ts

···
 import type { Artists, Plays } from "kysely-codegen";
 
 export interface TealFMPlay extends Plays {
-  artists: Artists
+  artists: Artists;
 }

packages/tsconfig/tsconfig.base.json

···
     "allowImportingTsExtensions": true,
     "noUncheckedSideEffectImports": true,
     "moduleDetection": "force",
-    "skipLibCheck": true,
+    "skipLibCheck": true
   }
 }

packages/tsconfig/tsconfig.node.json

···
 {
   "extends": "./tsconfig.base.json",
   "compilerOptions": {
-    "lib": [
-      "esnext"
-    ],
-    "types": [
-      "node"
-    ],
+    "lib": ["esnext"],
+    "types": ["node"]
   }
 }

pnpm-lock.yaml

···
 
   .:
     devDependencies:
+      lefthook:
+        specifier: ^2.0.13
+        version: 2.0.13
+      oxfmt:
+        specifier: ^0.20.0
+        version: 0.20.0
       oxlint:
         specifier: ^1.35.0
         version: 1.35.0
···
     cpu: [x64]
     os: [win32]
 
+  '@oxfmt/darwin-arm64@0.20.0':
+    resolution: {integrity: sha512-bjR5dqvrd9gxKYfYR0ljUu3/T3+TuDVWcwA7d+tsfmx9lqidlw3zhgBTblnjF1mrd1zkPMoc5zzq86GeSEt1cA==}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@oxfmt/darwin-x64@0.20.0':
+    resolution: {integrity: sha512-esUDes8FlJX3IY4TVjFLgZrnZlIIyPDlhkCaHgGR3+z2eHFZOvQu68kTSpZLCEJmGXdSpU5rlveycQ6n8tk9ew==}
+    cpu: [x64]
+    os: [darwin]
+
+  '@oxfmt/linux-arm64-gnu@0.20.0':
+    resolution: {integrity: sha512-irE0RO9B0R6ziQE6kUVZtZ6IuTdRyuumn1cPWhDfpa0XUa5sE0ly8pjVsvJbj/J9qerVtidU05txeXBB5CirQg==}
+    cpu: [arm64]
+    os: [linux]
+
+  '@oxfmt/linux-arm64-musl@0.20.0':
+    resolution: {integrity: sha512-eXPBLwYJm26DCmwMwhelEwQMRwuGNaYhYZOhd+CYYsmVoF+h6L6dtjwj0Ovuu0Gqh18EL8vfsaoUvb+jr3vEBg==}
+    cpu: [arm64]
+    os: [linux]
+
+  '@oxfmt/linux-x64-gnu@0.20.0':
+    resolution: {integrity: sha512-dTPW38Hjgb7LoD2mNgyQGBaJ1hu5YgPrxImhl5Eb04eiws+ETCM0wrb2TWGduA+Nv3rHKn3vZEkMTEjklZXgRw==}
+    cpu: [x64]
+    os: [linux]
+
+  '@oxfmt/linux-x64-musl@0.20.0':
+    resolution: {integrity: sha512-b4duw9JGDK/kZoqrPNU9tBOOZQdUW8KJPZ7gW7z54X1eGSqCJ1PT0XLNmZ7SOA1BzQwQ0a3qmQWfFVOsH3a5bw==}
+    cpu: [x64]
+    os: [linux]
+
+  '@oxfmt/win32-arm64@0.20.0':
+    resolution: {integrity: sha512-XAzvBhw4K+Fe16dBaFgYAdob9WaM8RYEXl0ibbm5NlNaQEq+5bH9xwc0oaYlHFnLfcgXWmn9ceTAYqNlONQRNA==}
+    cpu: [arm64]
+    os: [win32]
+
+  '@oxfmt/win32-x64@0.20.0':
+    resolution: {integrity: sha512-fkJqHbJaoOMRmrjHSljyb4/7BgXO3xPLBsJSFGtm3mpfW0HHFbAKvd4/6njhqJz9KY+b3RWP1WssjFshcqQQ4w==}
+    cpu: [x64]
+    os: [win32]
+
   '@oxlint/darwin-arm64@1.35.0':
     resolution: {integrity: sha512-ieiYVHkNZPo77Hgrxav595wGS4rRNKuDNrljf+4xhwpJsddrxMpM64IQUf2IvR3MhK4FxdGzhhB6OVmGVHY5/w==}
     cpu: [arm64]
···
     resolution: {integrity: sha512-3BeXMoiOhpOwu62CiVpO6lxfq4eS6KMYfQdMsN/2kUCRNuF2YiEr7u0HLHaQU+O4Xu8YXE3bHVkwaQ85i72EuA==}
     engines: {node: '>=20.0.0'}
 
+  lefthook-darwin-arm64@2.0.13:
+    resolution: {integrity: sha512-KbQqpNSNTugjtPzt97CNcy/XZy5asJ0+uSLoHc4ML8UCJdsXKYJGozJHNwAd0Xfci/rQlj82A7rPOuTdh0jY0Q==}
+    cpu: [arm64]
+    os: [darwin]
+
+  lefthook-darwin-x64@2.0.13:
+    resolution: {integrity: sha512-s/vI6sEE8/+rE6CONZzs59LxyuSc/KdU+/3adkNx+Q13R1+p/AvQNeszg3LAHzXmF3NqlxYf8jbj/z5vBzEpRw==}
+    cpu: [x64]
+    os: [darwin]
+
+  lefthook-freebsd-arm64@2.0.13:
+    resolution: {integrity: sha512-iQeJTU7Zl8EJlCMQxNZQpJFAQ9xl40pydUIv5SYnbJ4nqIr9ONuvrioNv6N2LtKP5aBl1nIWQQ9vMjgVyb3k+A==}
+    cpu: [arm64]
+    os: [freebsd]
+
+  lefthook-freebsd-x64@2.0.13:
+    resolution: {integrity: sha512-99cAXKRIzpq/u3obUXbOQJCHP+0ZkJbN3TF+1ZQZlRo3Y6+mPSCg9fh/oi6dgbtu4gTI5Ifz3o5p2KZzAIF9ZQ==}
+    cpu: [x64]
+    os: [freebsd]
+
+  lefthook-linux-arm64@2.0.13:
+    resolution: {integrity: sha512-RWarenY3kLy/DT4/8dY2bwDlYwlELRq9MIFq+FiMYmoBHES3ckWcLX2JMMlM49Y672paQc7MbneSrNUn/FQWhg==}
+    cpu: [arm64]
+    os: [linux]
+
+  lefthook-linux-x64@2.0.13:
+    resolution: {integrity: sha512-QZRcxXGf8Uj/75ITBqoBh0zWhJE7+uFoRxEHwBq0Qjv55Q4KcFm7FBN/IFQCSd14reY5pmY3kDaWVVy60cAGJA==}
+    cpu: [x64]
+    os: [linux]
+
+  lefthook-openbsd-arm64@2.0.13:
+    resolution: {integrity: sha512-LAuOWwnNmOlRE0RxKMOhIz5Kr9tXi0rCjzXtDARW9lvfAV6Br2wP+47q0rqQ8m/nVwBYoxfJ/RDunLbb86O1nA==}
+    cpu: [arm64]
+    os: [openbsd]
+
+  lefthook-openbsd-x64@2.0.13:
+    resolution: {integrity: sha512-n9TIN3QLncyxOHomiKKwzDFHKOCm5H28CVNAZFouKqDwEaUGCs5TJI88V85j4/CgmLVUU8uUn4ClVCxIWYG59w==}
+    cpu: [x64]
+    os: [openbsd]
+
+  lefthook-windows-arm64@2.0.13:
+    resolution: {integrity: sha512-sdSC4F9Di7y0t43Of9MOA5g/0CmvkM4juQ3sKfUhRcoygetLJn4PR2/pvuDOIaGf4mNMXBP5IrcKaeDON9HrcA==}
+    cpu: [arm64]
+    os: [win32]
+
+  lefthook-windows-x64@2.0.13:
+    resolution: {integrity: sha512-ccl1v7Fl10qYoghEtjXN+JC1x/y/zLM/NSHf3NFGeKEGBNd1P5d/j6w8zVmhfzi+ekS8whXrcNbRAkLdAqUrSw==}
+    cpu: [x64]
+    os: [win32]
+
+  lefthook@2.0.13:
+    resolution: {integrity: sha512-D39rCVl7/GpqakvhQvqz07SBpzUWTvWjXKnBZyIy8O6D+Lf9xD6tnbHtG5nWXd9iPvv1AKGQwL9R/e5rNtV6SQ==}
+    hasBin: true
+
   lines-and-columns@1.2.4:
     resolution: {integrity: sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==}
 
···
 
   once@1.4.0:
     resolution: {integrity: sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==}
+
+  oxfmt@0.20.0:
+    resolution: {integrity: sha512-+7f8eV8iaK3tENN/FUVxZM1g78HjPehybN8/+/dvEA1O893Dcvk6O7/Q1wTQOHMD7wvdwWdujKl+Uo8QMiKDrQ==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    hasBin: true
 
   oxlint@1.35.0:
     resolution: {integrity: sha512-QDX1aUgaiqznkGfTM2qHwva2wtKqhVoqPSVXrnPz+yLUhlNadikD3QRuRtppHl7WGuy3wG6nKAuR8lash3aWSg==}
···
   thread-stream@3.1.0:
     resolution: {integrity: sha512-OqyPZ9u96VohAyMfJykzmivOrY2wfMSf3C5TtFJVgN+Hm6aj+voFhlK+kZEIv2FBh1X6Xp3DlnCOfEQ3B2J86A==}
 
+  tinypool@2.0.0:
+    resolution: {integrity: sha512-/RX9RzeH2xU5ADE7n2Ykvmi9ED3FBGPAjw9u3zucrNNaEBIO0HPSYgL0NT7+3p147ojeSdaVu08F6hjpv31HJg==}
+    engines: {node: ^20.0.0 || >=22.0.0}
+
   to-regex-range@5.0.1:
     resolution: {integrity: sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==}
     engines: {node: '>=8.0'}
···
   '@esbuild/win32-x64@0.27.2':
     optional: true
 
+  '@oxfmt/darwin-arm64@0.20.0':
+    optional: true
+
+  '@oxfmt/darwin-x64@0.20.0':
+    optional: true
+
+  '@oxfmt/linux-arm64-gnu@0.20.0':
+    optional: true
+
+  '@oxfmt/linux-arm64-musl@0.20.0':
+    optional: true
+
+  '@oxfmt/linux-x64-gnu@0.20.0':
+    optional: true
+
+  '@oxfmt/linux-x64-musl@0.20.0':
+    optional: true
+
+  '@oxfmt/win32-arm64@0.20.0':
+    optional: true
+
+  '@oxfmt/win32-x64@0.20.0':
+    optional: true
+
   '@oxlint/darwin-arm64@1.35.0':
     optional: true
 
···
 
   kysely@0.28.9: {}
 
+  lefthook-darwin-arm64@2.0.13:
+    optional: true
+
+  lefthook-darwin-x64@2.0.13:
+    optional: true
+
+  lefthook-freebsd-arm64@2.0.13:
+    optional: true
+
+  lefthook-freebsd-x64@2.0.13:
+    optional: true
+
+  lefthook-linux-arm64@2.0.13:
+    optional: true
+
+  lefthook-linux-x64@2.0.13:
+    optional: true
+
+  lefthook-openbsd-arm64@2.0.13:
+    optional: true
+
+  lefthook-openbsd-x64@2.0.13:
+    optional: true
+
+  lefthook-windows-arm64@2.0.13:
+    optional: true
+
+  lefthook-windows-x64@2.0.13:
+    optional: true
+
+  lefthook@2.0.13:
+    optionalDependencies:
+      lefthook-darwin-arm64: 2.0.13
+      lefthook-darwin-x64: 2.0.13
+      lefthook-freebsd-arm64: 2.0.13
+      lefthook-freebsd-x64: 2.0.13
+      lefthook-linux-arm64: 2.0.13
+      lefthook-linux-x64: 2.0.13
+      lefthook-openbsd-arm64: 2.0.13
+      lefthook-openbsd-x64: 2.0.13
+      lefthook-windows-arm64: 2.0.13
+      lefthook-windows-x64: 2.0.13
+
   lines-and-columns@1.2.4: {}
 
   lodash.snakecase@4.1.1: {}
···
   once@1.4.0:
     dependencies:
       wrappy: 1.0.2
+
+  oxfmt@0.20.0:
+    dependencies:
+      tinypool: 2.0.0
+    optionalDependencies:
+      '@oxfmt/darwin-arm64': 0.20.0
+      '@oxfmt/darwin-x64': 0.20.0
+      '@oxfmt/linux-arm64-gnu': 0.20.0
+      '@oxfmt/linux-arm64-musl': 0.20.0
+      '@oxfmt/linux-x64-gnu': 0.20.0
+      '@oxfmt/linux-x64-musl': 0.20.0
+      '@oxfmt/win32-arm64': 0.20.0
+      '@oxfmt/win32-x64': 0.20.0
 
   oxlint@1.35.0:
     optionalDependencies:
···
   thread-stream@3.1.0:
     dependencies:
       real-require: 0.2.0
+
+  tinypool@2.0.0: {}
 
   to-regex-range@5.0.1:
     dependencies: