funcade 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Maxim Molochkov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,287 @@
+# Funcade
+
+Build type-safe fluent object APIs from functional JavaScript libraries.
+
+Funcade turns standalone functions into methods over a current value while preserving their
+arguments, compatible overloads, and return types. It is immutable, has no runtime dependencies,
+and does not modify the wrapped library.
+
+## Installation
+
+```sh
+npm install funcade
+```
+
+## Configuration
+
+`funcade` accepts an initializer and a readonly list of method groups:
+
+```ts
+import { add, format, sub, toDate } from 'date-fns'
+import { chain, funcade, result } from 'funcade'
+
+const date = funcade({
+  init: toDate,
+  methods: [chain({ add, sub }), result({ format })],
+})
+
+const formatted = date(new Date(2024, 0, 15))
+  .add({ days: 4 })
+  .sub({ days: 2 })
+  .format('yyyy-MM-dd')
+
+// formatted: string
+// => '2024-01-17'
+```
+
+- `init` creates the initial current value and determines its type. Its parameters become the
+  parameters of the generated `date` factory.
+- `methods` defines the methods shared by every wrapper created by that factory.
+- Method overloads incompatible with the current value are removed from the generated API.
+- A group is rejected if none of a method's overloads are compatible.
+
+Calling the generated factory creates the first immutable wrapper. Chain methods create subsequent
+wrappers, while result methods return a value directly.
+
+## Method groups
+
+Every function belongs to one of three method groups.
+
+### `chain`
+
+Calls the function and wraps its result in a new Funcade API. The original wrapper is not changed.
+A chain method must return a value assignable to the current value type.
+
+```ts
+const numbers = funcade({
+  init: (value: number) => value,
+  methods: [
+    chain({
+      add: (value: number, amount: number) => value + amount,
+    }),
+  ],
+})
+
+const original = numbers(2)
+const changed = original.add(3)
+
+// original and changed are different wrappers
+```
+
+### `result`
+
+Calls the function and returns its result directly, ending the chain. Result methods may return any
+type.
+
+```ts
+const numbers = funcade({
+  init: (value: number) => value,
+  methods: [
+    result({
+      isPositive: (value: number) => value > 0,
+    }),
+  ],
+})
+
+const positive = numbers(2).isPositive()
+// positive: boolean
+```
+
+### `tap`
+
+Calls the function for an observation or side effect and returns the same wrapper.
+
+```ts
+const numbers = funcade({
+  init: (value: number) => value,
+  methods: [
+    tap({
+      inspect: (value: number, label: string) => console.log(label, value),
+    }),
+    result({ read: (value: number) => value }),
+  ],
+})
+
+const value = numbers(2).inspect('current').read()
+```
+
+Method names must be unique across all groups in one Funcade API.
+
+## Calling strategies
+
+A strategy defines how a source function receives the current value and method arguments.
+
+### Data-first
+
+The default strategy expects the current value as the first argument:
+
+```ts
+fn(value, ...methodArguments)
+```
+
+This is equivalent to passing `dataFirst` explicitly:
+
+```ts
+chain({ add })
+chain({ add }, dataFirst)
+```
+
+### Curried FP functions
+
+The `fp` strategy first applies the method arguments, then passes the current value to the returned
+function:
+
+```ts
+fn(...methodArguments)(value)
+```
+
+```ts
+import { add, format } from 'date-fns/fp'
+import { chain, fp, funcade, result } from 'funcade'
+
+const date = funcade({
+  init: (value: Date) => value,
+  methods: [chain({ add }, fp), result({ format }, fp)],
+})
+
+date(new Date()).add({ months: 1 }).format('yyyy-MM-dd')
+```
+
+## Custom strategies
+
+Use `defineStrategy` when a library has a different application model. A custom strategy consists
+of two independent parts:
+
+- The function passed to `defineStrategy` implements the runtime call.
+- A `StrategySpec` describes the same call to TypeScript. It does not exist at runtime.
+
+### How a strategy specification works
+
+`StrategySpec` acts as a type-level function. Funcade evaluates it separately for every source
+function overload and provides two placeholders:
+
+- `this['_fn']` is the source function overload currently being converted into a method.
+- `this['_value']` is the value stored in the current Funcade wrapper.
+
+The specification derives four public fields from those placeholders:
+
+| Field    | Meaning                                                                               |
+| -------- | ------------------------------------------------------------------------------------- |
+| `args`   | Arguments exposed by the generated object method.                                     |
+| `result` | Declared return type of the strategy. For `chain`, it must preserve the wrapped type. |
+| `input`  | Value type accepted by the source operation.                                          |
+| `value`  | Relevant type represented by the current wrapped value.                               |
+
+Funcade considers a method compatible when `value` is assignable to `input`. For a `chain` group,
+it additionally checks that `result` is assignable to the type of `this['_value']`. This is why
+`input` and `value` are separate: the wrapped value may be a container, such as a schema, while the
+operation consumes the type represented by that container.
+
+A specification has this general data flow:
+
+```text
+this['_fn']    -> args, input
+this['_value'] -> value
+runtime call   -> result
+```
+
+Do not assign `_fn` or `_value` in the specification. They are type-only placeholders supplied by
+Funcade through `this`. The other fields should derive from them instead of referring to one
+concrete function or wrapped value type. If a source function is overloaded, Funcade evaluates the
+specification for each overload independently before assembling the generated method overloads.
+
+The runtime callback intentionally accepts broad function, value, and argument types. TypeScript
+cannot prove that its implementation matches the specification, so the specification is a contract
+maintained by the strategy author. In particular, `result` must describe what the callback actually
+returns, and the callback must interpret `args` in the same way as the `args` field.
+
+### Valibot example
+
+Valibot actions are not called with a schema. An action is created from the method arguments and
+then composed with the current schema through `v.pipe`:
+
+```ts
+action(...methodArguments) // creates an action
+v.pipe(schema, action) // creates the next schema
+```
+
+The corresponding specification needs to connect three different types: the action constructor,
+the schema object, and the data flowing through that schema. Here is the complete strategy:
+
+```ts
+import * as v from 'valibot'
+import { defineStrategy } from 'funcade'
+import type { StrategySpec } from 'funcade'
+
+type InputOf<T> = T extends {
+  readonly '~types'?: { readonly input: infer Input } | undefined
+}
+  ? Input
+  : unknown
+
+type OutputOf<T> = T extends {
+  readonly '~types'?: { readonly output: infer Output } | undefined
+}
+  ? Output
+  : T
+
+interface ValibotStrategySpec extends StrategySpec {
+  readonly args: Parameters<this['_fn']>
+  readonly result: this['_value']
+  readonly input: InputOf<ReturnType<this['_fn']>>
+  readonly value: OutputOf<this['_value']>
+}
+
+const valibotStrategy = defineStrategy<ValibotStrategySpec>((action, schema, args) =>
+  v.pipe(schema, action(...args)),
+)
+```
+
+Here is how each field maps to Valibot:
+
+- `args` preserves all parameters of the action constructor. For example, `v.minLength` becomes
+  `.minLength(requirement, message?)`.
+- `result` declares that `v.pipe` returns another schema suitable for the same wrapper API. Keeping
+  it as `this['_value']` allows the operation to be used in a `chain` group.
+- `input` extracts the data type accepted by the created action.
+- `value` extracts the output type represented by the current schema.
+
+For a string schema and `v.minLength`, both compatibility types are `string`. With `v.minSize`, the
+action input is `SizeInput`, which is incompatible with the schema's `string` output, so Funcade
+rejects the method where the group is declared.
+
+For one compatible `v.minLength` overload, Funcade evaluates the specification approximately as
+follows:
+
+```text
+_fn     = (requirement: number, message?: ErrorMessage<string>) => MinLengthAction<string, ...>
+_value  = StringSchema<...>
+
+args    = [requirement: number, message?: ErrorMessage<string>]
+result  = StringSchema<...>
+input   = string
+value   = string
+```
+
+The generated method therefore accepts the action constructor's arguments, while compatibility is
+checked against the data flowing through the schema rather than against the schema object itself.
+
+The complete API can then use the custom strategy like any built-in strategy:
+
+```ts
+import * as v from 'valibot'
+import { chain, funcade, result } from 'funcade'
+
+// valibotStrategy is defined above.
+
+const stringSchema = funcade({
+  init: () => v.string(),
+  methods: [
+    chain({ trim: v.trim, minLength: v.minLength }, valibotStrategy),
+    result({ parse: v.parse, safeParse: v.safeParse }),
+  ],
+})
+
+stringSchema().trim().minLength(3).parse('  hello  ')
+// => 'hello'
+```

package/dist/funcade.d.ts

@@ -0,0 +1,43 @@
+import { BivariantFn, FnMap, IsAny } from "./types.js";
+import { SpecFor, Strategy } from "./strategies.js";
+import { MethodGroup, MethodGroupBase, MethodKind } from "./methods.js";
+type TypeError<T extends readonly unknown[]> = {
+  readonly __typeError: T;
+};
+type UnionToIntersection<T> = (T extends unknown ? (value: T) => void : never) extends ((value: infer U) => void) ? U : never;
+type SpecArgs<Spec> = Spec extends {
+  readonly args: infer Args extends readonly unknown[];
+} ? Args : never;
+type SpecResult<Spec> = Spec extends {
+  readonly result: infer Result;
+} ? Result : never;
+type AnyArray = readonly unknown[];
+type FunctionProperties<T extends object> = { [Key in keyof T]: T[Key]; };
+/** @ts-expect-error TypeScript cannot verify extending the generic object type T. */
+interface AddSignature<T extends object, Args extends AnyArray, Result> extends T {
+  (...args: Args): Result;
+}
+type Signature<Args extends AnyArray, Result> = (...args: Args) => Result;
+type MethodResult<Kind extends MethodKind, Spec, Value, Groups extends readonly MethodGroup[]> = Kind extends "result" ? SpecResult<Spec> : FuncadeApi<Value, Groups>;
+type IsAssignable<Value, Input> = IsAny<Value> extends true ? true : Value extends Input ? true : false;
+type IsCompatible<Spec> = Spec extends {
+  readonly input: infer Input;
+  readonly value: infer Actual;
+} ? IsAssignable<Actual, Input> : true;
+type IsMethodCompatible<Spec, Kind extends MethodKind, Value> = IsCompatible<Spec> extends true ? Kind extends "chain" ? IsAssignable<SpecResult<Spec>, Value> : true : false;
+type AddMethodSignature<Shape extends object, Args extends AnyArray, Result, S extends Strategy, Value, Kind extends MethodKind, Groups extends readonly MethodGroup[], Spec = SpecFor<Signature<Args, Result>, S, Value>> = IsMethodCompatible<Spec, Kind, Value> extends true ? AddSignature<Shape, SpecArgs<Spec>, MethodResult<Kind, Spec, Value, Groups>> : Shape;
+type MapMethodOverloads<Fn extends object, S extends Strategy, Value, Kind extends MethodKind, Groups extends readonly MethodGroup[], Shape extends object, ResultShape extends object> = Shape extends Fn ? ResultShape : Fn extends AddSignature<Shape, infer Args, infer Result> ? MapMethodOverloads<Fn, S, Value, Kind, Groups, AddSignature<Shape, Args, Result>, AddMethodSignature<ResultShape, Args, Result, S, Value, Kind, Groups>> : ResultShape;
+type MethodOverloads<Fn extends object, S extends Strategy, Value, Kind extends MethodKind, Groups extends readonly MethodGroup[]> = MapMethodOverloads<Fn, S, Value, Kind, Groups, FunctionProperties<Fn>, object>;
+type GroupMethods<Value, Groups extends readonly MethodGroup[], Kind extends MethodKind, Methods extends FnMap, S extends Strategy> = { [Key in keyof Methods]: MethodOverloads<Methods[Key], S, Value, Kind, Groups>; };
+type MethodsFromGroup<Value, Groups extends readonly MethodGroup[], Group> = Group extends MethodGroupBase<infer Kind, infer Methods, infer S> ? GroupMethods<Value, Groups, Kind, Methods, S> : unknown;
+type FuncadeApi<Value, Groups extends readonly MethodGroup[]> = UnionToIntersection<MethodsFromGroup<Value, Groups, Groups[number]>>;
+type HasCompatibleOverload<Fn extends object, S extends Strategy, Value, Kind extends MethodKind> = MethodOverloads<Fn, S, Value, Kind, readonly []> extends BivariantFn ? true : false;
+type IncompatibleMethods<Value, Kind extends MethodKind, Methods extends FnMap, S extends Strategy> = { [Key in keyof Methods]: HasCompatibleOverload<Methods[Key], S, Value, Kind> extends true ? never : TypeError<[Key, "method is incompatible with the current value"]>; }[keyof Methods];
+type IncompatibleGroup<Value, Group> = Group extends MethodGroupBase<infer Kind, infer Methods, infer S> ? IncompatibleMethods<Value, Kind, Methods, S> : never;
+type ValidatedGroups<Value, Groups extends readonly MethodGroup[]> = { [Index in keyof Groups]: [IncompatibleGroup<Value, Groups[Index]>] extends [never] ? Groups[Index] : IncompatibleGroup<Value, Groups[Index]>; };
+type FuncadeConfig<Init extends BivariantFn, Groups extends readonly MethodGroup[]> = {
+  init: Init;
+  methods: Groups & ValidatedGroups<ReturnType<NoInfer<Init>>, NoInfer<Groups>>;
+};
+declare function funcade<const Init extends BivariantFn, const Groups extends readonly MethodGroup[]>(config: FuncadeConfig<Init, Groups>): (...args: Parameters<Init>) => FuncadeApi<ReturnType<Init>, Groups>;
+export { FuncadeApi, FuncadeConfig, TypeError, funcade };

package/dist/funcade.js

@@ -0,0 +1,29 @@
+const apiValue = Symbol("funcade.apiValue");
+function funcade(config) {
+	const prototype = Object.create(null);
+	const createApi = (value) => {
+		const api = Object.create(prototype);
+		api[apiValue] = value;
+		return api;
+	};
+	for (const group of config.methods) {
+		const { kind, strategy } = group;
+		for (const [name, fn] of Object.entries(group.methods)) {
+			if (Object.hasOwn(prototype, name)) throw new Error(`Duplicate objectified API method: "${name}"`);
+			let method;
+			if (kind === "result") method = function(...args) {
+				return strategy(fn, this[apiValue], args);
+			};
+			else if (kind === "tap") method = function(...args) {
+				strategy(fn, this[apiValue], args);
+				return this;
+			};
+			else method = function(...args) {
+				return createApi(strategy(fn, this[apiValue], args));
+			};
+			prototype[name] = method;
+		}
+	}
+	return (...args) => createApi(config.init(...args));
+}
+export { funcade };

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import { DataFirstStrategy, FpStrategy, Strategy, StrategyApply, StrategySpec, dataFirst, defineStrategy, fp } from "./strategies.js";
+import { ChainGroup, MethodGroup, MethodGroupBase, MethodKind, ResultGroup, TapGroup, chain, result, tap } from "./methods.js";
+import { FuncadeApi, FuncadeConfig, TypeError, funcade } from "./funcade.js";
+export { type ChainGroup, type DataFirstStrategy, type FpStrategy, type FuncadeApi, type FuncadeConfig, type MethodGroup, type MethodGroupBase, type MethodKind, type ResultGroup, type Strategy, type StrategyApply, type StrategySpec, type TapGroup, type TypeError, chain, dataFirst, defineStrategy, fp, funcade, result, tap };

package/dist/index.js

@@ -0,0 +1,4 @@
+import { funcade } from "./funcade.js";
+import { dataFirst, defineStrategy, fp } from "./strategies.js";
+import { chain, result, tap } from "./methods.js";
+export { chain, dataFirst, defineStrategy, fp, funcade, result, tap };

package/dist/methods.d.ts

@@ -0,0 +1,16 @@
+import { FnMap } from "./types.js";
+import { DataFirstStrategy, Strategy } from "./strategies.js";
+type MethodKind = "chain" | "result" | "tap";
+type MethodGroupBase<Kind extends MethodKind, Methods extends FnMap = FnMap, S extends Strategy = Strategy> = Readonly<{
+  kind: Kind;
+  strategy: S;
+  methods: Methods;
+}>;
+type ChainGroup<Methods extends FnMap = FnMap, S extends Strategy = Strategy> = MethodGroupBase<"chain", Methods, S>;
+type ResultGroup<Methods extends FnMap = FnMap, S extends Strategy = Strategy> = MethodGroupBase<"result", Methods, S>;
+type TapGroup<Methods extends FnMap = FnMap, S extends Strategy = Strategy> = MethodGroupBase<"tap", Methods, S>;
+type MethodGroup = MethodGroupBase<MethodKind>;
+declare const chain: <const Methods extends FnMap, S extends Strategy = DataFirstStrategy>(methods: Methods, strategy?: S) => ChainGroup<Methods, NoInfer<S>>;
+declare const result: <const Methods extends FnMap, S extends Strategy = DataFirstStrategy>(methods: Methods, strategy?: S) => ResultGroup<Methods, NoInfer<S>>;
+declare const tap: <const Methods extends FnMap, S extends Strategy = DataFirstStrategy>(methods: Methods, strategy?: S) => TapGroup<Methods, NoInfer<S>>;
+export { ChainGroup, MethodGroup, MethodGroupBase, MethodKind, ResultGroup, TapGroup, chain, result, tap };

package/dist/methods.js

@@ -0,0 +1,10 @@
+import { dataFirst } from "./strategies.js";
+const createGroup = (kind, methods, strategy) => ({
+	kind,
+	strategy: strategy ?? dataFirst,
+	methods
+});
+const chain = (methods, strategy) => createGroup("chain", methods, strategy);
+const result = (methods, strategy) => createGroup("result", methods, strategy);
+const tap = (methods, strategy) => createGroup("tap", methods, strategy);
+export { chain, result, tap };

package/dist/strategies.d.ts

@@ -0,0 +1,54 @@
+import { AnyFn, BivariantFn, IsAny } from "./types.js";
+type Tail<T extends readonly unknown[]> = T extends readonly [unknown, ...infer Rest] ? Rest : [];
+type StrategyApply = (fn: AnyFn, value: any, args: readonly unknown[]) => unknown;
+type StrategySpec = Readonly<{
+  _fn: BivariantFn;
+  _value: unknown;
+  args: unknown[];
+  result: unknown;
+  input: unknown;
+  value: unknown;
+}>;
+type FnOf<T> = T extends BivariantFn ? T : never;
+type ApplyStrategySpec<GetSpec extends StrategySpec, Fn, Value> = {
+  args: (GetSpec & {
+    readonly _fn: Fn;
+    readonly _value: Value;
+  })["args"];
+  result: (GetSpec & {
+    readonly _fn: Fn;
+    readonly _value: Value;
+  })["result"];
+  input: (GetSpec & {
+    readonly _fn: Fn;
+  })["input"];
+  value: (GetSpec & {
+    readonly _value: Value;
+  })["value"];
+};
+type Strategy<GetSpec extends StrategySpec = StrategySpec> = StrategyApply & {
+  readonly __spec: GetSpec;
+};
+interface DataFirstSpec extends StrategySpec {
+  readonly args: Tail<Parameters<FnOf<this["_fn"]>>>;
+  readonly result: ReturnType<FnOf<this["_fn"]>>;
+  readonly input: Parameters<FnOf<this["_fn"]>>[0];
+  readonly value: this["_value"];
+}
+interface FpSpec extends StrategySpec {
+  readonly args: CurriedApplyArgs<FnOf<this["_fn"]>>;
+  readonly result: CurriedApplyResult<FnOf<this["_fn"]>>;
+  readonly input: CurriedValue<FnOf<this["_fn"]>>;
+  readonly value: this["_value"];
+}
+type DataFirstStrategy = Strategy<DataFirstSpec>;
+type FpStrategy = Strategy<FpSpec>;
+type SpecFor<Fn, S extends Strategy, Value> = ApplyStrategySpec<S["__spec"], Fn, Value>;
+type CurriedConsumer<Fn extends BivariantFn> = IsAny<ReturnType<Fn>> extends true ? never : ReturnType<Fn> extends BivariantFn ? ReturnType<Fn> : never;
+type CurriedApplyArgs<Fn extends BivariantFn> = CurriedConsumer<Fn> extends never ? never : Parameters<Fn>;
+type CurriedApplyResult<Fn extends BivariantFn> = ReturnType<CurriedConsumer<Fn>>;
+type CurriedValue<Fn extends BivariantFn> = Parameters<CurriedConsumer<Fn>>[0];
+declare const defineStrategy: <GetSpec extends StrategySpec = StrategySpec>(apply: StrategyApply) => Strategy<GetSpec>;
+declare const dataFirst: Strategy<DataFirstSpec>;
+declare const fp: Strategy<FpSpec>;
+export { DataFirstStrategy, FpStrategy, SpecFor, Strategy, StrategyApply, StrategySpec, dataFirst, defineStrategy, fp };

package/dist/strategies.js

@@ -0,0 +1,8 @@
+const defineStrategy = (apply) => apply;
+const dataFirst = defineStrategy((fn, value, args) => fn(value, ...args));
+const fp = defineStrategy((fn, value, args) => {
+	const partiallyApplied = fn(...args);
+	if (typeof partiallyApplied !== "function") throw new TypeError("FP strategy expects a function that returns another function before receiving the current value");
+	return partiallyApplied(value);
+});
+export { dataFirst, defineStrategy, fp };

package/dist/types.d.ts

@@ -0,0 +1,7 @@
+type BivariantFn = {
+  fn(...args: unknown[]): unknown;
+}["fn"];
+type FnMap = Record<string, BivariantFn>;
+type AnyFn = (...args: any[]) => any;
+type IsAny<T> = 0 extends 1 & T ? true : false;
+export { AnyFn, BivariantFn, FnMap, IsAny };

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "funcade",
+  "type": "module",
+  "version": "1.0.0",
+  "description": "Build type-safe fluent object APIs from functional JavaScript libraries",
+  "author": "Maxim Molochkov <klaseca@gmail.com> (https://github.com/klaseca)",
+  "keywords": [
+    "functional-programming",
+    "fp",
+    "fluent-api",
+    "method-chaining",
+    "api-adapter",
+    "facade",
+    "currying",
+    "immutable",
+    "wrapper"
+  ],
+  "license": "MIT",
+  "homepage": "https://github.com/klaseca/funcade#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/klaseca/funcade.git"
+  },
+  "bugs": {
+    "url": "https://github.com/klaseca/funcade/issues"
+  },
+  "devEngines": {
+    "runtime": {
+      "name": "node",
+      "version": ">=24.18"
+    },
+    "packageManager": {
+      "name": "npm",
+      "version": ">=11"
+    }
+  },
+  "exports": {
+    ".": "./dist/index.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "prepare": "husky",
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "test": "node --test",
+    "test:watch": "node --test --watch",
+    "typecheck": "tsc --noEmit",
+    "fmt": "prettier -w -u .",
+    "prerelease": "npm run typecheck && npm run test",
+    "release": "bumpp",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "@types/node": "^26.1.1",
+    "bumpp": "^11.1.0",
+    "date-fns": "^4.1.0",
+    "expect-type": "^1.4.0",
+    "husky": "^9.1.7",
+    "lint-staged": "^17.0.8",
+    "prettier": "^3.9.5",
+    "tsdown": "^0.22.9",
+    "typescript": "^7.0.2",
+    "valibot": "^1.4.2"
+  }
+}