@warlock.js/seal 4.0.174 → 4.1.1

package/esm/validators/lazy-validator.d.mts

@@ -0,0 +1,70 @@
+import { JsonSchemaResult, JsonSchemaTarget } from "../standard-schema/json-schema.mjs";
+import { SchemaContext } from "../types/context-types.mjs";
+import { ValidationResult } from "../types/result-types.mjs";
+import { BaseValidator } from "./base-validator.mjs";
+
+//#region ../../@warlock.js/seal/src/validators/lazy-validator.d.ts
+/**
+ * Lazy validator — defers resolution of the inner validator until validate-time.
+ *
+ * Solves the chicken-and-egg of self-referencing schemas. JavaScript evaluates
+ * an object literal before the `const` binding completes, so this can't work:
+ *
+ * ```ts
+ * const categorySchema = v.object({
+ *   name: v.string(),
+ *   children: v.array(categorySchema),  // ❌ ReferenceError
+ * });
+ * ```
+ *
+ * Wrap the recursive reference in `v.lazy(() => …)` — the thunk isn't invoked
+ * during construction, only when `validate()` is called:
+ *
+ * ```ts
+ * type Category = { name: string; children: Category[] };
+ *
+ * const categorySchema: ObjectValidator<...> = v.object({
+ *   name: v.string(),
+ *   children: v.array(v.lazy(() => categorySchema)),
+ * });
+ *
+ * type T = Infer<typeof categorySchema>;
+ * // { name: string; children: T[] }   ← recursive type
+ * ```
+ *
+ * The thunk is memoized — it's invoked once on the first validate (or
+ * `matchesType` / `toJsonSchema`) call and the result is cached. The thunk is
+ * expected to return a stable validator; calling it on every validate would be
+ * wasteful and could mask bugs where the user accidentally returns a fresh
+ * validator each time.
+ *
+ * **JSON Schema caveat.** v1 uses simple resolve-and-delegate — recursive
+ * schemas will infinite-loop in `toJsonSchema()`. If you need JSON Schema for
+ * a recursive shape, generate it manually with `$defs` + `$ref` until v2 lands.
+ *
+ * @see `domains/seal/plans/2026-05-12-lazy-validator.md`
+ */
+declare class LazyValidator<T extends BaseValidator = BaseValidator> extends BaseValidator {
+  private thunk;
+  private resolvedValidator;
+  constructor(thunk: () => T);
+  /**
+   * Resolve the inner validator. Memoizes the result so subsequent calls
+   * don't re-execute the thunk.
+   */
+  private resolve;
+  validate(data: any, context: SchemaContext): Promise<ValidationResult>;
+  matchesType(value: any): boolean;
+  clone(): this;
+  /**
+   * JSON Schema generation — simple resolve-and-delegate.
+   *
+   * **Recursive schemas will infinite-loop.** Until v2 adds `$ref` + `$defs`
+   * generation, callers needing JSON Schema for recursive shapes must build
+   * the schema manually.
+   */
+  toJsonSchema(target?: JsonSchemaTarget): JsonSchemaResult;
+}
+//#endregion
+export { LazyValidator };
+//# sourceMappingURL=lazy-validator.d.mts.map

package/esm/validators/lazy-validator.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazy-validator.d.mts","names":[],"sources":["../../../../../../@warlock.js/seal/src/validators/lazy-validator.ts"],"mappings":";;;;;;;;;AA4CA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAa,aAAA,WAAwB,aAAA,GAAgB,aAAA,UAAuB,aAAA;EAAA,QAG/C,KAAA;EAAA,QAFnB,iBAAA;cAEmB,KAAA,QAAa,CAAA;;;;;UAYhC,OAAA;EAQc,QAAA,CAAS,IAAA,OAAW,OAAA,EAAS,aAAA,GAAgB,OAAA,CAAQ,gBAAA;EAI3D,WAAA,CAAY,KAAA;EAIZ,KAAA,CAAA;;;;;;;;EAkBA,YAAA,CAAa,MAAA,GAAQ,gBAAA,GAAqC,gBAAA;AAAA"}

package/esm/validators/lazy-validator.mjs

@@ -0,0 +1,85 @@
+import { BaseValidator } from "./base-validator.mjs";
+
+//#region ../../@warlock.js/seal/src/validators/lazy-validator.ts
+/**
+* Lazy validator — defers resolution of the inner validator until validate-time.
+*
+* Solves the chicken-and-egg of self-referencing schemas. JavaScript evaluates
+* an object literal before the `const` binding completes, so this can't work:
+*
+* ```ts
+* const categorySchema = v.object({
+*   name: v.string(),
+*   children: v.array(categorySchema),  // ❌ ReferenceError
+* });
+* ```
+*
+* Wrap the recursive reference in `v.lazy(() => …)` — the thunk isn't invoked
+* during construction, only when `validate()` is called:
+*
+* ```ts
+* type Category = { name: string; children: Category[] };
+*
+* const categorySchema: ObjectValidator<...> = v.object({
+*   name: v.string(),
+*   children: v.array(v.lazy(() => categorySchema)),
+* });
+*
+* type T = Infer<typeof categorySchema>;
+* // { name: string; children: T[] }   ← recursive type
+* ```
+*
+* The thunk is memoized — it's invoked once on the first validate (or
+* `matchesType` / `toJsonSchema`) call and the result is cached. The thunk is
+* expected to return a stable validator; calling it on every validate would be
+* wasteful and could mask bugs where the user accidentally returns a fresh
+* validator each time.
+*
+* **JSON Schema caveat.** v1 uses simple resolve-and-delegate — recursive
+* schemas will infinite-loop in `toJsonSchema()`. If you need JSON Schema for
+* a recursive shape, generate it manually with `$defs` + `$ref` until v2 lands.
+*
+* @see `domains/seal/plans/2026-05-12-lazy-validator.md`
+*/
+var LazyValidator = class extends BaseValidator {
+	constructor(thunk) {
+		super();
+		this.thunk = thunk;
+		this.requiredRule = null;
+		this.isOptional = true;
+	}
+	/**
+	* Resolve the inner validator. Memoizes the result so subsequent calls
+	* don't re-execute the thunk.
+	*/
+	resolve() {
+		if (this.resolvedValidator === void 0) this.resolvedValidator = this.thunk();
+		return this.resolvedValidator;
+	}
+	async validate(data, context) {
+		return this.resolve().validate(data, context);
+	}
+	matchesType(value) {
+		return this.resolve().matchesType(value);
+	}
+	clone() {
+		const cloned = super.clone();
+		cloned.thunk = this.thunk;
+		cloned.resolvedValidator = void 0;
+		return cloned;
+	}
+	/**
+	* JSON Schema generation — simple resolve-and-delegate.
+	*
+	* **Recursive schemas will infinite-loop.** Until v2 adds `$ref` + `$defs`
+	* generation, callers needing JSON Schema for recursive shapes must build
+	* the schema manually.
+	*/
+	toJsonSchema(target = "draft-2020-12") {
+		return this.resolve().toJsonSchema(target);
+	}
+};
+
+//#endregion
+export { LazyValidator };
+//# sourceMappingURL=lazy-validator.mjs.map

package/esm/validators/lazy-validator.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazy-validator.mjs","names":[],"sources":["../../../../../../@warlock.js/seal/src/validators/lazy-validator.ts"],"sourcesContent":["import type { JsonSchemaResult, JsonSchemaTarget } from \"../standard-schema/json-schema\";\nimport type { SchemaContext, ValidationResult } from \"../types\";\nimport { BaseValidator } from \"./base-validator\";\n\n/**\n * Lazy validator — defers resolution of the inner validator until validate-time.\n *\n * Solves the chicken-and-egg of self-referencing schemas. JavaScript evaluates\n * an object literal before the `const` binding completes, so this can't work:\n *\n * ```ts\n * const categorySchema = v.object({\n *   name: v.string(),\n *   children: v.array(categorySchema),  // ❌ ReferenceError\n * });\n * ```\n *\n * Wrap the recursive reference in `v.lazy(() => …)` — the thunk isn't invoked\n * during construction, only when `validate()` is called:\n *\n * ```ts\n * type Category = { name: string; children: Category[] };\n *\n * const categorySchema: ObjectValidator<...> = v.object({\n *   name: v.string(),\n *   children: v.array(v.lazy(() => categorySchema)),\n * });\n *\n * type T = Infer<typeof categorySchema>;\n * // { name: string; children: T[] }   ← recursive type\n * ```\n *\n * The thunk is memoized — it's invoked once on the first validate (or\n * `matchesType` / `toJsonSchema`) call and the result is cached. The thunk is\n * expected to return a stable validator; calling it on every validate would be\n * wasteful and could mask bugs where the user accidentally returns a fresh\n * validator each time.\n *\n * **JSON Schema caveat.** v1 uses simple resolve-and-delegate — recursive\n * schemas will infinite-loop in `toJsonSchema()`. If you need JSON Schema for\n * a recursive shape, generate it manually with `$defs` + `$ref` until v2 lands.\n *\n * @see `domains/seal/plans/2026-05-12-lazy-validator.md`\n */\nexport class LazyValidator<T extends BaseValidator = BaseValidator> extends BaseValidator {\n  private resolvedValidator: T | undefined;\n\n  public constructor(private thunk: () => T) {\n    super();\n    // Lazy itself defers required handling to the inner validator —\n    // mark the wrapper as optional so the required check doesn't fire here.\n    this.requiredRule = null;\n    this.isOptional = true;\n  }\n\n  /**\n   * Resolve the inner validator. Memoizes the result so subsequent calls\n   * don't re-execute the thunk.\n   */\n  private resolve(): T {\n    if (this.resolvedValidator === undefined) {\n      this.resolvedValidator = this.thunk();\n    }\n\n    return this.resolvedValidator;\n  }\n\n  public override async validate(data: any, context: SchemaContext): Promise<ValidationResult> {\n    return this.resolve().validate(data, context);\n  }\n\n  public override matchesType(value: any): boolean {\n    return this.resolve().matchesType(value);\n  }\n\n  public override clone(): this {\n    const cloned = super.clone();\n    // Share the thunk reference; reset the memo so the clone resolves\n    // independently on its first call (in case the thunk closure resolves\n    // differently in a different context — unlikely but cheap insurance).\n    cloned.thunk = this.thunk;\n    cloned.resolvedValidator = undefined;\n\n    return cloned;\n  }\n\n  /**\n   * JSON Schema generation — simple resolve-and-delegate.\n   *\n   * **Recursive schemas will infinite-loop.** Until v2 adds `$ref` + `$defs`\n   * generation, callers needing JSON Schema for recursive shapes must build\n   * the schema manually.\n   */\n  public override toJsonSchema(target: JsonSchemaTarget = \"draft-2020-12\"): JsonSchemaResult {\n    return this.resolve().toJsonSchema(target);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4CA,IAAa,gBAAb,cAA4E,cAAc;CAGxF,AAAO,YAAY,AAAQ,OAAgB;EACzC,MAAM;EADmB;EAIzB,KAAK,eAAe;EACpB,KAAK,aAAa;CACpB;;;;;CAMA,AAAQ,UAAa;EACnB,IAAI,KAAK,sBAAsB,QAC7B,KAAK,oBAAoB,KAAK,MAAM;EAGtC,OAAO,KAAK;CACd;CAEA,MAAsB,SAAS,MAAW,SAAmD;EAC3F,OAAO,KAAK,QAAQ,EAAE,SAAS,MAAM,OAAO;CAC9C;CAEA,AAAgB,YAAY,OAAqB;EAC/C,OAAO,KAAK,QAAQ,EAAE,YAAY,KAAK;CACzC;CAEA,AAAgB,QAAc;EAC5B,MAAM,SAAS,MAAM,MAAM;EAI3B,OAAO,QAAQ,KAAK;EACpB,OAAO,oBAAoB;EAE3B,OAAO;CACT;;;;;;;;CASA,AAAgB,aAAa,SAA2B,iBAAmC;EACzF,OAAO,KAAK,QAAQ,EAAE,aAAa,MAAM;CAC3C;AACF"}

package/esm/validators/literal-validator.d.mts

@@ -0,0 +1,52 @@
+import { JsonSchemaResult, JsonSchemaTarget } from "../standard-schema/json-schema.mjs";
+import { BaseValidator } from "./base-validator.mjs";
+
+//#region ../../@warlock.js/seal/src/validators/literal-validator.d.ts
+/**
+ * Literal validator class
+ *
+ * Accepts a fixed tuple of primitive literal values (string, number, boolean).
+ * The TypeScript type narrows to the union of those literals — `v.literal("a", "b")`
+ * infers as `"a" | "b"`, not `string`. Use for discriminator fields, enum-like
+ * unions of constants, and any case where `oneOf([...])` would lose literal types.
+ *
+ * @example
+ * v.literal("items")               // type: "items"
+ * v.literal("draft", "published")  // type: "draft" | "published"
+ * v.literal(1, 2, 3)               // type: 1 | 2 | 3
+ * v.literal(true)                  // type: true
+ */
+declare class LiteralValidator<T extends readonly (string | number | boolean)[] = readonly (string | number | boolean)[]> extends BaseValidator {
+  values: T;
+  constructor(values: T, errorMessage?: string);
+  /**
+   * Check if value is one of the configured literals
+   */
+  matchesType(value: any): boolean;
+  /**
+   * Clone the validator, preserving the literal `values` set.
+   *
+   * The base `clone()` only copies `BaseValidator` fields, so without this
+   * override a cloned literal loses its public `values` array — which breaks
+   * any consumer that reads it (e.g. `discriminatedUnion` branch routing).
+   */
+  clone(): this;
+  /**
+   * @inheritdoc
+   *
+   * Single literal → `{ const: <value> }`. Multiple → `{ enum: [...] }`.
+   *
+   * @example
+   * ```ts
+   * v.literal("items").toJsonSchema()
+   * // → { const: "items" }
+   *
+   * v.literal("draft", "published").toJsonSchema()
+   * // → { enum: ["draft", "published"] }
+   * ```
+   */
+  toJsonSchema(target?: JsonSchemaTarget): JsonSchemaResult;
+}
+//#endregion
+export { LiteralValidator };
+//# sourceMappingURL=literal-validator.d.mts.map

package/esm/validators/literal-validator.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"literal-validator.d.mts","names":[],"sources":["../../../../../../@warlock.js/seal/src/validators/literal-validator.ts"],"mappings":";;;;;;AAmBA;;;;;;;;;;;;cAAa,gBAAA,oGAEH,aAAA;EACD,MAAA,EAAQ,CAAA;cAEI,MAAA,EAAQ,CAAA,EAAG,YAAA;EAAH;;;EASpB,WAAA,CAAY,KAAA;EAAA;;;;;;;EAWH,KAAA,CAAA;;;;;;;;;;;;;;;EAoBA,YAAA,CAAa,MAAA,GAAQ,gBAAA,GAAqC,gBAAA;AAAA"}

package/esm/validators/literal-validator.mjs

@@ -0,0 +1,67 @@
+import { applyNullable } from "../standard-schema/json-schema.mjs";
+import { BaseValidator } from "./base-validator.mjs";
+import { literalRule } from "../rules/common/literal.mjs";
+
+//#region ../../@warlock.js/seal/src/validators/literal-validator.ts
+/**
+* Literal validator class
+*
+* Accepts a fixed tuple of primitive literal values (string, number, boolean).
+* The TypeScript type narrows to the union of those literals — `v.literal("a", "b")`
+* infers as `"a" | "b"`, not `string`. Use for discriminator fields, enum-like
+* unions of constants, and any case where `oneOf([...])` would lose literal types.
+*
+* @example
+* v.literal("items")               // type: "items"
+* v.literal("draft", "published")  // type: "draft" | "published"
+* v.literal(1, 2, 3)               // type: 1 | 2 | 3
+* v.literal(true)                  // type: true
+*/
+var LiteralValidator = class extends BaseValidator {
+	constructor(values, errorMessage) {
+		super();
+		this.values = values;
+		this.addMutableRule(literalRule, errorMessage, { values });
+	}
+	/**
+	* Check if value is one of the configured literals
+	*/
+	matchesType(value) {
+		return this.values.includes(value);
+	}
+	/**
+	* Clone the validator, preserving the literal `values` set.
+	*
+	* The base `clone()` only copies `BaseValidator` fields, so without this
+	* override a cloned literal loses its public `values` array — which breaks
+	* any consumer that reads it (e.g. `discriminatedUnion` branch routing).
+	*/
+	clone() {
+		const cloned = super.clone();
+		cloned.values = this.values;
+		return cloned;
+	}
+	/**
+	* @inheritdoc
+	*
+	* Single literal → `{ const: <value> }`. Multiple → `{ enum: [...] }`.
+	*
+	* @example
+	* ```ts
+	* v.literal("items").toJsonSchema()
+	* // → { const: "items" }
+	*
+	* v.literal("draft", "published").toJsonSchema()
+	* // → { enum: ["draft", "published"] }
+	* ```
+	*/
+	toJsonSchema(target = "draft-2020-12") {
+		const schema = this.values.length === 1 ? { const: this.values[0] } : { enum: [...this.values] };
+		if (this.isNullable) applyNullable(schema, target);
+		return schema;
+	}
+};
+
+//#endregion
+export { LiteralValidator };
+//# sourceMappingURL=literal-validator.mjs.map

package/esm/validators/literal-validator.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"literal-validator.mjs","names":[],"sources":["../../../../../../@warlock.js/seal/src/validators/literal-validator.ts"],"sourcesContent":["import { literalRule } from \"../rules/common/literal\";\nimport { applyNullable } from \"../standard-schema/json-schema\";\nimport type { JsonSchemaResult, JsonSchemaTarget } from \"../standard-schema/json-schema\";\nimport { BaseValidator } from \"./base-validator\";\n\n/**\n * Literal validator class\n *\n * Accepts a fixed tuple of primitive literal values (string, number, boolean).\n * The TypeScript type narrows to the union of those literals — `v.literal(\"a\", \"b\")`\n * infers as `\"a\" | \"b\"`, not `string`. Use for discriminator fields, enum-like\n * unions of constants, and any case where `oneOf([...])` would lose literal types.\n *\n * @example\n * v.literal(\"items\")               // type: \"items\"\n * v.literal(\"draft\", \"published\")  // type: \"draft\" | \"published\"\n * v.literal(1, 2, 3)               // type: 1 | 2 | 3\n * v.literal(true)                  // type: true\n */\nexport class LiteralValidator<\n  T extends readonly (string | number | boolean)[] = readonly (string | number | boolean)[],\n> extends BaseValidator {\n  public values: T;\n\n  public constructor(values: T, errorMessage?: string) {\n    super();\n    this.values = values;\n    this.addMutableRule(literalRule, errorMessage, { values });\n  }\n\n  /**\n   * Check if value is one of the configured literals\n   */\n  public matchesType(value: any): boolean {\n    return (this.values as readonly any[]).includes(value);\n  }\n\n  /**\n   * Clone the validator, preserving the literal `values` set.\n   *\n   * The base `clone()` only copies `BaseValidator` fields, so without this\n   * override a cloned literal loses its public `values` array — which breaks\n   * any consumer that reads it (e.g. `discriminatedUnion` branch routing).\n   */\n  public override clone(): this {\n    const cloned = super.clone();\n    cloned.values = this.values;\n    return cloned;\n  }\n\n  /**\n   * @inheritdoc\n   *\n   * Single literal → `{ const: <value> }`. Multiple → `{ enum: [...] }`.\n   *\n   * @example\n   * ```ts\n   * v.literal(\"items\").toJsonSchema()\n   * // → { const: \"items\" }\n   *\n   * v.literal(\"draft\", \"published\").toJsonSchema()\n   * // → { enum: [\"draft\", \"published\"] }\n   * ```\n   */\n  public override toJsonSchema(target: JsonSchemaTarget = \"draft-2020-12\"): JsonSchemaResult {\n    const schema: JsonSchemaResult =\n      this.values.length === 1 ? { const: this.values[0] } : { enum: [...this.values] };\n    if (this.isNullable) applyNullable(schema, target);\n    return schema;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAmBA,IAAa,mBAAb,cAEU,cAAc;CAGtB,AAAO,YAAY,QAAW,cAAuB;EACnD,MAAM;EACN,KAAK,SAAS;EACd,KAAK,eAAe,aAAa,cAAc,EAAE,OAAO,CAAC;CAC3D;;;;CAKA,AAAO,YAAY,OAAqB;EACtC,OAAQ,KAAK,OAA0B,SAAS,KAAK;CACvD;;;;;;;;CASA,AAAgB,QAAc;EAC5B,MAAM,SAAS,MAAM,MAAM;EAC3B,OAAO,SAAS,KAAK;EACrB,OAAO;CACT;;;;;;;;;;;;;;;CAgBA,AAAgB,aAAa,SAA2B,iBAAmC;EACzF,MAAM,SACJ,KAAK,OAAO,WAAW,IAAI,EAAE,OAAO,KAAK,OAAO,GAAG,IAAI,EAAE,MAAM,CAAC,GAAG,KAAK,MAAM,EAAE;EAClF,IAAI,KAAK,YAAY,cAAc,QAAQ,MAAM;EACjD,OAAO;CACT;AACF"}

package/esm/validators/managed-validator.d.mts

@@ -0,0 +1,42 @@
+import { SchemaContext } from "../types/context-types.mjs";
+import { BaseValidator } from "./base-validator.mjs";
+import { ComputedValidator } from "./computed-validator.mjs";
+
+//#region ../../@warlock.js/seal/src/validators/managed-validator.d.ts
+/**
+ * Callback function for managed fields
+ * Receives only schema context (no data dependency)
+ */
+type ManagedCallback<TResult = any> = (context: SchemaContext) => TResult | Promise<TResult>;
+/**
+ * Managed field validator
+ *
+ * The callback is optional - if not provided, the framework can inject the value.
+ * @example
+ * ```ts
+ * // With callback (framework executes it)
+ * const schema = v.object({
+ *   name: v.string(),
+ *   createdAt: v.managed(() => new Date()),
+ *   updatedAt: v.managed(() => new Date()),
+ * });
+ *
+ * // Without callback (framework injects value)
+ * const schema = v.object({
+ *   name: v.string(),
+ *   id: v.managed(() => 1),
+ * });
+ * ```
+ */
+declare class ManagedValidator<TResult = any> extends ComputedValidator<TResult> {
+  /**
+   * Create a new managed field validator
+   *
+   * @param callback - Optional function to generate the value
+   * @param resultValidator - Optional validator to validate the generated result
+   */
+  constructor(callback: ManagedCallback<TResult>, resultValidator?: BaseValidator);
+}
+//#endregion
+export { ManagedCallback, ManagedValidator };
+//# sourceMappingURL=managed-validator.d.mts.map

package/esm/validators/managed-validator.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"managed-validator.d.mts","names":[],"sources":["../../../../../../@warlock.js/seal/src/validators/managed-validator.ts"],"mappings":";;;;;;;AAQA;;KAAY,eAAA,mBAAkC,OAAA,EAAS,aAAA,KAAkB,OAAA,GAAU,OAAA,CAAQ,OAAA;;;;;;;;;;;;;;AAAO;AAsBlG;;;;;;cAAa,gBAAA,wBAAwC,iBAAA,CAAkB,OAAA;EAAlB;;;;;;cAOvC,QAAA,EAAU,eAAA,CAAgB,OAAA,GAAU,eAAA,GAAkB,aAAA;AAAA"}

package/esm/validators/managed-validator.mjs

@@ -0,0 +1,39 @@
+import { ComputedValidator } from "./computed-validator.mjs";
+
+//#region ../../@warlock.js/seal/src/validators/managed-validator.ts
+/**
+* Managed field validator
+*
+* The callback is optional - if not provided, the framework can inject the value.
+* @example
+* ```ts
+* // With callback (framework executes it)
+* const schema = v.object({
+*   name: v.string(),
+*   createdAt: v.managed(() => new Date()),
+*   updatedAt: v.managed(() => new Date()),
+* });
+*
+* // Without callback (framework injects value)
+* const schema = v.object({
+*   name: v.string(),
+*   id: v.managed(() => 1),
+* });
+* ```
+*/
+var ManagedValidator = class extends ComputedValidator {
+	/**
+	* Create a new managed field validator
+	*
+	* @param callback - Optional function to generate the value
+	* @param resultValidator - Optional validator to validate the generated result
+	*/
+	constructor(callback, resultValidator) {
+		const computedCallback = (_data, context) => callback(context);
+		super(computedCallback, resultValidator);
+	}
+};
+
+//#endregion
+export { ManagedValidator };
+//# sourceMappingURL=managed-validator.mjs.map

package/esm/validators/managed-validator.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"managed-validator.mjs","names":[],"sources":["../../../../../../@warlock.js/seal/src/validators/managed-validator.ts"],"sourcesContent":["import type { SchemaContext } from \"../types\";\nimport type { BaseValidator } from \"./base-validator\";\nimport { ComputedValidator, type ComputedCallback } from \"./computed-validator\";\n\n/**\n * Callback function for managed fields\n * Receives only schema context (no data dependency)\n */\nexport type ManagedCallback<TResult = any> = (context: SchemaContext) => TResult | Promise<TResult>;\n\n/**\n * Managed field validator\n *\n * The callback is optional - if not provided, the framework can inject the value.\n * @example\n * ```ts\n * // With callback (framework executes it)\n * const schema = v.object({\n *   name: v.string(),\n *   createdAt: v.managed(() => new Date()),\n *   updatedAt: v.managed(() => new Date()),\n * });\n *\n * // Without callback (framework injects value)\n * const schema = v.object({\n *   name: v.string(),\n *   id: v.managed(() => 1),\n * });\n * ```\n */\nexport class ManagedValidator<TResult = any> extends ComputedValidator<TResult> {\n  /**\n   * Create a new managed field validator\n   *\n   * @param callback - Optional function to generate the value\n   * @param resultValidator - Optional validator to validate the generated result\n   */\n  constructor(callback: ManagedCallback<TResult>, resultValidator?: BaseValidator) {\n    // Convert ManagedCallback to ComputedCallback\n    // Managed callbacks don't receive data, only context\n    const computedCallback: ComputedCallback<TResult> = (_data, context) => callback(context);\n\n    super(computedCallback, resultValidator);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AA8BA,IAAa,mBAAb,cAAqD,kBAA2B;;;;;;;CAO9E,YAAY,UAAoC,iBAAiC;EAG/E,MAAM,oBAA+C,OAAO,YAAY,SAAS,OAAO;EAExF,MAAM,kBAAkB,eAAe;CACzC;AACF"}

package/esm/validators/methods/equality-conditional-methods.d.mts

@@ -0,0 +1,90 @@
+import { WhenRuleOptions } from "../../types/conditional-types.mjs";
+
+//#region ../../@warlock.js/seal/src/validators/methods/equality-conditional-methods.d.ts
+declare module "../base-validator" {
+  interface BaseValidator {
+    /**
+     * Value must be equal to the given value
+     */
+    equal(value: any, errorMessage?: string): this;
+    /**
+     * Value must be the same as another field's value
+     */
+    sameAs(field: string, errorMessage?: string): this;
+    /**
+     * Value must be the same as another sibling field's value
+     */
+    sameAsSibling(field: string, errorMessage?: string): this;
+    /**
+     * Value must be different from another field's value
+     */
+    differentFrom(field: string, errorMessage?: string): this;
+    /**
+     * Value must be different from another sibling field's value
+     */
+    differentFromSibling(field: string, errorMessage?: string): this;
+    /**
+     * Apply different validation rules based on another field's value (global scope)
+     *
+     * Use this when you need to apply completely different validators
+     * based on another field's value (not just required/optional).
+     *
+     * @param field - Field name to check (can be nested with dot notation)
+     * @param options - Validation options per field value
+     *
+     * @example
+     * ```ts
+     * // Different allowed values based on user type
+     * v.object({
+     *   userType: v.string().in(['admin', 'user']),
+     *   role: v.string().when('userType', {
+     *     is: {
+     *       admin: v.string().in(['super', 'moderator']),
+     *       user: v.string().in(['member', 'guest'])
+     *     },
+     *     otherwise: v.string().optional()
+     *   })
+     * })
+     *
+     * // Different validation rules based on type
+     * v.object({
+     *   contactType: v.string().in(['email', 'phone']),
+     *   contact: v.string().when('contactType', {
+     *     is: {
+     *       email: v.string().email(),
+     *       phone: v.string().pattern(/^\d{10}$/)
+     *     }
+     *   })
+     * })
+     * ```
+     * @category Conditional Validation
+     */
+    when(field: string, options: Omit<WhenRuleOptions, "field" | "scope">): this;
+    /**
+     * Apply different validation rules based on sibling field's value
+     *
+     * Use this for nested objects where you need to check a field
+     * within the same parent object.
+     *
+     * @param siblingField - Sibling field name to check
+     * @param options - Validation options per field value
+     *
+     * @example
+     * ```ts
+     * // Array of users with role-based permissions
+     * v.array(v.object({
+     *   userType: v.string().in(['admin', 'user']),
+     *   permissions: v.string().whenSibling('userType', {
+     *     is: {
+     *       admin: v.string().in(['read', 'write', 'delete']),
+     *       user: v.string().in(['read'])
+     *     }
+     *   })
+     * }))
+     * ```
+     * @category Conditional Validation
+     */
+    whenSibling(siblingField: string, options: Omit<WhenRuleOptions, "field" | "scope">): this;
+  }
+} //# sourceMappingURL=equality-conditional-methods.d.ts.map
+//# sourceMappingURL=equality-conditional-methods.d.mts.map

package/esm/validators/methods/equality-conditional-methods.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"equality-conditional-methods.d.mts","names":[],"sources":["../../../../../../../@warlock.js/seal/src/validators/methods/equality-conditional-methods.ts"],"mappings":";;;;YAOY,aAAA;IAJuC;;;IAQ/C,KAAA,CAAM,KAAA,OAAY,YAAA;IA0DW;;;IArD7B,MAAA,CAAO,KAAA,UAAe,YAAA;IA+EyB;;;IA1E/C,aAAA,CAAc,KAAA,UAAe,YAAA;IAVX;;;IAelB,aAAA,CAAc,KAAA,UAAe,YAAA;IAL7B;;;IAUA,oBAAA,CAAqB,KAAA,UAAe,YAAA;IALtB;;;;;;;;;;;;;;;;;AAqEqE;;;;;;;;;;;;;;;;;;;IA1BnF,IAAA,CAAK,KAAA,UAAe,OAAA,EAAS,IAAA,CAAK,eAAA;;;;;;;;;;;;;;;;;;;;;;;;;IA0BlC,WAAA,CAAY,YAAA,UAAsB,OAAA,EAAS,IAAA,CAAK,eAAA;EAAA;AAAA"}

package/esm/validators/methods/equality-conditional-methods.mjs

@@ -0,0 +1,129 @@
+import { BaseValidator } from "../base-validator.mjs";
+import { equalRule } from "../../rules/core/equal.mjs";
+import { whenRule } from "../../rules/core/when.mjs";
+import { equalsFieldRule, notEqualsFieldRule } from "../../rules/common/equals-field-rules.mjs";
+import "../../rules/index.mjs";
+
+//#region ../../@warlock.js/seal/src/validators/methods/equality-conditional-methods.ts
+/**
+* Value must be equal to the given value
+*/
+BaseValidator.prototype.equal = function(value, errorMessage) {
+	return this.addRule(equalRule, errorMessage, { value });
+};
+/**
+* Value must be the same as another field's value
+*/
+BaseValidator.prototype.sameAs = function(field, errorMessage) {
+	return this.addRule(equalsFieldRule, errorMessage, {
+		field,
+		scope: "global"
+	});
+};
+/**
+* Value must be the same as another sibling field's value
+*/
+BaseValidator.prototype.sameAsSibling = function(field, errorMessage) {
+	return this.addRule(equalsFieldRule, errorMessage, {
+		field,
+		scope: "sibling"
+	});
+};
+/**
+* Value must be different from another field's value
+*/
+BaseValidator.prototype.differentFrom = function(field, errorMessage) {
+	return this.addRule(notEqualsFieldRule, errorMessage, {
+		field,
+		scope: "global"
+	});
+};
+/**
+* Value must be different from another sibling field's value
+*/
+BaseValidator.prototype.differentFromSibling = function(field, errorMessage) {
+	return this.addRule(notEqualsFieldRule, errorMessage, {
+		field,
+		scope: "sibling"
+	});
+};
+/**
+* Apply different validation rules based on another field's value (global scope)
+*
+* Use this when you need to apply completely different validators
+* based on another field's value (not just required/optional).
+*
+* @param field - Field name to check (can be nested with dot notation)
+* @param options - Validation options per field value
+*
+* @example
+* ```ts
+* // Different allowed values based on user type
+* v.object({
+*   userType: v.string().in(['admin', 'user']),
+*   role: v.string().when('userType', {
+*     is: {
+*       admin: v.string().in(['super', 'moderator']),
+*       user: v.string().in(['member', 'guest'])
+*     },
+*     otherwise: v.string().optional()
+*   })
+* })
+*
+* // Different validation rules based on type
+* v.object({
+*   contactType: v.string().in(['email', 'phone']),
+*   contact: v.string().when('contactType', {
+*     is: {
+*       email: v.string().email(),
+*       phone: v.string().pattern(/^\d{10}$/)
+*     }
+*   })
+* })
+* ```
+* @category Conditional Validation
+*/
+BaseValidator.prototype.when = function(field, options) {
+	return this.addRule(whenRule, void 0, {
+		field,
+		is: options.is,
+		otherwise: options.otherwise,
+		scope: "global"
+	});
+};
+/**
+* Apply different validation rules based on sibling field's value
+*
+* Use this for nested objects where you need to check a field
+* within the same parent object.
+*
+* @param siblingField - Sibling field name to check
+* @param options - Validation options per field value
+*
+* @example
+* ```ts
+* // Array of users with role-based permissions
+* v.array(v.object({
+*   userType: v.string().in(['admin', 'user']),
+*   permissions: v.string().whenSibling('userType', {
+*     is: {
+*       admin: v.string().in(['read', 'write', 'delete']),
+*       user: v.string().in(['read'])
+*     }
+*   })
+* }))
+* ```
+* @category Conditional Validation
+*/
+BaseValidator.prototype.whenSibling = function(siblingField, options) {
+	return this.addRule(whenRule, void 0, {
+		field: siblingField,
+		is: options.is,
+		otherwise: options.otherwise,
+		scope: "sibling"
+	});
+};
+
+//#endregion
+export {  };
+//# sourceMappingURL=equality-conditional-methods.mjs.map

package/esm/validators/methods/equality-conditional-methods.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"equality-conditional-methods.mjs","names":[],"sources":["../../../../../../../@warlock.js/seal/src/validators/methods/equality-conditional-methods.ts"],"sourcesContent":["import { equalsFieldRule, notEqualsFieldRule } from \"../../rules\";\nimport { equalRule } from \"../../rules/core/equal\";\nimport { whenRule } from \"../../rules/core/when\";\nimport type { WhenRuleOptions } from \"../../types\";\nimport { BaseValidator } from \"../base-validator\";\n\ndeclare module \"../base-validator\" {\n  interface BaseValidator {\n    /**\n     * Value must be equal to the given value\n     */\n    equal(value: any, errorMessage?: string): this;\n\n    /**\n     * Value must be the same as another field's value\n     */\n    sameAs(field: string, errorMessage?: string): this;\n\n    /**\n     * Value must be the same as another sibling field's value\n     */\n    sameAsSibling(field: string, errorMessage?: string): this;\n\n    /**\n     * Value must be different from another field's value\n     */\n    differentFrom(field: string, errorMessage?: string): this;\n\n    /**\n     * Value must be different from another sibling field's value\n     */\n    differentFromSibling(field: string, errorMessage?: string): this;\n\n    /**\n     * Apply different validation rules based on another field's value (global scope)\n     *\n     * Use this when you need to apply completely different validators\n     * based on another field's value (not just required/optional).\n     *\n     * @param field - Field name to check (can be nested with dot notation)\n     * @param options - Validation options per field value\n     *\n     * @example\n     * ```ts\n     * // Different allowed values based on user type\n     * v.object({\n     *   userType: v.string().in(['admin', 'user']),\n     *   role: v.string().when('userType', {\n     *     is: {\n     *       admin: v.string().in(['super', 'moderator']),\n     *       user: v.string().in(['member', 'guest'])\n     *     },\n     *     otherwise: v.string().optional()\n     *   })\n     * })\n     *\n     * // Different validation rules based on type\n     * v.object({\n     *   contactType: v.string().in(['email', 'phone']),\n     *   contact: v.string().when('contactType', {\n     *     is: {\n     *       email: v.string().email(),\n     *       phone: v.string().pattern(/^\\d{10}$/)\n     *     }\n     *   })\n     * })\n     * ```\n     * @category Conditional Validation\n     */\n    when(field: string, options: Omit<WhenRuleOptions, \"field\" | \"scope\">): this;\n\n    /**\n     * Apply different validation rules based on sibling field's value\n     *\n     * Use this for nested objects where you need to check a field\n     * within the same parent object.\n     *\n     * @param siblingField - Sibling field name to check\n     * @param options - Validation options per field value\n     *\n     * @example\n     * ```ts\n     * // Array of users with role-based permissions\n     * v.array(v.object({\n     *   userType: v.string().in(['admin', 'user']),\n     *   permissions: v.string().whenSibling('userType', {\n     *     is: {\n     *       admin: v.string().in(['read', 'write', 'delete']),\n     *       user: v.string().in(['read'])\n     *     }\n     *   })\n     * }))\n     * ```\n     * @category Conditional Validation\n     */\n    whenSibling(siblingField: string, options: Omit<WhenRuleOptions, \"field\" | \"scope\">): this;\n  }\n}\n\n/**\n * Value must be equal to the given value\n */\nBaseValidator.prototype.equal = function (value: any, errorMessage?: string) {\n  return this.addRule(equalRule, errorMessage, { value });\n};\n\n/**\n * Value must be the same as another field's value\n */\nBaseValidator.prototype.sameAs = function (field: string, errorMessage?: string) {\n  return this.addRule(equalsFieldRule, errorMessage, {\n    field,\n    scope: \"global\",\n  });\n};\n\n/**\n * Value must be the same as another sibling field's value\n */\nBaseValidator.prototype.sameAsSibling = function (field: string, errorMessage?: string) {\n  return this.addRule(equalsFieldRule, errorMessage, {\n    field,\n    scope: \"sibling\",\n  });\n};\n\n/**\n * Value must be different from another field's value\n */\nBaseValidator.prototype.differentFrom = function (field: string, errorMessage?: string) {\n  return this.addRule(notEqualsFieldRule, errorMessage, {\n    field,\n    scope: \"global\",\n  });\n};\n\n/**\n * Value must be different from another sibling field's value\n */\nBaseValidator.prototype.differentFromSibling = function (field: string, errorMessage?: string) {\n  return this.addRule(notEqualsFieldRule, errorMessage, {\n    field,\n    scope: \"sibling\",\n  });\n};\n\n/**\n * Apply different validation rules based on another field's value (global scope)\n *\n * Use this when you need to apply completely different validators\n * based on another field's value (not just required/optional).\n *\n * @param field - Field name to check (can be nested with dot notation)\n * @param options - Validation options per field value\n *\n * @example\n * ```ts\n * // Different allowed values based on user type\n * v.object({\n *   userType: v.string().in(['admin', 'user']),\n *   role: v.string().when('userType', {\n *     is: {\n *       admin: v.string().in(['super', 'moderator']),\n *       user: v.string().in(['member', 'guest'])\n *     },\n *     otherwise: v.string().optional()\n *   })\n * })\n *\n * // Different validation rules based on type\n * v.object({\n *   contactType: v.string().in(['email', 'phone']),\n *   contact: v.string().when('contactType', {\n *     is: {\n *       email: v.string().email(),\n *       phone: v.string().pattern(/^\\d{10}$/)\n *     }\n *   })\n * })\n * ```\n * @category Conditional Validation\n */\nBaseValidator.prototype.when = function (\n  field: string,\n  options: Omit<WhenRuleOptions, \"field\" | \"scope\">,\n) {\n  return this.addRule(whenRule, undefined, {\n    field,\n    is: options.is,\n    otherwise: options.otherwise,\n    scope: \"global\",\n  });\n};\n\n/**\n * Apply different validation rules based on sibling field's value\n *\n * Use this for nested objects where you need to check a field\n * within the same parent object.\n *\n * @param siblingField - Sibling field name to check\n * @param options - Validation options per field value\n *\n * @example\n * ```ts\n * // Array of users with role-based permissions\n * v.array(v.object({\n *   userType: v.string().in(['admin', 'user']),\n *   permissions: v.string().whenSibling('userType', {\n *     is: {\n *       admin: v.string().in(['read', 'write', 'delete']),\n *       user: v.string().in(['read'])\n *     }\n *   })\n * }))\n * ```\n * @category Conditional Validation\n */\nBaseValidator.prototype.whenSibling = function (\n  siblingField: string,\n  options: Omit<WhenRuleOptions, \"field\" | \"scope\">,\n) {\n  return this.addRule(whenRule, undefined, {\n    field: siblingField,\n    is: options.is,\n    otherwise: options.otherwise,\n    scope: \"sibling\",\n  });\n};\n"],"mappings":";;;;;;;;;;AAsGA,cAAc,UAAU,QAAQ,SAAU,OAAY,cAAuB;CAC3E,OAAO,KAAK,QAAQ,WAAW,cAAc,EAAE,MAAM,CAAC;AACxD;;;;AAKA,cAAc,UAAU,SAAS,SAAU,OAAe,cAAuB;CAC/E,OAAO,KAAK,QAAQ,iBAAiB,cAAc;EACjD;EACA,OAAO;CACT,CAAC;AACH;;;;AAKA,cAAc,UAAU,gBAAgB,SAAU,OAAe,cAAuB;CACtF,OAAO,KAAK,QAAQ,iBAAiB,cAAc;EACjD;EACA,OAAO;CACT,CAAC;AACH;;;;AAKA,cAAc,UAAU,gBAAgB,SAAU,OAAe,cAAuB;CACtF,OAAO,KAAK,QAAQ,oBAAoB,cAAc;EACpD;EACA,OAAO;CACT,CAAC;AACH;;;;AAKA,cAAc,UAAU,uBAAuB,SAAU,OAAe,cAAuB;CAC7F,OAAO,KAAK,QAAQ,oBAAoB,cAAc;EACpD;EACA,OAAO;CACT,CAAC;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCA,cAAc,UAAU,OAAO,SAC7B,OACA,SACA;CACA,OAAO,KAAK,QAAQ,UAAU,QAAW;EACvC;EACA,IAAI,QAAQ;EACZ,WAAW,QAAQ;EACnB,OAAO;CACT,CAAC;AACH;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,cAAc,UAAU,cAAc,SACpC,cACA,SACA;CACA,OAAO,KAAK,QAAQ,UAAU,QAAW;EACvC,OAAO;EACP,IAAI,QAAQ;EACZ,WAAW,QAAQ;EACnB,OAAO;CACT,CAAC;AACH"}