@nerd-bible/valio 0.0.11 → 0.1.0

package/.github/workflows/publish.yml

@@ -0,0 +1,26 @@
+name: Publish
+on:
+  push:
+    tags:
+      - v[0-9]+.[0-9]+.[0-9]+
+  workflow_dispatch:
+
+permissions:
+  contents: read
+  id-token: write
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - uses: actions/setup-node@v6
+        with:
+          node-version: lts/*
+          registry-url: 'https://registry.npmjs.org'
+      - run: npm install
+      - run: npm test
+      - run: node ./publish.ts "$GITHUB_SERVER_URL/$GITHUB_REPOSITORY"

package/.github/workflows/test.yml

@@ -0,0 +1,14 @@
+name: Test
+on:
+  push:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v6
+        with:
+          node-version: lts/*
+      - run: npm install
+      - run: npm test

package/LICENSE.md

@@ -0,0 +1,111 @@
+Creative Commons Legal Code
+
+CC0 1.0 Universal
+
+    CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE
+    LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN
+    ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS
+    INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES
+    REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS
+    PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM
+    THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED
+    HEREUNDER.
+
+Statement of Purpose
+
+The laws of most jurisdictions throughout the world automatically confer
+exclusive Copyright and Related Rights (defined below) upon the creator and
+subsequent owner(s) (each and all, an "owner") of an original work of authorship
+and/or a database (each, a "Work").
+
+Certain owners wish to permanently relinquish those rights to a Work for the
+purpose of contributing to a commons of creative, cultural and scientific works
+("Commons") that the public can reliably and without fear of later claims of
+infringement build upon, modify, incorporate in other works, reuse and
+redistribute as freely as possible in any form whatsoever and for any purposes,
+including without limitation commercial purposes. These owners may contribute to
+the Commons to promote the ideal of a free culture and the further production of
+creative, cultural and scientific works, or to gain reputation or greater
+distribution for their Work in part through the use and efforts of others.
+
+For these and/or other purposes and motivations, and without any expectation of
+additional consideration or compensation, the person associating CC0 with a Work
+(the "Affirmer"), to the extent that he or she is an owner of Copyright and
+Related Rights in the Work, voluntarily elects to apply CC0 to the Work and
+publicly distribute the Work under its terms, with knowledge of his or her
+Copyright and Related Rights in the Work and the meaning and intended legal
+effect of CC0 on those rights.
+
+1. Copyright and Related Rights. A Work made available under CC0 may be
+   protected by copyright and related or neighboring rights ("Copyright and
+   Related Rights"). Copyright and Related Rights include, but are not limited
+   to, the following:
+
+i. the right to reproduce, adapt, distribute, perform, display, communicate, and
+translate a Work; ii. moral rights retained by the original author(s) and/or
+performer(s); iii. publicity and privacy rights pertaining to a person's image
+or likeness depicted in a Work; iv. rights protecting against unfair competition
+in regards to a Work, subject to the limitations in paragraph 4(a), below; v.
+rights protecting the extraction, dissemination, use and reuse of data in a
+Work; vi. database rights (such as those arising under Directive 96/9/EC of the
+European Parliament and of the Council of 11 March 1996 on the legal protection
+of databases, and under any national implementation thereof, including any
+amended or successor version of such directive); and vii. other similar,
+equivalent or corresponding rights throughout the world based on applicable law
+or treaty, and any national implementations thereof.
+
+2. Waiver. To the greatest extent permitted by, but not in contravention of,
+   applicable law, Affirmer hereby overtly, fully, permanently, irrevocably and
+   unconditionally waives, abandons, and surrenders all of Affirmer's Copyright
+   and Related Rights and associated claims and causes of action, whether now
+   known or unknown (including existing as well as future claims and causes of
+   action), in the Work (i) in all territories worldwide, (ii) for the maximum
+   duration provided by applicable law or treaty (including future time
+   extensions), (iii) in any current or future medium and for any number of
+   copies, and (iv) for any purpose whatsoever, including without limitation
+   commercial, advertising or promotional purposes (the "Waiver"). Affirmer
+   makes the Waiver for the benefit of each member of the public at large and to
+   the detriment of Affirmer's heirs and successors, fully intending that such
+   Waiver shall not be subject to revocation, rescission, cancellation,
+   termination, or any other legal or equitable action to disrupt the quiet
+   enjoyment of the Work by the public as contemplated by Affirmer's express
+   Statement of Purpose.
+
+3. Public License Fallback. Should any part of the Waiver for any reason be
+   judged legally invalid or ineffective under applicable law, then the Waiver
+   shall be preserved to the maximum extent permitted taking into account
+   Affirmer's express Statement of Purpose. In addition, to the extent the
+   Waiver is so judged Affirmer hereby grants to each affected person a
+   royalty-free, non transferable, non sublicensable, non exclusive, irrevocable
+   and unconditional license to exercise Affirmer's Copyright and Related Rights
+   in the Work (i) in all territories worldwide, (ii) for the maximum duration
+   provided by applicable law or treaty (including future time extensions),
+   (iii) in any current or future medium and for any number of copies, and (iv)
+   for any purpose whatsoever, including without limitation commercial,
+   advertising or promotional purposes (the "License"). The License shall be
+   deemed effective as of the date CC0 was applied by Affirmer to the Work.
+   Should any part of the License for any reason be judged legally invalid or
+   ineffective under applicable law, such partial invalidity or ineffectiveness
+   shall not invalidate the remainder of the License, and in such case Affirmer
+   hereby affirms that he or she will not (i) exercise any of his or her
+   remaining Copyright and Related Rights in the Work or (ii) assert any
+   associated claims and causes of action with respect to the Work, in either
+   case contrary to Affirmer's express Statement of Purpose.
+
+4. Limitations and Disclaimers.
+
+a. No trademark or patent rights held by Affirmer are waived, abandoned,
+surrendered, licensed or otherwise affected by this document. b. Affirmer offers
+the Work as-is and makes no representations or warranties of any kind concerning
+the Work, express, implied, statutory or otherwise, including without limitation
+warranties of title, merchantability, fitness for a particular purpose, non
+infringement, or the absence of latent or other defects, accuracy, or the
+present or absence of errors, whether or not discoverable, all to the greatest
+extent permissible under applicable law. c. Affirmer disclaims responsibility
+for clearing rights of other persons that may apply to the Work or any use
+thereof, including without limitation any person's Copyright and Related Rights
+in the Work. Further, Affirmer disclaims responsibility for obtaining any
+necessary consents, permissions or other rights required for any use of the
+Work. d. Affirmer understands and acknowledges that Creative Commons is not a
+party to this document and has no duty or obligation with respect to this CC0 or
+use of the Work.

package/README.md

@@ -35,8 +35,8 @@ const schema = v.number(); // Pipe<number, number>
 
 expect(schema.decode(5)).toEqual({ success: true, output: 5 });
 expect(schema.decodeAny("5")).toEqual({
-success: false,
-errors: { ".": [{ input: "5", message: "not type number" }] },
+    success: false,
+    errors: { ".": [{ input: "5", message: "not type number" }] },
 });
 ```
 

package/package.json

@@ -1,27 +1,26 @@
 {
   "name": "@nerd-bible/valio",
   "type": "module",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "devDependencies": {
-    "@biomejs/biome": "^2.3.1",
-    "@types/bun": "latest"
+  "exports": {
+    ".": {
+      "import": {
+        "nbsource": "./src/index.ts",
+        "node": "./dist/index.js"
+      }
+    },
+    "./package.json": "./package.json"
   },
   "scripts": {
-    "build": "tsc",
-    "fmt": "biome check",
-    "fmt-fix": "biome check --write --unsafe"
+    "build": "tsc -p ./tsconfig.build.json",
+    "test": "node --test"
   },
-  "peerDependencies": {
+  "devDependencies": {
+    "@types/node": "^25.3.3",
+    "expect": "^30.2.0",
     "typescript": "^5.9.3"
   },
-  "files": [
-    "README.md",
-    "src",
-    "dist"
-  ],
-  "version": "0.0.11",
+  "version": "0.1.0",
   "repository": {
-    "url": "git+https://github.com/nerd-bible/valio"
+    "url": "https://github.com/nerd-bible/valio"
   }
-}
+}

package/publish.ts

@@ -0,0 +1,52 @@
+// This script allows using Git tags as the source of truth for versions rather
+// than package.json.
+import { execSync } from "node:child_process";
+import { readFileSync, writeFileSync } from "node:fs";
+
+const repoUrl = process.argv.slice(2).find((a) => !a.startsWith("--"));
+if (!repoUrl) throw Error("Required arg: repo URL");
+const dry = process.argv.includes("--dry");
+
+function execGit(args: string, allowFailure = false) {
+	try {
+		return execSync(`git ${args}`, {
+			encoding: "utf8",
+			stdio: ["ignore", "pipe", "ignore"],
+		}).trim();
+	} catch (err) {
+		if (!allowFailure) throw err;
+	}
+}
+
+execGit("fetch --tags");
+const tagCmd = "describe --tags --abbrev=0 --match='v[0-9]*.[0-9]*.[0-9]*'";
+let version = execGit(`${tagCmd} --exact-match`, true);
+
+if (!version) {
+	const lastVersion = execGit(tagCmd, true) ?? "v0.0.0";
+	console.log("No manual tag, bumping", lastVersion);
+
+	const split = lastVersion.split(".");
+	// Tags should only be missing for minor bumps.
+	const last = parseInt(split.pop()!) + 1;
+	version = [...split, last].join(".");
+
+	if (!dry) {
+		console.log("Tagging + pushing", version);
+		execGit(`tag ${version}`);
+		execGit("push --tags origin master");
+	}
+} else {
+	console.log("Using manual tag", version);
+}
+
+if (!dry) {
+	console.log("Writing temporary package.json");
+	const pkg = JSON.parse(readFileSync("package.json", "utf8"));
+	pkg.version = version.substring(1);
+	pkg.repository = { url: repoUrl };
+	writeFileSync("package.json", JSON.stringify(pkg, null, 2));
+
+	console.log("Publishing to NPM", version);
+	execSync("npm publish --access public");
+}

package/src/codecs.test.ts

@@ -1,5 +1,6 @@
-import { expect, test } from "bun:test";
-import * as v from "./index";
+import { test } from "node:test";
+import expect from "expect";
+import * as v from "./index.ts";
 
 test("number codec", () => {
 	const schema = v.codecs.number();
@@ -65,7 +66,7 @@ test("array number codec", () => {
 });
 
 test("boolean codec", () => {
-	const schema = v.codecs.boolean({ true: ["yes"], false: ["no"] });
+	const schema = v.codecs.boolean({ true: /yes|^[1-9]/, false: /no|^0?$/ });
 
 	expect(schema.decode("yes")).toEqual({ success: true, output: true });
 	expect(schema.decode("no")).toEqual({ success: true, output: false });

package/src/codecs.ts

@@ -1,6 +1,5 @@
-import * as c from "./containers";
-import type { Context, Pipe, Result } from "./pipe";
-import * as p from "./primitives";
+import type { Context, Pipe, Result } from "./pipe.ts";
+import * as p from "./primitives.ts";
 
 export function custom<I, O>(
 	input: Pipe<I, any>,
@@ -20,37 +19,37 @@ export function custom<I, O>(
 export function number(
 	parser = Number.parseFloat,
 ): p.Comparable<string | number | null | undefined, number> {
-	return custom(
-		c.union([p.string(), p.number(), p.null(), p.undefined()]),
-		p.number(),
-		{
-			decode(input, ctx) {
-				if (typeof input == "number") return { success: true, output: input };
-				if (input == null || input.toLowerCase() == "nan")
-					return { success: true, output: Number.NaN };
+	return custom(p.any(), p.number(), {
+		decode(input, ctx) {
+			if (typeof input === "number") return { success: true, output: input };
+			if (!input || input.toLowerCase() === "nan")
+				return { success: true, output: Number.NaN };
 
-				const output = parser(input);
-				if (!Number.isNaN(output)) return { success: true, output };
+			const output = parser(input);
+			if (!Number.isNaN(output)) return { success: true, output };
 
-				ctx.pushErrorFmt("coerce", input, { expected: "number" });
-				return { success: false, errors: ctx.errors };
-			},
+			ctx.pushErrorFmt("coerce", input, { expected: "number" });
+			return { success: false, errors: ctx.errors };
 		},
-	) as ReturnType<typeof number>;
+	}) as ReturnType<typeof number>;
 }
 
 export function boolean(opts: {
-	true?: string[];
-	false?: string[];
+	true?: RegExp;
+	false?: RegExp;
 }): Pipe<any, boolean> {
 	return custom(p.any(), p.boolean(), {
-		decode(input) {
+		decode(input, ctx) {
+			if (typeof input === "boolean") return { success: true, output: input };
 			if (typeof input === "string") {
-				if (opts.true?.includes(input)) return { success: true, output: true };
-				if (opts.false?.includes(input))
-					return { success: true, output: false };
+				if (opts.true?.test(input)) return { success: true, output: true };
+				if (opts.false?.test(input)) return { success: true, output: false };
 			}
-			return { success: true, output: Boolean(input) };
+			if (typeof input === "number")
+				return { success: true, output: Boolean(input) };
+
+			ctx.pushErrorFmt("coerce", input, { expected: "boolean" });
+			return { success: false, errors: ctx.errors };
 		},
 	});
 }

package/src/containers.test.ts

@@ -1,5 +1,6 @@
-import { expect, test } from "bun:test";
-import * as v from "./index";
+import { test } from "node:test";
+import expect from "expect";
+import * as v from "./index.ts";
 
 test("array", () => {
 	const schema = v.array(v.number());

package/src/containers.ts

@@ -1,14 +1,20 @@
-import type { Input, Output, Result } from "./pipe";
-import { type Context, HalfPipe, Pipe } from "./pipe";
-import * as p from "./primitives";
+import type { Input, Output, Result } from "./pipe.ts";
+import { Context, HalfPipe, Pipe } from "./pipe.ts";
+import * as p from "./primitives.ts";
 
 class ValioArray<T> extends p.Arrayish<any[], T[]> {
-	constructor(public element: Pipe<any, T>) {
+	element: Pipe<any, T>;
+
+	static typeCheck(v: any): v is any[] {
+		return Array.isArray(v);
+	}
+
+	constructor(element: Pipe<any, T>) {
 		super(
 			new HalfPipe(
 				"array",
-				(v: any): v is any[] => Array.isArray(v),
-				(input: any[], ctx: Context): Result<T[]> => {
+				ValioArray.typeCheck,
+				function parseAnyArr(input: any[], ctx: Context): Result<T[]> {
 					const output = new Array<T>(input.length);
 					let success = true;
 
@@ -25,12 +31,16 @@ class ValioArray<T> extends p.Arrayish<any[], T[]> {
 					return { success, output };
 				},
 			),
-			new HalfPipe(`array<${element.o.name}>`, (v: any): v is T[] => {
-				if (!Array.isArray(v)) return false;
-				for (const e of v) if (!element.o.typeCheck(e)) return false;
-				return true;
-			}),
+			new HalfPipe(
+				`array<${element.o.name}>`,
+				function isArrT(v: any): v is T[] {
+					if (!ValioArray.typeCheck(v)) return false;
+					for (const e of v) if (!element.o.typeCheck(e)) return false;
+					return true;
+				},
+			),
 		);
+		this.element = element;
 	}
 }
 export function array<T>(element: Pipe<any, T>): ValioArray<T> {
@@ -41,16 +51,22 @@ class ValioRecord<K extends PropertyKey, V> extends Pipe<
 	Record<any, any>,
 	Record<K, V>
 > {
-	constructor(
-		public keyPipe: Pipe<any, K>,
-		public valPipe: Pipe<any, V>,
-	) {
+	keyPipe: Pipe<any, K>;
+	valPipe: Pipe<any, V>;
+
+	static typeCheck(v: any): v is Record<any, any> {
+		return Object.prototype.toString.call(v) === "[object Object]";
+	}
+
+	constructor(keyPipe: Pipe<any, K>, valPipe: Pipe<any, V>) {
 		super(
 			new HalfPipe(
 				"object",
-				(v): v is Record<any, any> =>
-					Object.prototype.toString.call(v) == "[object Object]",
-				(input: Record<any, any>, ctx: Context): Result<Record<K, V>> => {
+				ValioRecord.typeCheck,
+				function anyToRecordKV(
+					input: Record<any, any>,
+					ctx: Context,
+				): Result<Record<K, V>> {
 					const output = {} as Record<K, V>;
 
 					let success = true;
@@ -77,9 +93,8 @@ class ValioRecord<K extends PropertyKey, V> extends Pipe<
 			),
 			new HalfPipe(
 				`record<${keyPipe.o.name},${valPipe.o.name}>`,
-				(v): v is Record<K, V> => {
-					if (Object.prototype.toString.call(v) != "[object Object]")
-						return false;
+				function recordCheckV(v): v is Record<K, V> {
+					if (!ValioRecord.typeCheck(v)) return false;
 					for (const k in v) {
 						// Keys will always be strings.
 						// if (!keyPipe.o.typeCheck(k)) return false;
@@ -89,6 +104,8 @@ class ValioRecord<K extends PropertyKey, V> extends Pipe<
 				},
 			),
 		);
+		this.keyPipe = keyPipe;
+		this.valPipe = valPipe;
 	}
 }
 export function record<K extends PropertyKey, V>(
@@ -102,32 +119,39 @@ class Union<T extends Readonly<Pipe[]>> extends Pipe<
 	Output<T[number]>,
 	Output<T[number]>
 > {
-	constructor(public options: T) {
+	options: T;
+
+	constructor(options: T) {
 		const name = options.map((o) => o.o.name).join("|");
 		type O = Output<T[number]>;
 		super(
 			new HalfPipe(
 				name,
-				(v: any): v is O => {
+				function isUnionType(v: any): v is O {
 					for (const f of options) if (f.i.typeCheck(v)) return true;
 					return false;
 				},
 				(data: O, ctx: Context): Result<O> => {
-					const newCtx = ctx.clone();
-					for (const s in options) {
-						const decoded = options[s]!.decode(data, newCtx);
+					// Throw away errors since we expect them.
+					const newCtx = new Context();
+					newCtx.pushErrorFmt = () => {};
+					newCtx.pushError = () => {};
+					for (const f of options) {
+						const decoded = f.decode(data, newCtx);
 						if (decoded.success) return decoded;
 					}
 
-					Object.assign(ctx.errors, newCtx.errors);
+					// Sad path -- do again with real ctx to gather errors.
+					for (const f of options) f.decode(data, ctx);
 					return { success: false, errors: ctx.errors };
 				},
 			),
-			new HalfPipe(name, (v: any): v is O => {
+			new HalfPipe(name, function isUnionType2(v: any): v is O {
 				for (const f of options) if (f.o.typeCheck(v)) return true;
 				return false;
 			}),
 		);
+		this.options = options;
 	}
 }
 export function union<T extends Readonly<Pipe[]>>(options: T): Union<T> {
@@ -151,19 +175,21 @@ type Extend<A extends Record<any, any>, B extends Record<any, any>> = Flatten<
 			}
 >;
 
-class ValioObject<Shape extends Record<any, Pipe<any, any>>> extends Pipe<
-	Record<any, any>,
-	ObjectOutput<Shape>
-> {
-	constructor(
-		public shape: Shape,
-		public isLoose: boolean,
-	) {
+export class ValioObject<
+	Shape extends Record<any, Pipe<any, any>>,
+> extends Pipe<Record<any, any>, ObjectOutput<Shape>> {
+	shape: Shape;
+	isLoose: boolean;
+
+	static typeCheck(v: any): v is Record<any, any> {
+		return typeof v === "object";
+	}
+
+	constructor(shape: Shape, isLoose: boolean) {
 		super(
 			new HalfPipe(
 				"object",
-				(v): v is Record<any, any> =>
-					Object.prototype.toString.call(v) == "[object Object]",
+				ValioObject.typeCheck,
 				(data, ctx) => this.transformInput(data, ctx),
 			),
 			new HalfPipe(
@@ -173,6 +199,9 @@ class ValioObject<Shape extends Record<any, Pipe<any, any>>> extends Pipe<
 				(v) => this.typeCheckOutput(v),
 			),
 		);
+
+		this.shape = shape;
+		this.isLoose = isLoose;
 	}
 
 	clone(): this {
@@ -204,7 +233,7 @@ class ValioObject<Shape extends Record<any, Pipe<any, any>>> extends Pipe<
 	}
 
 	protected typeCheckOutput(v: any): v is ObjectOutput<Shape> {
-		if (Object.prototype.toString.call(v) != "[object Object]") return false;
+		if (!ValioObject.typeCheck(v)) return false;
 		for (const s in this.shape)
 			if (!this.shape[s]!.o.typeCheck(v[s])) return false;
 		return true;

package/src/index.ts

@@ -1,4 +1,4 @@
-export * as codecs from "./codecs";
-export * from "./containers";
-export * from "./pipe";
-export * from "./primitives";
+export * as codecs from "./codecs.ts";
+export * from "./containers.ts";
+export * from "./pipe.ts";
+export * from "./primitives.ts";

package/src/pipe.ts

@@ -1,4 +1,4 @@
-import enFormat from "./locales/en";
+import enFormat from "./locales/en.ts";
 
 export type Error = { input: any; message: string };
 export type Errors = { [inputPath: string]: Error[] };
@@ -20,21 +20,31 @@ interface Check<T> {
 }
 
 export class HalfPipe<I, O = never> {
-	constructor(
-		/** The type name */
-		public name: string,
-		/** The first check to run */
-		public typeCheck: (v: any) => v is I,
-		/** Optional transform for pipe to run at end. Useful for containers */
-		public transform?: (v: I, ctx: Context) => Result<O>,
-	) {}
-	/** The second checks to run */
+	name: string;
+	typeCheck: (v: any) => v is I;
+	transform?: (v: I, ctx: Context) => Result<O>;
+	/** Checks to run after type check */
 	checks: Check<I>[] = [];
 
-	clone(): this {
-		const res = clone(this);
-		res.checks = res.checks.slice();
-		return res;
+	constructor(
+		name: string,
+		typeCheck: (v: any) => v is I,
+		transform?: (v: I, ctx: Context) => Result<O>,
+		checks: Check<I>[] = [],
+	) {
+		this.name = name;
+		this.typeCheck = typeCheck;
+		this.transform = transform;
+		this.checks = checks;
+	}
+
+	clone(): HalfPipe<I, O> {
+		return new HalfPipe(
+			this.name,
+			this.typeCheck,
+			this.transform,
+			this.checks.slice(),
+		);
 	}
 }
 
@@ -48,9 +58,9 @@ export class Context {
 	}
 
 	clone(): Context {
-		const res = clone(this);
-		res.jsonPath = res.jsonPath.slice();
-		res.errors = { ...res.errors };
+		const res = new Context();
+		res.jsonPath = this.jsonPath.slice();
+		res.errors = { ...this.errors };
 		return res;
 	}
 
@@ -83,13 +93,17 @@ export class Context {
 }
 
 export class Pipe<I = any, O = any> {
-	constructor(
-		public i: HalfPipe<I, O>,
-		public o: HalfPipe<O, I>,
-	) {}
+	i: HalfPipe<I, O>;
+	o: HalfPipe<O, I>;
+
+	constructor(i: HalfPipe<I, O>, o: HalfPipe<O, I>) {
+		this.i = i;
+		this.o = o;
+	}
 
 	pipes: Pipe<any, any>[] = [];
 	registry: Record<PropertyKey, any> = {};
+	debug = false;
 
 	clone(): this {
 		const res = clone(this);
@@ -103,7 +117,7 @@ export class Pipe<I = any, O = any> {
 	refine(
 		valid: (data: O, ctx: Context) => boolean,
 		name: string,
-		props: Record<any, any>,
+		props: Record<any, any> = {},
 	): this {
 		const res = this.clone();
 		res.o.checks.push({ valid, name, props });