@classytic/repo-core 0.1.0 → 0.3.0

package/dist/tenant/types.d.mts

@@ -0,0 +1,142 @@
+//#region src/tenant/types.d.ts
+/**
+ * Tenant scope configuration — canonical static contract for the org.
+ *
+ * **`@classytic/repo-core/tenant` is the single source of truth.** Every
+ * multi-tenant-capable package (`@classytic/mongokit`, `@classytic/sqlitekit`,
+ * future kits, arc presets, services) consumes {@link TenantConfig} for its
+ * static fields and extends with kit-specific runtime callbacks via
+ * `Pick<TenantConfig, ...>` to lock the field vocabulary by structural typing.
+ *
+ * Three strategies are supported:
+ * - `'field'` (default) — filter every query by a scalar field on documents.
+ *   The common case; used by `multiTenantPlugin` in mongokit and sqlitekit.
+ * - `'none'` — disable scoping entirely (single-tenant app). Equivalent to
+ *   `enabled: false`; `strategy: 'none'` is the explicit form.
+ * - `'custom'` — caller supplies a `resolve(ctx)` function that returns the
+ *   filter shape to inject. **The escape hatch for custom systems** —
+ *   covers multi-field composite tenants, context-derived filters
+ *   (region + partner id), non-scalar scope keys, or any tenancy model that
+ *   doesn't fit the simple `field === id` pattern.
+ *
+ * **Why this layer is static-only.** Runtime callbacks (`skipWhen(ctx, op)`,
+ * `resolveContext()`, `resolveTenantId(ctx)`) genuinely differ across kits
+ * because their `RepositoryContext` shapes differ — mongokit's resolver
+ * returns just an id, sqlitekit's takes a richer context object. Each kit
+ * extends `TenantConfig` with its own runtime-callback fields. Hosts who
+ * need a single config object can compose: pass the static `TenantConfig`
+ * through {@link resolveTenantConfig} once, then forward the resolved
+ * static fields into each kit's runtime options alongside the kit-specific
+ * callbacks.
+ */
+/**
+ * Storage / cast strategy for the tenant identifier on documents.
+ *
+ * - `'objectId'` (recommended for new packages) — `Schema.Types.ObjectId`
+ *   with `ref`. Enables `$lookup`, `.populate()`, QueryParser `?lookup=...`
+ *   on Mongo-shaped kits. SQL kits typically ignore this and rely on
+ *   schema-defined column types instead.
+ * - `'string'` — plain string. Use when the host auth system issues UUIDs
+ *   or slugs rather than ObjectIds.
+ */
+type TenantFieldType = 'objectId' | 'string';
+/** Scope resolution strategy. */
+type TenantStrategy = 'field' | 'none' | 'custom';
+interface TenantConfig {
+  /**
+   * Scope strategy. Omit for the common `'field'` case — explicit `'none'`
+   * / `'custom'` lets packages collapse what used to live in a separate
+   * `ScopeConfig` type.
+   *
+   * @default 'field'
+   */
+  strategy?: TenantStrategy;
+  /**
+   * Whether tenant scoping is active. When `false`, the package runs in
+   * single-tenant mode — no filter injection, no tenant field on documents.
+   * Equivalent to `strategy: 'none'`.
+   *
+   * @default true
+   */
+  enabled?: boolean;
+  /**
+   * Document / column field name that stores the tenant id. Used when
+   * `strategy === 'field'`.
+   *
+   * @default 'organizationId'
+   */
+  tenantField?: string;
+  /**
+   * How to store / cast the tenant id.
+   *
+   * @default 'objectId'
+   */
+  fieldType?: TenantFieldType;
+  /**
+   * Mongoose ref for `'objectId'` types. Ignored by SQL kits and when
+   * `fieldType === 'string'`.
+   *
+   * @default 'organization'
+   */
+  ref?: string;
+  /**
+   * Which key on the repository context to read the tenant id from.
+   *
+   * Defaults cascade: if omitted, falls back to the caller's `tenantField`
+   * (if supplied), else to `'organizationId'`. Rationale: when a host renames
+   * `tenantField` to e.g. `'branchId'`, their context almost always carries
+   * the value under the same key — mirroring `tenantField` is the
+   * least-surprise behavior. Override explicitly if the context key diverges
+   * from the document field (e.g. `tenantField: 'branchId'`,
+   * `contextKey: 'organizationId'`).
+   *
+   * @default tenantField ?? 'organizationId'
+   */
+  contextKey?: string;
+  /**
+   * Whether the field is required. When `false`, the package permits
+   * unscoped / cross-tenant reads (typically only for admin paths).
+   *
+   * @default true
+   */
+  required?: boolean;
+  /**
+   * Custom resolver — called when `strategy === 'custom'` to produce the
+   * filter object injected into queries. Packages pass the request /
+   * repository context; the resolver returns the filter shape.
+   *
+   * Use for tenancy models that don't fit the simple `field === id`
+   * pattern: multi-field composites, context-derived filters
+   * (region + partner id), hash-derived shards, etc.
+   *
+   * @example
+   * ```ts
+   * {
+   *   strategy: 'custom',
+   *   resolve: (ctx) => ({
+   *     organizationId: ctx.organizationId,
+   *     region: ctx.region,
+   *     partnerId: ctx.partnerId,
+   *   }),
+   * }
+   * ```
+   */
+  resolve?: (ctx: Record<string, unknown>) => Record<string, unknown>;
+}
+/**
+ * Resolved shape returned by `resolveTenantConfig`. Always includes the
+ * field defaults (so packages can inspect field names even when
+ * `enabled: false`) and threads `resolve` when `strategy === 'custom'`.
+ */
+type ResolvedTenantConfig = {
+  strategy: TenantStrategy;
+  enabled: boolean;
+  tenantField: string;
+  fieldType: TenantFieldType;
+  ref: string;
+  contextKey: string;
+  required: boolean;
+  resolve?: TenantConfig['resolve'];
+};
+//#endregion
+export { ResolvedTenantConfig, TenantConfig, TenantFieldType, TenantStrategy };

package/dist/update/builders.d.mts

@@ -0,0 +1,52 @@
+import { UpdateSpec } from "./types.mjs";
+
+//#region src/update/builders.d.ts
+/**
+ * Compose an `UpdateSpec` from the four primitive mutations.
+ *
+ * ```ts
+ * update({
+ *   set:          { status: 'pending', visibleAt: new Date() },
+ *   unset:        ['leaseOwner'],
+ *   setOnInsert:  { createdAt: new Date() },
+ *   inc:          { attempts: 1 },
+ * });
+ * ```
+ *
+ * Keys with `undefined` values in `set` / `setOnInsert` are dropped — a
+ * common gotcha when spreading optional fields. To actually clear a field,
+ * use `unset` instead (matches mongokit's `$set: { x: undefined }` / `$unset`
+ * distinction).
+ *
+ * Throws if every mutation bucket is empty — an update with nothing to
+ * do is always a caller bug.
+ */
+declare function update(spec: {
+  set?: Record<string, unknown>;
+  unset?: readonly string[];
+  setOnInsert?: Record<string, unknown>;
+  inc?: Record<string, number>;
+}): UpdateSpec;
+/** Sugar: `update({ set: fields })`. Most updates are simple assignments. */
+declare function setFields(fields: Record<string, unknown>): UpdateSpec;
+/** Sugar: `update({ unset: fields })`. */
+declare function unsetFields(...fields: string[]): UpdateSpec;
+/** Sugar: `update({ inc: deltas })`. Each key's value is the delta (positive or negative). */
+declare function incFields(deltas: Record<string, number>): UpdateSpec;
+/** Sugar: `update({ setOnInsert: fields })`. Pairs with an upsert. */
+declare function setOnInsertFields(fields: Record<string, unknown>): UpdateSpec;
+/**
+ * Merge multiple `UpdateSpec` values into one.
+ *
+ *   - `set` / `setOnInsert` / `inc`: shallow-merged, later entries win per
+ *     key. For `inc`, later-wins is usually a bug — callers who want to
+ *     stack deltas should pass `inc({ x: a + b })` directly.
+ *   - `unset`: concatenated + de-duplicated.
+ *
+ * Empty input returns an identity-style spec with `set: {}`, which
+ * `update()` would reject — so we throw here too. An empty combine is
+ * always a caller bug.
+ */
+declare function combineUpdates(...specs: readonly UpdateSpec[]): UpdateSpec;
+//#endregion
+export { combineUpdates, incFields, setFields, setOnInsertFields, unsetFields, update };

package/dist/update/builders.mjs

@@ -0,0 +1,92 @@
+//#region src/update/builders.ts
+/**
+* Compose an `UpdateSpec` from the four primitive mutations.
+*
+* ```ts
+* update({
+*   set:          { status: 'pending', visibleAt: new Date() },
+*   unset:        ['leaseOwner'],
+*   setOnInsert:  { createdAt: new Date() },
+*   inc:          { attempts: 1 },
+* });
+* ```
+*
+* Keys with `undefined` values in `set` / `setOnInsert` are dropped — a
+* common gotcha when spreading optional fields. To actually clear a field,
+* use `unset` instead (matches mongokit's `$set: { x: undefined }` / `$unset`
+* distinction).
+*
+* Throws if every mutation bucket is empty — an update with nothing to
+* do is always a caller bug.
+*/
+function update(spec) {
+	const set = stripUndefined(spec.set);
+	const setOnInsert = stripUndefined(spec.setOnInsert);
+	const inc = spec.inc ? Object.freeze({ ...spec.inc }) : void 0;
+	const unset = spec.unset && spec.unset.length > 0 ? Object.freeze([...spec.unset]) : void 0;
+	if (!(set && Object.keys(set).length > 0 || setOnInsert && Object.keys(setOnInsert).length > 0 || inc && Object.keys(inc).length > 0 || unset && unset.length > 0)) throw new Error("update(): spec is empty. At least one of `set`, `unset`, `setOnInsert`, or `inc` must be populated.");
+	const node = {
+		op: "update",
+		...set && { set },
+		...unset && { unset },
+		...setOnInsert && { setOnInsert },
+		...inc && { inc }
+	};
+	return Object.freeze(node);
+}
+/** Sugar: `update({ set: fields })`. Most updates are simple assignments. */
+function setFields(fields) {
+	return update({ set: fields });
+}
+/** Sugar: `update({ unset: fields })`. */
+function unsetFields(...fields) {
+	return update({ unset: fields });
+}
+/** Sugar: `update({ inc: deltas })`. Each key's value is the delta (positive or negative). */
+function incFields(deltas) {
+	return update({ inc: deltas });
+}
+/** Sugar: `update({ setOnInsert: fields })`. Pairs with an upsert. */
+function setOnInsertFields(fields) {
+	return update({ setOnInsert: fields });
+}
+/**
+* Merge multiple `UpdateSpec` values into one.
+*
+*   - `set` / `setOnInsert` / `inc`: shallow-merged, later entries win per
+*     key. For `inc`, later-wins is usually a bug — callers who want to
+*     stack deltas should pass `inc({ x: a + b })` directly.
+*   - `unset`: concatenated + de-duplicated.
+*
+* Empty input returns an identity-style spec with `set: {}`, which
+* `update()` would reject — so we throw here too. An empty combine is
+* always a caller bug.
+*/
+function combineUpdates(...specs) {
+	if (specs.length === 0) throw new Error("combineUpdates(): at least one spec required.");
+	if (specs.length === 1) return specs[0];
+	const set = {};
+	const setOnInsert = {};
+	const inc = {};
+	const unsetSet = /* @__PURE__ */ new Set();
+	for (const s of specs) {
+		if (s.set) Object.assign(set, s.set);
+		if (s.setOnInsert) Object.assign(setOnInsert, s.setOnInsert);
+		if (s.inc) Object.assign(inc, s.inc);
+		if (s.unset) for (const f of s.unset) unsetSet.add(f);
+	}
+	return update({
+		...Object.keys(set).length > 0 && { set },
+		...Object.keys(setOnInsert).length > 0 && { setOnInsert },
+		...Object.keys(inc).length > 0 && { inc },
+		...unsetSet.size > 0 && { unset: Array.from(unsetSet) }
+	});
+}
+function stripUndefined(record) {
+	if (!record) return void 0;
+	const out = {};
+	for (const [k, v] of Object.entries(record)) if (v !== void 0) out[k] = v;
+	return Object.keys(out).length > 0 ? Object.freeze(out) : void 0;
+}
+//#endregion
+export { combineUpdates, incFields, setFields, setOnInsertFields, unsetFields, update };

package/dist/update/compile.d.mts

@@ -0,0 +1,46 @@
+import { UpdateSpec } from "./types.mjs";
+
+//#region src/update/compile.d.ts
+/**
+ * Compile an `UpdateSpec` to a Mongo operator record.
+ *
+ * Empty buckets are omitted — passing `{ $set: {} }` to Mongo is a no-op
+ * per-op but still round-trips through the driver as a valid update, so
+ * leaving them out keeps the wire format tidy.
+ *
+ * `$unset` values follow the Mongo convention (empty string) — the value
+ * is ignored by the server, only the key matters.
+ */
+declare function compileUpdateSpecToMongo(spec: UpdateSpec): Record<string, unknown>;
+/**
+ * Compile an `UpdateSpec` to a SQL-friendly breakdown.
+ *
+ * SQL kits can't express a single "update record" the way Mongo can — they
+ * need:
+ *
+ *   - `data` for plain `SET col = ?` assignments (both `set` and
+ *     `setOnInsert` feed here; the kit decides how to route `setOnInsert`
+ *     when the UPDATE path hits a matched row vs inserted row).
+ *   - `unset` for `SET col = NULL` clauses.
+ *   - `inc` for `SET col = coalesce(col, 0) + ?` clauses.
+ *   - `insertDefaults` for the INSERT branch of an upsert — fields that
+ *     should ONLY apply when no row matched.
+ *
+ * Callers build the final SQL from these pieces. This helper intentionally
+ * doesn't emit SQL strings — driver quoting, parameter binding, and
+ * `ON CONFLICT` grammar differ too much between SQLite, Postgres, and
+ * Prisma for a shared compiler to own it.
+ */
+interface SqlUpdatePlan {
+  /** Plain column assignments. Merge of `set` — applied on UPDATE and INSERT. */
+  readonly data: Readonly<Record<string, unknown>>;
+  /** Columns to set NULL. */
+  readonly unset: readonly string[];
+  /** Atomic numeric deltas — kit emits `col = coalesce(col, 0) + ?`. */
+  readonly inc: Readonly<Record<string, number>>;
+  /** Fields to set only when the upsert takes the INSERT branch. */
+  readonly insertDefaults: Readonly<Record<string, unknown>>;
+}
+declare function compileUpdateSpecToSql(spec: UpdateSpec): SqlUpdatePlan;
+//#endregion
+export { SqlUpdatePlan, compileUpdateSpecToMongo, compileUpdateSpecToSql };

package/dist/update/compile.mjs

@@ -0,0 +1,33 @@
+//#region src/update/compile.ts
+/**
+* Compile an `UpdateSpec` to a Mongo operator record.
+*
+* Empty buckets are omitted — passing `{ $set: {} }` to Mongo is a no-op
+* per-op but still round-trips through the driver as a valid update, so
+* leaving them out keeps the wire format tidy.
+*
+* `$unset` values follow the Mongo convention (empty string) — the value
+* is ignored by the server, only the key matters.
+*/
+function compileUpdateSpecToMongo(spec) {
+	const out = {};
+	if (spec.set && Object.keys(spec.set).length > 0) out["$set"] = { ...spec.set };
+	if (spec.unset && spec.unset.length > 0) {
+		const unsetRecord = {};
+		for (const field of spec.unset) unsetRecord[field] = "";
+		out["$unset"] = unsetRecord;
+	}
+	if (spec.setOnInsert && Object.keys(spec.setOnInsert).length > 0) out["$setOnInsert"] = { ...spec.setOnInsert };
+	if (spec.inc && Object.keys(spec.inc).length > 0) out["$inc"] = { ...spec.inc };
+	return out;
+}
+function compileUpdateSpecToSql(spec) {
+	return Object.freeze({
+		data: Object.freeze({ ...spec.set ?? {} }),
+		unset: Object.freeze([...spec.unset ?? []]),
+		inc: Object.freeze({ ...spec.inc ?? {} }),
+		insertDefaults: Object.freeze({ ...spec.setOnInsert ?? {} })
+	});
+}
+//#endregion
+export { compileUpdateSpecToMongo, compileUpdateSpecToSql };

package/dist/update/guard.d.mts

@@ -0,0 +1,20 @@
+import { UpdateSpec } from "./types.mjs";
+
+//#region src/update/guard.d.ts
+/**
+ * True when `value` is an `UpdateSpec` — i.e. the portable, compile-to-native
+ * form.
+ *
+ * Fast structural gate: checks the discriminant tag. Deeper validation (no
+ * `$`-prefixed keys inside `set`, `inc` values are numbers, ...) is left
+ * to the compiler; that's where kit-specific constraints live.
+ */
+declare function isUpdateSpec(value: unknown): value is UpdateSpec;
+/**
+ * True when `value` is a Mongo aggregation pipeline (`findOneAndUpdate`'s
+ * array form). Kits use this to short-circuit SQL paths that can't execute
+ * pipelines.
+ */
+declare function isUpdatePipeline(value: unknown): value is Record<string, unknown>[];
+//#endregion
+export { isUpdatePipeline, isUpdateSpec };

package/dist/update/guard.mjs

@@ -0,0 +1,24 @@
+//#region src/update/guard.ts
+/**
+* True when `value` is an `UpdateSpec` — i.e. the portable, compile-to-native
+* form.
+*
+* Fast structural gate: checks the discriminant tag. Deeper validation (no
+* `$`-prefixed keys inside `set`, `inc` values are numbers, ...) is left
+* to the compiler; that's where kit-specific constraints live.
+*/
+function isUpdateSpec(value) {
+	if (!value || typeof value !== "object") return false;
+	if (Array.isArray(value)) return false;
+	return value.op === "update";
+}
+/**
+* True when `value` is a Mongo aggregation pipeline (`findOneAndUpdate`'s
+* array form). Kits use this to short-circuit SQL paths that can't execute
+* pipelines.
+*/
+function isUpdatePipeline(value) {
+	return Array.isArray(value);
+}
+//#endregion
+export { isUpdatePipeline, isUpdateSpec };

package/dist/update/index.d.mts

@@ -0,0 +1,5 @@
+import { UpdateInput, UpdateSpec } from "./types.mjs";
+import { combineUpdates, incFields, setFields, setOnInsertFields, unsetFields, update } from "./builders.mjs";
+import { SqlUpdatePlan, compileUpdateSpecToMongo, compileUpdateSpecToSql } from "./compile.mjs";
+import { isUpdatePipeline, isUpdateSpec } from "./guard.mjs";
+export { type SqlUpdatePlan, type UpdateInput, type UpdateSpec, combineUpdates, compileUpdateSpecToMongo, compileUpdateSpecToSql, incFields, isUpdatePipeline, isUpdateSpec, setFields, setOnInsertFields, unsetFields, update };

package/dist/update/index.mjs

@@ -0,0 +1,4 @@
+import { combineUpdates, incFields, setFields, setOnInsertFields, unsetFields, update } from "./builders.mjs";
+import { compileUpdateSpecToMongo, compileUpdateSpecToSql } from "./compile.mjs";
+import { isUpdatePipeline, isUpdateSpec } from "./guard.mjs";
+export { combineUpdates, compileUpdateSpecToMongo, compileUpdateSpecToSql, incFields, isUpdatePipeline, isUpdateSpec, setFields, setOnInsertFields, unsetFields, update };

package/dist/update/types.d.mts

@@ -0,0 +1,62 @@
+//#region src/update/types.d.ts
+/**
+ * Update IR — driver-agnostic mutation spec.
+ *
+ * An `UpdateSpec` is a structured description of an atomic update that every
+ * kit compiles to its native shape — mongokit emits `$set`/`$unset`/`$inc`/
+ * `$setOnInsert` records, SQL kits emit column assignments + `NULL` columns
+ * + `column = coalesce(column, 0) + delta`, Prisma emits the equivalent
+ * `update` arg.
+ *
+ * The IR covers the subset every backend supports:
+ *
+ *   - **set**          — assign field values (mongokit `$set`, SQL column = ?)
+ *   - **unset**        — clear fields (mongokit `$unset`, SQL column = NULL)
+ *   - **setOnInsert**  — only on upsert insert (mongokit `$setOnInsert`, SQL INSERT default)
+ *   - **inc**          — atomic numeric delta (mongokit `$inc`, SQL col = col + ?)
+ *
+ * Kit-native update features (Mongo `$push`/`$pull`/`$addToSet`, aggregation
+ * pipeline updates, Postgres `jsonb_set`, SQL CASE expressions) stay
+ * kit-native. Pass a raw Mongo operator record or pipeline array when you
+ * need them — the `UpdateInput` union accepts both.
+ *
+ * **Compat invariant:** mongokit's existing Mongo-operator records (`$set`,
+ * `$unset`, ...) are NOT `UpdateSpec` values. Kits route by the `op:
+ * 'update'` tag via `isUpdateSpec`, treating raw records as pre-compiled
+ * and passing them to the driver unchanged.
+ */
+/**
+ * Portable update spec — the tagged-union root every kit compiles.
+ *
+ * At least one of `set` / `unset` / `setOnInsert` / `inc` must be populated.
+ * An empty spec is a wiring bug (nothing to update); kits MAY treat it as
+ * a no-op or throw.
+ */
+interface UpdateSpec {
+  readonly op: 'update';
+  /** Fields to assign. Overrides existing values. */
+  readonly set?: Readonly<Record<string, unknown>>;
+  /** Fields to clear. Mongo `$unset`, SQL `NULL`. */
+  readonly unset?: readonly string[];
+  /** Fields to set only when upsert creates a new row. Ignored otherwise. */
+  readonly setOnInsert?: Readonly<Record<string, unknown>>;
+  /** Atomic numeric deltas. Kits compile to `$inc` / `col = col + ?`. */
+  readonly inc?: Readonly<Record<string, number>>;
+}
+/**
+ * Accepted update argument across every write method. A kit's
+ * `findOneAndUpdate` / `updateMany` implementation accepts:
+ *
+ *   1. `UpdateSpec` — portable, kit-agnostic. Compiles to the native shape.
+ *   2. `Record<string, unknown>` — kit-native raw record (mongokit
+ *      `$`-operators, Prisma `update` input). Passed through unchanged.
+ *   3. `Record<string, unknown>[]` — Mongo aggregation pipeline. Mongo-only
+ *      kits execute it; SQL kits throw `UnsupportedOperationError`.
+ *
+ * Arc's stores (outbox, idempotency, audit) should prefer form (1). Forms
+ * (2) and (3) remain for kit-specific fast paths and the aggregation-update
+ * escape hatch (e.g. outbox's `$ifNull` to preserve `firstFailedAt`).
+ */
+type UpdateInput = UpdateSpec | Record<string, unknown> | Record<string, unknown>[];
+//#endregion
+export { UpdateInput, UpdateSpec };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@classytic/repo-core",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Driver-agnostic repository primitives: hooks, Filter IR, operations, pagination, cache contract. Foundation for mongokit, sqlitekit, pgkit, and prismakit. Lean by design — no plugins ship here; each kit owns its own.",
   "type": "module",
   "sideEffects": false,
@@ -38,6 +38,10 @@
       "types": "./dist/filter/index.d.mts",
       "default": "./dist/filter/index.mjs"
     },
+    "./update": {
+      "types": "./dist/update/index.d.mts",
+      "default": "./dist/update/index.mjs"
+    },
     "./query-parser": {
       "types": "./dist/query-parser/index.d.mts",
       "default": "./dist/query-parser/index.mjs"
@@ -58,6 +62,10 @@
       "types": "./dist/testing/index.d.mts",
       "default": "./dist/testing/index.mjs"
     },
+    "./tenant": {
+      "types": "./dist/tenant/index.d.mts",
+      "default": "./dist/tenant/index.mjs"
+    },
     "./lookup": {
       "types": "./dist/lookup/index.d.mts",
       "default": "./dist/lookup/index.mjs"
@@ -104,13 +112,17 @@
     "format": "biome format src tests --write",
     "check": "biome ci src tests --diagnostic-level=error",
     "knip": "knip",
+    "push": "classytic-push",
     "prepublishOnly": "npm run check && npm run build && npm run typecheck && npm test",
+    "release:tag": "node -e \"require('child_process').execSync('npm run push -- v'+require('./package.json').version,{stdio:'inherit'})\"",
+    "release": "npm run push -- main && npm run release:tag && npm publish",
     "publish:dry": "npm publish --dry-run --access public",
     "publish:npm": "npm publish --access public"
   },
   "devDependencies": {
     "@arethetypeswrong/cli": "^0.18.2",
     "@biomejs/biome": "^2.4.12",
+    "@classytic/dev-tools": "^0.2.0",
     "@types/node": "^22.0.0",
     "@vitest/coverage-v8": "^4.1.4",
     "knip": "^6.3.0",