@warlock.js/seal 5.4.0 → 5.6.0

package/esm/factory/validate.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"validate.mjs","names":[],"sources":["../../../../../../../seal/src/factory/validate.ts"],"sourcesContent":["import { getSealConfig } from \"../config\";\r\nimport type { SchemaContext, ValidationResult } from \"../types\";\r\nimport type { BaseValidator } from \"../validators\";\r\nimport { type ValidateOptions } from \"./validators\";\r\n\r\n/**\r\n * Validate data against a schema\r\n */\r\nexport const validate = async <T extends BaseValidator>(\r\n  schema: T,\r\n  data: any, // Temporarily use any - will fix type inference\r\n  { context: extendedContext, ...configurations }: ValidateOptions = getSealConfig() || {},\r\n): Promise<ValidationResult> => {\r\n  const context: SchemaContext = {\r\n    allValues: data,\r\n    parent: null,\r\n    value: data,\r\n    key: \"\",\r\n    path: \"\",\r\n    context: extendedContext,\r\n    rootContext: extendedContext,\r\n    translateRule(ruleTranslation) {\r\n      return configurations.translateRule?.(ruleTranslation) ?? \"\";\r\n    },\r\n    translateAttribute(attributeTranslation) {\r\n      return configurations.translateAttribute?.(attributeTranslation) ?? \"\";\r\n    },\r\n    configurations,\r\n  };\r\n\r\n  const result = await schema.validate(data, context);\r\n\r\n  // A failed validation never hands back the input it just rejected.\r\n  //\r\n  // `object` used to return the raw input on failure while `discriminatedUnion`\r\n  // returned `undefined` — the same call shape with two different contracts.\r\n  // The object behaviour was the dangerous one: validating an outbound DTO\r\n  // specifically to keep internal fields out of a response, then doing the\r\n  // natural `const { data } = await v.validate(dto, record); reply.send(data)`,\r\n  // shipped every field the schema existed to exclude. A guard that returns the\r\n  // unsafe value on failure reads as safe and isn't.\r\n  if (!result.isValid) {\r\n    return { ...result, data: undefined };\r\n  }\r\n\r\n  return result;\r\n};\r\n"],"mappings":";;;;;;AAQA,MAAa,WAAW,OACtB,QACA,MACA,EAAE,SAAS,iBAAiB,GAAG,mBAAoC,cAAc,KAAK,CAAC,MACzD;CAC9B,MAAM,UAAyB;EAC7B,WAAW;EACX,QAAQ;EACR,OAAO;EACP,KAAK;EACL,MAAM;EACN,SAAS;EACT,aAAa;EACb,cAAc,iBAAiB;GAC7B,OAAO,eAAe,gBAAgB,eAAe,KAAK;EAC5D;EACA,mBAAmB,sBAAsB;GACvC,OAAO,eAAe,qBAAqB,oBAAoB,KAAK;EACtE;EACA;CACF;CAEA,MAAM,SAAS,MAAM,OAAO,SAAS,MAAM,OAAO;CAWlD,IAAI,CAAC,OAAO,SACV,OAAO;EAAE,GAAG;EAAQ,MAAM;CAAU;CAGtC,OAAO;AACT"}
+{"version":3,"file":"validate.mjs","names":[],"sources":["../../../../../../../seal/src/factory/validate.ts"],"sourcesContent":["import { getSealConfig } from \"../config\";\r\nimport type { SchemaContext, ValidationResult } from \"../types\";\r\nimport type { BaseValidator } from \"../validators\";\r\nimport type { ValidateOptions } from \"./validators\";\r\n\r\n/**\r\n * Validate data against a schema\r\n */\r\nexport const validate = async <T extends BaseValidator>(\r\n  schema: T,\r\n  data: any, // Temporarily use any - will fix type inference\r\n  { context: extendedContext, ...configurations }: ValidateOptions = getSealConfig() || {},\r\n): Promise<ValidationResult> => {\r\n  const context: SchemaContext = {\r\n    allValues: data,\r\n    parent: null,\r\n    value: data,\r\n    key: \"\",\r\n    path: \"\",\r\n    context: extendedContext,\r\n    rootContext: extendedContext,\r\n    translateRule(ruleTranslation) {\r\n      return configurations.translateRule?.(ruleTranslation) ?? \"\";\r\n    },\r\n    translateAttribute(attributeTranslation) {\r\n      return configurations.translateAttribute?.(attributeTranslation) ?? \"\";\r\n    },\r\n    configurations,\r\n  };\r\n\r\n  const result = await schema.validate(data, context);\r\n\r\n  // A failed validation never hands back the input it just rejected.\r\n  //\r\n  // `object` used to return the raw input on failure while `discriminatedUnion`\r\n  // returned `undefined` — the same call shape with two different contracts.\r\n  // The object behaviour was the dangerous one: validating an outbound DTO\r\n  // specifically to keep internal fields out of a response, then doing the\r\n  // natural `const { data } = await v.validate(dto, record); reply.send(data)`,\r\n  // shipped every field the schema existed to exclude. A guard that returns the\r\n  // unsafe value on failure reads as safe and isn't.\r\n  if (!result.isValid) {\r\n    return { ...result, data: undefined };\r\n  }\r\n\r\n  return result;\r\n};\r\n"],"mappings":";;;;;;AAQA,MAAa,WAAW,OACtB,QACA,MACA,EAAE,SAAS,iBAAiB,GAAG,mBAAoC,cAAc,KAAK,CAAC,MACzD;CAC9B,MAAM,UAAyB;EAC7B,WAAW;EACX,QAAQ;EACR,OAAO;EACP,KAAK;EACL,MAAM;EACN,SAAS;EACT,aAAa;EACb,cAAc,iBAAiB;GAC7B,OAAO,eAAe,gBAAgB,eAAe,KAAK;EAC5D;EACA,mBAAmB,sBAAsB;GACvC,OAAO,eAAe,qBAAqB,oBAAoB,KAAK;EACtE;EACA;CACF;CAEA,MAAM,SAAS,MAAM,OAAO,SAAS,MAAM,OAAO;CAWlD,IAAI,CAAC,OAAO,SACV,OAAO;EAAE,GAAG;EAAQ,MAAM;CAAU;CAGtC,OAAO;AACT"}

package/esm/factory/validators.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"validators.mjs","names":["validateFunction"],"sources":["../../../../../../../seal/src/factory/validators.ts"],"sourcesContent":["import { type SealConfig } from \"../config\";\nimport type { StandardSchemaV1 } from \"../standard-schema/types\";\nimport type { Schema, SchemaContext, ValidationResult } from \"../types\";\nimport type { Infer } from \"../types/inference-types\";\nimport { AnyValidator } from \"../validators/any-validator\";\nimport { ArrayValidator } from \"../validators/array-validator\";\nimport type { BaseValidator } from \"../validators/base-validator\";\nimport { BooleanValidator } from \"../validators/boolean-validator\";\nimport { ComputedValidator } from \"../validators/computed-validator\";\nimport { DateValidator } from \"../validators/date-validator\";\nimport { DiscriminatedUnionValidator } from \"../validators/discriminated-union-validator\";\nimport { FloatValidator } from \"../validators/float-validator\";\nimport { InstanceOfValidator } from \"../validators/instanceof-validator\";\nimport { IntValidator } from \"../validators/int-validator\";\nimport { LazyValidator } from \"../validators/lazy-validator\";\nimport { LiteralValidator } from \"../validators/literal-validator\";\nimport { ManagedValidator } from \"../validators/managed-validator\";\nimport { NumberValidator } from \"../validators/number-validator\";\nimport { NumericValidator } from \"../validators/numeric-validator\";\nimport { ObjectValidator } from \"../validators/object-validator\";\nimport { RecordValidator } from \"../validators/record-validator\";\nimport { ScalarValidator } from \"../validators/scalar-validator\";\nimport { StringValidator } from \"../validators/string-validator\";\nimport { TupleValidator } from \"../validators/tuple-validator\";\nimport { UnionValidator } from \"../validators/union-validator\";\n// BaseValidator prototype augmentations — side-effect imports so the `v`\n// factory always exposes the chain methods (.required, .requiredIf, .sameAs,\n// .present, .forbidden, .when, …) regardless of which entry path loaded it.\n// The package barrel (src/index.ts) loads these via the validators barrel, but\n// importing the factory leaf directly would otherwise yield a half-built `v`.\nimport \"../validators/methods/equality-conditional-methods\";\nimport \"../validators/methods/forbidden-methods\";\nimport \"../validators/methods/present-methods\";\nimport \"../validators/methods/required-methods\";\nimport { validate as validateFunction } from \"./validate\";\n\n/**\n * Seal factory object - creates instances of validators\n *\n * Use 'v' to create validation schemas (seals) for your data\n */\nexport const v: ValidatorV = {\n  /** Create an object validator */\n  object: <T extends Schema>(schema: T, errorMessage?: string) =>\n    new ObjectValidator<T>(schema, errorMessage) as ObjectValidator<T> &\n      StandardSchemaV1<Infer<ObjectValidator<T>>>,\n\n  /** Create an any validator */\n  any: () => new AnyValidator() as AnyValidator & StandardSchemaV1<any>,\n\n  /** Create an array validator */\n  array: <T extends BaseValidator>(validator: T, errorMessage?: string) =>\n    new ArrayValidator(validator, errorMessage) as ArrayValidator & {\n      validator: T;\n    } & StandardSchemaV1<Array<Infer<T>>>,\n\n  /** Create a record validator - object with dynamic keys and consistent value types */\n  record: <T extends BaseValidator>(validator?: T, errorMessage?: string) =>\n    new RecordValidator(validator || v.any(), errorMessage) as RecordValidator & {\n      valueValidator: T;\n    } & StandardSchemaV1<Record<string, Infer<T>>>,\n\n  /** Create a tuple validator - fixed-length array with position-specific types */\n  tuple: <T extends BaseValidator[]>(validators: T, errorMessage?: string) =>\n    new TupleValidator(validators, errorMessage) as TupleValidator & {\n      validators: T;\n    } & StandardSchemaV1<{ [K in keyof T]: Infer<T[K]> }>,\n\n  /** Create a date validator */\n  date: (errorMessage?: string) =>\n    new DateValidator(errorMessage) as DateValidator & StandardSchemaV1<Date>,\n\n  /**\n   * Create a literal validator — narrows to the union of given literal values\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   */\n  literal: <T extends readonly [string | number | boolean, ...(string | number | boolean)[]]>(\n    ...values: T\n  ) =>\n    new LiteralValidator<T>(values) as LiteralValidator<T> & StandardSchemaV1<T[number]>,\n\n  /**\n   * Create an instanceof validator — value must be `instanceof` the constructor\n   *\n   * @example\n   * v.instanceof(File)        // type: File\n   * v.instanceof(Buffer)      // type: Buffer\n   * v.instanceof(MyClass)     // type: MyClass\n   */\n  instanceof: <T>(ctor: new (...args: any[]) => T, errorMessage?: string) =>\n    new InstanceOfValidator<T>(ctor, errorMessage) as InstanceOfValidator<T> &\n      StandardSchemaV1<T>,\n\n  /**\n   * Create a lazy validator — defers resolution of the inner validator until\n   * validate-time. Use for recursive or forward-referenced schemas.\n   *\n   * @example\n   * type Category = { name: string; children: Category[] };\n   *\n   * const category: ObjectValidator<...> = v.object({\n   *   name: v.string(),\n   *   children: v.array(v.lazy(() => category)),\n   * });\n   */\n  lazy: <T extends BaseValidator>(thunk: () => T) =>\n    new LazyValidator(thunk) as LazyValidator<T> & StandardSchemaV1<Infer<T>>,\n\n  /** Create a string validator */\n  string: (errorMessage?: string) =>\n    new StringValidator(errorMessage) as StringValidator & StandardSchemaV1<string>,\n\n  /** Create an email validator */\n  email: (emailErrorMessage?: string, errorMessage?: string) =>\n    new StringValidator(errorMessage).email(emailErrorMessage) as StringValidator &\n      StandardSchemaV1<string>,\n\n  /**\n   * Create an enum validator — preserves the literal union of accepted\n   * values in the inferred Standard Schema output.\n   *\n   * Two input shapes:\n   * - Tuple of literals: `v.enum([\"draft\", \"published\"])` →\n   *   `StandardSchemaV1<\"draft\" | \"published\">`\n   * - TypeScript enum object: `v.enum(Status)` →\n   *   `StandardSchemaV1<Status[keyof Status]>`\n   *\n   * Implementation is loosely typed; the public `ValidatorV.enum`\n   * surface declares the precise overloads.\n   */\n  enum: ((values: any, errorMessage?: string) =>\n    Array.isArray(values)\n      ? new StringValidator().oneOf(values, errorMessage)\n      : new ScalarValidator().enum(values, errorMessage)) as ValidatorV[\"enum\"],\n\n  /** Create a number validator */\n  number: (errorMessage?: string) =>\n    new NumberValidator(errorMessage) as NumberValidator & StandardSchemaV1<number>,\n\n  /** Create a numeric validator */\n  numeric: (errorMessage?: string) =>\n    new NumericValidator(errorMessage) as NumericValidator & StandardSchemaV1<number>,\n\n  /** Create an integer validator */\n  int: (errorMessage?: string) =>\n    new IntValidator(errorMessage) as IntValidator & StandardSchemaV1<number>,\n\n  /** Create a float validator */\n  float: (errorMessage?: string) =>\n    new FloatValidator(errorMessage) as FloatValidator & StandardSchemaV1<number>,\n\n  /** Create a boolean validator */\n  boolean: (errorMessage?: string) =>\n    new BooleanValidator(errorMessage) as BooleanValidator & StandardSchemaV1<boolean>,\n\n  /** Create a scalar validator */\n  scalar: (errorMessage?: string) =>\n    new ScalarValidator(errorMessage) as ScalarValidator &\n      StandardSchemaV1<string | number | boolean>,\n\n  /** Create a union validator - validates against multiple types */\n  union: <T extends BaseValidator[]>(validators: T, errorMessage?: string) =>\n    new UnionValidator().union(validators, errorMessage) as UnionValidator &\n      StandardSchemaV1<Infer<T[number]>>,\n\n  /**\n   * Create a discriminated union — routes payloads by a shared literal\n   * discriminator field. Each branch must be a `v.object(...)` with the\n   * discriminator typed as `v.literal(...)`.\n   *\n   * @example\n   * const email = v.object({ type: v.literal(\"email\"), email: v.string().email() });\n   * const sms   = v.object({ type: v.literal(\"sms\"),   phone: v.string() });\n   * const notif = v.discriminatedUnion(\"type\", [email, sms]);\n   * // type T = Infer<typeof notif>;\n   * // → { type: \"email\", email: string } | { type: \"sms\", phone: string }\n   */\n  discriminatedUnion: <\n    K extends string,\n    Branches extends ReadonlyArray<ObjectValidator<any>>,\n  >(\n    discriminator: K,\n    validators: Branches,\n  ) =>\n    new DiscriminatedUnionValidator(discriminator, validators) as DiscriminatedUnionValidator<\n      K,\n      Branches\n    > &\n      StandardSchemaV1<Infer<Branches[number]>>,\n\n  /** Create a computed field validator - derives value from other validated fields */\n  computed: <TResult = any>(\n    callback: (data: any, context: SchemaContext) => TResult | Promise<TResult>,\n    resultValidator?: BaseValidator,\n  ) =>\n    new ComputedValidator<TResult>(callback, resultValidator) as ComputedValidator<TResult> &\n      StandardSchemaV1<TResult>,\n\n  /** Create a managed field validator - framework-injected value */\n  managed: <TResult = any>(\n    callback: (context: SchemaContext) => TResult | Promise<TResult>,\n    resultValidator?: BaseValidator,\n  ) =>\n    new ManagedValidator<TResult>(callback, resultValidator) as ManagedValidator<TResult> &\n      StandardSchemaV1<TResult>,\n\n  /** Validate data against a schema */\n  validate: validateFunction,\n} as unknown as ValidatorV;\n\nexport type ValidateOptions = {\n  context?: Record<string, any>;\n} & SealConfig;\n\nexport interface ValidatorV {\n  object: <T extends Schema>(\n    schema: T,\n    errorMessage?: string,\n  ) => ObjectValidator<T> & StandardSchemaV1<Infer<ObjectValidator<T>>>;\n  any: () => AnyValidator & StandardSchemaV1<any>;\n  array: <T extends BaseValidator>(\n    validator: T,\n    errorMessage?: string,\n  ) => ArrayValidator & {\n    validator: T;\n  } & StandardSchemaV1<Array<Infer<T>>>;\n  record: <T extends BaseValidator>(\n    validator?: T,\n    errorMessage?: string,\n  ) => RecordValidator & {\n    valueValidator: T;\n  } & StandardSchemaV1<Record<string, Infer<T>>>;\n  tuple: <T extends BaseValidator[]>(\n    validators: T,\n    errorMessage?: string,\n  ) => TupleValidator & {\n    validators: T;\n  } & StandardSchemaV1<{ [K in keyof T]: Infer<T[K]> }>;\n  date: (errorMessage?: string) => DateValidator & StandardSchemaV1<Date>;\n  literal: <T extends readonly [string | number | boolean, ...(string | number | boolean)[]]>(\n    ...values: T\n  ) => LiteralValidator<T> & StandardSchemaV1<T[number]>;\n  instanceof: <T>(\n    ctor: new (...args: any[]) => T,\n    errorMessage?: string,\n  ) => InstanceOfValidator<T> & StandardSchemaV1<T>;\n  lazy: <T extends BaseValidator>(\n    thunk: () => T,\n  ) => LazyValidator<T> & StandardSchemaV1<Infer<T>>;\n  string: (errorMessage?: string) => StringValidator & StandardSchemaV1<string>;\n  email: (errorMessage?: string) => StringValidator & StandardSchemaV1<string>;\n  enum: {\n    <const T extends readonly (string | number | boolean)[]>(\n      values: T,\n      errorMessage?: string,\n    ): ScalarValidator & StandardSchemaV1<T[number]>;\n    <const T extends Record<string, string | number>>(\n      values: T,\n      errorMessage?: string,\n    ): ScalarValidator & StandardSchemaV1<T[keyof T]>;\n  };\n  number: (errorMessage?: string) => NumberValidator & StandardSchemaV1<number>;\n  numeric: (errorMessage?: string) => NumericValidator & StandardSchemaV1<number>;\n  int: (errorMessage?: string) => IntValidator & StandardSchemaV1<number>;\n  float: (errorMessage?: string) => FloatValidator & StandardSchemaV1<number>;\n  boolean: (errorMessage?: string) => BooleanValidator & StandardSchemaV1<boolean>;\n  scalar: (\n    errorMessage?: string,\n  ) => ScalarValidator & StandardSchemaV1<string | number | boolean>;\n  union: <T extends BaseValidator[]>(\n    validators: T,\n    errorMessage?: string,\n  ) => UnionValidator & StandardSchemaV1<Infer<T[number]>>;\n  discriminatedUnion: <\n    K extends string,\n    Branches extends ReadonlyArray<ObjectValidator<any>>,\n  >(\n    discriminator: K,\n    validators: Branches,\n  ) => DiscriminatedUnionValidator<K, Branches> & StandardSchemaV1<Infer<Branches[number]>>;\n  computed: <TResult = any>(\n    callback: (data: any, context: SchemaContext) => TResult | Promise<TResult>,\n    resultValidator?: BaseValidator,\n  ) => ComputedValidator<TResult> & StandardSchemaV1<TResult>;\n  managed: <TResult = any>(\n    callback?: (context: SchemaContext) => TResult | Promise<TResult>,\n    resultValidator?: BaseValidator,\n  ) => ManagedValidator<TResult> & StandardSchemaV1<TResult>;\n  validate: <T extends BaseValidator>(\n    schema: T,\n    data: any,\n    options?: ValidateOptions,\n  ) => Promise<ValidationResult>;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCA,MAAa,IAAgB;;CAE3B,SAA2B,QAAW,iBACpC,IAAI,gBAAmB,QAAQ,YAAY;;CAI7C,WAAW,IAAI,aAAa;;CAG5B,QAAiC,WAAc,iBAC7C,IAAI,eAAe,WAAW,YAAY;;CAK5C,SAAkC,WAAe,iBAC/C,IAAI,gBAAgB,aAAa,EAAE,IAAI,GAAG,YAAY;;CAKxD,QAAmC,YAAe,iBAChD,IAAI,eAAe,YAAY,YAAY;;CAK7C,OAAO,iBACL,IAAI,cAAc,YAAY;;;;;;;;;CAUhC,UACE,GAAG,WAEH,IAAI,iBAAoB,MAAM;;;;;;;;;CAUhC,aAAgB,MAAiC,iBAC/C,IAAI,oBAAuB,MAAM,YAAY;;;;;;;;;;;;;CAe/C,OAAgC,UAC9B,IAAI,cAAc,KAAK;;CAGzB,SAAS,iBACP,IAAI,gBAAgB,YAAY;;CAGlC,QAAQ,mBAA4B,iBAClC,IAAI,gBAAgB,YAAY,CAAC,CAAC,MAAM,iBAAiB;;;;;;;;;;;;;;CAgB3D,QAAQ,QAAa,iBACnB,MAAM,QAAQ,MAAM,IAChB,IAAI,gBAAgB,CAAC,CAAC,MAAM,QAAQ,YAAY,IAChD,IAAI,gBAAgB,CAAC,CAAC,KAAK,QAAQ,YAAY;;CAGrD,SAAS,iBACP,IAAI,gBAAgB,YAAY;;CAGlC,UAAU,iBACR,IAAI,iBAAiB,YAAY;;CAGnC,MAAM,iBACJ,IAAI,aAAa,YAAY;;CAG/B,QAAQ,iBACN,IAAI,eAAe,YAAY;;CAGjC,UAAU,iBACR,IAAI,iBAAiB,YAAY;;CAGnC,SAAS,iBACP,IAAI,gBAAgB,YAAY;;CAIlC,QAAmC,YAAe,iBAChD,IAAI,eAAe,CAAC,CAAC,MAAM,YAAY,YAAY;;;;;;;;;;;;;CAerD,qBAIE,eACA,eAEA,IAAI,4BAA4B,eAAe,UAAU;;CAO3D,WACE,UACA,oBAEA,IAAI,kBAA2B,UAAU,eAAe;;CAI1D,UACE,UACA,oBAEA,IAAI,iBAA0B,UAAU,eAAe;;CAI/CA;AACZ"}
+{"version":3,"file":"validators.mjs","names":["validateFunction"],"sources":["../../../../../../../seal/src/factory/validators.ts"],"sourcesContent":["import type { SealConfig } from \"../config\";\r\nimport type { StandardSchemaV1 } from \"../standard-schema/types\";\r\nimport type { Schema, SchemaContext, ValidationResult } from \"../types\";\r\nimport type { Infer } from \"../types/inference-types\";\r\nimport { AnyValidator } from \"../validators/any-validator\";\r\nimport { ArrayValidator } from \"../validators/array-validator\";\r\nimport type { BaseValidator } from \"../validators/base-validator\";\r\nimport { BooleanValidator } from \"../validators/boolean-validator\";\r\nimport { ComputedValidator } from \"../validators/computed-validator\";\r\nimport { DateValidator } from \"../validators/date-validator\";\r\nimport { DiscriminatedUnionValidator } from \"../validators/discriminated-union-validator\";\r\nimport { FloatValidator } from \"../validators/float-validator\";\r\nimport { InstanceOfValidator } from \"../validators/instanceof-validator\";\r\nimport { IntValidator } from \"../validators/int-validator\";\r\nimport { LazyValidator } from \"../validators/lazy-validator\";\r\nimport { LiteralValidator } from \"../validators/literal-validator\";\r\nimport { ManagedValidator } from \"../validators/managed-validator\";\r\nimport { NumberValidator } from \"../validators/number-validator\";\r\nimport { NumericValidator } from \"../validators/numeric-validator\";\r\nimport { ObjectValidator } from \"../validators/object-validator\";\r\nimport { RecordValidator } from \"../validators/record-validator\";\r\nimport { ScalarValidator } from \"../validators/scalar-validator\";\r\nimport { StringValidator } from \"../validators/string-validator\";\r\nimport { TupleValidator } from \"../validators/tuple-validator\";\r\nimport { UnionValidator } from \"../validators/union-validator\";\r\n// BaseValidator prototype augmentations — side-effect imports so the `v`\r\n// factory always exposes the chain methods (.required, .requiredIf, .sameAs,\r\n// .present, .forbidden, .when, …) regardless of which entry path loaded it.\r\n// The package barrel (src/index.ts) loads these via the validators barrel, but\r\n// importing the factory leaf directly would otherwise yield a half-built `v`.\r\nimport \"../validators/methods/equality-conditional-methods\";\r\nimport \"../validators/methods/forbidden-methods\";\r\nimport \"../validators/methods/present-methods\";\r\nimport \"../validators/methods/required-methods\";\r\nimport { validate as validateFunction } from \"./validate\";\r\n\r\n/**\r\n * Seal factory object - creates instances of validators\r\n *\r\n * Use 'v' to create validation schemas (seals) for your data\r\n */\r\nexport const v: ValidatorV = {\r\n  /** Create an object validator */\r\n  object: <T extends Schema>(schema: T, errorMessage?: string) =>\r\n    new ObjectValidator<T>(schema, errorMessage) as ObjectValidator<T> &\r\n      StandardSchemaV1<Infer<ObjectValidator<T>>>,\r\n\r\n  /** Create an any validator */\r\n  any: () => new AnyValidator() as AnyValidator & StandardSchemaV1<any>,\r\n\r\n  /** Create an array validator */\r\n  array: <T extends BaseValidator>(validator: T, errorMessage?: string) =>\r\n    new ArrayValidator(validator, errorMessage) as ArrayValidator & {\r\n      validator: T;\r\n    } & StandardSchemaV1<Array<Infer<T>>>,\r\n\r\n  /** Create a record validator - object with dynamic keys and consistent value types */\r\n  record: <T extends BaseValidator>(validator?: T, errorMessage?: string) =>\r\n    new RecordValidator(validator || v.any(), errorMessage) as RecordValidator & {\r\n      valueValidator: T;\r\n    } & StandardSchemaV1<Record<string, Infer<T>>>,\r\n\r\n  /** Create a tuple validator - fixed-length array with position-specific types */\r\n  tuple: <T extends BaseValidator[]>(validators: T, errorMessage?: string) =>\r\n    new TupleValidator(validators, errorMessage) as TupleValidator & {\r\n      validators: T;\r\n    } & StandardSchemaV1<{ [K in keyof T]: Infer<T[K]> }>,\r\n\r\n  /** Create a date validator */\r\n  date: (errorMessage?: string) =>\r\n    new DateValidator(errorMessage) as DateValidator & StandardSchemaV1<Date>,\r\n\r\n  /**\r\n   * Create a literal validator — narrows to the union of given literal values\r\n   *\r\n   * @example\r\n   * v.literal(\"items\")               // type: \"items\"\r\n   * v.literal(\"draft\", \"published\")  // type: \"draft\" | \"published\"\r\n   * v.literal(1, 2, 3)               // type: 1 | 2 | 3\r\n   */\r\n  literal: <T extends readonly [string | number | boolean, ...(string | number | boolean)[]]>(\r\n    ...values: T\r\n  ) =>\r\n    new LiteralValidator<T>(values) as LiteralValidator<T> & StandardSchemaV1<T[number]>,\r\n\r\n  /**\r\n   * Create an instanceof validator — value must be `instanceof` the constructor\r\n   *\r\n   * @example\r\n   * v.instanceof(File)        // type: File\r\n   * v.instanceof(Buffer)      // type: Buffer\r\n   * v.instanceof(MyClass)     // type: MyClass\r\n   */\r\n  instanceof: <T>(ctor: new (...args: any[]) => T, errorMessage?: string) =>\r\n    new InstanceOfValidator<T>(ctor, errorMessage) as InstanceOfValidator<T> &\r\n      StandardSchemaV1<T>,\r\n\r\n  /**\r\n   * Create a lazy validator — defers resolution of the inner validator until\r\n   * validate-time. Use for recursive or forward-referenced schemas.\r\n   *\r\n   * @example\r\n   * type Category = { name: string; children: Category[] };\r\n   *\r\n   * const category: ObjectValidator<...> = v.object({\r\n   *   name: v.string(),\r\n   *   children: v.array(v.lazy(() => category)),\r\n   * });\r\n   */\r\n  lazy: <T extends BaseValidator>(thunk: () => T) =>\r\n    new LazyValidator(thunk) as LazyValidator<T> & StandardSchemaV1<Infer<T>>,\r\n\r\n  /** Create a string validator */\r\n  string: (errorMessage?: string) =>\r\n    new StringValidator(errorMessage) as StringValidator & StandardSchemaV1<string>,\r\n\r\n  /** Create an email validator */\r\n  email: (emailErrorMessage?: string, errorMessage?: string) =>\r\n    new StringValidator(errorMessage).email(emailErrorMessage) as StringValidator &\r\n      StandardSchemaV1<string>,\r\n\r\n  /**\r\n   * Create an enum validator — preserves the literal union of accepted\r\n   * values in the inferred Standard Schema output.\r\n   *\r\n   * Two input shapes:\r\n   * - Tuple of literals: `v.enum([\"draft\", \"published\"])` →\r\n   *   `StandardSchemaV1<\"draft\" | \"published\">`\r\n   * - TypeScript enum object: `v.enum(Status)` →\r\n   *   `StandardSchemaV1<Status[keyof Status]>`\r\n   *\r\n   * Implementation is loosely typed; the public `ValidatorV.enum`\r\n   * surface declares the precise overloads.\r\n   */\r\n  enum: ((values: any, errorMessage?: string) =>\r\n    Array.isArray(values)\r\n      ? new StringValidator().oneOf(values, errorMessage)\r\n      : new ScalarValidator().enum(values, errorMessage)) as ValidatorV[\"enum\"],\r\n\r\n  /** Create a number validator */\r\n  number: (errorMessage?: string) =>\r\n    new NumberValidator(errorMessage) as NumberValidator & StandardSchemaV1<number>,\r\n\r\n  /** Create a numeric validator */\r\n  numeric: (errorMessage?: string) =>\r\n    new NumericValidator(errorMessage) as NumericValidator & StandardSchemaV1<number>,\r\n\r\n  /** Create an integer validator */\r\n  int: (errorMessage?: string) =>\r\n    new IntValidator(errorMessage) as IntValidator & StandardSchemaV1<number>,\r\n\r\n  /** Create a float validator */\r\n  float: (errorMessage?: string) =>\r\n    new FloatValidator(errorMessage) as FloatValidator & StandardSchemaV1<number>,\r\n\r\n  /** Create a boolean validator */\r\n  boolean: (errorMessage?: string) =>\r\n    new BooleanValidator(errorMessage) as BooleanValidator & StandardSchemaV1<boolean>,\r\n\r\n  /** Create a scalar validator */\r\n  scalar: (errorMessage?: string) =>\r\n    new ScalarValidator(errorMessage) as ScalarValidator &\r\n      StandardSchemaV1<string | number | boolean>,\r\n\r\n  /** Create a union validator - validates against multiple types */\r\n  union: <T extends BaseValidator[]>(validators: T, errorMessage?: string) =>\r\n    new UnionValidator().union(validators, errorMessage) as UnionValidator &\r\n      StandardSchemaV1<Infer<T[number]>>,\r\n\r\n  /**\r\n   * Create a discriminated union — routes payloads by a shared literal\r\n   * discriminator field. Each branch must be a `v.object(...)` with the\r\n   * discriminator typed as `v.literal(...)`.\r\n   *\r\n   * @example\r\n   * const email = v.object({ type: v.literal(\"email\"), email: v.string().email() });\r\n   * const sms   = v.object({ type: v.literal(\"sms\"),   phone: v.string() });\r\n   * const notif = v.discriminatedUnion(\"type\", [email, sms]);\r\n   * // type T = Infer<typeof notif>;\r\n   * // → { type: \"email\", email: string } | { type: \"sms\", phone: string }\r\n   */\r\n  discriminatedUnion: <\r\n    K extends string,\r\n    Branches extends ReadonlyArray<ObjectValidator<any>>,\r\n  >(\r\n    discriminator: K,\r\n    validators: Branches,\r\n  ) =>\r\n    new DiscriminatedUnionValidator(discriminator, validators) as DiscriminatedUnionValidator<\r\n      K,\r\n      Branches\r\n    > &\r\n      StandardSchemaV1<Infer<Branches[number]>>,\r\n\r\n  /** Create a computed field validator - derives value from other validated fields */\r\n  computed: <TResult = any>(\r\n    callback: (data: any, context: SchemaContext) => TResult | Promise<TResult>,\r\n    resultValidator?: BaseValidator,\r\n  ) =>\r\n    new ComputedValidator<TResult>(callback, resultValidator) as ComputedValidator<TResult> &\r\n      StandardSchemaV1<TResult>,\r\n\r\n  /** Create a managed field validator - framework-injected value */\r\n  managed: <TResult = any>(\r\n    callback: (context: SchemaContext) => TResult | Promise<TResult>,\r\n    resultValidator?: BaseValidator,\r\n  ) =>\r\n    new ManagedValidator<TResult>(callback, resultValidator) as ManagedValidator<TResult> &\r\n      StandardSchemaV1<TResult>,\r\n\r\n  /** Validate data against a schema */\r\n  validate: validateFunction,\r\n} as unknown as ValidatorV;\r\n\r\nexport type ValidateOptions = {\r\n  context?: Record<string, any>;\r\n} & SealConfig;\r\n\r\nexport interface ValidatorV {\r\n  object: <T extends Schema>(\r\n    schema: T,\r\n    errorMessage?: string,\r\n  ) => ObjectValidator<T> & StandardSchemaV1<Infer<ObjectValidator<T>>>;\r\n  any: () => AnyValidator & StandardSchemaV1<any>;\r\n  array: <T extends BaseValidator>(\r\n    validator: T,\r\n    errorMessage?: string,\r\n  ) => ArrayValidator & {\r\n    validator: T;\r\n  } & StandardSchemaV1<Array<Infer<T>>>;\r\n  record: <T extends BaseValidator>(\r\n    validator?: T,\r\n    errorMessage?: string,\r\n  ) => RecordValidator & {\r\n    valueValidator: T;\r\n  } & StandardSchemaV1<Record<string, Infer<T>>>;\r\n  tuple: <T extends BaseValidator[]>(\r\n    validators: T,\r\n    errorMessage?: string,\r\n  ) => TupleValidator & {\r\n    validators: T;\r\n  } & StandardSchemaV1<{ [K in keyof T]: Infer<T[K]> }>;\r\n  date: (errorMessage?: string) => DateValidator & StandardSchemaV1<Date>;\r\n  literal: <T extends readonly [string | number | boolean, ...(string | number | boolean)[]]>(\r\n    ...values: T\r\n  ) => LiteralValidator<T> & StandardSchemaV1<T[number]>;\r\n  instanceof: <T>(\r\n    ctor: new (...args: any[]) => T,\r\n    errorMessage?: string,\r\n  ) => InstanceOfValidator<T> & StandardSchemaV1<T>;\r\n  lazy: <T extends BaseValidator>(\r\n    thunk: () => T,\r\n  ) => LazyValidator<T> & StandardSchemaV1<Infer<T>>;\r\n  string: (errorMessage?: string) => StringValidator & StandardSchemaV1<string>;\r\n  email: (errorMessage?: string) => StringValidator & StandardSchemaV1<string>;\r\n  enum: {\r\n    <const T extends readonly (string | number | boolean)[]>(\r\n      values: T,\r\n      errorMessage?: string,\r\n    ): ScalarValidator & StandardSchemaV1<T[number]>;\r\n    <const T extends Record<string, string | number>>(\r\n      values: T,\r\n      errorMessage?: string,\r\n    ): ScalarValidator & StandardSchemaV1<T[keyof T]>;\r\n  };\r\n  number: (errorMessage?: string) => NumberValidator & StandardSchemaV1<number>;\r\n  numeric: (errorMessage?: string) => NumericValidator & StandardSchemaV1<number>;\r\n  int: (errorMessage?: string) => IntValidator & StandardSchemaV1<number>;\r\n  float: (errorMessage?: string) => FloatValidator & StandardSchemaV1<number>;\r\n  boolean: (errorMessage?: string) => BooleanValidator & StandardSchemaV1<boolean>;\r\n  scalar: (\r\n    errorMessage?: string,\r\n  ) => ScalarValidator & StandardSchemaV1<string | number | boolean>;\r\n  union: <T extends BaseValidator[]>(\r\n    validators: T,\r\n    errorMessage?: string,\r\n  ) => UnionValidator & StandardSchemaV1<Infer<T[number]>>;\r\n  discriminatedUnion: <\r\n    K extends string,\r\n    Branches extends ReadonlyArray<ObjectValidator<any>>,\r\n  >(\r\n    discriminator: K,\r\n    validators: Branches,\r\n  ) => DiscriminatedUnionValidator<K, Branches> & StandardSchemaV1<Infer<Branches[number]>>;\r\n  computed: <TResult = any>(\r\n    callback: (data: any, context: SchemaContext) => TResult | Promise<TResult>,\r\n    resultValidator?: BaseValidator,\r\n  ) => ComputedValidator<TResult> & StandardSchemaV1<TResult>;\r\n  managed: <TResult = any>(\r\n    callback?: (context: SchemaContext) => TResult | Promise<TResult>,\r\n    resultValidator?: BaseValidator,\r\n  ) => ManagedValidator<TResult> & StandardSchemaV1<TResult>;\r\n  validate: <T extends BaseValidator>(\r\n    schema: T,\r\n    data: any,\r\n    options?: ValidateOptions,\r\n  ) => Promise<ValidationResult>;\r\n}\r\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCA,MAAa,IAAgB;;CAE3B,SAA2B,QAAW,iBACpC,IAAI,gBAAmB,QAAQ,YAAY;;CAI7C,WAAW,IAAI,aAAa;;CAG5B,QAAiC,WAAc,iBAC7C,IAAI,eAAe,WAAW,YAAY;;CAK5C,SAAkC,WAAe,iBAC/C,IAAI,gBAAgB,aAAa,EAAE,IAAI,GAAG,YAAY;;CAKxD,QAAmC,YAAe,iBAChD,IAAI,eAAe,YAAY,YAAY;;CAK7C,OAAO,iBACL,IAAI,cAAc,YAAY;;;;;;;;;CAUhC,UACE,GAAG,WAEH,IAAI,iBAAoB,MAAM;;;;;;;;;CAUhC,aAAgB,MAAiC,iBAC/C,IAAI,oBAAuB,MAAM,YAAY;;;;;;;;;;;;;CAe/C,OAAgC,UAC9B,IAAI,cAAc,KAAK;;CAGzB,SAAS,iBACP,IAAI,gBAAgB,YAAY;;CAGlC,QAAQ,mBAA4B,iBAClC,IAAI,gBAAgB,YAAY,CAAC,CAAC,MAAM,iBAAiB;;;;;;;;;;;;;;CAgB3D,QAAQ,QAAa,iBACnB,MAAM,QAAQ,MAAM,IAChB,IAAI,gBAAgB,CAAC,CAAC,MAAM,QAAQ,YAAY,IAChD,IAAI,gBAAgB,CAAC,CAAC,KAAK,QAAQ,YAAY;;CAGrD,SAAS,iBACP,IAAI,gBAAgB,YAAY;;CAGlC,UAAU,iBACR,IAAI,iBAAiB,YAAY;;CAGnC,MAAM,iBACJ,IAAI,aAAa,YAAY;;CAG/B,QAAQ,iBACN,IAAI,eAAe,YAAY;;CAGjC,UAAU,iBACR,IAAI,iBAAiB,YAAY;;CAGnC,SAAS,iBACP,IAAI,gBAAgB,YAAY;;CAIlC,QAAmC,YAAe,iBAChD,IAAI,eAAe,CAAC,CAAC,MAAM,YAAY,YAAY;;;;;;;;;;;;;CAerD,qBAIE,eACA,eAEA,IAAI,4BAA4B,eAAe,UAAU;;CAO3D,WACE,UACA,oBAEA,IAAI,kBAA2B,UAAU,eAAe;;CAI1D,UACE,UACA,oBAEA,IAAI,iBAA0B,UAAU,eAAe;;CAI/CA;AACZ"}

package/llms-full.txt

@@ -2121,7 +2121,7 @@ Schema-first validation. Single entry point: the `v` factory. Every validator ch
 ## Install
 
 ```bash
-yarn add @warlock.js/seal
+npm install @warlock.js/seal
 ```
 
 Most warlock projects already have `@warlock.js/seal` transitively via `@warlock.js/core` (which re-exports the `v` factory and `Infer` types). Import direct from the package you control: `@warlock.js/seal` if you build a leaf package, `@warlock.js/core` if you write app code.

package/package.json

@@ -22,7 +22,7 @@
   ],
   "author": "hassanzohdy",
   "license": "MIT",
-  "version": "5.4.0",
+  "version": "5.6.0",
   "main": "./cjs/index.cjs",
   "module": "./esm/index.mjs",
   "types": "./esm/index.d.mts",

package/skills/seal-basics/SKILL.md

@@ -12,7 +12,7 @@ Schema-first validation. Single entry point: the `v` factory. Every validator ch
 ## Install
 
 ```bash
-pnpm add @warlock.js/seal
+npm install @warlock.js/seal
 ```
 
 Most warlock projects already have `@warlock.js/seal` transitively via `@warlock.js/core` (which re-exports the `v` factory and `Infer` types). Import direct from the package you control: `@warlock.js/seal` if you build a leaf package, `@warlock.js/core` if you write app code.