@zudojs/types 0.1.0 → 1.1.0

package/dist/typeConverters/typeConverters.core.js

@@ -3,12 +3,35 @@
  *
  * @module typeConverters/typeConverters
  */
+/** Property names that mutate a prototype instead of adding a key. */
+const UNSAFE_KEYS = new Set([
+    "__proto__",
+    "constructor",
+    "prototype",
+]);
 /**
  * Safely parse JSON with a fallback value.
+ *
+ * "Safe" here means only that malformed JSON yields the fallback rather than
+ * throwing. The result is cast to `T` without validation — parse a trust
+ * boundary with `@zudojs/validation` or `@zudojs/schema` instead of relying on
+ * this cast.
+ *
+ * `__proto__`, `constructor` and `prototype` keys are dropped at every depth.
+ * `JSON.parse` itself never routes them through a prototype, so this is a
+ * deliberate deny-list, not a parser fix: a downstream deep merge that walks
+ * `constructor.prototype` or `__proto__` would otherwise reach
+ * `Object.prototype`. A payload whose legitimate field is named
+ * `constructor` or `prototype` loses that field; parse it with plain
+ * `JSON.parse` and validate it instead.
  */
 export function safeJsonParse(json, fallback) {
     try {
-        return JSON.parse(json);
+        return JSON.parse(json, function reviver(key, value) {
+            if (UNSAFE_KEYS.has(key))
+                return undefined;
+            return value;
+        });
     }
     catch {
         return fallback;
@@ -16,48 +39,81 @@ export function safeJsonParse(json, fallback) {
 }
 /**
  * Convert a value to a string safely.
+ *
+ * Always returns a string. `JSON.stringify` returns the *value* `undefined`
+ * — not a string, and without throwing — for functions, symbols and
+ * `undefined`, so its result is checked rather than returned directly.
  */
 export function toString(value, fallback = "") {
     if (value === null || value === undefined)
         return fallback;
     if (typeof value === "string")
         return value;
-    if (typeof value === "number" || typeof value === "boolean")
+    if (typeof value === "number" || typeof value === "boolean") {
         return String(value);
+    }
+    if (typeof value === "bigint")
+        return `${value}`;
+    if (typeof value === "symbol")
+        return value.toString();
+    if (typeof value === "function")
+        return fallback;
     try {
-        return JSON.stringify(value);
+        const serialized = JSON.stringify(value);
+        return typeof serialized === "string" ? serialized : fallback;
     }
     catch {
         return fallback;
     }
 }
 /**
- * Convert a value to a number safely.
+ * Convert a value to a finite number safely.
+ *
+ * Blank strings, hexadecimal literals and infinities all fall back rather than
+ * converting: a missing query parameter arriving as `""` becoming a real zero
+ * silently turns into a page size, a price or a limit.
  */
 export function toNumber(value, fallback = NaN) {
-    if (typeof value === "number")
-        return value;
+    if (typeof value === "number") {
+        return Number.isFinite(value) ? value : fallback;
+    }
     if (typeof value === "string") {
-        const num = Number(value);
-        return Number.isNaN(num) ? fallback : num;
+        const trimmed = value.trim();
+        if (trimmed.length === 0)
+            return fallback;
+        if (!/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$/u.test(trimmed)) {
+            return fallback;
+        }
+        const parsed = Number(trimmed);
+        return Number.isFinite(parsed) ? parsed : fallback;
     }
     return fallback;
 }
 /**
  * Convert a value to a boolean safely.
+ *
+ * `NaN` falls back rather than converting to true. It is what `toNumber`
+ * produces on failure, so chaining the two would otherwise turn a parse
+ * failure into the permissive answer for a flag.
  */
 export function toBoolean(value, fallback = false) {
     if (typeof value === "boolean")
         return value;
     if (typeof value === "string") {
         const lower = value.toLowerCase().trim();
-        if (lower === "true" || lower === "1" || lower === "yes")
+        if (lower === "true" || lower === "1" || lower === "yes" || lower === "on")
             return true;
-        if (lower === "false" || lower === "0" || lower === "no" || lower === "")
+        if (lower === "false" ||
+            lower === "0" ||
+            lower === "no" ||
+            lower === "off" ||
+            lower === "")
             return false;
+        return fallback;
+    }
+    if (typeof value === "number") {
+        return Number.isNaN(value) ? fallback : value !== 0;
     }
-    if (typeof value === "number")
-        return value !== 0;
     return fallback;
 }
 /**
@@ -70,11 +126,22 @@ export function toArray(value) {
 }
 /**
  * Convert a Map to a plain object.
+ *
+ * Built on a null-prototype object with `defineProperty`. Assigning into an
+ * object literal routes a `__proto__` key through the prototype setter, so a
+ * Map built from request data — headers, form fields, query parameters — could
+ * replace the result's prototype with attacker-supplied values that
+ * `Object.keys` does not reveal.
  */
 export function mapToObject(map) {
-    const obj = {};
+    const obj = Object.create(null);
     for (const [key, value] of map) {
-        obj[key] = value;
+        Object.defineProperty(obj, key, {
+            value,
+            enumerable: true,
+            writable: true,
+            configurable: true,
+        });
     }
     return obj;
 }
@@ -88,24 +155,48 @@ export function objectToMap(obj) {
  * Convert snake_case to camelCase.
  */
 export function snakeToCamel(str) {
-    return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+    return str.replace(/(?<!_)_+([a-z0-9])/gu, (_, char) => char.toUpperCase());
+}
+/**
+ * Split a camelCase or PascalCase identifier into its words.
+ *
+ * Runs of capitals are kept together, so `parseHTTPResponse` yields
+ * `["parse", "HTTP", "Response"]` rather than one word per letter. Letter
+ * classes are Unicode-aware (`caféAuLait` keeps its `é`), existing `_`, `-`
+ * and whitespace separators are word boundaries, and any other character is
+ * kept in place rather than silently dropped.
+ */
+function splitCamelWords(str) {
+    return str
+        .replace(/([\p{Ll}\p{N}])(\p{Lu})/gu, "$1\u0000$2")
+        .replace(/(\p{Lu})(\p{Lu}\p{Ll})/gu, "$1\u0000$2")
+        .split(/[\u0000\s_-]+/u)
+        .filter((word) => word.length > 0);
 }
 /**
- * Convert camelCase to snake_case.
+ * Convert camelCase or PascalCase to snake_case.
+ *
+ * Leading capitals do not produce a leading separator, and acronyms survive
+ * as single words — an identifier like `_hello_world` is not a valid column
+ * name, and `parse_h_t_t_p_response` is not a useful one.
  */
 export function camelToSnake(str) {
-    return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+    return splitCamelWords(str)
+        .map((word) => word.toLowerCase())
+        .join("_");
 }
 /**
  * Convert kebab-case to camelCase.
  */
 export function kebabToCamel(str) {
-    return str.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+    return str.replace(/(?<!-)-+([a-z0-9])/gu, (_, char) => char.toUpperCase());
 }
 /**
- * Convert camelCase to kebab-case.
+ * Convert camelCase or PascalCase to kebab-case.
  */
 export function camelToKebab(str) {
-    return str.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);
+    return splitCamelWords(str)
+        .map((word) => word.toLowerCase())
+        .join("-");
 }
 //# sourceMappingURL=typeConverters.core.js.map

package/dist/typeGuards/index.d.ts

@@ -3,5 +3,5 @@
  *
  * @module typeGuards
  */
-export { isPlainObject, isNonNullObject, isNonEmptyString, isPositiveNumber, isInteger, isDate, isUrl, isEmail, isUuid, isIsoDateString, isArrayOfType, isDefined, isFunction, isPromise, } from "./typeGuards.core.js";
+export { MAX_EMAIL_LENGTH, isPlainObject, isNonNullObject, isNonEmptyString, isPositiveNumber, isFiniteNumber, isInteger, isDate, isUrl, isEmail, isUuid, isUuidV4, isIsoDateString, isIsoDateTimeString, isArrayOfType, isDefined, isFunction, isPromise, isThenable, } from "./typeGuards.core.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/typeGuards/index.js

@@ -3,5 +3,5 @@
  *
  * @module typeGuards
  */
-export { isPlainObject, isNonNullObject, isNonEmptyString, isPositiveNumber, isInteger, isDate, isUrl, isEmail, isUuid, isIsoDateString, isArrayOfType, isDefined, isFunction, isPromise, } from "./typeGuards.core.js";
+export { MAX_EMAIL_LENGTH, isPlainObject, isNonNullObject, isNonEmptyString, isPositiveNumber, isFiniteNumber, isInteger, isDate, isUrl, isEmail, isUuid, isUuidV4, isIsoDateString, isIsoDateTimeString, isArrayOfType, isDefined, isFunction, isPromise, isThenable, } from "./typeGuards.core.js";
 //# sourceMappingURL=index.js.map

package/dist/typeGuards/typeGuards.core.d.ts

@@ -16,7 +16,14 @@ export declare function isNonNullObject(value: unknown): value is Record<string,
  */
 export declare function isNonEmptyString(value: unknown): value is string;
 /**
- * Check if a value is a positive number.
+ * Check if a value is a finite number.
+ */
+export declare function isFiniteNumber(value: unknown): value is number;
+/**
+ * Check if a value is a positive, finite number.
+ *
+ * `Infinity` is excluded: a positive-number guard is normally protecting a
+ * size, a count or a price, none of which have a meaningful infinite value.
  */
 export declare function isPositiveNumber(value: unknown): value is number;
 /**
@@ -31,18 +38,52 @@ export declare function isDate(value: unknown): value is Date;
  * Check if a value is a valid URL string.
  */
 export declare function isUrl(value: unknown): value is string;
+/**
+ * Longest input `isEmail` will examine.
+ *
+ * RFC 5321 caps a forward path at 254 characters; anything longer cannot be a
+ * deliverable address, and refusing it up front keeps an attacker from
+ * handing the domain pattern a megabyte to backtrack over.
+ */
+export declare const MAX_EMAIL_LENGTH = 254;
 /**
  * Check if a value is a valid email string.
+ *
+ * This is the monorepo's reference email check. `ValidationPattern.EMAIL`
+ * in `@zudojs/constants` (and therefore `createEmailAddress` and the schema
+ * `email` format) encodes the same acceptance set, including the 254
+ * character bound. `@zudojs/validation`'s `email` constraint still carries
+ * its own copy of the pattern without the length bound; until it delegates
+ * here, an address over 254 characters passes that constraint only.
  */
 export declare function isEmail(value: unknown): value is string;
 /**
- * Check if a value is a valid UUID v4 string.
+ * Check if a value is a UUID string of any defined version.
+ *
+ * Accepts versions 1 through 8 — UUIDv7 included — plus the nil and max
+ * UUIDs. Use {@link isUuidV4} when the version genuinely matters.
  */
 export declare function isUuid(value: unknown): value is string;
 /**
- * Check if a value is a valid ISO 8601 date string.
+ * Check if a value is specifically a UUID v4 string.
+ */
+export declare function isUuidV4(value: unknown): value is string;
+/**
+ * Check if a value is a valid ISO 8601 date string, with or without a time.
+ *
+ * Validates the calendar date as well as the shape, and accepts numeric UTC
+ * offsets. Checking digit counts alone accepted `2024-13-45T99:99:99Z` and
+ * rejected `2024-01-01T00:00:00+02:00` — wrong in both directions.
+ *
+ * Use {@link isIsoDateTimeString} where a time component is required.
  */
 export declare function isIsoDateString(value: unknown): value is string;
+/**
+ * Check if a value is a valid ISO 8601 date-time string.
+ *
+ * Like {@link isIsoDateString}, but a time component is mandatory.
+ */
+export declare function isIsoDateTimeString(value: unknown): value is string;
 /**
  * Check if a value is an array of a specific element type.
  */
@@ -56,7 +97,15 @@ export declare function isDefined<T>(value: T | null | undefined): value is T;
  */
 export declare function isFunction(value: unknown): value is (...args: unknown[]) => unknown;
 /**
- * Check if a value is a Promise.
+ * Check if a value is a native Promise.
  */
 export declare function isPromise(value: unknown): value is Promise<unknown>;
+/**
+ * Check if a value is awaitable.
+ *
+ * Narrows to `PromiseLike`, not `Promise`: a plain thenable is safe to
+ * `await` but has no `.catch()` or `.finally()`, so claiming it is a Promise
+ * makes those calls throw at the point the guard was supposed to make safe.
+ */
+export declare function isThenable(value: unknown): value is PromiseLike<unknown>;
 //# sourceMappingURL=typeGuards.core.d.ts.map

package/dist/typeGuards/typeGuards.core.js

@@ -25,10 +25,19 @@ export function isNonEmptyString(value) {
     return typeof value === "string" && value.length > 0;
 }
 /**
- * Check if a value is a positive number.
+ * Check if a value is a finite number.
+ */
+export function isFiniteNumber(value) {
+    return typeof value === "number" && Number.isFinite(value);
+}
+/**
+ * Check if a value is a positive, finite number.
+ *
+ * `Infinity` is excluded: a positive-number guard is normally protecting a
+ * size, a count or a price, none of which have a meaningful infinite value.
  */
 export function isPositiveNumber(value) {
-    return typeof value === "number" && value > 0 && !Number.isNaN(value);
+    return isFiniteNumber(value) && value > 0;
 }
 /**
  * Check if a value is a valid integer.
@@ -56,29 +65,108 @@ export function isUrl(value) {
         return false;
     }
 }
+/**
+ * Longest input `isEmail` will examine.
+ *
+ * RFC 5321 caps a forward path at 254 characters; anything longer cannot be a
+ * deliverable address, and refusing it up front keeps an attacker from
+ * handing the domain pattern a megabyte to backtrack over.
+ */
+export const MAX_EMAIL_LENGTH = 254;
 /**
  * Check if a value is a valid email string.
+ *
+ * This is the monorepo's reference email check. `ValidationPattern.EMAIL`
+ * in `@zudojs/constants` (and therefore `createEmailAddress` and the schema
+ * `email` format) encodes the same acceptance set, including the 254
+ * character bound. `@zudojs/validation`'s `email` constraint still carries
+ * its own copy of the pattern without the length bound; until it delegates
+ * here, an address over 254 characters passes that constraint only.
  */
 export function isEmail(value) {
     if (typeof value !== "string")
         return false;
-    return /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/.test(value);
+    // Bound the input before the pattern runs against it. The domain half
+    // contains `(?:[a-z0-9-]*[a-z0-9])?` nested inside `(?:\. … )+`, which is
+    // the ambiguous-quantifier shape that backtracks super-linearly on a long
+    // non-matching label. RFC 5321 caps a path at 254 characters, so nothing
+    // legitimate is lost by refusing to even look at more.
+    if (value.length > MAX_EMAIL_LENGTH)
+        return false;
+    if (value.includes(".."))
+        return false;
+    return /^[^\s@,;<>"[\]\\]+@[a-z0-9](?:[a-z0-9-]*[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]*[a-z0-9])?)+$/iu.test(value);
 }
 /**
- * Check if a value is a valid UUID v4 string.
+ * Check if a value is a UUID string of any defined version.
+ *
+ * Accepts versions 1 through 8 — UUIDv7 included — plus the nil and max
+ * UUIDs. Use {@link isUuidV4} when the version genuinely matters.
  */
 export function isUuid(value) {
     if (typeof value !== "string")
         return false;
-    return /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value);
+    if (value === "00000000-0000-0000-0000-000000000000")
+        return true;
+    if (value.toLowerCase() === "ffffffff-ffff-ffff-ffff-ffffffffffff") {
+        return true;
+    }
+    return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu.test(value);
 }
 /**
- * Check if a value is a valid ISO 8601 date string.
+ * Check if a value is specifically a UUID v4 string.
+ */
+export function isUuidV4(value) {
+    if (typeof value !== "string")
+        return false;
+    return /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu.test(value);
+}
+/**
+ * Check if a value is a valid ISO 8601 date string, with or without a time.
+ *
+ * Validates the calendar date as well as the shape, and accepts numeric UTC
+ * offsets. Checking digit counts alone accepted `2024-13-45T99:99:99Z` and
+ * rejected `2024-01-01T00:00:00+02:00` — wrong in both directions.
+ *
+ * Use {@link isIsoDateTimeString} where a time component is required.
  */
 export function isIsoDateString(value) {
     if (typeof value !== "string")
         return false;
-    return /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?Z?$/.test(value);
+    if (!/^\d{4}-\d{2}-\d{2}(?:[T ]\d{2}:\d{2}(?::\d{2}(?:\.\d{1,9})?)?(?:Z|[+-]\d{2}:\d{2})?)?$/u.test(value)) {
+        return false;
+    }
+    if (Number.isNaN(new Date(value).getTime()))
+        return false;
+    // Real guards rather than `!` assertions: the regex above already fixes the
+    // shape, but an assertion would turn any future loosening of it into silent
+    // NaN propagation through Date.UTC instead of a `false`.
+    const parts = value.slice(0, 10).split("-").map(Number);
+    const [year, month, day] = parts;
+    if (year === undefined || month === undefined || day === undefined) {
+        return false;
+    }
+    if (!Number.isInteger(year) ||
+        !Number.isInteger(month) ||
+        !Number.isInteger(day)) {
+        return false;
+    }
+    const asUtc = new Date(Date.UTC(year, month - 1, day));
+    return (asUtc.getUTCFullYear() === year &&
+        asUtc.getUTCMonth() === month - 1 &&
+        asUtc.getUTCDate() === day);
+}
+/**
+ * Check if a value is a valid ISO 8601 date-time string.
+ *
+ * Like {@link isIsoDateString}, but a time component is mandatory.
+ */
+export function isIsoDateTimeString(value) {
+    if (typeof value !== "string")
+        return false;
+    if (!/[T ]\d{2}:\d{2}/u.test(value))
+        return false;
+    return isIsoDateString(value);
 }
 /**
  * Check if a value is an array of a specific element type.
@@ -101,13 +189,24 @@ export function isFunction(value) {
     return typeof value === "function";
 }
 /**
- * Check if a value is a Promise.
+ * Check if a value is a native Promise.
  */
 export function isPromise(value) {
-    return (value instanceof Promise ||
-        (typeof value === "object" &&
-            value !== null &&
-            "then" in value &&
-            typeof value.then === "function"));
+    return value instanceof Promise;
+}
+/**
+ * Check if a value is awaitable.
+ *
+ * Narrows to `PromiseLike`, not `Promise`: a plain thenable is safe to
+ * `await` but has no `.catch()` or `.finally()`, so claiming it is a Promise
+ * makes those calls throw at the point the guard was supposed to make safe.
+ */
+export function isThenable(value) {
+    if (value instanceof Promise)
+        return true;
+    return (typeof value === "object" &&
+        value !== null &&
+        "then" in value &&
+        typeof value.then === "function");
 }
 //# sourceMappingURL=typeGuards.core.js.map

package/dist/typeUtilities/index.d.ts

@@ -3,5 +3,5 @@
  *
  * @module typeUtilities
  */
-export type { DeepReadonly, DeepPartial, DeepRequired, Prettify, StringKeysOf, NumberKeysOf, PartialExcept, RequiredExcept, OptionalKeys, RequireKeys, AsyncReturnType, Nullable, Undefinable, Maybe, MaybePromise, NestedKeyOf, NestedValueOf, OmitByValue, PickByValue, } from "./typeUtilities.core.js";
+export type { DeepReadonly, DeepPartial, DeepRequired, Prettify, StringKeysOf, NumberKeysOf, PartialExcept, RequiredExcept, PartialKeys, OptionalKeyNames, RequireKeys, AsyncReturnType, Nullable, Undefinable, Maybe, MaybePromise, NestedKeyOf, NestedValueOf, OmitByValue, PickByValue, } from "./typeUtilities.core.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/typeUtilities/typeUtilities.core.d.ts

@@ -44,17 +44,36 @@ export type PartialExcept<T, K extends keyof T> = Partial<Omit<T, K>> & Pick<T,
  */
 export type RequiredExcept<T, K extends keyof T> = Required<Omit<T, K>> & Pick<T, K>;
 /**
- * Create a type that makes specified keys optional.
+ * Create a type that makes the specified keys optional.
+ *
+ * Named `PartialKeys` to pair with {@link RequireKeys}. It was `OptionalKeys`,
+ * which in every other utility library means "the union of `T`'s optional key
+ * names" — the opposite kind of thing, and a two-parameter type that reads as
+ * a one-parameter one. Use {@link OptionalKeyNames} for that meaning.
  */
-export type OptionalKeys<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+export type PartialKeys<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+/**
+ * The union of `T`'s optional key names.
+ *
+ * This is what `OptionalKeys<T>` reads as, and there was no type that did it.
+ */
+export type OptionalKeyNames<T> = {
+    [K in keyof T]-?: object extends Pick<T, K> ? K : never;
+}[keyof T];
 /**
  * Create a type that makes specified keys required.
  */
 export type RequireKeys<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;
 /**
  * Extract the return type of an async function.
+ *
+ * The constraint uses `never[]` rather than `unknown[]`. Parameters are
+ * contravariant, so `(id: string) => Promise<User>` is **not** assignable to
+ * `(...args: unknown[]) => Promise<unknown>` — the previous constraint
+ * rejected almost every real async function, and nothing caught it because no
+ * test instantiated the type.
  */
-export type AsyncReturnType<T extends (...args: unknown[]) => Promise<unknown>> = T extends (...args: unknown[]) => Promise<infer R> ? R : never;
+export type AsyncReturnType<T extends (...args: never[]) => Promise<unknown>> = T extends (...args: never[]) => Promise<infer R> ? R : never;
 /**
  * Make a type nullable (allows null).
  */

package/package.json

@@ -1,8 +1,12 @@
 {
   "name": "@zudojs/types",
-  "version": "0.1.0",
+  "version": "1.1.0",
   "description": "Shared type guards, utility types, and type converters for the Zudojs framework.",
   "license": "MIT",
+  "author": {
+    "name": "Oluwayemi Oyinlola",
+    "url": "https://github.com/oyinlola-tech"
+  },
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -15,22 +19,18 @@
     }
   },
   "files": [
-    "dist"
+    "dist",
+    "!dist/**/*.map",
+    "!dist/**/*.tsbuildinfo",
+    "!dist/.tsbuildinfo"
   ],
-  "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "typecheck": "tsc -p tsconfig.json --noEmit",
-    "clean": "rm -rf dist",
-    "test": "vitest run",
-    "test:watch": "vitest"
-  },
   "dependencies": {},
   "engines": {
     "node": ">=24.0.0"
   },
   "devDependencies": {
     "@types/node": "^26.4.1",
-    "typescript": "^7.0.2",
+    "typescript": "7.0.2",
     "vitest": "^4.1.11"
   },
   "publishConfig": {
@@ -43,8 +43,19 @@
     "utilities"
   ],
   "homepage": "https://github.com/oyinlola-tech/zudo#readme",
+  "bugs": {
+    "url": "https://github.com/oyinlola-tech/zudo/issues"
+  },
   "repository": {
     "type": "git",
-    "url": "https://github.com/oyinlola-tech/zudo"
+    "url": "https://github.com/oyinlola-tech/zudo",
+    "directory": "packages/types"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit && tsc -p tsconfig.test.json --noEmit",
+    "clean": "rm -rf dist",
+    "test": "vitest run",
+    "test:watch": "vitest"
   }
-}
+}