@modulify/validator 0.2.1 → 0.3.1

package/CHANGELOG.md

@@ -1,6 +1,33 @@
 # Changelog
 
-All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
+## 0.3.1
+
+## 0.3.0
+
+### ⚠ BREAKING CHANGE* **types:** Public type names were simplified
+* **types:** Exported public type names were renamed without compatibility aliases.
+* Object shape refinements were made async-first
+* shape.refine(...) was changed to the async-first object-level API. Use shape.refine.sync(...) for explicitly sync-safe object rules.
+* ObjectShapeRefinement now describes the async-first refinement contract. Use ObjectShapeRefinementSync for the explicit sync-only type name.
+* validate.sync(...), matches.sync(...), and shape.check(...) now throw when they encounter async object-level shape refinements.
+
+
+### Features
+
+* Object shape refinements were made async-first ([8877b93](https://github.com/modulify/validator/commit/8877b93fa4a8b7c29c918d5d9df08e90ae816379))
+* Built-in value guards were expanded ([1846c17](https://github.com/modulify/validator/commit/1846c176188182b76074b46a60c12d3a2af790a0))
+
+### Bug Fixes
+
+* **predicates:** Shape field validation and inference were corrected ([b2c0e44](https://github.com/modulify/validator/commit/b2c0e441ecf923c0ed3e3a8cbe432a052fed42ce))
+* **types:** Strict assertion contracts were aligned ([2bdd390](https://github.com/modulify/validator/commit/2bdd39019caff5522821ab3b07d832efdd4ca1ab))
+* **build:** Packed ESM and CommonJS consumers were supported ([6fd0c3b](https://github.com/modulify/validator/commit/6fd0c3b2ad7adca314b321283245f831deb2e160))
+
+### Performance Improvements
+
+* **build:** Tree-shaking hints were added ([29bbc70](https://github.com/modulify/validator/commit/29bbc7017b58ef50927ccda745a7be76a8b73ba4))
+
+All notable changes to this project will be documented in this file. Release notes are generated by [@modulify/conventional-release](https://github.com/modulify/conventional/tree/main/packages/conventional-release) from Conventional Commits.
 
 ### [0.2.1](https://github.com/modulify/validator/compare/v0.2.0...v0.2.1) (2026-03-09)
 
@@ -73,3 +100,4 @@ All notable changes to this project will be documented in this file. See [standa
 * Added meta to OneOf violation ([8dd59fc](https://github.com/modulify/validator/commit/8dd59fc2663df1e791ad95449ba774374b6e0bf8))
 * Added possibility to override initial valitators set ([0192f44](https://github.com/modulify/validator/commit/0192f44e4e9e487cbc1230cd588ea62d926e7143))
 * Asynchronous validation ([1505f41](https://github.com/modulify/validator/commit/1505f417bd869ba762f6a91d1d30a360d2505ad4))
+

package/README.md

@@ -204,7 +204,7 @@ if (ok) {
 
 ## Shape API
 
-`shape(...)` is the reusable object-shape API. It validates nested record-like objects and exposes small immutable helpers such as `strict()`, `pick()`, `omit()`, `partial()`, `extend()`, `merge()`, `refine()`, and `fieldsMatch(...)`.
+`shape(...)` is the reusable object-shape API. It validates nested record-like objects and exposes small immutable helpers such as `strict()`, `pick()`, `omit()`, `partial()`, `extend()`, `merge()`, async-first `refine()`, explicit `refine.sync()`, and `fieldsMatch(...)`.
 
 ```typescript
 import {
@@ -270,11 +270,17 @@ A practical way to think about the library is:
 
 In the current API this usually looks like:
 
-- leaf checks with assertions such as `isString`, `isDefined`, `hasLength`, `oneOf`;
+- guard assertions such as `isString`, `isNumber`, `isDefined`, `oneOf(...)` establish the base domain for a value;
+- refinement assertions such as `hasLength(...)`, `hasPattern(...)`, `startsWith(...)`, `hasValue(...)`, `multipleOf(...)` validate properties inside that domain;
 - schema composition with combinators such as `exact`, `optional`, `nullable`, `nullish`, `shape(...)`, `each(...)`;
 - typed validation through `validate(...)` or `validate.sync(...)`;
 - narrowing of the original sync variable through `matches.sync(...)`.
 
+Sequential assertion arrays are stage-aware. A tuple like `[isString, hasLength({ min: 3 })]` is valid, while incompatible combinations like `[isNumber, hasLength({ min: 3 })]` are rejected by TypeScript.
+Refinement assertions are not meant to be passed to `validate(...)` or `matches.sync(...)` on their own.
+
+`validate(...)` is the default async-first validation entrypoint. `validate.sync(...)` and `matches.sync(...)` are specialized sync APIs and will throw if they encounter async validators or async object-level `shape(...).refine(...)` rules.
+
 ## Violations
 
 `validate(...)` returns machine-readable `Violation[]`, and `collection(...)` can wrap that list into a small helper API for exact path lookups and tree traversal.
@@ -354,6 +360,8 @@ Two additional guides are useful when you want faster practical navigation inste
 - [Common Recipes](./docs/en/06-common-recipes.md) - task-oriented examples for payload validation, wrapper choice, reusable shapes, form error mapping, and JSON Schema export.
 - [AI Reference](./docs/en/07-ai-reference.md) - compact contract summary for agents, tooling, and quick semantic lookup.
 
+- [Migration From 0.2.1](./docs/en/09-migration.md)
+
 ## Notes
 
 - Assertions return structured metadata instead of messages.
@@ -366,3 +374,5 @@ Two additional guides are useful when you want faster practical navigation inste
 ## Translations
 
 - [Russian](./docs/ru/README.md)
+
+Release workflow and npm OIDC setup: [Releasing](docs/RELEASING.md).

package/dist/assert.cjs

@@ -1,66 +1,102 @@
-"use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const metadata = require("./metadata.cjs.js");
-const assert = (predicate, meta, constraints = []) => {
-  const assertionCode = meta.code ?? meta.name;
-  const assertionArgs = meta.args ?? [];
-  const violationSubject = {
-    kind: "assertion",
-    name: meta.name,
-    code: assertionCode,
-    args: assertionArgs
-  };
-  const assertion = ((value) => {
-    if (!predicate(value)) {
-      return {
-        value,
-        violates: violationSubject
-      };
-    }
-    for (const [extract, check, code, ...args] of constraints) {
-      if (!check(extract(value), ...args)) {
-        const constraintSubject = {
-          kind: "assertion",
-          name: meta.name,
-          code,
-          args
-        };
-        return {
-          value,
-          violates: constraintSubject
-        };
-      }
-    }
-    return null;
-  });
-  Object.defineProperties(assertion, {
-    name: {
-      configurable: true,
-      value: meta.name
-    },
-    bail: {
-      enumerable: true,
-      value: meta.bail
-    },
-    constraints: {
-      enumerable: true,
-      value: constraints
-    },
-    check: {
-      enumerable: true,
-      value: (value) => predicate(value) && (!constraints.length || constraints.every(([extract, check, , ...args]) => check(extract(value), ...args)))
-    }
-  });
-  return metadata.attachConstraintDescriptor(assertion, () => ({
-    kind: "assertion",
-    name: meta.name,
-    bail: meta.bail,
-    code: assertionCode,
-    args: assertionArgs,
-    constraints: constraints.map(([, , code, ...args]) => ({
-      code,
-      args
-    }))
-  }));
+const require_metadata = require("./metadata.cjs");
+//#region src/assert.ts
+var assertionStageSymbol = Symbol("modulify.validator.assertion.stage");
+var runRefinementSymbol = Symbol("modulify.validator.assertion.runRefinement");
+var checkRefinementSymbol = Symbol("modulify.validator.assertion.checkRefinement");
+var createAssertion = (stage, predicate, meta, constraints = []) => {
+	const assertionCode = meta.code ?? meta.name;
+	const assertionArgs = meta.args ?? [];
+	const violationSubject = {
+		kind: "assertion",
+		name: meta.name,
+		code: assertionCode,
+		args: assertionArgs
+	};
+	const runConstraints = (value) => {
+		for (const [extract, check, code, ...args] of constraints) if (!check(extract(value), ...args)) return {
+			value,
+			violates: {
+				kind: "assertion",
+				name: meta.name,
+				code,
+				args
+			}
+		};
+		return null;
+	};
+	const checkConstraints = (value) => !constraints.length || constraints.every(([extract, check, , ...args]) => check(extract(value), ...args));
+	const assertion = ((value) => {
+		if (!predicate(value)) return {
+			value,
+			violates: violationSubject
+		};
+		return runConstraints(value);
+	});
+	Object.defineProperties(assertion, {
+		name: {
+			configurable: true,
+			value: meta.name
+		},
+		bail: {
+			enumerable: true,
+			value: meta.bail
+		},
+		constraints: {
+			enumerable: true,
+			value: constraints
+		},
+		check: {
+			enumerable: true,
+			value: (value) => predicate(value) && checkConstraints(value)
+		},
+		[assertionStageSymbol]: {
+			enumerable: false,
+			value: stage
+		},
+		[runRefinementSymbol]: {
+			enumerable: false,
+			value: (value) => runConstraints(value)
+		},
+		[checkRefinementSymbol]: {
+			enumerable: false,
+			value: (value) => checkConstraints(value)
+		}
+	});
+	return /* @__PURE__ */ require_metadata.attachConstraintDescriptor(assertion, () => ({
+		kind: "assertion",
+		name: meta.name,
+		bail: meta.bail,
+		code: assertionCode,
+		args: assertionArgs,
+		constraints: constraints.map(([, , code, ...args]) => ({
+			code,
+			args
+		}))
+	}));
 };
+var assert = (predicate, meta, constraints = []) => {
+	return createAssertion("guard", predicate, meta, constraints);
+};
+var isRefinementAssertion = (constraint) => {
+	return typeof constraint === "function" && constraint[assertionStageSymbol] === "refinement";
+};
+var runRefinementAssertion = (constraint, value) => {
+	const runRefinement = constraint[runRefinementSymbol];
+	return runRefinement ? runRefinement(value) : constraint(value);
+};
+var checkRefinementAssertion = (constraint, value) => {
+	const checkRefinement = constraint[checkRefinementSymbol];
+	return checkRefinement ? checkRefinement(value) : constraint.check(value);
+};
+var createRefinement = (meta, constraints = []) => {
+	return createAssertion("refinement", ((value) => true), meta, constraints);
+};
+var refine = createRefinement;
+//#endregion
 exports.assert = assert;
+exports.checkRefinementAssertion = checkRefinementAssertion;
+exports.createRefinement = createRefinement;
+exports.isRefinementAssertion = isRefinementAssertion;
+exports.refine = refine;
+exports.runRefinementAssertion = runRefinementAssertion;

package/dist/assert.d.cts

@@ -0,0 +1,37 @@
+import { Assertion, Constraint, AssertionConstraint, Guard, Predicate, Refinement } from './types/index.cjs';
+type AssertMeta = {
+    name: string;
+    bail: boolean;
+    code?: string;
+    args?: readonly unknown[];
+};
+type ResolveAssertionCode<Name extends string, Code extends string | undefined> = Code extends string ? Code : Name;
+type ResolveAssertionArgs<Args extends readonly unknown[] | undefined> = Args extends readonly unknown[] ? Args : [];
+type ConstraintInputFunction<C extends AssertionConstraint> = C extends unknown ? (value: Parameters<C[0]>[0]) => void : never;
+type ConstraintInput<C extends readonly AssertionConstraint[]> = C extends readonly [] ? unknown : ConstraintInputFunction<C[number]> extends (value: infer Input) => void ? Input : never;
+type ConstraintArgs<C extends AssertionConstraint> = C extends readonly [unknown, unknown, string, ...infer Args] ? Args : never;
+type CompatibleAssertionConstraints<Input, C extends readonly AssertionConstraint[]> = {
+    [K in keyof C]: AssertionConstraint<Input, ReturnType<C[K][0]>, ConstraintArgs<C[K]>, C[K][2]>;
+};
+export declare const assert: <T, const Name extends string, const Bail extends boolean, const Code extends string | undefined = undefined, const Args extends readonly unknown[] | undefined = undefined, const C extends readonly AssertionConstraint<T, any, any[], string>[] = []>(predicate: Predicate<T>, meta: AssertMeta & {
+    name: Name;
+    bail: Bail;
+    code?: Code;
+    args?: Args;
+}, constraints?: C & CompatibleAssertionConstraints<T, C>) => Guard<T, C, ResolveAssertionCode<Name, Code>, ResolveAssertionArgs<Args>, Name>;
+export declare const isRefinementAssertion: (constraint: Constraint) => constraint is Assertion;
+export declare const runRefinementAssertion: (constraint: Assertion, value: unknown) => ReturnType<Assertion>;
+export declare const checkRefinementAssertion: (constraint: Assertion, value: unknown) => boolean;
+export declare const createRefinement: <const Name extends string, const Bail extends boolean, const Code extends string | undefined = undefined, const Args extends readonly unknown[] | undefined = undefined, const C extends readonly AssertionConstraint[] = []>(meta: AssertMeta & {
+    name: Name;
+    bail: Bail;
+    code?: Code;
+    args?: Args;
+}, constraints?: C) => Refinement<ConstraintInput<C>, C, ResolveAssertionCode<Name, Code>, ResolveAssertionArgs<Args>, Name>;
+export declare const refine: <const Name extends string, const Bail extends boolean, const Code extends string | undefined = undefined, const Args extends readonly unknown[] | undefined = undefined, const C extends readonly AssertionConstraint[] = []>(meta: AssertMeta & {
+    name: Name;
+    bail: Bail;
+    code?: Code;
+    args?: Args;
+}, constraints?: C & CompatibleAssertionConstraints<ConstraintInput<C>, C>) => Refinement<ConstraintInput<C>, C, ResolveAssertionCode<Name, Code>, ResolveAssertionArgs<Args>, Name>;
+export {};

package/dist/assert.d.mts

@@ -0,0 +1,37 @@
+import { Assertion, Constraint, AssertionConstraint, Guard, Predicate, Refinement } from './types/index.mjs';
+type AssertMeta = {
+    name: string;
+    bail: boolean;
+    code?: string;
+    args?: readonly unknown[];
+};
+type ResolveAssertionCode<Name extends string, Code extends string | undefined> = Code extends string ? Code : Name;
+type ResolveAssertionArgs<Args extends readonly unknown[] | undefined> = Args extends readonly unknown[] ? Args : [];
+type ConstraintInputFunction<C extends AssertionConstraint> = C extends unknown ? (value: Parameters<C[0]>[0]) => void : never;
+type ConstraintInput<C extends readonly AssertionConstraint[]> = C extends readonly [] ? unknown : ConstraintInputFunction<C[number]> extends (value: infer Input) => void ? Input : never;
+type ConstraintArgs<C extends AssertionConstraint> = C extends readonly [unknown, unknown, string, ...infer Args] ? Args : never;
+type CompatibleAssertionConstraints<Input, C extends readonly AssertionConstraint[]> = {
+    [K in keyof C]: AssertionConstraint<Input, ReturnType<C[K][0]>, ConstraintArgs<C[K]>, C[K][2]>;
+};
+export declare const assert: <T, const Name extends string, const Bail extends boolean, const Code extends string | undefined = undefined, const Args extends readonly unknown[] | undefined = undefined, const C extends readonly AssertionConstraint<T, any, any[], string>[] = []>(predicate: Predicate<T>, meta: AssertMeta & {
+    name: Name;
+    bail: Bail;
+    code?: Code;
+    args?: Args;
+}, constraints?: C & CompatibleAssertionConstraints<T, C>) => Guard<T, C, ResolveAssertionCode<Name, Code>, ResolveAssertionArgs<Args>, Name>;
+export declare const isRefinementAssertion: (constraint: Constraint) => constraint is Assertion;
+export declare const runRefinementAssertion: (constraint: Assertion, value: unknown) => ReturnType<Assertion>;
+export declare const checkRefinementAssertion: (constraint: Assertion, value: unknown) => boolean;
+export declare const createRefinement: <const Name extends string, const Bail extends boolean, const Code extends string | undefined = undefined, const Args extends readonly unknown[] | undefined = undefined, const C extends readonly AssertionConstraint[] = []>(meta: AssertMeta & {
+    name: Name;
+    bail: Bail;
+    code?: Code;
+    args?: Args;
+}, constraints?: C) => Refinement<ConstraintInput<C>, C, ResolveAssertionCode<Name, Code>, ResolveAssertionArgs<Args>, Name>;
+export declare const refine: <const Name extends string, const Bail extends boolean, const Code extends string | undefined = undefined, const Args extends readonly unknown[] | undefined = undefined, const C extends readonly AssertionConstraint[] = []>(meta: AssertMeta & {
+    name: Name;
+    bail: Bail;
+    code?: Code;
+    args?: Args;
+}, constraints?: C & CompatibleAssertionConstraints<ConstraintInput<C>, C>) => Refinement<ConstraintInput<C>, C, ResolveAssertionCode<Name, Code>, ResolveAssertionArgs<Args>, Name>;
+export {};

package/dist/assert.d.ts

@@ -1,4 +1,4 @@
-import { Assertion, AssertionConstraint, Predicate } from '../types';
+import { Assertion, Constraint, AssertionConstraint, Guard, Predicate, Refinement } from './types/index.js';
 type AssertMeta = {
     name: string;
     bail: boolean;
@@ -7,10 +7,31 @@ type AssertMeta = {
 };
 type ResolveAssertionCode<Name extends string, Code extends string | undefined> = Code extends string ? Code : Name;
 type ResolveAssertionArgs<Args extends readonly unknown[] | undefined> = Args extends readonly unknown[] ? Args : [];
-export declare const assert: <T, const Name extends string, const Bail extends boolean, const Code extends string | undefined = undefined, const Args extends readonly unknown[] | undefined = undefined, const C extends readonly AssertionConstraint[] = []>(predicate: Predicate<T>, meta: AssertMeta & {
+type ConstraintInputFunction<C extends AssertionConstraint> = C extends unknown ? (value: Parameters<C[0]>[0]) => void : never;
+type ConstraintInput<C extends readonly AssertionConstraint[]> = C extends readonly [] ? unknown : ConstraintInputFunction<C[number]> extends (value: infer Input) => void ? Input : never;
+type ConstraintArgs<C extends AssertionConstraint> = C extends readonly [unknown, unknown, string, ...infer Args] ? Args : never;
+type CompatibleAssertionConstraints<Input, C extends readonly AssertionConstraint[]> = {
+    [K in keyof C]: AssertionConstraint<Input, ReturnType<C[K][0]>, ConstraintArgs<C[K]>, C[K][2]>;
+};
+export declare const assert: <T, const Name extends string, const Bail extends boolean, const Code extends string | undefined = undefined, const Args extends readonly unknown[] | undefined = undefined, const C extends readonly AssertionConstraint<T, any, any[], string>[] = []>(predicate: Predicate<T>, meta: AssertMeta & {
+    name: Name;
+    bail: Bail;
+    code?: Code;
+    args?: Args;
+}, constraints?: C & CompatibleAssertionConstraints<T, C>) => Guard<T, C, ResolveAssertionCode<Name, Code>, ResolveAssertionArgs<Args>, Name>;
+export declare const isRefinementAssertion: (constraint: Constraint) => constraint is Assertion;
+export declare const runRefinementAssertion: (constraint: Assertion, value: unknown) => ReturnType<Assertion>;
+export declare const checkRefinementAssertion: (constraint: Assertion, value: unknown) => boolean;
+export declare const createRefinement: <const Name extends string, const Bail extends boolean, const Code extends string | undefined = undefined, const Args extends readonly unknown[] | undefined = undefined, const C extends readonly AssertionConstraint[] = []>(meta: AssertMeta & {
+    name: Name;
+    bail: Bail;
+    code?: Code;
+    args?: Args;
+}, constraints?: C) => Refinement<ConstraintInput<C>, C, ResolveAssertionCode<Name, Code>, ResolveAssertionArgs<Args>, Name>;
+export declare const refine: <const Name extends string, const Bail extends boolean, const Code extends string | undefined = undefined, const Args extends readonly unknown[] | undefined = undefined, const C extends readonly AssertionConstraint[] = []>(meta: AssertMeta & {
     name: Name;
     bail: Bail;
     code?: Code;
     args?: Args;
-}, constraints?: C) => Assertion<T, C, ResolveAssertionCode<Name, Code>, ResolveAssertionArgs<Args>, Name>;
+}, constraints?: C & CompatibleAssertionConstraints<ConstraintInput<C>, C>) => Refinement<ConstraintInput<C>, C, ResolveAssertionCode<Name, Code>, ResolveAssertionArgs<Args>, Name>;
 export {};

package/dist/assert.mjs

@@ -1,66 +1,96 @@
-import { e as attachConstraintDescriptor } from "./metadata.es.js";
-const assert = (predicate, meta, constraints = []) => {
-  const assertionCode = meta.code ?? meta.name;
-  const assertionArgs = meta.args ?? [];
-  const violationSubject = {
-    kind: "assertion",
-    name: meta.name,
-    code: assertionCode,
-    args: assertionArgs
-  };
-  const assertion = ((value) => {
-    if (!predicate(value)) {
-      return {
-        value,
-        violates: violationSubject
-      };
-    }
-    for (const [extract, check, code, ...args] of constraints) {
-      if (!check(extract(value), ...args)) {
-        const constraintSubject = {
-          kind: "assertion",
-          name: meta.name,
-          code,
-          args
-        };
-        return {
-          value,
-          violates: constraintSubject
-        };
-      }
-    }
-    return null;
-  });
-  Object.defineProperties(assertion, {
-    name: {
-      configurable: true,
-      value: meta.name
-    },
-    bail: {
-      enumerable: true,
-      value: meta.bail
-    },
-    constraints: {
-      enumerable: true,
-      value: constraints
-    },
-    check: {
-      enumerable: true,
-      value: (value) => predicate(value) && (!constraints.length || constraints.every(([extract, check, , ...args]) => check(extract(value), ...args)))
-    }
-  });
-  return attachConstraintDescriptor(assertion, () => ({
-    kind: "assertion",
-    name: meta.name,
-    bail: meta.bail,
-    code: assertionCode,
-    args: assertionArgs,
-    constraints: constraints.map(([, , code, ...args]) => ({
-      code,
-      args
-    }))
-  }));
+import { attachConstraintDescriptor } from "./metadata.mjs";
+//#region src/assert.ts
+var assertionStageSymbol = Symbol("modulify.validator.assertion.stage");
+var runRefinementSymbol = Symbol("modulify.validator.assertion.runRefinement");
+var checkRefinementSymbol = Symbol("modulify.validator.assertion.checkRefinement");
+var createAssertion = (stage, predicate, meta, constraints = []) => {
+	const assertionCode = meta.code ?? meta.name;
+	const assertionArgs = meta.args ?? [];
+	const violationSubject = {
+		kind: "assertion",
+		name: meta.name,
+		code: assertionCode,
+		args: assertionArgs
+	};
+	const runConstraints = (value) => {
+		for (const [extract, check, code, ...args] of constraints) if (!check(extract(value), ...args)) return {
+			value,
+			violates: {
+				kind: "assertion",
+				name: meta.name,
+				code,
+				args
+			}
+		};
+		return null;
+	};
+	const checkConstraints = (value) => !constraints.length || constraints.every(([extract, check, , ...args]) => check(extract(value), ...args));
+	const assertion = ((value) => {
+		if (!predicate(value)) return {
+			value,
+			violates: violationSubject
+		};
+		return runConstraints(value);
+	});
+	Object.defineProperties(assertion, {
+		name: {
+			configurable: true,
+			value: meta.name
+		},
+		bail: {
+			enumerable: true,
+			value: meta.bail
+		},
+		constraints: {
+			enumerable: true,
+			value: constraints
+		},
+		check: {
+			enumerable: true,
+			value: (value) => predicate(value) && checkConstraints(value)
+		},
+		[assertionStageSymbol]: {
+			enumerable: false,
+			value: stage
+		},
+		[runRefinementSymbol]: {
+			enumerable: false,
+			value: (value) => runConstraints(value)
+		},
+		[checkRefinementSymbol]: {
+			enumerable: false,
+			value: (value) => checkConstraints(value)
+		}
+	});
+	return /* @__PURE__ */ attachConstraintDescriptor(assertion, () => ({
+		kind: "assertion",
+		name: meta.name,
+		bail: meta.bail,
+		code: assertionCode,
+		args: assertionArgs,
+		constraints: constraints.map(([, , code, ...args]) => ({
+			code,
+			args
+		}))
+	}));
 };
-export {
-  assert
+var assert = (predicate, meta, constraints = []) => {
+	return createAssertion("guard", predicate, meta, constraints);
 };
+var isRefinementAssertion = (constraint) => {
+	return typeof constraint === "function" && constraint[assertionStageSymbol] === "refinement";
+};
+var runRefinementAssertion = (constraint, value) => {
+	const runRefinement = constraint[runRefinementSymbol];
+	return runRefinement ? runRefinement(value) : constraint(value);
+};
+var checkRefinementAssertion = (constraint, value) => {
+	const checkRefinement = constraint[checkRefinementSymbol];
+	return checkRefinement ? checkRefinement(value) : constraint.check(value);
+};
+var createRefinement = (meta, constraints = []) => {
+	return createAssertion("refinement", ((value) => true), meta, constraints);
+};
+var refine = createRefinement;
+//#endregion
+export { assert, checkRefinementAssertion, createRefinement, isRefinementAssertion, refine, runRefinementAssertion };