@purposeinplay/payload-version-retention 0.1.1

package/dist/lib/version-row.d.ts

@@ -0,0 +1,19 @@
+import type { VersionRow } from '../types.js';
+/**
+ * Narrows one row returned by `findVersions` / `findGlobalVersions` to the
+ * columns this plugin reads.
+ *
+ * The adapters return rows shaped by whatever `select` was passed and by which
+ * optional version columns the collection has (`autosave` only exists when
+ * autosave is on, `publishedLocale` only with locales), so every field is read
+ * defensively rather than asserted. Rows without a usable `id` or `updatedAt`
+ * are dropped — a retention decision cannot be made about them.
+ */
+export declare function toVersionRow(doc: unknown): null | VersionRow;
+/** `toVersionRow` over a result page, dropping rows that cannot be used. */
+export declare function toVersionRows(docs: unknown): VersionRow[];
+/**
+ * Parent-only variant for the stale-version index walk, where `updatedAt` is
+ * not selected and the row would otherwise be dropped.
+ */
+export declare function toParentIds(docs: unknown): (number | string)[];

package/dist/lib/version-row.js

@@ -0,0 +1,77 @@
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function readId(value) {
+    return typeof value === 'number' || typeof value === 'string' ? value : undefined;
+}
+function readOptionalString(value) {
+    return typeof value === 'string' ? value : undefined;
+}
+function readOptionalBoolean(value) {
+    return typeof value === 'boolean' ? value : undefined;
+}
+function readBody(value) {
+    return isRecord(value) ? value : undefined;
+}
+/**
+ * Narrows one row returned by `findVersions` / `findGlobalVersions` to the
+ * columns this plugin reads.
+ *
+ * The adapters return rows shaped by whatever `select` was passed and by which
+ * optional version columns the collection has (`autosave` only exists when
+ * autosave is on, `publishedLocale` only with locales), so every field is read
+ * defensively rather than asserted. Rows without a usable `id` or `updatedAt`
+ * are dropped — a retention decision cannot be made about them.
+ */ export function toVersionRow(doc) {
+    if (!isRecord(doc)) {
+        return null;
+    }
+    const id = readId(doc.id);
+    const updatedAt = readOptionalString(doc.updatedAt);
+    if (id === undefined || updatedAt === undefined) {
+        return null;
+    }
+    return {
+        autosave: readOptionalBoolean(doc.autosave),
+        createdAt: readOptionalString(doc.createdAt),
+        id,
+        latest: readOptionalBoolean(doc.latest),
+        parent: readId(doc.parent),
+        publishedLocale: readOptionalString(doc.publishedLocale),
+        snapshot: readOptionalBoolean(doc.snapshot),
+        updatedAt,
+        version: readBody(doc.version)
+    };
+}
+/** `toVersionRow` over a result page, dropping rows that cannot be used. */ export function toVersionRows(docs) {
+    if (!Array.isArray(docs)) {
+        return [];
+    }
+    const rows = [];
+    for (const doc of docs){
+        const row = toVersionRow(doc);
+        if (row) {
+            rows.push(row);
+        }
+    }
+    return rows;
+}
+/**
+ * Parent-only variant for the stale-version index walk, where `updatedAt` is
+ * not selected and the row would otherwise be dropped.
+ */ export function toParentIds(docs) {
+    if (!Array.isArray(docs)) {
+        return [];
+    }
+    const parents = [];
+    for (const doc of docs){
+        if (!isRecord(doc)) {
+            continue;
+        }
+        const parent = readId(doc.parent);
+        if (parent !== undefined && !parents.includes(parent)) {
+            parents.push(parent);
+        }
+    }
+    return parents;
+}

package/dist/plugin.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from 'payload';
+import type { VersionRetentionPluginOptions } from './types.js';
+export declare function versionRetentionPlugin(options?: VersionRetentionPluginOptions): Plugin;

package/dist/plugin.js

@@ -0,0 +1,91 @@
+import { createDedupVersionsHook } from './hooks/dedup-versions.js';
+import { resolveOnSaveDedupCollections } from './lib/entities.js';
+import { checkStateGlobal, runSchedulingStartupChecks, warnScheduleDisabled } from './lib/startup-checks.js';
+import { createStateGlobal } from './lib/state.js';
+import { createJanitorTask, DEFAULT_JANITOR_SCHEDULE } from './tasks/janitor.js';
+export function versionRetentionPlugin(options = {}) {
+    return (incomingConfig)=>{
+        const config = {
+            ...incomingConfig
+        };
+        config.custom = {
+            ...config.custom ?? {},
+            versionRetention: options
+        };
+        // Registered before every early return, deliberately. The global is schema,
+        // and schema must not depend on a runtime flag: gating it would make
+        // `migrate:create` emit a DROP in an environment where the plugin happens
+        // to be disabled, and `push: true` in dev drop the table outright.
+        config.globals = [
+            ...config.globals ?? [],
+            createStateGlobal()
+        ];
+        if (options.enabled === false) {
+            return config;
+        }
+        // The experimental on-save hook — off unless the consumer asked for
+        // `dedup: { mode: 'onSave' }`. In the default `'sweep'` mode nothing is
+        // attached to the write path at all.
+        const dedupSlugs = resolveOnSaveDedupCollections(config.collections ?? [], options);
+        if (dedupSlugs.length > 0) {
+            config.collections = (config.collections ?? []).map((collection)=>{
+                if (!dedupSlugs.includes(collection.slug)) {
+                    return collection;
+                }
+                const dedupHook = createDedupVersionsHook(collection.slug);
+                const existingAfterChange = collection.hooks?.afterChange ?? [];
+                return {
+                    ...collection,
+                    hooks: {
+                        ...collection.hooks,
+                        // Last, so a consumer hook that writes again in `afterChange`
+                        // has already produced its version row before we compare.
+                        afterChange: [
+                            ...existingAfterChange,
+                            dedupHook
+                        ]
+                    }
+                };
+            });
+        }
+        if (options.janitor === false) {
+            return config;
+        }
+        const janitor = options.janitor ?? {};
+        const schedule = janitor.schedule ?? DEFAULT_JANITOR_SCHEDULE;
+        config.jobs = {
+            ...config.jobs,
+            tasks: [
+                ...config.jobs?.tasks ?? [],
+                createJanitorTask(options, janitor)
+            ]
+        };
+        // Scheduling a task flips `jobs.scheduling` on for the whole config, and
+        // `handleSchedules` then reads the `payload-jobs-stats` global on every
+        // autoRun tick — before `jobs.run`. Without its table that throw stalls
+        // the consumer's entire default queue, so surface it loudly at boot
+        // instead of leaving it to a silent per-minute failure. An empty schedule
+        // schedules nothing at all, which is worth one line too.
+        const scheduledQueues = [
+            ...new Set(schedule.map((entry)=>entry.queue))
+        ];
+        const startupCheck = async (payload)=>{
+            // Checked whether or not there is a schedule: a consumer who queues the
+            // janitor by hand still writes the dedup cursor to this global.
+            await checkStateGlobal(payload);
+            if (scheduledQueues.length === 0) {
+                warnScheduleDisabled(payload);
+                return;
+            }
+            await runSchedulingStartupChecks(payload, scheduledQueues);
+        };
+        const existingOnInit = config.onInit;
+        config.onInit = async (payload)=>{
+            if (existingOnInit) {
+                await existingOnInit(payload);
+            }
+            await startupCheck(payload);
+        };
+        return config;
+    };
+}

package/dist/tasks/janitor.d.ts

@@ -0,0 +1,8 @@
+import type { TaskConfig } from 'payload';
+import { JANITOR_TASK_SLUG } from '../defaults.js';
+import type { VersionRetentionJanitorOptions, VersionRetentionPluginOptions, VersionRetentionScheduleConfig } from '../types.js';
+type JanitorTaskConfig = TaskConfig<typeof JANITOR_TASK_SLUG>;
+/** Daily 03:00 on the `default` queue — the queue consumers actually drain. */
+export declare const DEFAULT_JANITOR_SCHEDULE: VersionRetentionScheduleConfig[];
+export declare function createJanitorTask(options: VersionRetentionPluginOptions, janitor?: VersionRetentionJanitorOptions): JanitorTaskConfig;
+export {};

package/dist/tasks/janitor.js

@@ -0,0 +1,116 @@
+import { DEFAULT_JANITOR_CRON, DEFAULT_JANITOR_QUEUE, DEFAULT_JANITOR_RETRIES, DEFAULT_MAX_DELETIONS_PER_RUN, DEFAULT_MAX_DOCUMENTS_PER_RUN, DEFAULT_RUN_LOCK_TTL_MS, JANITOR_TASK_SLUG, LOG_PREFIX } from '../defaults.js';
+import { readPreviousDedupCursor, toJanitorInput } from '../lib/dedup-cursor.js';
+import { resolveMaxDedupBodies, resolveVersionedCollections, resolveVersionedGlobals } from '../lib/entities.js';
+import { anotherJanitorIsRunning } from '../lib/run-lock.js';
+import { readStoredCursor, writeStoredCursor } from '../lib/state.js';
+import { runRetentionSweep } from '../lib/sweep.js';
+/** The report of a run that declined to start. */ function skippedOutput() {
+    return {
+        dedupCursor: null,
+        dedupedCount: 0,
+        deletedCount: 0,
+        failedDocuments: 0,
+        // Not this run's business to say; the run that IS working will report it.
+        hasMore: false,
+        scannedDocuments: 0,
+        skippedRaced: 0
+    };
+}
+/** Daily 03:00 on the `default` queue — the queue consumers actually drain. */ export const DEFAULT_JANITOR_SCHEDULE = [
+    {
+        cron: DEFAULT_JANITOR_CRON,
+        queue: DEFAULT_JANITOR_QUEUE
+    }
+];
+export function createJanitorTask(options, janitor = {}) {
+    const schedule = janitor.schedule ?? DEFAULT_JANITOR_SCHEDULE;
+    const maxDeletionsPerRun = janitor.maxDeletionsPerRun ?? DEFAULT_MAX_DELETIONS_PER_RUN;
+    const maxDocumentsPerRun = janitor.maxDocumentsPerRun ?? DEFAULT_MAX_DOCUMENTS_PER_RUN;
+    const runLockTtl = janitor.runLockTtl ?? DEFAULT_RUN_LOCK_TTL_MS;
+    const task = {
+        slug: JANITOR_TASK_SLUG,
+        // Without retries a single transient failure (pool exhaustion, a restart
+        // mid-pass) silently skips the whole day's retention pass.
+        retries: DEFAULT_JANITOR_RETRIES,
+        // Payload's sanitizer turns scheduling on for the whole config when any
+        // task merely *has* a `schedule` key — `[]` included, which would demand
+        // the payload_jobs_stats table while scheduling nothing. Omit the key
+        // entirely for an empty schedule.
+        ...schedule.length > 0 ? {
+            schedule
+        } : {},
+        handler: async ({ input, job, req })=>{
+            const { payload } = req;
+            if (await anotherJanitorIsRunning({
+                ownJob: job,
+                req,
+                ttlMs: runLockTtl
+            })) {
+                return {
+                    output: skippedOutput()
+                };
+            }
+            // The cursor lives in the plugin's own global: Payload deletes a
+            // completed job row by default, so a cursor kept in the job's output
+            // would be gone before the next run could read it. An explicit input
+            // wins; the last job's output is consulted only for consumers carrying
+            // one over from an earlier version of this plugin.
+            const dedupCursor = toJanitorInput(input).dedupCursor ?? await readStoredCursor(payload) ?? await readPreviousDedupCursor(req);
+            // Resolved from the running config rather than the incoming one, so a
+            // collection added by a plugin registered after this one is still swept.
+            const collections = resolveVersionedCollections(payload.config.collections ?? [], options);
+            const globals = resolveVersionedGlobals(payload.config.globals ?? [], options);
+            const output = await runRetentionSweep({
+                collections,
+                dedupCursor,
+                globals,
+                maxDedupBodiesPerRun: resolveMaxDedupBodies(options),
+                maxDeletionsPerRun,
+                maxDocumentsPerRun,
+                payload
+            });
+            await writeStoredCursor(payload, output.dedupCursor);
+            payload.logger.info(output.deletedCount === 0 && !output.hasMore ? `${LOG_PREFIX} Janitor finished: nothing to do — ${output.scannedDocuments} ` + 'document(s) scanned, no deletable version rows.' : `${LOG_PREFIX} Janitor finished: deleted ${output.deletedCount} version row(s) ` + `(${output.dedupedCount} identical) across ${output.scannedDocuments} document(s)` + (output.skippedRaced > 0 ? `, ${output.skippedRaced} skipped as raced` : '') + (output.failedDocuments > 0 ? `, ${output.failedDocuments} failed` : '') + (output.hasMore ? ' — work remains, the next run continues' : ''));
+            return {
+                output
+            };
+        },
+        inputSchema: [
+            {
+                name: 'dedupCursor',
+                type: 'json'
+            }
+        ],
+        outputSchema: [
+            {
+                name: 'dedupCursor',
+                type: 'json'
+            },
+            {
+                name: 'dedupedCount',
+                type: 'number'
+            },
+            {
+                name: 'deletedCount',
+                type: 'number'
+            },
+            {
+                name: 'failedDocuments',
+                type: 'number'
+            },
+            {
+                name: 'hasMore',
+                type: 'checkbox'
+            },
+            {
+                name: 'scannedDocuments',
+                type: 'number'
+            },
+            {
+                name: 'skippedRaced',
+                type: 'number'
+            }
+        ]
+    };
+    return task;
+}

package/dist/types.d.ts

@@ -0,0 +1,239 @@
+/**
+ * Cron entry for the version-retention janitor. Structurally compatible with
+ * Payload's `ScheduleConfig`, which is not exported from the package root.
+ */
+export interface VersionRetentionScheduleConfig {
+    /**
+     * Cron expression. Payload accepts the standard 5-field form and an
+     * optional leading seconds field.
+     */
+    cron: string;
+    /**
+     * Queue the scheduled job is added to. Payload's `handleSchedules` skips
+     * every queue the running autoRun config does not drain (unless it is
+     * invoked with `allQueues`), so this must be a queue that is actually
+     * drained — normally `'default'`.
+     */
+    queue: string;
+}
+/** Per-slug overrides, keyed by collection slug or global slug. */
+export interface VersionRetentionOverride {
+    /**
+     * Retention window in days for this entity only. Falls back to the
+     * top-level `days`.
+     */
+    days?: number;
+    /**
+     * Floor on version rows kept per document for this entity only. Falls back
+     * to the top-level `minVersionsPerDocument`.
+     */
+    minVersionsPerDocument?: number;
+    /** Disable identical-snapshot dedup for this collection or global only. */
+    dedup?: boolean;
+}
+/**
+ * Where identical-snapshot dedup runs.
+ *
+ * - `'sweep'` (default) — inside the nightly janitor, off the write path.
+ * - `'off'` — not at all.
+ * - `'onSave'` — **experimental**, see the README. An `afterChange` hook that
+ *   collapses the duplicate inside the editor's own save transaction.
+ */
+export type VersionRetentionDedupMode = 'off' | 'onSave' | 'sweep';
+export interface VersionRetentionDedupOptions {
+    /**
+     * Ceiling on version bodies the sweep reads for dedup per invocation,
+     * across every collection and global. Bodies are what make these tables
+     * large, so they get a budget of their own.
+     * @default 2000
+     */
+    maxDedupBodiesPerRun?: number;
+    /** @default 'sweep' */
+    mode?: VersionRetentionDedupMode;
+}
+export interface VersionRetentionJanitorOptions {
+    /**
+     * Ceiling on version rows deleted in a single invocation, across every
+     * collection and global. The first run after adopting the plugin meets the
+     * entire accumulated backlog; without a bound it would hold a job slot for
+     * as long as that takes. The handler reports `hasMore` instead and the next
+     * scheduled run continues.
+     * @default 5000
+     */
+    maxDeletionsPerRun?: number;
+    /**
+     * Ceiling on documents examined in a single invocation. A second bound for
+     * the case where a very large backlog is spread thinly — many documents,
+     * few deletable rows each.
+     * @default 20000
+     */
+    maxDocumentsPerRun?: number;
+    /**
+     * How old a `processing` janitor job may be before its lock is ignored as
+     * debris from a crashed run, in milliseconds. Payload never clears
+     * `processing` itself.
+     * @default 21600000 (6 hours)
+     */
+    runLockTtl?: number;
+    /**
+     * Cron entries for the janitor.
+     *
+     * Registering a schedule turns on Payload's job scheduling config-wide,
+     * which requires the `payload_jobs_stats` table — see the README section
+     * "Scheduling requires a consumer migration".
+     *
+     * Pass `[]` to register the task without scheduling it (queue it yourself).
+     * @default [{ cron: '0 3 * * *', queue: 'default' }]
+     */
+    schedule?: VersionRetentionScheduleConfig[];
+}
+export interface VersionRetentionPluginOptions {
+    /**
+     * Collection slugs to sweep and dedup. When omitted, every collection with
+     * `versions` enabled is included.
+     */
+    collections?: string[];
+    /**
+     * Retention window in days. Versions whose `updatedAt` is older than this
+     * are deleted, except the protected rows (see the README).
+     * @default 30
+     */
+    days?: number;
+    /**
+     * Identical-snapshot dedup. `true` is `{ mode: 'sweep' }`, `false` is
+     * `{ mode: 'off' }`.
+     * @default { mode: 'sweep', maxDedupBodiesPerRun: 2000 }
+     */
+    dedup?: boolean | VersionRetentionDedupOptions;
+    /**
+     * Enable/disable the plugin entirely.
+     * @default true
+     */
+    enabled?: boolean;
+    /** Collection slugs to skip, applied after `collections`. */
+    excludeCollections?: string[];
+    /** Global slugs to skip, applied after `globals`. */
+    excludeGlobals?: string[];
+    /**
+     * Global slugs to sweep. When omitted, every global with `versions` enabled
+     * is included.
+     */
+    globals?: string[];
+    /**
+     * Janitor task configuration, or `false` to register neither the task nor
+     * the schedule (leaving only the dedup hook).
+     */
+    janitor?: false | VersionRetentionJanitorOptions;
+    /**
+     * Floor on version rows the janitor leaves behind per document (per global),
+     * whatever their age. The protected rows count toward it, and the rows kept
+     * to reach it are the newest deletable ones.
+     *
+     * Pass `0` for age-and-status only.
+     * @default 5
+     */
+    minVersionsPerDocument?: number;
+    /**
+     * Per-slug overrides keyed by collection or global slug. Unknown slugs are
+     * ignored.
+     */
+    overrides?: Record<string, VersionRetentionOverride>;
+}
+/** A version body as stored in the `version` column. */
+export type VersionBody = Record<string, unknown>;
+/**
+ * The subset of a version row the janitor needs. Mirrors Payload's
+ * `TypeWithVersion` narrowed to the columns the retention decision reads.
+ */
+export interface VersionRow {
+    /** Only present when the collection has autosave enabled. */
+    autosave?: boolean;
+    createdAt?: string;
+    id: number | string;
+    latest?: boolean;
+    /** Id of the document this version belongs to. Absent for globals. */
+    parent?: number | string;
+    publishedLocale?: string;
+    /**
+     * Payload's pre-publish snapshot row. The admin hides these, so they are
+     * never a protected row and never count toward the floor.
+     */
+    snapshot?: boolean;
+    updatedAt: string;
+    /** Absent when the read narrowed the select away from the body. */
+    version?: VersionBody;
+}
+/** A version row reduced to the facts the retention plan is built from. */
+export interface RetentionCandidate {
+    id: number | string;
+    /**
+     * True when `version._status` is `'draft'` — or, under
+     * `drafts.localizeStatus`, when the per-locale status object holds
+     * `'draft'` for any locale.
+     */
+    isDraft: boolean;
+    /** As `isDraft`, for `'published'`. */
+    isPublished: boolean;
+    latest: boolean;
+    /** Payload's pre-publish snapshot row; excluded from protection and floor. */
+    snapshot: boolean;
+    updatedAt: string;
+}
+/**
+ * Where the previous run's dedup pass stopped, as a position in the run's
+ * entity order — not a per-slug map.
+ *
+ * A per-slug map was not enough: the entities *before* the stalled one carried
+ * no cursor, so every run re-read them from the start and spent the whole body
+ * budget before reaching the stalled entity again. Dedup never got past it.
+ * One ordered position lets a run skip everything already covered in this
+ * cycle and pick up exactly where the last one stopped.
+ */
+export interface VersionRetentionDedupCursor {
+    /** Resume after this document. Absent means "resume at the entity's start". */
+    parentId?: number | string;
+    /** Collection or global slug the pass stopped inside. */
+    slug: string;
+}
+/** Input the janitor accepts, carried forward from the previous run. */
+export interface VersionRetentionJanitorInput {
+    dedupCursor?: VersionRetentionDedupCursor;
+}
+/** Outcome of one janitor invocation. */
+export interface VersionRetentionJanitorOutput {
+    /**
+     * Where dedup stopped, or `null` when it completed a full cycle over every
+     * entity. Fed back in as the next run's input so the body budget advances
+     * through the whole corpus instead of restarting at the first entity.
+     */
+    dedupCursor: null | VersionRetentionDedupCursor;
+    /** Rows removed because they were byte-identical to their predecessor. */
+    dedupedCount: number;
+    /** Total rows removed, dedup included. */
+    deletedCount: number;
+    /** Documents (or entities) whose sweep threw. Logged, skipped, retried. */
+    failedDocuments: number;
+    /**
+     * True only when deletable work is known to remain: a document was cut by
+     * the deletion budget, the index walk stopped with parents unvisited, or a
+     * document held more history than one pass inspects. Reaching a budget with
+     * nothing left to do does NOT set it.
+     */
+    hasMore: boolean;
+    scannedDocuments: number;
+    /**
+     * Documents skipped because their version rows changed underneath the pass
+     * (a concurrent publish or unpublish). Retried on the next run.
+     */
+    skippedRaced: number;
+}
+/** A collection or global resolved to the settings the janitor runs with. */
+export interface ResolvedEntity {
+    days: number;
+    /** Whether the sweep should dedup identical consecutive rows here. */
+    dedup: boolean;
+    /** Whether `version._status` exists at all for this entity. */
+    hasDrafts: boolean;
+    minVersionsPerDocument: number;
+    slug: string;
+}

package/dist/types.js

@@ -0,0 +1,4 @@
+/**
+ * Cron entry for the version-retention janitor. Structurally compatible with
+ * Payload's `ScheduleConfig`, which is not exported from the package root.
+ */ /** A collection or global resolved to the settings the janitor runs with. */ export { };

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@purposeinplay/payload-version-retention",
+  "version": "0.1.1",
+  "description": "Version retention plugin for Payload CMS 3 — age-and-status version janitor plus identical-snapshot dedup, so version history stops growing without count caps evicting the last good publish.",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/exports/index.js",
+  "types": "./dist/exports/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/exports/index.d.ts",
+      "import": "./dist/exports/index.js",
+      "default": "./dist/exports/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "peerDependencies": {
+    "payload": "^3.0.0"
+  },
+  "devDependencies": {
+    "@payloadcms/db-postgres": "^3.85.2",
+    "payload": "^3.85.2",
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.10"
+  },
+  "keywords": [
+    "payload",
+    "payloadcms",
+    "plugin",
+    "versions",
+    "retention",
+    "cleanup",
+    "drafts"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/purposeinplay/payload-plugins.git",
+    "directory": "packages/payload-version-retention"
+  },
+  "homepage": "https://github.com/purposeinplay/payload-plugins/tree/main/packages/payload-version-retention#readme",
+  "bugs": {
+    "url": "https://github.com/purposeinplay/payload-plugins/issues"
+  },
+  "scripts": {
+    "build": "pnpm run build:types && pnpm run build:swc && pnpm run build:fix-esm",
+    "build:types": "tsc -p tsconfig.build.json --emitDeclarationOnly --outDir dist",
+    "build:swc": "swc ./src -d ./dist --config-file ../../.swcrc --strip-leading-paths --ignore \"**/__tests__/**\"",
+    "build:fix-esm": "node ../../scripts/fix-dist-extensions.mjs dist && node ../../scripts/check-dist-esm.mjs dist",
+    "typecheck": "tsc -p tsconfig.json --noEmit && tsc -p tsconfig.int.json",
+    "test": "vitest run",
+    "clean": "rm -rf dist *.tsbuildinfo",
+    "test:int": "vitest run -c vitest.int.config.ts"
+  }
+}