@regle/schemas 1.13.0 → 1.14.0-beta.3

package/dist/regle-schemas.d.ts

@@ -1,9 +1,9 @@
 import * as _regle_core0 from "@regle/core";
-import { ArrayElement, CreateScopedUseRegleOptions, DeepMaybeRef, DeepReactiveState, HasNamedKeys, HaveAnyRequiredProps, JoinDiscriminatedUnions, LocalRegleBehaviourOptions, Maybe, MaybeOutput, NoInferLegacy, PrimitiveTypes, RegleBehaviourOptions, RegleCollectionErrors, RegleCommonStatus, RegleErrorTree, RegleFieldIssue, RegleIssuesTree, RegleRuleStatus, RegleShortcutDefinition, RegleStaticImpl, TupleToPlainObj, UseScopedRegleOptions, useCollectScopeFn } from "@regle/core";
+import { ArrayElement, CreateScopedUseRegleOptions, DeepMaybeRef, DeepPartial, DeepReactiveState, HasNamedKeys, HaveAnyRequiredProps, JoinDiscriminatedUnions, LocalRegleBehaviourOptions, Maybe, MaybeOutput, NoInferLegacy, PrimitiveTypes, RegleBehaviourOptions, RegleCollectionErrors, RegleCommonStatus, RegleErrorTree, RegleFieldIssue, RegleIssuesTree, RegleRuleStatus, RegleShortcutDefinition, RegleStaticImpl, TupleToPlainObj, UseScopedRegleOptions, useCollectScopeFn } from "@regle/core";
 import * as vue0 from "vue";
 import { MaybeRef, Raw, UnwrapNestedRefs } from "vue";
 import { StandardSchemaV1 } from "@standard-schema/spec";
-import { EmptyObject, IsUnion, PartialDeep, UnionToTuple } from "type-fest";
+import { EmptyObject, IsUnion, UnionToTuple } from "type-fest";
 type MaybeSchemaVariantStatus<TState extends Record<string, any> | undefined = Record<string, any>, TSchema extends StandardSchemaV1 = StandardSchemaV1, TShortcuts extends RegleShortcutDefinition = {}, TRoot extends boolean = false> = IsUnion<NonNullable<TState>> extends true ? Omit<RegleSchemaStatus<TState, TSchema, TShortcuts, TRoot>, '$fields'> & {
   $fields: ProcessChildrenFields<TState, TShortcuts>[keyof ProcessChildrenFields<TState, TShortcuts>];
 } & (HasNamedKeys<TState> extends true ? ProcessChildrenFields<TState, TShortcuts>[keyof ProcessChildrenFields<TState, TShortcuts>] : {}) : RegleSchemaStatus<TState, TSchema, TShortcuts, TRoot>;
@@ -29,7 +29,7 @@ type RegleSingleFieldSchema<TState extends Maybe<PrimitiveTypes>, TSchema extend
 } & TAdditionalReturnProperties;
 type RegleSchemaResult<TSchema extends unknown> = {
   valid: false;
-  data: PartialDeep<TSchema>;
+  data: DeepPartial<TSchema>;
   issues: RegleIssuesTree<TSchema, true>;
   errors: RegleErrorTree<TSchema, false, true>;
 } | {
@@ -56,7 +56,7 @@ type RegleSchemaStatus<TState extends Record<string, any> | undefined = Record<s
   /** Collection of all the error messages, collected for all children properties. */
   readonly $silentErrors: RegleErrorTree<TState, false, true>;
   /** Will return a copy of your state with only the fields that are dirty. By default it will filter out nullish values or objects, but you can override it with the first parameter $extractDirtyFields(false). */
-  $extractDirtyFields: (filterNullishValues?: boolean) => PartialDeep<TState>;
+  $extractDirtyFields: (filterNullishValues?: boolean) => DeepPartial<TState>;
 } & ProcessNestedFields<TState, TShortcuts> & (IsRoot extends true ? {
   /** Sets all properties as dirty, triggering all rules. It returns a promise that will either resolve to false or a type safe copy of your form state. Values that had the required rule will be transformed into a non-nullable value (type only). */
   $validate: (forceValues?: TState extends EmptyObject ? (HasNamedKeys<TState> extends true ? TState : any) : TState) => Promise<RegleSchemaResult<StandardSchemaV1.InferOutput<TSchema>>>;
@@ -105,7 +105,7 @@ type RegleSchemaFieldStatus<TState = any, TShortcuts extends RegleShortcutDefini
     [`~validator`]: RegleRuleStatus<TState, []>;
   };
   /** Will return a copy of your state with only the fields that are dirty. By default it will filter out nullish values or objects, but you can override it with the first parameter $extractDirtyFields(false). */
-  $extractDirtyFields: (filterNullishValues?: boolean) => PartialDeep<TState>;
+  $extractDirtyFields: (filterNullishValues?: boolean) => DeepPartial<TState>;
 } & ([TShortcuts['fields']] extends [never] ? {} : { [K in keyof TShortcuts['fields']]: ReturnType<NonNullable<TShortcuts['fields']>[K]> });
 /**
  * @public
@@ -128,7 +128,7 @@ type RegleSchemaCollectionStatus<TState extends any[], TShortcuts extends RegleS
   /** Collection of all the error messages, collected for all children properties and nested forms.  */
   readonly $silentErrors: RegleCollectionErrors<TState>;
   /** Will return a copy of your state with only the fields that are dirty. By default, it will filter out nullish values or objects, but you can override it with the first parameter $extractDirtyFields(false). */
-  $extractDirtyFields: (filterNullishValues?: boolean) => PartialDeep<TState>;
+  $extractDirtyFields: (filterNullishValues?: boolean) => DeepPartial<TState>;
 } & ([TShortcuts['collections']] extends [never] ? {} : { [K in keyof TShortcuts['collections']]: ReturnType<NonNullable<TShortcuts['collections']>[K]> });
 type RegleSchemaBehaviourOptions = {
   /**
@@ -147,73 +147,137 @@ type RegleSchemaBehaviourOptions = {
 };
 type useRegleSchemaFnOptions<TAdditionalOptions extends Record<string, any>> = Omit<Partial<DeepMaybeRef<RegleBehaviourOptions>> & LocalRegleBehaviourOptions<Record<string, any>, {}, never>, 'validationGroups' | 'lazy'> & RegleSchemaBehaviourOptions & TAdditionalOptions;
 interface useRegleSchemaFn<TShortcuts extends RegleShortcutDefinition<any> = never, TAdditionalReturnProperties extends Record<string, any> = {}, TAdditionalOptions extends Record<string, any> = {}> {
-  <TSchema extends StandardSchemaV1, TState extends StandardSchemaV1.InferInput<TSchema> | undefined>(...params: [state: MaybeRef<PartialDeep<NoInferLegacy<TState>, {
-    recurseIntoArrays: true;
-  }>> | DeepReactiveState<PartialDeep<NoInferLegacy<TState>, {
-    recurseIntoArrays: true;
-  }>>, rulesFactory: MaybeRef<TSchema>, ...(HaveAnyRequiredProps<useRegleSchemaFnOptions<TAdditionalOptions>> extends true ? [options: useRegleSchemaFnOptions<TAdditionalOptions>] : [options?: useRegleSchemaFnOptions<TAdditionalOptions>])]): NonNullable<TState> extends PrimitiveTypes ? RegleSingleFieldSchema<NonNullable<TState>, TSchema, TShortcuts, TAdditionalReturnProperties> : RegleSchema<UnwrapNestedRefs<NonNullable<TState>>, TSchema, TShortcuts, TAdditionalReturnProperties>;
+  <TSchema extends StandardSchemaV1, TState extends StandardSchemaV1.InferInput<TSchema> | undefined>(...params: [state: MaybeRef<DeepPartial<NoInferLegacy<TState>>> | DeepReactiveState<DeepPartial<NoInferLegacy<TState>>>, rulesFactory: MaybeRef<TSchema>, ...(HaveAnyRequiredProps<useRegleSchemaFnOptions<TAdditionalOptions>> extends true ? [options: useRegleSchemaFnOptions<TAdditionalOptions>] : [options?: useRegleSchemaFnOptions<TAdditionalOptions>])]): NonNullable<TState> extends PrimitiveTypes ? RegleSingleFieldSchema<NonNullable<TState>, TSchema, TShortcuts, TAdditionalReturnProperties> : RegleSchema<UnwrapNestedRefs<NonNullable<TState>>, TSchema, TShortcuts, TAdditionalReturnProperties>;
 }
 /**
- * useRegle serves as the foundation for validation logic.
+ * `useRegleSchema` enables validation using Standard Schema compatible libraries
+ * like Zod, Valibot, or ArkType.
  *
- * It accepts the following inputs:
- *
- * @param state - This can be a plain object, a ref, a reactive object, or a structure containing nested refs.
- * @param schema - These should align with the structure of your state.
- * @param modifiers - customize regle behaviour
+ * @param state - Your form data (plain object, ref, reactive object, or structure with nested refs)
+ * @param schema - A Standard Schema compliant schema (Zod, Valibot, ArkType, etc.)
+ * @param modifiers - Optional configuration to customize regle behavior
+ * @returns An object containing `r$` - the reactive validation state
  *
+ * @example
  * ```ts
  * import { useRegleSchema } from '@regle/schemas';
  * import * as v from 'valibot';
  *
- * const { r$ } = useRegleSchema({ name: '' }, v.object({
- *   name: v.pipe(v.string(), v.minLength(3))
- * }))
+ * // With Valibot
+ * const { r$ } = useRegleSchema(
+ *   { name: '', email: '' },
+ *   v.object({
+ *     name: v.pipe(v.string(), v.minLength(3)),
+ *     email: v.pipe(v.string(), v.email())
+ *   })
+ * );
+ *
+ * // With Zod
+ * import { z } from 'zod';
+ *
+ * const { r$ } = useRegleSchema(
+ *   { name: '' },
+ *   z.object({
+ *     name: z.string().min(3)
+ *   })
+ * );
+ *
+ * // Access validation state
+ * r$.$valid        // Whether all validations pass
+ * r$.$value        // The current form values
+ * r$.name.$errors  // Errors for the name field
  * ```
- * Docs: {@link https://reglejs.dev/integrations/schemas-libraries}
+ *
+ * @see {@link https://reglejs.dev/integrations/schemas-libraries Documentation}
  */
 declare const useRegleSchema: useRegleSchemaFn<RegleShortcutDefinition<any>, {}, {}>;
 /**
+ * Force a schema validation to re-run when specified dependencies change.
+ * Useful when your schema depends on reactive values that aren't automatically tracked.
+ *
+ * @param schema - The Standard Schema to wrap
+ * @param _depsArray - Array of reactive dependencies (their values will trigger re-validation)
+ * @returns The same schema (passthrough)
  *
- * Force dependency on any RPC schema
+ * @example
  * ```ts
- * const foo = ref('');
+ * import { withDeps, useRegleSchema } from '@regle/schemas';
+ * import * as v from 'valibot';
+ *
+ * const compareValue = ref('');
  *
  * const schema = computed(() => v.object({
- *    name: withDeps(
- *       v.pipe(v.string(), v.check((value) => value === foo.value)),
- *       [foo.value]
- *    )
- * }))
+ *   name: withDeps(
+ *     v.pipe(
+ *       v.string(),
+ *       v.check((value) => value === compareValue.value)
+ *     ),
+ *     [compareValue.value] // Re-validate when this changes
+ *   )
+ * }));
  *
- * useRegleSchema({name: ''}, schema)
+ * const { r$ } = useRegleSchema({ name: '' }, schema);
  * ```
+ *
+ * @see {@link https://reglejs.dev/integrations/schemas-libraries Documentation}
  */
 declare function withDeps<TSchema extends StandardSchemaV1, TParams extends unknown[] = []>(schema: TSchema, _depsArray: [...TParams]): TSchema;
 interface inferSchemaFn {
-  <TSchema extends StandardSchemaV1, TState extends StandardSchemaV1.InferInput<TSchema> | undefined>(state: MaybeRef<PartialDeep<TState, {
-    recurseIntoArrays: true;
-  }>> | DeepReactiveState<PartialDeep<TState, {
-    recurseIntoArrays: true;
-  }>>, rulesFactory: MaybeRef<TSchema>): NoInferLegacy<TSchema>;
+  <TSchema extends StandardSchemaV1, TState extends StandardSchemaV1.InferInput<TSchema> | undefined>(state: MaybeRef<DeepPartial<TState>> | DeepReactiveState<DeepPartial<TState>>, rulesFactory: MaybeRef<TSchema>): NoInferLegacy<TSchema>;
 }
 /**
- * Rule type helper to provide autocomplete and typecheck to your form rules or part of your form rules
- * It will just return the rules without any processing.
+ * Type helper to provide autocomplete and type-checking for your schema.
+ * Returns the schema without any processing - useful with computed schemas.
  *
  * @param state - The state reference
- * @param schema - Your schema
+ * @param schema - Your Standard Schema (Zod, Valibot, ArkType, etc.)
+ * @returns The schema (passthrough)
+ *
+ * @example
+ * ```ts
+ * import { inferSchema, useRegleSchema } from '@regle/schemas';
+ * import { z } from 'zod';
+ *
+ * const state = ref({ name: '' });
+ *
+ * // inferSchema preserves TypeScript autocompletion
+ * const schema = computed(() => {
+ *   return inferSchema(state, z.object({
+ *     name: z.string().min(2)
+ *   }));
+ * });
+ *
+ * const { r$ } = useRegleSchema(state, schema);
+ * ```
+ *
+ * @see {@link https://reglejs.dev/integrations/schemas-libraries Documentation}
  */
 declare const inferSchema: inferSchemaFn;
 /**
- * Define a global regle configuration, where you can:
- * - Define global modifiers
- * - Define shortcuts
+ * Define a global configuration for `useRegleSchema`.
+ *
+ * Features:
+ * - Define global modifiers (lazy, rewardEarly, etc.)
+ * - Define shortcuts for common validation patterns
+ *
+ * @param options - Configuration options
+ * @param options.modifiers - Global behavior modifiers
+ * @param options.shortcuts - Reusable validation shortcuts
+ * @returns Object containing typed `useRegleSchema` and `inferSchema` functions
+ *
+ * @example
+ * ```ts
+ * import { defineRegleSchemaConfig } from '@regle/schemas';
  *
- * It will return:
+ * export const { useRegleSchema, inferSchema } = defineRegleSchemaConfig({
+ *   modifiers: {
+ *     lazy: true,
+ *     rewardEarly: true
+ *   }
+ * });
+ * ```
  *
- * - a `useRegleSchema` composable that can typecheck your custom rules
- * - an `inferSchema` helper that can typecheck your custom rules
+ * @see {@link https://reglejs.dev/integrations/schemas-libraries Documentation}
  */
 declare function defineRegleSchemaConfig<TShortcuts extends RegleShortcutDefinition>({
   modifiers,
@@ -234,6 +298,29 @@ type CreateScopedUseRegleSchemaOptions<TCustomRegle extends useRegleSchemaFn<any
 declare const useCollectSchemaScope: <TValue$1 extends Record<string, unknown>[] = Record<string, unknown>[]>(namespace?: vue0.MaybeRefOrGetter<string | string[]>) => {
     r$: _regle_core0.MergedScopedRegles<TValue$1>;
   }, useScopedRegleSchema: useRegleSchemaFn<_regle_core0.RegleShortcutDefinition<any>, {}, {}>;
+/**
+ * Create a scoped validation system for schema-based validation.
+ * Similar to `createScopedUseRegle` but for use with Standard Schema libraries.
+ *
+ * @param options - Configuration options
+ * @param options.customUseRegle - Custom useRegleSchema instance with your global config
+ * @param options.customStore - External ref to store collected instances
+ * @param options.asRecord - If true, collect instances in a Record (requires `id` param)
+ * @returns Object containing `useScopedRegle` and `useCollectScope` functions
+ *
+ * @example
+ * ```ts
+ * import { createScopedUseRegleSchema, defineRegleSchemaConfig } from '@regle/schemas';
+ *
+ * const { useRegleSchema } = defineRegleSchemaConfig({...});
+ *
+ * export const { useScopedRegle, useCollectScope } = createScopedUseRegleSchema({
+ *   customUseRegle: useRegleSchema
+ * });
+ * ```
+ *
+ * @see {@link https://reglejs.dev/advanced-usage/scoped-validation Documentation}
+ */
 declare const createScopedUseRegleSchema: <TCustomRegle extends useRegleSchemaFn = useRegleSchemaFn, TAsRecord extends boolean = false, TReturnedRegle extends useRegleSchemaFn<any, any, any> = (TCustomRegle extends useRegleSchemaFn<infer S> ? useRegleSchemaFn<S, {
   dispose: () => void;
   register: () => void;

package/dist/regle-schemas.js

@@ -9,12 +9,34 @@ function isFile(value) {
 }
 
 /**
-* This is the inverse of isFilled. It will check if the value is in any way empty (including arrays and objects)
+* Checks if a value is empty in any way (including arrays and objects).
+* This is the inverse of `isFilled`.
 *
-* isEmpty also acts as a type guard.
+* `isEmpty` also acts as a type guard.
 *
-* @param value - the target value
-* @param [considerEmptyArrayInvalid=true] - will return false if set to `false`. (default: `true`)
+* By default, it considers an empty array as `true`. You can override this behavior with `considerEmptyArrayInvalid`.
+*
+* @param value - The target value to check
+* @param considerEmptyArrayInvalid - When `false`, empty arrays are not considered empty (default: `true`)
+* @returns `true` if the value is empty, `false` otherwise
+*
+* @example
+* ```ts
+* import { createRule, type Maybe } from '@regle/core';
+* import { isEmpty } from '@regle/rules';
+*
+* const rule = createRule({
+*   validator(value: Maybe<string>) {
+*     if (isEmpty(value)) {
+*       return true;
+*     }
+*     return check(value);
+*   },
+*   message: 'Error'
+* })
+* ```
+*
+* @see {@link https://reglejs.dev/core-concepts/rules/validations-helpers#isempty Documentation}
 */
 function isEmpty(value, considerEmptyArrayInvalid = true) {
 	if (value === void 0 || value === null) return true;
@@ -290,41 +312,77 @@ function createUseRegleSchemaComposable(options, shortcuts) {
 	return useRegleSchema$1;
 }
 /**
-* useRegle serves as the foundation for validation logic.
-*
-* It accepts the following inputs:
+* `useRegleSchema` enables validation using Standard Schema compatible libraries
+* like Zod, Valibot, or ArkType.
 *
-* @param state - This can be a plain object, a ref, a reactive object, or a structure containing nested refs.
-* @param schema - These should align with the structure of your state.
-* @param modifiers - customize regle behaviour
+* @param state - Your form data (plain object, ref, reactive object, or structure with nested refs)
+* @param schema - A Standard Schema compliant schema (Zod, Valibot, ArkType, etc.)
+* @param modifiers - Optional configuration to customize regle behavior
+* @returns An object containing `r$` - the reactive validation state
 *
+* @example
 * ```ts
 * import { useRegleSchema } from '@regle/schemas';
 * import * as v from 'valibot';
 *
-* const { r$ } = useRegleSchema({ name: '' }, v.object({
-*   name: v.pipe(v.string(), v.minLength(3))
-* }))
+* // With Valibot
+* const { r$ } = useRegleSchema(
+*   { name: '', email: '' },
+*   v.object({
+*     name: v.pipe(v.string(), v.minLength(3)),
+*     email: v.pipe(v.string(), v.email())
+*   })
+* );
+*
+* // With Zod
+* import { z } from 'zod';
+*
+* const { r$ } = useRegleSchema(
+*   { name: '' },
+*   z.object({
+*     name: z.string().min(3)
+*   })
+* );
+*
+* // Access validation state
+* r$.$valid        // Whether all validations pass
+* r$.$value        // The current form values
+* r$.name.$errors  // Errors for the name field
 * ```
-* Docs: {@link https://reglejs.dev/integrations/schemas-libraries}
+*
+* @see {@link https://reglejs.dev/integrations/schemas-libraries Documentation}
 */
 const useRegleSchema = createUseRegleSchemaComposable();
 
 /**
+* Force a schema validation to re-run when specified dependencies change.
+* Useful when your schema depends on reactive values that aren't automatically tracked.
+*
+* @param schema - The Standard Schema to wrap
+* @param _depsArray - Array of reactive dependencies (their values will trigger re-validation)
+* @returns The same schema (passthrough)
 *
-* Force dependency on any RPC schema
+* @example
 * ```ts
-* const foo = ref('');
+* import { withDeps, useRegleSchema } from '@regle/schemas';
+* import * as v from 'valibot';
+*
+* const compareValue = ref('');
 *
 * const schema = computed(() => v.object({
-*    name: withDeps(
-*       v.pipe(v.string(), v.check((value) => value === foo.value)),
-*       [foo.value]
-*    )
-* }))
+*   name: withDeps(
+*     v.pipe(
+*       v.string(),
+*       v.check((value) => value === compareValue.value)
+*     ),
+*     [compareValue.value] // Re-validate when this changes
+*   )
+* }));
 *
-* useRegleSchema({name: ''}, schema)
+* const { r$ } = useRegleSchema({ name: '' }, schema);
 * ```
+*
+* @see {@link https://reglejs.dev/integrations/schemas-libraries Documentation}
 */
 function withDeps(schema, _depsArray) {
 	return schema;
@@ -337,23 +395,59 @@ function createInferSchemaHelper() {
 	return inferSchema$1;
 }
 /**
-* Rule type helper to provide autocomplete and typecheck to your form rules or part of your form rules
-* It will just return the rules without any processing.
+* Type helper to provide autocomplete and type-checking for your schema.
+* Returns the schema without any processing - useful with computed schemas.
 *
 * @param state - The state reference
-* @param schema - Your schema
+* @param schema - Your Standard Schema (Zod, Valibot, ArkType, etc.)
+* @returns The schema (passthrough)
+*
+* @example
+* ```ts
+* import { inferSchema, useRegleSchema } from '@regle/schemas';
+* import { z } from 'zod';
+*
+* const state = ref({ name: '' });
+*
+* // inferSchema preserves TypeScript autocompletion
+* const schema = computed(() => {
+*   return inferSchema(state, z.object({
+*     name: z.string().min(2)
+*   }));
+* });
+*
+* const { r$ } = useRegleSchema(state, schema);
+* ```
+*
+* @see {@link https://reglejs.dev/integrations/schemas-libraries Documentation}
 */
 const inferSchema = createInferSchemaHelper();
 
 /**
-* Define a global regle configuration, where you can:
-* - Define global modifiers
-* - Define shortcuts
+* Define a global configuration for `useRegleSchema`.
+*
+* Features:
+* - Define global modifiers (lazy, rewardEarly, etc.)
+* - Define shortcuts for common validation patterns
 *
-* It will return:
+* @param options - Configuration options
+* @param options.modifiers - Global behavior modifiers
+* @param options.shortcuts - Reusable validation shortcuts
+* @returns Object containing typed `useRegleSchema` and `inferSchema` functions
+*
+* @example
+* ```ts
+* import { defineRegleSchemaConfig } from '@regle/schemas';
+*
+* export const { useRegleSchema, inferSchema } = defineRegleSchemaConfig({
+*   modifiers: {
+*     lazy: true,
+*     rewardEarly: true
+*   }
+* });
+* ```
 *
-* - a `useRegleSchema` composable that can typecheck your custom rules
-* - an `inferSchema` helper that can typecheck your custom rules
+* @see {@link https://reglejs.dev/integrations/schemas-libraries Documentation}
 */
 function defineRegleSchemaConfig({ modifiers, shortcuts }) {
 	return {
@@ -363,6 +457,29 @@ function defineRegleSchemaConfig({ modifiers, shortcuts }) {
 }
 
 const { useCollectScope: useCollectSchemaScope, useScopedRegle: useScopedRegleSchema } = createScopedUseRegle({ customUseRegle: useRegleSchema });
+/**
+* Create a scoped validation system for schema-based validation.
+* Similar to `createScopedUseRegle` but for use with Standard Schema libraries.
+*
+* @param options - Configuration options
+* @param options.customUseRegle - Custom useRegleSchema instance with your global config
+* @param options.customStore - External ref to store collected instances
+* @param options.asRecord - If true, collect instances in a Record (requires `id` param)
+* @returns Object containing `useScopedRegle` and `useCollectScope` functions
+*
+* @example
+* ```ts
+* import { createScopedUseRegleSchema, defineRegleSchemaConfig } from '@regle/schemas';
+*
+* const { useRegleSchema } = defineRegleSchemaConfig({...});
+*
+* export const { useScopedRegle, useCollectScope } = createScopedUseRegleSchema({
+*   customUseRegle: useRegleSchema
+* });
+* ```
+*
+* @see {@link https://reglejs.dev/advanced-usage/scoped-validation Documentation}
+*/
 const createScopedUseRegleSchema = (options) => {
 	const { customStore, customUseRegle = useRegleSchema, asRecord = false } = options ?? {};
 	return createScopedUseRegle({

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@regle/schemas",
-  "version": "1.13.0",
+  "version": "1.14.0-beta.3",
   "description": "Schemas adapter for Regle",
   "dependencies": {
     "@standard-schema/spec": "1.0.0",
     "type-fest": "5.2.0",
-    "@regle/rules": "1.13.0",
-    "@regle/core": "1.13.0"
+    "@regle/core": "1.14.0-beta.3",
+    "@regle/rules": "1.14.0-beta.3"
   },
   "peerDependencies": {
     "valibot": "^1.0.0",